dsl

Regular expression DSL and output types for structured generation.

This module contains elements related to three logical steps in the use of output types for structured generation:

Definition of Term classes that contain output type definitions. That includes both terms intended to be used by themselves such as JsonSchema or CFG and terms that are part of the regular expression DSL such as Alternatives or KleeneStar (and the related functions).
Conversion of Python types into Term instances (python_types_to_terms).
Conversion of a Term instance into a regular expression (to_regex).

`CFG` `dataclass`

Bases: Term

Class representing a context-free grammar.

Parameters:

Name	Type	Description	Default
`definition`	`str`	The definition of the context-free grammar as a string.	required

Source code in outlines/types/dsl.py

@dataclass
class CFG(Term):
    """Class representing a context-free grammar.

    Parameters
    ----------
    definition
        The definition of the context-free grammar as a string.

    """
    definition: str

    def _display_node(self) -> str:
        return f"CFG('{self.definition}')"

    def __repr__(self):
        return f"CFG(definition='{self.definition}')"

    def __eq__(self, other):
        if not isinstance(other, CFG):
            return False
        return self.definition == other.definition

    @classmethod
    def from_file(cls, path: str) -> "CFG":
        """Create a CFG instance from a file containing a CFG definition.

        Parameters
        ----------
        path : str
            The path to the file containing the CFG definition.
        Returns
        -------
        CFG
            A CFG instance.

        """
        with open(path, "r") as f:
            definition = f.read()
        return cls(definition)

`from_file(path)` `classmethod`

Create a CFG instance from a file containing a CFG definition.

Parameters:

Name	Type	Description	Default
`path`	`str`	The path to the file containing the CFG definition.	required

Returns:

Type	Description
`CFG`	A CFG instance.

Source code in outlines/types/dsl.py

@classmethod
def from_file(cls, path: str) -> "CFG":
    """Create a CFG instance from a file containing a CFG definition.

    Parameters
    ----------
    path : str
        The path to the file containing the CFG definition.
    Returns
    -------
    CFG
        A CFG instance.

    """
    with open(path, "r") as f:
        definition = f.read()
    return cls(definition)

`Choice` `dataclass`

Bases: Term

Class representing a choice between different items.

Parameters:

Name	Type	Description	Default
`items`	`List[Any]`	The items to choose from.	required

Source code in outlines/types/dsl.py

@dataclass
class Choice(Term):
    """Class representing a choice between different items.

    Parameters
    ----------
    items
        The items to choose from.

    """
    items: List[Any]

    def _display_node(self) -> str:
        return f"Choice({repr(self.items)})"

    def __repr__(self):
        return f"Choice(items={repr(self.items)})"

`JsonSchema`

Bases: Term

Class representing a JSON schema.

The JSON schema object from which to instantiate the class can be a dictionary, a string, a Pydantic model, a typed dict, a dataclass, or a genSON schema builder.

Source code in outlines/types/dsl.py

