Skip to content

Outlines

Bases: PydanticEngine[PromptSignature, Result, Model, InferenceMode]

Engine for Outlines with multiple structured inference modes.

Source code in sieves/engines/outlines_.py 
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
class Outlines(PydanticEngine[PromptSignature, Result, Model, InferenceMode]):
    """Engine for Outlines with multiple structured inference modes."""

    @override
    @property
    def inference_modes(self) -> type[InferenceMode]:
        return InferenceMode

    @override
    def build_executable(
        self,
        inference_mode: InferenceMode,
        prompt_template: str | None,  # noqa: UP007
        prompt_signature: type[PromptSignature] | PromptSignature,
        fewshot_examples: Sequence[pydantic.BaseModel] = (),
    ) -> Executable[Result | None]:
        template = self._create_template(prompt_template)

        # Create Generator instance responsible for generating non-parsed text.
        if isinstance(prompt_signature, list):
            prompt_signature = Literal[*prompt_signature]

        if inference_mode == InferenceMode.regex:
            prompt_signature = outlines.types.Regex(prompt_signature)

        generator = outlines.Generator(self._model, output_type=prompt_signature, **self._init_kwargs)

        def execute(values: Sequence[dict[str, Any]]) -> Iterable[Result | None]:
            """Execute prompts with engine for given values.

            :param values: Values to inject into prompts.
            :return Iterable[Result | None]: Results for prompts. Results are None if corresponding prompt failed.
            """

            def generate(prompts: list[str]) -> Iterable[Result]:
                try:
                    results = generator.batch(prompts, **self._inference_kwargs)
                # Batch mode is not implemented for all Outlines wrappers. Fall back to single-prompt mode in that case.
                except NotImplementedError:

                    async def generate_async(prompt: str) -> Result | None:
                        """Generate result async.

                        :param prompt: Prompt to generate result for.
                        :return: Result for prompt. Results are None if corresponding prompt failed.
                        """
                        return generator(prompt, **self._inference_kwargs)

                    calls = [generate_async(prompt) for prompt in prompts]
                    results = asyncio.run(self._execute_async_calls(calls))

                if inference_mode == InferenceMode.json:
                    assert len(results) == len(prompts)
                    assert isinstance(prompt_signature, type) and issubclass(prompt_signature, pydantic.BaseModel)
                    yield from [prompt_signature.model_validate_json(result) for result in results]
                else:
                    yield from results

            yield from self._infer(
                generate,
                template,
                values,
                fewshot_examples,
            )

        return execute

generation_settings property

Return generation settings.

Returns:

Type Description
GenerationSettings

Generation settings.

model property

Return model instance.

Returns:

Type Description
EngineModel

Model instance.

__init__(model, generation_settings)

Initialize engine with model and generation settings.

Parameters:

Name Type Description Default
model EngineModel

Instantiated model instance.

 required
generation_settings GenerationSettings

Generation settings.

 required
Source code in sieves/engines/core.py 
37
38
39
40
41
42
43
44
45
46
47
def __init__(self, model: EngineModel, generation_settings: GenerationSettings):
    """Initialize engine with model and generation settings.

    :param model: Instantiated model instance.
    :param generation_settings: Generation settings.
    """
    self._model = model
    self._generation_settings = generation_settings
    self._inference_kwargs = generation_settings.inference_kwargs or {}
    self._init_kwargs = generation_settings.init_kwargs or {}
    self._strict_mode = generation_settings.strict_mode

convert_fewshot_examples(fewshot_examples) staticmethod

Convert few‑shot examples to dicts.

Parameters:

Name Type Description Default
fewshot_examples Sequence[BaseModel]

Fewshot examples to convert.

 required

Returns:

Type Description
list[dict[str, Any]]

Fewshot examples as dicts.
Source code in sieves/engines/core.py 
100
101
102
103
104
105
106
107
@staticmethod
def convert_fewshot_examples(fewshot_examples: Sequence[pydantic.BaseModel]) -> list[dict[str, Any]]:
    """Convert few‑shot examples to dicts.

    :param fewshot_examples: Fewshot examples to convert.
    :return: Fewshot examples as dicts.
    """
    return [fs_example.model_dump(serialize_as_any=True) for fs_example in fewshot_examples]