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

ommlds/backends/openai/protocol/_marshal.py

@@ -0,0 +1,27 @@
+from omlish import lang
+from omlish import marshal as msh
+
+from .chatcompletion.contentpart import ChatCompletionContentPart
+from .chatcompletion.message import ChatCompletionMessage
+from .chatcompletion.responseformat import ChatCompletionResponseFormat
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    for root_cls, tag_field in [
+        (ChatCompletionContentPart, 'type'),
+        (ChatCompletionMessage, 'role'),
+        (ChatCompletionResponseFormat, 'type'),
+    ]:
+        msh.install_standard_factories(*msh.standard_polymorphism_factories(
+            msh.polymorphism_from_subclasses(
+                root_cls,
+                naming=msh.Naming.SNAKE,
+                strip_suffix=msh.AutoStripSuffix,
+            ),
+            msh.FieldTypeTagging(tag_field),
+            unions='partial',
+        ))

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

@@ -1,71 +1,98 @@
 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
 
 
 ##
 
 
-class ChatCompletionChunkChoiceDeltaToolCallFunction(ta.TypedDict, total=False):
-    arguments: str
-    name: str
-
-
-class ChatCompletionChunkChoiceDeltaToolCall(ta.TypedDict):
-    index: int
-    id: ta.NotRequired[str]
-    function: ta.NotRequired[ChatCompletionChunkChoiceDeltaToolCallFunction]
-    type: ta.Literal['function']
-
-
-#
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionChunkChoiceDelta(lang.Final):
+    content: str | None = None
 
+    refusal: str | None = None
 
-class ChatCompletionChunkChoiceDelta(ta.TypedDict, total=False):
-    content: str
-    refusal: str
     role: ta.Literal[
         'developer',
         'system',
         'user',
         'assistant',
         'tool',
-    ]
-    tool_calls: ta.Sequence[ChatCompletionChunkChoiceDeltaToolCall]
+    ] | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    class ToolCall(lang.Final):
+        index: int
 
-#
+        id: str | None = None
+
+        @dc.dataclass(frozen=True, kw_only=True)
+        class Function(lang.Final):
+            arguments: str | None = None
+            name: str | None = None
+
+        function: Function | None = None
 
+        type: ta.Literal['function'] = dc.xfield('function', repr=False)
 