class JsonSchema(Term):
    """Class representing a JSON schema.

    The JSON schema object from which to instantiate the class can be a
    dictionary, a string, a Pydantic model, a typed dict, a dataclass, or a
    genSON schema builder.

    """
    schema: str
    whitespace_pattern: OptionalType[str]

    def __init__(
        self,
        schema: Union[
            dict, str, type[BaseModel], _TypedDictMeta, type, SchemaBuilder
        ],
        whitespace_pattern: OptionalType[str] = None,
        ensure_ascii: bool = True,
    ):
        """
        Parameters
        ----------
        schema
            The object containing the JSON schema.
        whitespace_pattern
            The pattern to use to match whitespace characters.
        ensure_ascii
            Whether to ensure the schema is ASCII-only.

        """
        schema_str: str

        if is_dict_instance(schema):
            schema_str = json.dumps(schema, ensure_ascii=ensure_ascii)
        elif is_str_instance(schema):
            schema_str = str(schema)
        elif is_pydantic_model(schema):
            schema_str = json.dumps(schema.model_json_schema(), ensure_ascii=ensure_ascii) # type: ignore
        elif is_typed_dict(schema):
            schema_str = json.dumps(TypeAdapter(schema).json_schema(), ensure_ascii=ensure_ascii)
        elif is_dataclass(schema):
            schema_str = json.dumps(TypeAdapter(schema).json_schema(), ensure_ascii=ensure_ascii)
        elif is_genson_schema_builder(schema):
            schema_str = schema.to_json(ensure_ascii=ensure_ascii)  # type: ignore
        else:
            raise ValueError(
                f"Cannot parse schema {schema}. The schema must be either "
                + "a Pydantic class, typed dict, a dataclass, a genSON schema "
                + "builder or a string or dict that contains the JSON schema "
                + "specification"
            )

        self.schema = schema_str
        self.whitespace_pattern = whitespace_pattern

    def __post_init__(self):
        jsonschema.Draft7Validator.check_schema(json.loads(self.schema))

    @classmethod
    def is_json_schema(cls, obj: Any) -> bool:
        """Check if the object provided is a JSON schema type.

        Parameters
        ----------
        obj: Any
            The object to check

        Returns
        -------
        bool
            True if the object is a JSON schema type, False otherwise

        """
        return (
            isinstance(obj, cls)
            or is_pydantic_model(obj)
            or is_typed_dict(obj)
            or is_dataclass(obj)
            or is_genson_schema_builder(obj)
        )

    @classmethod
    def convert_to(
        cls,
        schema: Union[
            "JsonSchema",
            type[BaseModel],
            _TypedDictMeta,
            type,
            SchemaBuilder,
        ],
        target_types: List[Literal[
            "str",
            "dict",
            "pydantic",
            "typeddict",
            "dataclass",
            "genson",
        ]],
    ) -> Union[str, dict, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]:
        """Convert a JSON schema type to a different JSON schema type.

        If the schema provided is already of a type in the target_types, return
        it unchanged.

        Parameters
        ----------
        schema: Union[JsonSchema, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]
            The schema to convert
        target_types: List[Literal["str", "dict", "pydantic", "typeddict", "dataclass", "genson"]]
            The target types to convert to

        """
        # If the schema provided is already of a type in the target_types,
        # just return it
        if isinstance(schema, cls):
            if "str" in target_types:
                return schema.schema
            elif "dict" in target_types:
                return json.loads(schema.schema)
        elif is_pydantic_model(schema) and "pydantic" in target_types:
            return schema
        elif is_typed_dict(schema) and "typeddict" in target_types:
            return schema
        elif is_dataclass(schema) and "dataclass" in target_types:
            return schema
        elif is_genson_schema_builder(schema) and "genson" in target_types:
            return schema

        # Convert the schema to a JSON schema string/dict
        if isinstance(schema, cls):
            schema_str = schema.schema
        else:
            schema_str = cls(schema).schema
        schema_dict = json.loads(schema_str)

        for target_type in target_types:
            try:
                # Convert the JSON schema string to the target type
                if target_type == "str":
                    return schema_str
                elif target_type == "dict":
                    return schema_dict
                elif target_type == "pydantic":
                    return json_schema_dict_to_pydantic(schema_dict)
                elif target_type == "typeddict":
                    return json_schema_dict_to_typeddict(schema_dict)
                elif target_type == "dataclass":
                    return json_schema_dict_to_dataclass(schema_dict)
                # No conversion available for genson
            except Exception as e:  # pragma: no cover
                warnings.warn(
                    f"Cannot convert schema type {type(schema)} to {target_type}: {e}"
                )
                continue

        raise ValueError(
            f"Cannot convert schema type {type(schema)} to any of the target "
            f"types {target_types}"
        )

    def _display_node(self) -> str:
        return f"JsonSchema('{self.schema}')"

    def __repr__(self):
        return f"JsonSchema(schema='{self.schema}')"

    def __eq__(self, other):
        if not isinstance(other, JsonSchema):
            return False
        try:
            self_dict = json.loads(self.schema)
            other_dict = json.loads(other.schema)
            return self_dict == other_dict
        except json.JSONDecodeError:  # pragma: no cover
            return self.schema == other.schema

    @classmethod
    def from_file(cls, path: str) -> "JsonSchema":
        """Create a JsonSchema instance from a .json file containing a JSON
        schema.

        Parameters
        ----------
        path:
            The path to the file containing the JSON schema.
        Returns
        -------
        JsonSchema
            A JsonSchema instance.

        """
        with open(path, "r") as f:
            schema = json.load(f)
        return cls(schema)

