Skip to content

dottxt

Integration with Dottxt's API.

AsyncDottxt

Bases: AsyncModel

Async thin wrapper around the dottxt.client.AsyncDotTxt client.

This wrapper is used to convert the input and output types specified by the users at a higher level to arguments to the dottxt.client.AsyncDotTxt client.

Source code in outlines/models/dottxt.py 
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
class AsyncDottxt(AsyncModel):
    """Async thin wrapper around the `dottxt.client.AsyncDotTxt` client.

    This wrapper is used to convert the input and output types specified by the
    users at a higher level to arguments to the `dottxt.client.AsyncDotTxt`
    client.

    """

    def __init__(
        self,
        client: "AsyncDottxtClient",
        model: Optional[str] = None,
    ):
        """
        Parameters
        ----------
        client
            A `dottxt.AsyncDotTxt` client.
        model
            The model identifier to use (e.g. ``"dottxt/dottxt-v1-alpha"``).

        """
        self.client = client
        self.model = model
        self.type_adapter = DottxtTypeAdapter()

    async def generate(
        self,
        model_input: str,
        output_type: Optional[Any] = None,
        **inference_kwargs: Any,
    ) -> str:
        """Generate text using Dottxt asynchronously.

        Parameters
        ----------
        model_input
            The prompt based on which the model will generate a response.
        output_type
            The desired format of the response generated by the model. The
            output type must be of a type that can be converted to a JSON
            schema.
        **inference_kwargs
            Additional keyword arguments to pass to the client.

        Returns
        -------
        str
            The text generated by the model as a JSON string.

        """
        prompt = self.type_adapter.format_input(model_input)
        json_schema = self.type_adapter.format_output_type(output_type)

        if "model" not in inference_kwargs and self.model is not None:
            inference_kwargs["model"] = self.model

        if "model" not in inference_kwargs:
            raise ValueError(
                "A model identifier is required. Pass it to `from_dottxt_async()` "
                "or as a `model=` keyword argument at generation time."
            )

        result = await self.client.generate(
            input=prompt,
            response_format=json_schema,
            **inference_kwargs,
        )
        return json.dumps(result)

    async def generate_batch(
        self,
        model_input,
        output_type=None,
        **inference_kwargs,
    ):
        raise NotImplementedError(
            "Dottxt does not support batch generation."
        )

    async def generate_stream(  # type: ignore[override]
        self,
        model_input,
        output_type=None,
        **inference_kwargs,
    ):
        raise NotImplementedError(
            "Dottxt does not support streaming. Call the model/generator for "
            + "regular generation instead."
        )
        yield  # makes this an async generator so `async for` can consume it

__init__(client, model=None)

Parameters:

Name Type Description Default
client AsyncDotTxt

A dottxt.AsyncDotTxt client.

 required
model Optional[str]

The model identifier to use (e.g. "dottxt/dottxt-v1-alpha").

 None
Source code in outlines/models/dottxt.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
def __init__(
    self,
    client: "AsyncDottxtClient",
    model: Optional[str] = None,
):
    """
    Parameters
    ----------
    client
        A `dottxt.AsyncDotTxt` client.
    model
        The model identifier to use (e.g. ``"dottxt/dottxt-v1-alpha"``).

    """
    self.client = client
    self.model = model
    self.type_adapter = DottxtTypeAdapter()

generate(model_input, output_type=None, **inference_kwargs) async

Generate text using Dottxt asynchronously.

Parameters:

Name Type Description Default
model_input str

The prompt based on which the model will generate a response.

 required
output_type Optional[Any]

The desired format of the response generated by the model. The output type must be of a type that can be converted to a JSON schema.

 None
**inference_kwargs Any

Additional keyword arguments to pass to the client.

 {}

Returns:

Type Description
str

The text generated by the model as a JSON string.
Source code in outlines/models/dottxt.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
async def generate(
    self,
    model_input: str,
    output_type: Optional[Any] = None,
    **inference_kwargs: Any,
) -> str:
    """Generate text using Dottxt asynchronously.

    Parameters
    ----------
    model_input
        The prompt based on which the model will generate a response.
    output_type
        The desired format of the response generated by the model. The
        output type must be of a type that can be converted to a JSON
        schema.
    **inference_kwargs
        Additional keyword arguments to pass to the client.

    Returns
    -------
    str
        The text generated by the model as a JSON string.

    """
    prompt = self.type_adapter.format_input(model_input)
    json_schema = self.type_adapter.format_output_type(output_type)

    if "model" not in inference_kwargs and self.model is not None:
        inference_kwargs["model"] = self.model

    if "model" not in inference_kwargs:
        raise ValueError(
            "A model identifier is required. Pass it to `from_dottxt_async()` "
            "or as a `model=` keyword argument at generation time."
        )

    result = await self.client.generate(
        input=prompt,
        response_format=json_schema,
        **inference_kwargs,
    )
    return json.dumps(result)

Dottxt

Bases: Model

Thin wrapper around the dottxt.client.DotTxt client.

