mistral_common.guidance.grammar_factory

def get_lark_for_json_schema(self, template: str, json_schema: dict[str, Any]) -> str:
    r"""Return a lark grammar that only accepts JSON matching the given schema.

    Convenience wrapper around `get_lark_from_jinja` that disables tool calls
    and text alternatives, constraining output to the JSON schema alone.

    Args:
        template: Jinja template to render, as obtained from `select_jinja_template`.
        json_schema: The JSON schema the output must conform to.

    Returns:
        The rendered lark grammar string that only matches the given JSON schema.
    """
    return self.get_lark_from_jinja(
        template=template,
        mode=ToolChoiceEnum.none,
        tools=None,
        json_schema=json_schema,
        parallel_tool_calls=True,
        json_only=True,
    )

def get_lark_from_jinja(
    self,
    template: str,
    mode: ToolChoice,
    tools: list[Tool] | None,
    json_schema: dict[str, Any] | None,
    parallel_tool_calls: bool,
    json_only: bool = False,
) -> str:
    r"""Render a lark grammar from a jinja template.

    This is the general entry point for grammar generation. Combines tool call,
    JSON schema, and thinking sections according to the requested mode.

    Args:
        template: Jinja template to render, as obtained from `select_jinja_template`.
        mode: The tool choice. `ToolChoiceEnum.none` disables tool call sections;
            a NamedToolChoice restricts the grammar to that single tool.
        tools: The list of tools available. Required when mode is any/required
            or a NamedToolChoice; ignored when mode is none.
        json_schema: Optional JSON schema additionally allowed by the grammar,
            unioned with tool call and text alternatives. If `None`, no JSON
            section is added.
        parallel_tool_calls: If `True`, the grammar allows one or more tool
            calls in sequence; if `False`, exactly one.
        json_only: If `True`, generates only JSON schema grammar without
            text/tool call alternatives.

    Returns:
        The rendered lark grammar string.

    Raises:
        ValueError: If a NamedToolChoice references a tool not in tools, or
            mode is any/required with no tools provided.
    """
    # Verifies that the NamedToolChoice has a valid tool and "any", "required" has tools.
    _validate_mode_and_tools(mode=mode, tools=tools)

    fcall = _convert_tool_calls(tools, mode, parallel_tool_calls, self._special_token_lark)
    json_schema_str = json.dumps(json_schema, ensure_ascii=False) if json_schema else None
    # NamedToolChoice forces a specific tool, which maps to "required" grammar.
    template_mode = ToolChoiceEnum.required if isinstance(mode, NamedToolChoice) else ToolChoiceEnum(mode)
    think_with_json = self._tokenizer.version.supports_model_settings

    begin_think_token = self._get_optional_special_token_lark(SpecialTokens.begin_think.value)
    end_think_token = self._get_optional_special_token_lark(SpecialTokens.end_think.value)

    return _cached_get_lark_from_jinja(
        template=template,
        mode=template_mode.value,
        fcall=fcall,
        json_schema_str=json_schema_str,
        parallel_tool_calls=parallel_tool_calls,
        json_only=json_only,
        think_with_json=think_with_json,
        begin_think_token=begin_think_token,
        end_think_token=end_think_token,
    )

@staticmethod
def is_supported(tokenizer: MistralTokenizer) -> bool:
    r"""Check whether the given tokenizer is supported by guidance.

    Guidance requires a Tekken tokenizer with version >= v11.

    Args:
        tokenizer: The Mistral tokenizer to check.

    Returns:
        `True` if the tokenizer is a Tekkenizer of version >= v11, `False` otherwise.
    """
    inner = tokenizer.instruct_tokenizer.tokenizer
    return is_tekkenizer(inner) and not inner.version < TokenizerVersion.v11

def select_jinja_template(self, reasoning: bool | None = None) -> str:
    r"""Selects and returns the appropriate jinja template content.

    Selection derives from the tokenizer version and presence of think tokens:
    - Returns the `think` template when the tokenizer version is >= v13 and both
      `[THINK]` and `[/THINK]` special tokens are registered.
    - Returns the `base` template in all other cases.

    Args:
        reasoning: Deprecated and ignored. Template selection is determined solely
            by the tokenizer version and presence of think tokens. Will be removed
            in 1.13.0.

    Returns:
        The jinja template content as a string.
    """
    if reasoning is not None:
        warn_once(
            "select_jinja_template.reasoning",
            "The reasoning parameter of select_jinja_template is deprecated, "
            "no longer has any effect, and will be removed in 1.13.0.",
            DeprecationWarning,
            stacklevel=2,
        )
    has_begin_think = SpecialTokens.begin_think.value in self._special_token_map
    has_end_think = SpecialTokens.end_think.value in self._special_token_map
    assert has_begin_think == has_end_think, (
        f"both {SpecialTokens.begin_think.value} and {SpecialTokens.end_think.value} "
        "should be defined or none of them."
    )
    return _cached_get_jinja_template(tokenizer_version=self._tokenizer.version, has_think_tokens=has_begin_think)