`init(schema, whitespace_pattern=None, ensure_ascii=True)`

Parameters:

Name	Type	Description	Default
`schema`	`Union[dict, str, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]`	The object containing the JSON schema.	required
`whitespace_pattern`	`Optional[str]`	The pattern to use to match whitespace characters.	`None`
`ensure_ascii`	`bool`	Whether to ensure the schema is ASCII-only.	`True`

Source code in outlines/types/dsl.py

def __init__(
    self,
    schema: Union[
        dict, str, type[BaseModel], _TypedDictMeta, type, SchemaBuilder
    ],
    whitespace_pattern: OptionalType[str] = None,
    ensure_ascii: bool = True,
):
    """
    Parameters
    ----------
    schema
        The object containing the JSON schema.
    whitespace_pattern
        The pattern to use to match whitespace characters.
    ensure_ascii
        Whether to ensure the schema is ASCII-only.

    """
    schema_str: str

    if is_dict_instance(schema):
        schema_str = json.dumps(schema, ensure_ascii=ensure_ascii)
    elif is_str_instance(schema):
        schema_str = str(schema)
    elif is_pydantic_model(schema):
        schema_str = json.dumps(schema.model_json_schema(), ensure_ascii=ensure_ascii) # type: ignore
    elif is_typed_dict(schema):
        schema_str = json.dumps(TypeAdapter(schema).json_schema(), ensure_ascii=ensure_ascii)
    elif is_dataclass(schema):
        schema_str = json.dumps(TypeAdapter(schema).json_schema(), ensure_ascii=ensure_ascii)
    elif is_genson_schema_builder(schema):
        schema_str = schema.to_json(ensure_ascii=ensure_ascii)  # type: ignore
    else:
        raise ValueError(
            f"Cannot parse schema {schema}. The schema must be either "
            + "a Pydantic class, typed dict, a dataclass, a genSON schema "
            + "builder or a string or dict that contains the JSON schema "
            + "specification"
        )

    self.schema = schema_str
    self.whitespace_pattern = whitespace_pattern

`convert_to(schema, target_types)` `classmethod`

Convert a JSON schema type to a different JSON schema type.

If the schema provided is already of a type in the target_types, return it unchanged.

Parameters:

Name	Type	Description	Default
`schema`	`Union[JsonSchema, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]`	The schema to convert	required
`target_types`	`List[Literal['str', 'dict', 'pydantic', 'typeddict', 'dataclass', 'genson']]`	The target types to convert to	required

Source code in outlines/types/dsl.py