This wrapper is used to convert the input and output types specified by the users at a higher level to arguments to the dottxt.client.DotTxt client.

Source code in outlines/models/dottxt.py 
 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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
class Dottxt(Model):
    """Thin wrapper around the `dottxt.client.DotTxt` client.

    This wrapper is used to convert the input and output types specified by the
    users at a higher level to arguments to the `dottxt.client.DotTxt` client.

    """

    def __init__(
        self,
        client: "DottxtClient",
        model: Optional[str] = None,
    ):
        """
        Parameters
        ----------
        client
            A `dottxt.DotTxt` client.
        model
            The model identifier to use (e.g. ``"dottxt/dottxt-v1-alpha"``).

        """
        self.client = client
        self.model = model
        self.type_adapter = DottxtTypeAdapter()

    def generate(
        self,
        model_input: str,
        output_type: Optional[Any] = None,
        **inference_kwargs: Any,
    ) -> str:
        """Generate text using Dottxt.

        Parameters
        ----------
        model_input
            The prompt based on which the model will generate a response.
        output_type
            The desired format of the response generated by the model. The
            output type must be of a type that can be converted to a JSON
            schema.
        **inference_kwargs
            Additional keyword arguments to pass to the client.

        Returns
        -------
        str
            The text generated by the model as a JSON string.

        """
        prompt = self.type_adapter.format_input(model_input)
        json_schema = self.type_adapter.format_output_type(output_type)

        if "model" not in inference_kwargs and self.model is not None:
            inference_kwargs["model"] = self.model

        if "model" not in inference_kwargs:
            raise ValueError(
                "A model identifier is required. Pass it to `from_dottxt()` "
                "or as a `model=` keyword argument at generation time."
            )

        result = self.client.generate(
            input=prompt,
            response_format=json_schema,
            **inference_kwargs,
        )
        return json.dumps(result)

    def generate_batch(
        self,
        model_input,
        output_type=None,
        **inference_kwargs,
    ):
        raise NotImplementedError(
            "Dottxt does not support batch generation."
        )

    def generate_stream(
        self,
        model_input,
        output_type=None,
        **inference_kwargs,
    ):
        raise NotImplementedError(
            "Dottxt does not support streaming. Call the model/generator for "
            + "regular generation instead."
        )

__init__(client, model=None)

Parameters:

Name Type Description Default
client DotTxt

A dottxt.DotTxt client.

 required
model Optional[str]

The model identifier to use (e.g. "dottxt/dottxt-v1-alpha").

 None
Source code in outlines/models/dottxt.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def __init__(
    self,
    client: "DottxtClient",
    model: Optional[str] = None,
):
    """
    Parameters
    ----------
    client
        A `dottxt.DotTxt` client.
    model
        The model identifier to use (e.g. ``"dottxt/dottxt-v1-alpha"``).

    """
    self.client = client
    self.model = model
    self.type_adapter = DottxtTypeAdapter()

generate(model_input, output_type=None, **inference_kwargs)

Generate text using Dottxt.

Parameters:

Name Type Description Default
model_input str

The prompt based on which the model will generate a response.

 required
output_type Optional[Any]

The desired format of the response generated by the model. The output type must be of a type that can be converted to a JSON schema.

 None
**inference_kwargs Any

Additional keyword arguments to pass to the client.

 {}

Returns:

Type Description
str

The text generated by the model as a JSON string.
Source code in outlines/models/dottxt.py 
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def generate(
    self,
    model_input: str,
    output_type: Optional[Any] = None,
    **inference_kwargs: Any,
) -> str:
    """Generate text using Dottxt.

    Parameters
    ----------
    model_input
        The prompt based on which the model will generate a response.
    output_type
        The desired format of the response generated by the model. The
        output type must be of a type that can be converted to a JSON
        schema.
    **inference_kwargs
        Additional keyword arguments to pass to the client.

    Returns
    -------
    str
        The text generated by the model as a JSON string.

    """
    prompt = self.type_adapter.format_input(model_input)
    json_schema = self.type_adapter.format_output_type(output_type)

    if "model" not in inference_kwargs and self.model is not None:
        inference_kwargs["model"] = self.model

    if "model" not in inference_kwargs:
        raise ValueError(
            "A model identifier is required. Pass it to `from_dottxt()` "
            "or as a `model=` keyword argument at generation time."
        )

    result = self.client.generate(
        input=prompt,
        response_format=json_schema,
        **inference_kwargs,
    )
    return json.dumps(result)

DottxtTypeAdapter

Bases: ModelTypeAdapter

Type adapter for the Dottxt model.

