ommlds 0.0.0.dev426__py3-none-any.whl → 0.0.0.dev485__py3-none-any.whl

ommlds/backends/openai/protocol/chatcompletion/response.py

@@ -1,5 +1,9 @@
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .._common import _set_class_marshal_options
 from ..completionusage import CompletionUsage
 from .tokenlogprob import ChatCompletionTokenLogprob
 
@@ -7,84 +11,106 @@ from .tokenlogprob import ChatCompletionTokenLogprob
 ##
 
 
-class ChatCompletionResponseAnnotationUrlCitation(ta.TypedDict):
-    end_index: int
-    start_index: int
-    title: str
-    url: str
-
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionResponseMessage(lang.Final):
+    content: str | None = None
+    refusal: str | None = None
+    role: ta.Literal['assistant'] = dc.xfield('assistant', repr=False)
 
-class ChatCompletionResponseAnnotation(ta.TypedDict):
-    type: ta.Literal['url_citation']
-    url_citation: ChatCompletionResponseAnnotationUrlCitation
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Annotation(lang.Final):
+        type: ta.Literal['url_citation'] = dc.xfield('url_citation', repr=False)
 
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class UrlCitation(lang.Final):
+            end_index: int
+            start_index: int
+            title: str
+            url: str
 
-#
+        url_citation: UrlCitation
 
+    annotations: ta.Sequence[Annotation] | None = None
 
-class ChatCompletionResponseAudio(ta.TypedDict):
-    id: str
-    data: str
-    expires_at: int
-    transcript: str
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Audio(lang.Final):
+        id: str
+        data: str
+        expires_at: int
+        transcript: str
 
+    audio: Audio | None = None
 
-#
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class ToolCall(lang.Final):
+        id: str
 
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Function(lang.Final):
+            arguments: str
+            name: str
 
-class ChatCompletionResponseMessageToolCallFunction(ta.TypedDict):
-    arguments: str
-    name: str
+        function: Function
 
+        type: ta.Literal['function'] = dc.xfield('function', repr=False)
 
-class ChatCompletionResponseMessageToolCall(ta.TypedDict):
-    id: str
-    function: ChatCompletionResponseMessageToolCallFunction
-    type: ta.Literal['function']
-
-
-class ChatCompletionResponseMessage(ta.TypedDict, total=False):
-    content: str
-    refusal: str
-    role: ta.Required[ta.Literal['assistant']]
-    annotations: ta.Sequence[ChatCompletionResponseAnnotation]
-    audio: ChatCompletionResponseAudio
-    tool_calls: ta.Sequence[ChatCompletionResponseMessageToolCall]
+    tool_calls: ta.Sequence[ToolCall] | None = None
 
 
 #
 
 