@classmethod
def convert_to(
    cls,
    schema: Union[
        "JsonSchema",
        type[BaseModel],
        _TypedDictMeta,
        type,
        SchemaBuilder,
    ],
    target_types: List[Literal[
        "str",
        "dict",
        "pydantic",
        "typeddict",
        "dataclass",
        "genson",
    ]],
) -> Union[str, dict, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]:
    """Convert a JSON schema type to a different JSON schema type.

    If the schema provided is already of a type in the target_types, return
    it unchanged.

    Parameters
    ----------
    schema: Union[JsonSchema, type[BaseModel], _TypedDictMeta, type, SchemaBuilder]
        The schema to convert
    target_types: List[Literal["str", "dict", "pydantic", "typeddict", "dataclass", "genson"]]
        The target types to convert to

    """
    # If the schema provided is already of a type in the target_types,
    # just return it
    if isinstance(schema, cls):
        if "str" in target_types:
            return schema.schema
        elif "dict" in target_types:
            return json.loads(schema.schema)
    elif is_pydantic_model(schema) and "pydantic" in target_types:
        return schema
    elif is_typed_dict(schema) and "typeddict" in target_types:
        return schema
    elif is_dataclass(schema) and "dataclass" in target_types:
        return schema
    elif is_genson_schema_builder(schema) and "genson" in target_types:
        return schema

    # Convert the schema to a JSON schema string/dict
    if isinstance(schema, cls):
        schema_str = schema.schema
    else:
        schema_str = cls(schema).schema
    schema_dict = json.loads(schema_str)

    for target_type in target_types:
        try:
            # Convert the JSON schema string to the target type
            if target_type == "str":
                return schema_str
            elif target_type == "dict":
                return schema_dict
            elif target_type == "pydantic":
                return json_schema_dict_to_pydantic(schema_dict)
            elif target_type == "typeddict":
                return json_schema_dict_to_typeddict(schema_dict)
            elif target_type == "dataclass":
                return json_schema_dict_to_dataclass(schema_dict)
            # No conversion available for genson
        except Exception as e:  # pragma: no cover
            warnings.warn(
                f"Cannot convert schema type {type(schema)} to {target_type}: {e}"
            )
            continue

    raise ValueError(
        f"Cannot convert schema type {type(schema)} to any of the target "
        f"types {target_types}"
    )

`from_file(path)` `classmethod`

Create a JsonSchema instance from a .json file containing a JSON schema.

Parameters:

Name	Type	Description	Default
`path`	`str`	The path to the file containing the JSON schema.	required

Returns:

Type	Description
`JsonSchema`	A JsonSchema instance.

Source code in outlines/types/dsl.py

@classmethod
def from_file(cls, path: str) -> "JsonSchema":
    """Create a JsonSchema instance from a .json file containing a JSON
    schema.

    Parameters
    ----------
    path:
        The path to the file containing the JSON schema.
    Returns
    -------
    JsonSchema
        A JsonSchema instance.

    """
    with open(path, "r") as f:
        schema = json.load(f)
    return cls(schema)

`is_json_schema(obj)` `classmethod`

Check if the object provided is a JSON schema type.

Parameters:

Name	Type	Description	Default
`obj`	`Any`	The object to check	required

Returns:

Type	Description
`bool`	True if the object is a JSON schema type, False otherwise

Source code in outlines/types/dsl.py

@classmethod
def is_json_schema(cls, obj: Any) -> bool:
    """Check if the object provided is a JSON schema type.

    Parameters
    ----------
    obj: Any
        The object to check

    Returns
    -------
    bool
        True if the object is a JSON schema type, False otherwise

    """
    return (
        isinstance(obj, cls)
        or is_pydantic_model(obj)
        or is_typed_dict(obj)
        or is_dataclass(obj)
        or is_genson_schema_builder(obj)
    )

`Regex` `dataclass`

Bases: Term

Class representing a regular expression.

Parameters:

Name	Type	Description	Default
`pattern`	`str`	The regular expression as a string.	required

Source code in outlines/types/dsl.py

@dataclass
class Regex(Term):
    """Class representing a regular expression.

    Parameters
    ----------
    pattern
        The regular expression as a string.

    """
    pattern: str

    def _display_node(self) -> str:
        return f"Regex('{self.pattern}')"

    def __repr__(self):
        return f"Regex(pattern='{self.pattern}')"

`Term`

Represents types defined with a regular expression.

Regex instances can be used as a type in a Pydantic model definittion. They will be translated to JSON Schema as a "string" field with the "pattern" keyword set to the regular expression this class represents. The class also handles validation.

Examples:

>>> from outlines.types import Regex
>>> from pydantic import BaseModel
>>>
>>> age_type = Regex("[0-9]+")
>>>
>>> class User(BaseModel):
>>>     name: str
>>>     age: age_type

Source code in outlines/types/dsl.py