-class ChatCompletionChunkChoiceLogprobs(ta.TypedDict, total=False):
-    content: ta.Sequence[ChatCompletionTokenLogprob]
-    refusal: ta.Sequence[ChatCompletionTokenLogprob]
+    tool_calls: ta.Sequence[ToolCall] | None = None
+
+
+#
 
 
-class ChatCompletionChunkChoice(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionChunkChoice(lang.Final):
     delta: ChatCompletionChunkChoiceDelta
-    finish_reason: ta.NotRequired[ta.Literal[
+
+    finish_reason: ta.Literal[
         'stop',
         'length',
         'tool_calls',
         'content_filter',
-    ]]
+    ] | None = None
+
     index: int
-    logprobs: ta.NotRequired[ChatCompletionChunkChoiceLogprobs]
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    class Logprobs(lang.Final):
+        content: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+        refusal: ta.Sequence[ChatCompletionTokenLogprob] | None = None
+
+    logprobs: Logprobs | None = None
 
 
 #
 
 
-class ChatCompletionChunk(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionChunk(lang.Final):
     id: str
+
     choices: ta.Sequence[ChatCompletionChunkChoice]
+
     created: int
+
     model: str
-    object: ta.Literal['chat.completion.chunk']
-    service_tier: ta.NotRequired[ta.Literal[
+
+    object: ta.Literal['chat.completion.chunk'] = dc.xfield('chat.completion.chunk', repr=False)
+
+    service_tier: ta.Literal[
         'auto',
         'default',
         'flex',
-    ]]
-    system_fingerprint: ta.NotRequired[str]
+    ] | None = None
+
+    system_fingerprint: str | None = None
+
+    usage: CompletionUsage | None = None
+
+    obfuscation: str | None = None

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

@@ -1,77 +1,82 @@
-# 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 TextChatCompletionContentPart(ta.TypedDict):
-    text: str
-    type: ta.Literal['text']
+##
 
 
-#
+class ChatCompletionContentPart(lang.Abstract):
+    pass
 
 
-class ImageChatCompletionContentPartImageUrl(ta.TypedDict):
-    url: ta.Required[str]
-    detail: ta.NotRequired[ta.Literal[
-        'auto',
-        'low',
-        'high',
-    ]]
+#
 
 
-class ImageChatCompletionContentPart(ta.TypedDict):
-    image_url: ImageChatCompletionContentPartImageUrl
-    type: ta.Literal['image_url']
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class TextChatCompletionContentPart(ChatCompletionContentPart, lang.Final):
+    text: str
 
 
 #
 
 
-class FileChatCompletionContentPartFileInfo(ta.TypedDict, total=False):
-    file_data: str
-    file_id: str
-    filename: str
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class ImageUrlChatCompletionContentPart(ChatCompletionContentPart, lang.Final):
+    @dc.dataclass(frozen=True)
+    class ImageUrl(lang.Final):
+        url: str
+        detail: ta.Literal[
+            'auto',
+            'low',
+            'high',
+        ]
 
-
-class FileChatCompletionContentPart(ta.TypedDict):
-    file: FileChatCompletionContentPartFileInfo
-    type: ta.Literal['file']
+    image_url: ImageUrl
 
 
 #
 
 
-class InputAudioChatCompletionContentPartInputAudio(ta.TypedDict):
-    data: str
-    format: ta.Literal[
-        'wav',
-        'mp3',
-    ]
-
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class FileChatCompletionContentPart(ChatCompletionContentPart, lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    class File(lang.Final):
+        file_data: str | None = None
+        file_id: str | None = None
+        filename: str | None = None
 
-class InputAudioChatCompletionContentPart(ta.TypedDict):
-    input_audio: InputAudioChatCompletionContentPartInputAudio
-    type: ta.Literal['input_audio']
+    file: File
 
 
 #
 
 
-class RefusalChatCompletionContentPart(ta.TypedDict):
-    refusal: str
-    type: ta.Literal['refusal']
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class InputAudioChatCompletionContentPart(ChatCompletionContentPart, lang.Final):
+    @dc.dataclass(frozen=True)
+    @_set_class_marshal_options
+    class InputAudio(lang.Final):
+        data: str
+        format: ta.Literal[
+            'wav',
+            'mp3',
+        ]
+
+    input_audio: InputAudio
 
 
 #
 
 
-ChatCompletionContentPart: ta.TypeAlias = ta.Union[
-    TextChatCompletionContentPart,
-    ImageChatCompletionContentPart,
-    FileChatCompletionContentPart,
-    InputAudioChatCompletionContentPart,
-    RefusalChatCompletionContentPart,
-]
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class RefusalChatCompletionContentPart(ChatCompletionContentPart, lang.Final):
+    refusal: str

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

@@ -1,6 +1,9 @@
-# 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
 from .contentpart import ChatCompletionContentPart
 from .contentpart import RefusalChatCompletionContentPart
 from .contentpart import TextChatCompletionContentPart
@@ -9,83 +12,92 @@ from .contentpart import TextChatCompletionContentPart
 ##
 
 
-class DeveloperChatCompletionMessage(ta.TypedDict):
+class ChatCompletionMessage(lang.Abstract, lang.Sealed):
+    pass
+
+
+#
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class DeveloperChatCompletionMessage(ChatCompletionMessage, lang.Final):
     content: str | ta.Iterable[TextChatCompletionContentPart]
-    role: ta.Literal['developer']
-    name: ta.NotRequired[str]
+    name: str | None = None
 
 
 #
 
 
-class SystemChatCompletionMessage(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class SystemChatCompletionMessage(ChatCompletionMessage, lang.Final):
     content: str | ta.Iterable[TextChatCompletionContentPart]
-    role: ta.Literal['system']
-    name: ta.NotRequired[str]
+    name: str | None = None
 
 
 #
 
 
-class UserChatCompletionMessage(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class UserChatCompletionMessage(ChatCompletionMessage, lang.Final):
     content: str | ta.Iterable[ChatCompletionContentPart]
-    role: ta.Literal['user']
-    name: ta.NotRequired[str]
+    name: str | None = None
 
 
 #
 
 
-class AssistantChatCompletionMessageAudio(ta.TypedDict):
-    id: str
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class AssistantChatCompletionMessage(ChatCompletionMessage, lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Audio(lang.Final):
+        id: str
 
+    audio: Audio | None = None
 
-class AssistantChatCompletionMessageToolCallFunction(ta.TypedDict):
-    arguments: str
-    name: str
+    content: str | ta.Iterable[TextChatCompletionContentPart | RefusalChatCompletionContentPart] | None = None
 
+    name: str | None = None
 
-class AssistantChatCompletionMessageToolCall(ta.TypedDict):
-    id: str
-    function: AssistantChatCompletionMessageToolCallFunction
-    type: ta.Literal['function']
+    refusal: str | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class ToolCall(lang.Final):
+        id: str
 
-class AssistantChatCompletionMessage(ta.TypedDict, total=False):
-    role: ta.Required[ta.Literal['assistant']]
-    audio: AssistantChatCompletionMessageAudio
-    content: str | ta.Iterable[TextChatCompletionContentPart | RefusalChatCompletionContentPart]
-    name: str
-    refusal: str
-    tool_calls: ta.Iterable[AssistantChatCompletionMessageToolCall]
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Function(lang.Final):
+            arguments: str
+            name: str
+
+        function: Function
+
+        type: ta.Literal['function'] = dc.xfield('function', repr=False)
+
+    tool_calls: ta.Iterable[ToolCall] | None = None
 
 
 #
 
 
-class ToolChatCompletionMessage(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ToolChatCompletionMessage(ChatCompletionMessage, lang.Final):
     content: str | ta.Iterable[TextChatCompletionContentPart]
-    role: ta.Literal['tool']
     tool_call_id: str
 
 
 #
 
 
-class FunctionChatCompletionMessage(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class FunctionChatCompletionMessage(ChatCompletionMessage, lang.Final):
     content: str | None
     name: str
-    role: ta.Literal['function']
-
-
-#
-
-
-ChatCompletionMessage: ta.TypeAlias = ta.Union[
-    DeveloperChatCompletionMessage,
-    SystemChatCompletionMessage,
-    UserChatCompletionMessage,
-    AssistantChatCompletionMessage,
-    ToolChatCompletionMessage,
-    FunctionChatCompletionMessage,
-]

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

@@ -1,6 +1,10 @@
-# ruff: noqa: UP007 UP045
+# ruff: noqa: UP007
 import typing as ta
 
+from omlish import dataclasses as dc
+from omlish import lang
+
+from .._common import _set_class_marshal_options
 from .contentpart import TextChatCompletionContentPart
 from .message import ChatCompletionMessage
 from .responseformat import ChatCompletionResponseFormat
@@ -9,73 +13,85 @@ from .responseformat import ChatCompletionResponseFormat
 ##
 
 
-class ChatCompletionRequestWebSearchOptionsUserLocationApproximate(ta.TypedDict, total=False):
-    city: str
-    country: str
-    region: str
-    timezone: str
-
-
-class ChatCompletionRequestWebSearchOptionsUserLocation(ta.TypedDict):
-    approximate: ChatCompletionRequestWebSearchOptionsUserLocationApproximate
-    type: ta.Literal['approximate']
-
-
-class ChatCompletionRequestWebSearchOptions(ta.TypedDict, total=False):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionRequestWebSearchOptions(lang.Final):
     search_context_size: ta.Literal[
         'low',
         'medium',
         'high',
-    ]
-    user_location: ChatCompletionRequestWebSearchOptionsUserLocation
+    ] | None = None
 
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class UserLocation(lang.Final):
+        @dc.dataclass(frozen=True, kw_only=True)
+        @_set_class_marshal_options
+        class Approximate(lang.Final):
+            city: str | None = None
+            country: str | None = None
+            region: str | None = None
+            timezone: str | None = None
 
-#
+        approximate: Approximate
 
+        type: ta.Literal['approximate'] = dc.xfield('approximate', repr=False, kw_only=True)
 
-class ChatCompletionRequestPrediction(ta.TypedDict):
-    content: str | ta.Iterable[TextChatCompletionContentPart]
-    type: ta.Literal['content']
+    user_location: UserLocation | None = None
 
 
 #
 
 
-class ChatCompletionRequestToolFunction(ta.TypedDict, total=False):
-    name: ta.Required[str]
-    description: str
-    parameters: ta.Mapping[str, ta.Any]
-    strict: bool
-
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionRequestPrediction(lang.Final):
+    content: str | ta.Iterable[TextChatCompletionContentPart]
 
-class ChatCompletionRequestTool(ta.TypedDict):
-    function: ChatCompletionRequestToolFunction
-    type: ta.Literal['function']
+    type: ta.Literal['content'] = dc.xfield('content', repr=False, kw_only=True)
 
 
 #
 
 
-class ChatCompletionRequestStreamOptions(ta.TypedDict, total=False):
-    include_usage: bool
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class ChatCompletionRequestTool(lang.Final):
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class Function(lang.Final):
+        name: str
+        description: str | None = None
+        parameters: ta.Mapping[str, ta.Any] | None = None
+        strict: bool | None = None
+
+    function: Function
+
+    type: ta.Literal['function'] = dc.xfield('function', repr=False, kw_only=True)
 
 
 #
 
 
-class ChatCompletionRequestNamedToolChoiceFunction(ta.TypedDict):
-    name: str
+@dc.dataclass(frozen=True)
+@_set_class_marshal_options
+class ChatCompletionRequestNamedToolChoice(lang.Final):
+    @dc.dataclass(frozen=True)
+    @_set_class_marshal_options
+    class Function(lang.Final):
+        name: str
 
+    function: Function
 
-class ChatCompletionRequestNamedToolChoice(ta.TypedDict):
-    function: ChatCompletionRequestNamedToolChoiceFunction
-    type: ta.Literal['function']
+    type: ta.Literal['function'] = dc.xfield('function', repr=False, kw_only=True)
 
 
 #
 
 
-class ChatCompletionRequestAudio(ta.TypedDict):
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionRequestAudio(lang.Final):
     format: ta.Literal[
         'wav',
         'aac',
@@ -91,40 +107,68 @@ class ChatCompletionRequestAudio(ta.TypedDict):
 #
 
 
-class ChatCompletionRequest(ta.TypedDict, total=False):
-    messages: ta.Required[ta.Iterable[ChatCompletionMessage]]
-    model: ta.Required[str]
-    audio: ChatCompletionRequestAudio
-    frequency_penalty: float
-    logit_bias: ta.Mapping[str, int]
-    logprobs: bool
-    max_completion_tokens: int
-    max_tokens: int
-    metadata: ta.Mapping[str, str]
+@dc.dataclass(frozen=True, kw_only=True)
+@_set_class_marshal_options
+class ChatCompletionRequest(lang.Final):
+    messages: ta.Iterable[ChatCompletionMessage]
+
+    model: str
+
+    audio: ChatCompletionRequestAudio | None = None
+
+    frequency_penalty: float | None = None
+    logit_bias: ta.Mapping[str, int] | None = None
+    logprobs: bool | None = None
+
+    max_completion_tokens: int | None = None
+    max_tokens: int | None = None
+
+    metadata: ta.Mapping[str, str] | None = None
+
     modalities: ta.Sequence[ta.Literal[
         'text',
         'audio',
-    ]]
-    n: int
-    parallel_tool_calls: bool
-    prediction: ChatCompletionRequestPrediction
-    presence_penalty: float
+    ]] | None = None
+
+    n: int | None = None
+
+    parallel_tool_calls: bool | None = None
+
+    prediction: ChatCompletionRequestPrediction | None = None
+
+    presence_penalty: float | None = None
+
     reasoning_effort: ta.Literal[
         'low',
         'medium',
         'high',
-    ]
-    response_format: ChatCompletionResponseFormat
-    seed: int
+    ] | None = None
+
+    response_format: ChatCompletionResponseFormat | None = None
+
+    seed: int | None = None
+
     service_tier: ta.Literal[
         'auto',
         'default',
         'flex',
-    ]
-    stop: ta.Union[str, ta.Sequence[str], None]
-    store: bool
-    stream_options: ChatCompletionRequestStreamOptions
-    temperature: float
+    ] | None = None
+
+    stop: ta.Union[str, ta.Sequence[str], None] = None
+
+    store: bool | None = None
+
+    stream: bool | None = None
+
+    @dc.dataclass(frozen=True, kw_only=True)
+    @_set_class_marshal_options
+    class StreamOptions(lang.Final):
+        include_usage: bool | None = None
+
+    stream_options: StreamOptions | None = None
+
+    temperature: float | None = None
+
     tool_choice: ta.Union[
         ta.Literal[
             'none',
@@ -132,9 +176,13 @@ class ChatCompletionRequest(ta.TypedDict, total=False):
             'required',
         ],
         ChatCompletionRequestNamedToolChoice,
-    ]
-    tools: ta.Iterable[ChatCompletionRequestTool]
-    top_logprobs: int
-    top_p: float
-    user: str
-    web_search_options: ChatCompletionRequestWebSearchOptions
+    ] | None = None
+
+    tools: ta.Iterable[ChatCompletionRequestTool] | None = None
+
+    top_logprobs: int | None = None
+    top_p: float | None = None
+
+    user: str | None = None
+
+    web_search_options: ChatCompletionRequestWebSearchOptions | None = None