Source code in outlines/models/dottxt.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
class DottxtTypeAdapter(ModelTypeAdapter):
    """Type adapter for the `Dottxt` model."""

    def format_input(self, model_input: str) -> str:
        """Format the prompt to pass to the client.

        Parameters
        ----------
        model_input
            The input provided by the user.

        Returns
        -------
        str
            The input to pass to the client.

        """
        if isinstance(model_input, str):
            return model_input
        raise TypeError(
            f"The input type {model_input} is not available with Dottxt. "
            "The only available type is `str`."
        )

    def format_output_type(self, output_type: Optional[Any] = None) -> str:
        """Format the output type to pass to the client.

        Parameters
        ----------
        output_type
            The output type provided by the user.

        Returns
        -------
        str
            The output type to pass to the client as a JSON schema string.

        """
        if output_type is None:
            raise TypeError(
                "You must provide an output type. Dottxt only supports "
                "constrained generation."
            )
        elif isinstance(output_type, Regex):
            raise TypeError(
                "Regex-based structured outputs will soon be available with "
                "Dottxt. Use an open source model in the meantime."
            )
        elif isinstance(output_type, CFG):
            raise TypeError(
                "CFG-based structured outputs will soon be available with "
                "Dottxt. Use an open source model in the meantime."
            )
        elif JsonSchema.is_json_schema(output_type):
            return cast(str, JsonSchema.convert_to(output_type, ["str"]))
        else:
            type_name = getattr(output_type, "__name__", output_type)
            raise TypeError(
                f"The type `{type_name}` is not supported by Dottxt. "
                "Consider using a local mode instead."
            )

format_input(model_input)

Format the prompt to pass to the client.

Parameters:

Name Type Description Default
model_input str

The input provided by the user.

 required

Returns:

Type Description
str

The input to pass to the client.
Source code in outlines/models/dottxt.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def format_input(self, model_input: str) -> str:
    """Format the prompt to pass to the client.

    Parameters
    ----------
    model_input
        The input provided by the user.

    Returns
    -------
    str
        The input to pass to the client.

    """
    if isinstance(model_input, str):
        return model_input
    raise TypeError(
        f"The input type {model_input} is not available with Dottxt. "
        "The only available type is `str`."
    )

format_output_type(output_type=None)

Format the output type to pass to the client.

Parameters:

Name Type Description Default
output_type Optional[Any]

The output type provided by the user.

 None

Returns:

Type Description
str

The output type to pass to the client as a JSON schema string.
Source code in outlines/models/dottxt.py 
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
def format_output_type(self, output_type: Optional[Any] = None) -> str:
    """Format the output type to pass to the client.

    Parameters
    ----------
    output_type
        The output type provided by the user.

    Returns
    -------
    str
        The output type to pass to the client as a JSON schema string.

    """
    if output_type is None:
        raise TypeError(
            "You must provide an output type. Dottxt only supports "
            "constrained generation."
        )
    elif isinstance(output_type, Regex):
        raise TypeError(
            "Regex-based structured outputs will soon be available with "
            "Dottxt. Use an open source model in the meantime."
        )
    elif isinstance(output_type, CFG):
        raise TypeError(
            "CFG-based structured outputs will soon be available with "
            "Dottxt. Use an open source model in the meantime."
        )
    elif JsonSchema.is_json_schema(output_type):
        return cast(str, JsonSchema.convert_to(output_type, ["str"]))
    else:
        type_name = getattr(output_type, "__name__", output_type)
        raise TypeError(
            f"The type `{type_name}` is not supported by Dottxt. "
            "Consider using a local mode instead."
        )

from_dottxt(client, model=None)

Create an Outlines Dottxt or AsyncDottxt model instance from a dottxt.DotTxt or dottxt.AsyncDotTxt client instance.

Parameters:

Name Type Description Default
client Union[DotTxt, AsyncDotTxt]

A dottxt.DotTxt or dottxt.AsyncDotTxt client instance.

 required
model Optional[str]

The model identifier to use (e.g. "dottxt/dottxt-v1-alpha").

 None

Returns:

Type Description
Union[Dottxt, AsyncDottxt]

An Outlines Dottxt or AsyncDottxt model instance.
Source code in outlines/models/dottxt.py 
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
def from_dottxt(
    client: "Union[DottxtClient, AsyncDottxtClient]",
    model: Optional[str] = None,
) -> Union[Dottxt, AsyncDottxt]:
    """Create an Outlines `Dottxt` or `AsyncDottxt` model instance from a
    `dottxt.DotTxt` or `dottxt.AsyncDotTxt` client instance.

    Parameters
    ----------
    client
        A `dottxt.DotTxt` or `dottxt.AsyncDotTxt` client instance.
    model
        The model identifier to use (e.g. ``"dottxt/dottxt-v1-alpha"``).

    Returns
    -------
    Union[Dottxt, AsyncDottxt]
        An Outlines `Dottxt` or `AsyncDottxt` model instance.

    """
    from dottxt import AsyncDotTxt, DotTxt

    if isinstance(client, DotTxt):
        return Dottxt(client, model)
    elif isinstance(client, AsyncDotTxt):
        return AsyncDottxt(client, model)
    else:
        raise ValueError(
            "Invalid client type. The client must be an instance of "
            "`dottxt.DotTxt` or `dottxt.AsyncDotTxt`."
        )