-class ChatCompletionResponseChoiceLogprobs(ta.TypedDict, total=False):
-    content: ta.Sequence[ChatCompletionTokenLogprob]
-    refusal: ta.Sequence[ChatCompletionTokenLogprob]
-
-
-class ChatCompletionResponseChoice(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionResponseChoice(lang.Final):
     finish_reason: ta.Literal[
         'stop',
         'length',
         'tool_calls',
         'content_filter',
     ]
+
     index: int
-    logprobs: ta.NotRequired[ChatCompletionResponseChoiceLogprobs]
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Logprobs(lang.Final):
+        content: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+        refusal: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+
+    logprobs: Logprobs | None = None
+
     message: ChatCompletionResponseMessage
 
 
 #
 
 
-class ChatCompletionResponse(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionResponse(lang.Final):
     id: str
+
     choices: ta.Sequence[ChatCompletionResponseChoice]
+
     created: int
+
     model: str
-    object: ta.Literal['chat.completion']
-    service_tier: ta.NotRequired[ta.Literal[
+
+    object: ta.Literal['chat.completion'] = dc.xfield('chat.completion', repr=False)
+
+    service_tier: ta.Literal[
         'auto',
         'default',
         'flex',
-    ]]
-    system_fingerprint: ta.NotRequired[str]
-    usage: ta.NotRequired[CompletionUsage]
+    ] | None = None
+
+    system_fingerprint: str | None = None
+
+    usage: CompletionUsage | None = None

ommlds/backends/openai/protocol/chatcompletion/responseformat.py

@@ -1,41 +1,48 @@
-# ruff: noqa: UP007 UP045
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
 
-##
+from .._common import _set_class_marshal_options
 
 
-class TextChatCompletionResponseFormat(ta.TypedDict):
-    type: ta.Literal['text']
+##
 
 
-#
+class ChatCompletionResponseFormat(lang.Abstract, lang.Sealed):
+    pass
 
 
-class JsonSchemaChatCompletionResponseFormatJsonSchema(ta.TypedDict, total=False):
-    name: ta.Required[str]
-    description: str
-    schema: ta.Mapping[str, ta.Any]
-    strict: bool
+#
 
 
-class JsonSchemaChatCompletionResponseFormat(ta.TypedDict):
-    json_schema: JsonSchemaChatCompletionResponseFormatJsonSchema
-    type: ta.Literal['json_schema']
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class TextChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    pass
 
 
 #
 
 
-class JsonObjectChatCompletionResponseFormat(ta.TypedDict):
-    type: ta.Literal['json_object']
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class JsonSchemaChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class JsonSchema(lang.Final):
+        name: str
+        description: str | None = None
+        schema: ta.Mapping[str, ta.Any] | None = None
+        strict: bool | None = None
+
+    json_schema: JsonSchema
 
 
 #
 
 
-ChatCompletionResponseFormat: ta.TypeAlias = ta.Union[
-    TextChatCompletionResponseFormat,
-    JsonSchemaChatCompletionResponseFormat,
-    JsonObjectChatCompletionResponseFormat,
-]
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class JsonObjectChatCompletionResponseFormat(ChatCompletionResponseFormat, lang.Final):
+    pass

ommlds/backends/openai/protocol/chatcompletion/tokenlogprob.py

@@ -1,17 +1,26 @@
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .._common import _set_class_marshal_options
+
 
 ##
 
 
-class ChatCompletionTokenLogprobTopLogprob(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionTokenLogprob(lang.Final):
     token: str
-    bytes: ta.NotRequired[ta.Sequence[int]]
+    bytes: ta.Sequence[int] | None = None
     logprob: float
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class TopLogprob(lang.Final):
+        token: str
+        bytes: ta.Sequence[int] | None = None
+        logprob: float
 
-class ChatCompletionTokenLogprob(ta.TypedDict):
-    token: str
-    bytes: ta.NotRequired[ta.Sequence[int]]
-    logprob: float
-    top_logprobs: ta.Sequence[ChatCompletionTokenLogprobTopLogprob]
+    top_logprobs: ta.Sequence[TopLogprob]

ommlds/backends/openai/protocol/completionusage.py

@@ -1,24 +1,33 @@
-import typing as ta
+from omlish import dataclasses as dc
+from omlish import lang
+
+from ._common import _set_class_marshal_options
 
 
 ##
 
 
-class CompletionUsageCompletionTokensDetails(ta.TypedDict, total=False):
-    accepted_prediction_tokens: int
-    audio_tokens: int
-    reasoning_tokens: int
-    rejected_prediction_tokens: int
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class CompletionUsage(lang.Final):
+    completion_tokens: int
+    prompt_tokens: int
+    total_tokens: int
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class CompletionTokensDetails(lang.Final):
+        accepted_prediction_tokens: int | None = None
+        audio_tokens: int | None = None
+        reasoning_tokens: int | None = None
+        rejected_prediction_tokens: int | None = None
 
-class CompletionUsagePromptTokensDetails(ta.TypedDict, total=False):
-    audio_tokens: int
-    cached_tokens: int
+    completion_tokens_details: CompletionTokensDetails | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class PromptTokensDetails(lang.Final):
+        audio_tokens: int | None = None
+        cached_tokens: int | None = None
 
-class CompletionUsage(ta.TypedDict):
-    completion_tokens: int
-    prompt_tokens: int
-    total_tokens: int
-    completion_tokens_details: ta.NotRequired[CompletionUsageCompletionTokensDetails]
-    prompt_tokens_details: ta.NotRequired[CompletionUsagePromptTokensDetails]
+    prompt_tokens_details: PromptTokensDetails | None = None

ommlds/backends/tavily/__init__.py

@@ -0,0 +1,7 @@
+from omlish import dataclasses as _dc  # noqa
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)