class Term:
    """Represents types defined with a regular expression.

    `Regex` instances can be used as a type in a Pydantic model definittion.
    They will be translated to JSON Schema as a "string" field with the
    "pattern" keyword set to the regular expression this class represents. The
    class also handles validation.

    Examples
    --------

    >>> from outlines.types import Regex
    >>> from pydantic import BaseModel
    >>>
    >>> age_type = Regex("[0-9]+")
    >>>
    >>> class User(BaseModel):
    >>>     name: str
    >>>     age: age_type

    """

    def __add__(self: "Term", other: "Term") -> "Sequence":
        if is_str_instance(other):
            other = String(str(other))

        return Sequence([self, other])

    def __radd__(self: "Term", other: "Term") -> "Sequence":
        if is_str_instance(other):
            other = String(str(other))

        return Sequence([other, self])

    def __or__(self: "Term", other: "Term") -> "Alternatives":
        if is_str_instance(other):
            other = String(str(other))

        return Alternatives([self, other])

    def __ror__(self: "Term", other: "Term") -> "Alternatives":
        if is_str_instance(other):
            other = String(str(other))

        return Alternatives([other, self])

    def __get_validator__(self, _core_schema):
        def validate(input_value):
            return self.validate(input_value)

        return validate

    def __get_pydantic_core_schema__(
        self, source_type: Any, handler: GetCoreSchemaHandler
    ) -> cs.CoreSchema:
        return cs.no_info_plain_validator_function(lambda value: self.validate(value))

    def __get_pydantic_json_schema__(
        self, core_schema: cs.CoreSchema, handler: GetJsonSchemaHandler
    ) -> JsonSchemaValue:
        return {"type": "string", "pattern": to_regex(self)}

    def validate(self, value: str) -> str:
        pattern = to_regex(self)
        compiled = re.compile(pattern)
        if not compiled.fullmatch(str(value)):
            raise ValueError(
                f"Input should be in the language of the regular expression {pattern}"
            )
        return value

    def matches(self, value: str) -> bool:
        """Check that a given value is in the language defined by the Term.

        We make the assumption that the language defined by the term can
        be defined with a regular expression.

        """
        pattern = to_regex(self)
        compiled = re.compile(pattern)
        if compiled.fullmatch(str(value)):
            return True
        return False

    def display_ascii_tree(self, indent="", is_last=True) -> str:
        """Display the regex tree in ASCII format."""
        branch = "└── " if is_last else "├── "
        result = indent + branch + self._display_node() + "\n"

        # Calculate the new indent for children
        new_indent = indent + ("    " if is_last else "│   ")

        # Let each subclass handle its children
        result += self._display_children(new_indent)
        return result

    def _display_node(self):
        raise NotImplementedError

    def _display_children(self, indent: str) -> str:
        """Display the children of this node. Override in subclasses with children."""
        return ""

    def __str__(self):
        return self.display_ascii_tree()

    def optional(self) -> "Optional":
        return optional(self)

    def exactly(self, count: int) -> "QuantifyExact":
        return exactly(count, self)

    def at_least(self, count: int) -> "QuantifyMinimum":
        return at_least(count, self)

    def at_most(self, count: int) -> "QuantifyMaximum":
        return at_most(count, self)

    def between(self, min_count: int, max_count: int) -> "QuantifyBetween":
        return between(min_count, max_count, self)

    def one_or_more(self) -> "KleenePlus":
        return one_or_more(self)

    def zero_or_more(self) -> "KleeneStar":
        return zero_or_more(self)

`display_ascii_tree(indent='', is_last=True)`

Display the regex tree in ASCII format.

Source code in outlines/types/dsl.py

def display_ascii_tree(self, indent="", is_last=True) -> str:
    """Display the regex tree in ASCII format."""
    branch = "└── " if is_last else "├── "
    result = indent + branch + self._display_node() + "\n"

    # Calculate the new indent for children
    new_indent = indent + ("    " if is_last else "│   ")

    # Let each subclass handle its children
    result += self._display_children(new_indent)
    return result

`matches(value)`

Check that a given value is in the language defined by the Term.

We make the assumption that the language defined by the term can be defined with a regular expression.

Source code in outlines/types/dsl.py

def matches(self, value: str) -> bool:
    """Check that a given value is in the language defined by the Term.

    We make the assumption that the language defined by the term can
    be defined with a regular expression.

    """
    pattern = to_regex(self)
    compiled = re.compile(pattern)
    if compiled.fullmatch(str(value)):
        return True
    return False

`at_least(count, term)`

Repeat the term at least count times.

Source code in outlines/types/dsl.py

def at_least(count: int, term: Union[Term, str]) -> QuantifyMinimum:
    """Repeat the term at least `count` times."""
    term = String(term) if isinstance(term, str) else term
    return QuantifyMinimum(term, count)

`at_most(count, term)`

Repeat the term exactly count times.

Source code in outlines/types/dsl.py

def at_most(count: int, term: Union[Term, str]) -> QuantifyMaximum:
    """Repeat the term exactly `count` times."""
    term = String(term) if isinstance(term, str) else term
    return QuantifyMaximum(term, count)

`either(*terms)`

Represents an alternative between different terms or strings.

This factory function automatically translates string arguments into String objects.

Source code in outlines/types/dsl.py

def either(*terms: Union[str, Term]):
    """Represents an alternative between different terms or strings.

    This factory function automatically translates string arguments
    into `String` objects.

    """
    terms = [String(arg) if isinstance(arg, str) else arg for arg in terms]
    return Alternatives(terms)

`exactly(count, term)`

Repeat the term exactly count times.

Source code in outlines/types/dsl.py

def exactly(count: int, term: Union[Term, str]) -> QuantifyExact:
    """Repeat the term exactly `count` times."""
    term = String(term) if isinstance(term, str) else term
    return QuantifyExact(term, count)

`python_types_to_terms(ptype, recursion_depth=0)`

Convert Python types to Outlines DSL terms that constrain LLM output.

Parameters:

Name	Type	Description	Default
`ptype`	`Any`	The Python type to convert	required
`recursion_depth`	`int`	Current recursion depth to prevent infinite recursion	`0`

Returns:

Type	Description
`Term`	The corresponding DSL `Term` instance.

Source code in outlines/types/dsl.py

def python_types_to_terms(ptype: Any, recursion_depth: int = 0) -> Term:
    """Convert Python types to Outlines DSL terms that constrain LLM output.

    Parameters
    ----------
    ptype
        The Python type to convert
    recursion_depth
        Current recursion depth to prevent infinite recursion

    Returns
    -------
    Term
        The corresponding DSL `Term` instance.

    """
    if recursion_depth > 10:
        raise RecursionError(
            f"Maximum recursion depth exceeded when converting {ptype}. "
            "This might be due to a recursive type definition."
        )

    # First handle Term instances
    if isinstance(ptype, Term):
        return ptype

    # Basic types
    if is_int(ptype):
        return types.integer
    elif is_float(ptype):
        return types.number
    elif is_bool(ptype):
        return types.boolean
    elif is_str(ptype):
        return types.string
    elif is_native_dict(ptype):
        return CFG(grammars.json)
    elif is_time(ptype):
        return types.time
    elif is_date(ptype):
        return types.date
    elif is_datetime(ptype):
        return types.datetime

    # Basic type instances
    if is_str_instance(ptype):
        return String(ptype)
    elif is_int_instance(ptype) or is_float_instance(ptype):
        return Regex(str(ptype))

    # Structured types
    structured_type_checks = [
        lambda x: is_dataclass(x),
        lambda x: is_typed_dict(x),
        lambda x: is_pydantic_model(x),
    ]
    if any(check(ptype) for check in structured_type_checks):
        schema = TypeAdapter(ptype).json_schema()
        return JsonSchema(schema)

    elif is_genson_schema_builder(ptype):
        schema = ptype.to_json()
        return JsonSchema(schema)

    if is_enum(ptype):
        return Alternatives(
            [
                python_types_to_terms(member, recursion_depth + 1)
                for member in _get_enum_members(ptype)
            ]
        )

    args = get_args(ptype)
    if is_literal(ptype):
        return _handle_literal(args)
    elif is_union(ptype):
        return _handle_union(args, recursion_depth)
    elif is_typing_list(ptype):
        return _handle_list(args, recursion_depth)
    elif is_typing_tuple(ptype):
        return _handle_tuple(args, recursion_depth)
    elif is_typing_dict(ptype):
        return _handle_dict(args, recursion_depth)

    if is_callable(ptype):
        return JsonSchema(get_schema_from_signature(ptype))

    type_name = getattr(ptype, "__name__", ptype)
    raise TypeError(
        f"Type {type_name} is currently not supported. Please open an issue: "
        "https://github.com/dottxt-ai/outlines/issues"
    )

`to_regex(term)`

Convert a term to a regular expression.

We only consider self-contained terms that do not refer to another rule.

Parameters:

Name	Type	Description	Default
`term`	`Term`	The term to convert to a regular expression.	required

Returns:

Type	Description
`str`	The regular expression as a string.

Source code in outlines/types/dsl.py

def to_regex(term: Term) -> str:
    """Convert a term to a regular expression.

    We only consider self-contained terms that do not refer to another rule.

    Parameters
    ----------
    term
        The term to convert to a regular expression.

    Returns
    -------
    str
        The regular expression as a string.

    """
    if isinstance(term, String):
        return re.escape(term.value)
    elif isinstance(term, Regex):
        return f"({term.pattern})"
    elif isinstance(term, JsonSchema):
        regex_str = outlines_core.json_schema.build_regex_from_schema(term.schema, term.whitespace_pattern)
        return f"({regex_str})"
    elif isinstance(term, Choice):
        regexes = [to_regex(python_types_to_terms(item)) for item in term.items]
        return f"({'|'.join(regexes)})"
    elif isinstance(term, KleeneStar):
        return f"({to_regex(term.term)})*"
    elif isinstance(term, KleenePlus):
        return f"({to_regex(term.term)})+"
    elif isinstance(term, Optional):
        return f"({to_regex(term.term)})?"
    elif isinstance(term, Alternatives):
        regexes = [to_regex(subterm) for subterm in term.terms]
        return f"({'|'.join(regexes)})"
    elif isinstance(term, Sequence):
        regexes = [to_regex(subterm) for subterm in term.terms]
        return f"{''.join(regexes)}"
    elif isinstance(term, QuantifyExact):
        return f"({to_regex(term.term)}){{{term.count}}}"
    elif isinstance(term, QuantifyMinimum):
        return f"({to_regex(term.term)}){{{term.min_count},}}"
    elif isinstance(term, QuantifyMaximum):
        return f"({to_regex(term.term)}){{,{term.max_count}}}"
    elif isinstance(term, QuantifyBetween):
        return f"({to_regex(term.term)}){{{term.min_count},{term.max_count}}}"
    else:
        raise TypeError(
            f"Cannot convert object {repr(term)} to a regular expression."
        )

dsl

CFG dataclass

from_file(path) classmethod

Choice dataclass

JsonSchema

__init__(schema, whitespace_pattern=None, ensure_ascii=True)

convert_to(schema, target_types) classmethod

from_file(path) classmethod

is_json_schema(obj) classmethod

Regex dataclass

Term

display_ascii_tree(indent='', is_last=True)

matches(value)

at_least(count, term)

at_most(count, term)

either(*terms)

exactly(count, term)

python_types_to_terms(ptype, recursion_depth=0)

to_regex(term)

`CFG` `dataclass`

`from_file(path)` `classmethod`

`Choice` `dataclass`

`JsonSchema`

`init(schema, whitespace_pattern=None, ensure_ascii=True)`

`convert_to(schema, target_types)` `classmethod`

`from_file(path)` `classmethod`

`is_json_schema(obj)` `classmethod`

`Regex` `dataclass`

`Term`

`display_ascii_tree(indent='', is_last=True)`

`matches(value)`

`at_least(count, term)`

`at_most(count, term)`

`either(*terms)`

`exactly(count, term)`

`python_types_to_terms(ptype, recursion_depth=0)`

`to_regex(term)`