ommlds 0.0.0.dev440__py3-none-any.whl → 0.0.0.dev480__py3-none-any.whl

ommlds/_hacks/funcs.py

@@ -0,0 +1,110 @@
+import dataclasses as dc
+import linecache
+import textwrap
+import threading
+import types
+import typing as ta
+import uuid
+import warnings
+
+from omlish import check
+from omlish import lang
+
+from .names import NamespaceBuilder
+from .params import render_param_spec_call
+from .params import render_param_spec_def
+
+
+##
+
+
+@dc.dataclass()
+class _ReservedFilenameEntry:
+    unique_id: str
+    seq: int = 0
+
+
+_RESERVED_FILENAME_UUID_TLS = threading.local()
+
+
+def reserve_linecache_filename(prefix: str) -> str:
+    try:
+        e = _RESERVED_FILENAME_UUID_TLS.unique_id
+    except AttributeError:
+        e = _RESERVED_FILENAME_UUID_TLS.unique_id = _ReservedFilenameEntry(str(uuid.uuid4()))
+
+    while True:
+        unique_filename = f'<generated:{prefix}:{e.seq}>'
+        cache_line = (1, None, (e.unique_id,), unique_filename)
+        e.seq += 1
+        if linecache.cache.setdefault(unique_filename, cache_line) == cache_line:  # type: ignore
+            return unique_filename
+
+
+##
+
+
+def create_function(
+        name: str,
+        params: lang.CanParamSpec,
+        body: str,
+        *,
+        globals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+        locals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+        indent: str = '    ',
+) -> types.FunctionType:
+    params = lang.ParamSpec.of(params)
+    check.isinstance(body, str)
+    locals = dict(locals or {})  # noqa
+
+    nsb = NamespaceBuilder(reserved_names=set(locals) | set(globals or []))
+    sig = render_param_spec_def(params, nsb)
+    for k, v in nsb.items():
+        check.not_in(k, locals)
+        locals[k] = v
+
+    body_txt = '\n'.join([
+        f'def {name}{sig}:',
+        textwrap.indent(textwrap.dedent(body.strip()), indent),
+    ])
+
+    exec_txt = '\n'.join([
+        f'def __create_fn__({", ".join(locals.keys())}):',
+        textwrap.indent(body_txt, indent),
+        f'{indent}return {name}',
+    ])
+
+    ns: dict = {}
+    filename = reserve_linecache_filename(name)
+    bytecode = compile(exec_txt, filename, 'exec')
+    eval(bytecode, globals or {}, ns)  # type: ignore  # noqa
+
+    fn = ns['__create_fn__'](**locals)
+    fn.__source__ = body_txt
+    linecache.cache[filename] = (len(exec_txt), None, exec_txt.splitlines(True), filename)
+    return fn
+
+
+##
+
+
+def create_detour(
+        params: lang.CanParamSpec,
+        target: ta.Callable,
+        *,
+        as_kwargs: bool = False,
+) -> types.CodeType:
+    params = lang.ParamSpec.of(params)
+    check.callable(target)
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=SyntaxWarning)
+
+        gfn = create_function(
+            '_',
+            params,
+            f'return 1{render_param_spec_call(params, as_kwargs=as_kwargs)}',
+        )
+
+    check.state(gfn.__code__.co_consts[:2] == (None, 1))
+    return gfn.__code__.replace(co_consts=(None, target, *gfn.__code__.co_consts[2:]))

ommlds/_hacks/names.py

@@ -0,0 +1,158 @@
+"""
+TODO:
+ - releaseable names
+"""
+import string
+import typing as ta
+
+from omlish import check
+from omlish import collections as col
+
+
+##
+
+
+class NameGenerator(ta.Protocol):
+    def __call__(self, prefix: str = '') -> str: ...
+
+
+#
+
+
+class NameGeneratorImpl:
+    DEFAULT_PREFIX: ta.ClassVar[str] = '_'
+
+    def __init__(
+            self,
+            *,
+            reserved_names: ta.Iterable[str] | None = None,
+            global_prefix: str | None = None,
+            use_global_prefix_if_present: bool = False,
+            add_global_prefix_before_number: bool = False,
+    ) -> None:
+        super().__init__()
+
+        check.arg(not isinstance(reserved_names, str))
+        self._reserved_names = {check.isinstance(n, str) for n in (reserved_names or [])}
+        self._global_prefix = global_prefix if global_prefix is not None else self.DEFAULT_PREFIX
+        self._use_global_prefix_if_present = bool(use_global_prefix_if_present)
+        self._add_global_prefix_before_number = bool(add_global_prefix_before_number)
+
+        self._name_counts: dict[str, int] = {}
+
+    def __call__(self, prefix: str = '') -> str:
+        if self._use_global_prefix_if_present and prefix.startswith(self._global_prefix):
+            base_name = prefix
+        else:
+            base_name = self._global_prefix + prefix
+
+        base_count = -1
+        if base_name[-1] in string.digits:
+            i = len(base_name) - 2
+            while i >= 0 and base_name[i] in string.digits:
+                i -= 1
+            i += 1
+            base_count = int(base_name[i:])
+            base_name = base_name[:i]
+
+        if self._add_global_prefix_before_number:
+            if not (self._use_global_prefix_if_present and base_name.endswith(self._global_prefix)):
+                base_name += self._global_prefix
+
+        if base_count >= 0:
+            count = self._name_counts.setdefault(base_name, 0)
+            if base_count > count:
+                self._name_counts[base_name] = base_count
+
+        while True:
+            count = self._name_counts.get(base_name, 0)
+            self._name_counts[base_name] = count + 1
+            name = base_name + str(count)
+            if name not in self._reserved_names:
+                return name
+
+
+name_generator = NameGeneratorImpl
+
+
+##
+
+
+class NamespaceBuilder(ta.Mapping[str, ta.Any]):
+    def __init__(
+            self,
+            *,
+            reserved_names: ta.Iterable[str] | None = None,
+            name_generator: NameGenerator | None = None,  # noqa
+    ) -> None:
+        super().__init__()
+
+        self._reserved_names = {
+            check.isinstance(n, str)
+            for n in (check.not_isinstance(reserved_names, str) or [])
+        }
+        self._name_generator = check.callable(name_generator) if name_generator is not None else \
+            NameGeneratorImpl(reserved_names=self._reserved_names, use_global_prefix_if_present=True)
+
+        self._dct: ta.MutableMapping[str, ta.Any] = {}
+        self._dedupe_dct: ta.MutableMapping[ta.Any, str] = col.IdentityKeyDict()
+
+    @property
+    def reserved_names(self) -> ta.AbstractSet[str]:
+        return self._reserved_names
+
+    @property
+    def name_generator(self) -> NameGenerator:
+        return self._name_generator
+
+    def __getitem__(self, k: str) -> ta.Any:
+        return self._dct[k]
+
+    def __len__(self):
+        return len(self._dct)
+
+    def __iter__(self) -> ta.Iterator[str]:
+        return iter(self._dct)
+
+    def items(self) -> ta.ItemsView[str, ta.Any]:
+        return self._dct.items()
+
+    def put(
+            self,
+            value: ta.Any,
+            name: str | None = None,
+            *,
+            exact: bool = False,
+            dedupe: bool = False,
+    ) -> str:
+        check.arg(not (name is None and exact))
+        if name is not None:
+            check.isinstance(name, str)
+
+        if dedupe:
+            try:
+                return self._dedupe_dct[value]
+            except KeyError:
+                pass
+
+        if name is not None:
+            if name not in self._reserved_names:
+                try:
+                    existing = self._dct[name]
+                except KeyError:
+                    self._dct[name] = value
+                    if dedupe:
+                        self._dedupe_dct[value] = name
+                    return name
+                else:
+                    if existing is value:
+                        return name
+            if exact:
+                raise KeyError(name)
+
+        gen_name = self._name_generator(name or '')
+        check.not_in(gen_name, self._dct)
+        self._dct[gen_name] = value
+        if dedupe:
+            self._dedupe_dct[value] = gen_name
+        return gen_name

ommlds/_hacks/params.py

@@ -0,0 +1,73 @@
+import typing as ta
+
+from omlish import lang
+
+from .names import NamespaceBuilder
+
+
+##
+
+
+def render_param_spec_call(
+        params: lang.ParamSpec,
+        *,
+        as_kwargs: bool = False,
+) -> str:
+    src = ['(']
+
+    for i, p in enumerate(params):
+        if isinstance(p, lang.ParamSeparator):
+            continue
+
+        if i:
+            src.append(', ')
+
+        if as_kwargs:
+            if isinstance(p, lang.Param):
+                src.append(f'{p.name}={p.name}')
+            else:
+                raise TypeError(p)
+
+        else:
+            if isinstance(p, lang.ArgsParam):
+                src.append(f'*{p.name}')
+            elif isinstance(p, lang.KwargsParam):
+                src.append(f'**{p.name}')
+            elif isinstance(p, lang.PosOnlyParam):
+                src.append(p.name)
+            elif isinstance(p, lang.KwOnlyParam):
+                src.append(f'{p.name}={p.name}')
+            elif isinstance(p, lang.ValParam):
+                src.append(p.name)
+            else:
+                raise TypeError(p)
+
+    src.append(')')
+
+    return ''.join(src)
+
+
+def render_param_spec_def(
+        params: lang.ParamSpec,
+        nsb: NamespaceBuilder,
+        *,
+        return_ann: lang.Maybe[ta.Any] = lang.empty(),
+) -> str:
+    src = ['(']
+
+    for i, p in enumerate(params):
+        if i:
+            src.append(', ')
+
+        src.append(lang.param_render(
+            p,
+            render_annotation=lambda ann: nsb.put(ann, f'ann_{p.name}'),  # noqa
+            render_default=lambda dfl: nsb.put(dfl, f'dfl_{p.name}'),  # noqa
+        ))
+
+    src.append(')')
+
+    if return_ann.present:
+        src.append(f' -> {nsb.put(return_ann.must(), "ann_return")}')
+
+    return ''.join(src)

ommlds/_hacks/patches.py

@@ -1,7 +1,4 @@
 """
-Currently, and ideally, the only thing this codebase will ever interact with requiring these kinds of awful hacks is ML
-code - thus these 'helpers' are kept here, not in the core library.
-
 TODO:
  - patch lock
  - thread / context local gating

ommlds/backends/anthropic/protocol/_marshal.py

@@ -8,7 +8,7 @@ from .types import Content
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     for root_cls in [
         Content,
         Content.CacheControl,
@@ -17,7 +17,7 @@ def _install_standard_marshalling() -> None:
             msh.polymorphism_from_subclasses(
                 root_cls,
                 naming=msh.Naming.SNAKE,
-                strip_suffix='auto',
+                strip_suffix=msh.AutoStripSuffix,
             ),
             msh.FieldTypeTagging('type'),
         ))

ommlds/backends/anthropic/protocol/sse/_marshal.py

@@ -8,7 +8,7 @@ from .events import AnthropicSseDecoderEvents
 
 
 @lang.static_init
-def _install_standard_marshalling() -> None:
+def _install_standard_marshaling() -> None:
     for root_cls in [
         AnthropicSseDecoderEvents.Event,
         AnthropicSseDecoderEvents.ContentBlockStart.ContentBlock,

ommlds/backends/anthropic/protocol/sse/assemble.py

@@ -63,9 +63,10 @@ class AnthropicSseMessageAssembler(
         while True:
             ae: ta.Any = check.not_none((yield from self._next_event()))
             if isinstance(ae, AnthropicSseDecoderEvents.ContentBlockStart):
-                check.equal(ae.index, len(content))
+                # check.equal(ae.index, len(content))
                 c = yield from self._do_content_block(ae)
-                content.append(check.isinstance(c, Content))
+                if c is not None:
+                    content.append(check.isinstance(c, Content))
             elif isinstance(ae, AnthropicSseDecoderEvents.MessageDelta):
                 for k in ('stop_reason', 'stop_sequence'):
                     if (v := getattr(ae.delta, k)) is not None:
@@ -76,7 +77,7 @@ class AnthropicSseMessageAssembler(
             elif isinstance(ae, AnthropicSseDecoderEvents.MessageStop):
                 yield [Message(
                     id=ms.message.id,
-                    role=ms.message.role,
+                    role=ms.message.role,  # type: ignore[arg-type]
                     model=ms.message.model,
                     content=content,
                     stop_reason=dct['stop_reason'],
@@ -92,6 +93,8 @@ class AnthropicSseMessageAssembler(
             return (yield from self._do_text_content_block(cbs))
         elif isinstance(cbs.content_block, AnthropicSseDecoderEvents.ContentBlockStart.ToolUse):
             return (yield from self._do_tool_use_content_block(cbs))
+        elif isinstance(cbs.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Thinking):
+            return (yield from self._do_thinking_content_block(cbs))
         else:
             raise TypeError(cbs.content_block)
 
@@ -101,11 +104,11 @@ class AnthropicSseMessageAssembler(
         while True:
             ae: ta.Any = check.not_none((yield from self._next_event()))
             if isinstance(ae, AnthropicSseDecoderEvents.ContentBlockDelta):
-                check.equal(ae.index, cbs.index)
+                # check.equal(ae.index, cbs.index)
                 cdc = check.isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.TextDelta)
                 parts.append(cdc.text)
             elif isinstance(ae, AnthropicSseDecoderEvents.ContentBlockStop):
-                check.equal(ae.index, cbs.index)
+                # check.equal(ae.index, cbs.index)
                 return Text(''.join(parts))
             else:
                 raise TypeError(ae)
@@ -119,11 +122,11 @@ class AnthropicSseMessageAssembler(
         while True:
             ae: ta.Any = check.not_none((yield from self._next_event()))
             if isinstance(ae, AnthropicSseDecoderEvents.ContentBlockDelta):
-                check.equal(ae.index, cbs.index)
+                # check.equal(ae.index, cbs.index)
                 cdc = check.isinstance(ae.delta, AnthropicSseDecoderEvents.ContentBlockDelta.InputJsonDelta)
                 json_parts.append(cdc.partial_json)
             elif isinstance(ae, AnthropicSseDecoderEvents.ContentBlockStop):
-                check.equal(ae.index, cbs.index)
+                # check.equal(ae.index, cbs.index)
                 dj = ''.join(json_parts).strip()
                 if dj:
                     dd = check.isinstance(json.loads(dj), ta.Mapping)
@@ -138,3 +141,16 @@ class AnthropicSseMessageAssembler(
                 )
             else:
                 raise TypeError(ae)
+
+    def _do_thinking_content_block(self, cbs: AnthropicSseDecoderEvents.ContentBlockStart) -> ta.Any:
+        # csc = check.isinstance(cbs.content_block, AnthropicSseDecoderEvents.ContentBlockStart.Thinking)
+        while True:
+            ae: ta.Any = check.not_none((yield from self._next_event()))
+            if isinstance(ae, AnthropicSseDecoderEvents.ContentBlockDelta):
+                pass
+            elif isinstance(ae, AnthropicSseDecoderEvents.ContentBlockStop):
+                return None
+            else:
+                raise TypeError(ae)
+        return  # type: ignore  # noqa
+        yield  # noqa

ommlds/backends/anthropic/protocol/sse/events.py

@@ -80,6 +80,11 @@ class AnthropicSseDecoderEvents(lang.Namespace):
             name: str
             input: ta.Any
 
+        @dc.dataclass(frozen=True)
+        class Thinking(ContentBlock):
+            signature: str
+            thinking: str
+
         content_block: ContentBlock
         index: int
 
@@ -96,6 +101,14 @@ class AnthropicSseDecoderEvents(lang.Namespace):
         class InputJsonDelta(Delta):
             partial_json: str
 
+        @dc.dataclass(frozen=True)
+        class ThinkingDelta(Delta):
+            thinking: str
+
+        @dc.dataclass(frozen=True)
+        class SignatureDelta(Delta):
+            signature: str
+
         delta: Delta
         index: int
 

ommlds/backends/anthropic/protocol/types.py

@@ -1,3 +1,6 @@
+"""
+https://docs.claude.com/en/api/messages
+"""
 import typing as ta
 
 from omlish import dataclasses as dc
@@ -8,6 +11,22 @@ from omlish import marshal as msh
 ##
 
 
+def _set_class_marshal_options(cls):
+    msh.update_object_metadata(
+        cls,
+        field_defaults=msh.FieldMetadata(
+            options=msh.FieldOptions(
+                omit_if=lang.is_none,
+            ),
+        ),
+    )
+
+    return cls
+
+
+##
+
+
 class Content(lang.Abstract, lang.Sealed):
     class CacheControl(lang.Abstract, lang.Sealed):
         """https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching"""
@@ -18,7 +37,7 @@ class Content(lang.Abstract, lang.Sealed):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['cache_control'], omit_if=lang.is_none)
+@_set_class_marshal_options
 class Text(Content):
     text: str
 
@@ -28,7 +47,7 @@ class Text(Content):
 
 
 @dc.dataclass(frozen=True)
-@msh.update_fields_metadata(['cache_control'], omit_if=lang.is_none)
+@_set_class_marshal_options
 class ToolUse(Content):
     id: str
     name: str
@@ -40,6 +59,7 @@ class ToolUse(Content):
 
 
 @dc.dataclass(frozen=True)
+@_set_class_marshal_options
 class ToolResult(Content):
     tool_use_id: str
     content: str
@@ -49,7 +69,7 @@ class ToolResult(Content):
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-@msh.update_object_metadata(field_defaults=msh.FieldMetadata(options=msh.FieldOptions(omit_if=lang.is_none)))
+@_set_class_marshal_options
 class CacheCreation:
     ephemeral_5m_input_tokens: int | None = None
     ephemeral_1h_input_tokens: int | None = None
@@ -59,7 +79,7 @@ class CacheCreation:
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-@msh.update_object_metadata(field_defaults=msh.FieldMetadata(options=msh.FieldOptions(omit_if=lang.is_none)))
+@_set_class_marshal_options
 class Usage:
     input_tokens: int | None = None
     output_tokens: int | None = None
@@ -75,15 +95,15 @@ class Usage:
 
 
 @dc.dataclass(frozen=True, kw_only=True)
-@msh.update_object_metadata(field_defaults=msh.FieldMetadata(options=msh.FieldOptions(omit_if=lang.is_none)))
+@_set_class_marshal_options
 class Message:
     id: str | None = None
 
-    role: str | None = None
+    role: ta.Literal['user', 'assistant']
 
     model: str | None = None
 
-    content: ta.Sequence[Content] | None = None
+    content: str | ta.Sequence[Content] | None = None
 
     stop_reason: str | None = None
     stop_sequence: str | None = None
@@ -95,6 +115,7 @@ class Message:
 
 
 @dc.dataclass(frozen=True)
+@_set_class_marshal_options
 class ToolSpec:
     name: str
     description: str
@@ -105,7 +126,7 @@ class ToolSpec:
 
 
 @dc.dataclass(frozen=True)
-@msh.update_object_metadata(field_defaults=msh.FieldMetadata(options=msh.FieldOptions(omit_if=lang.is_none)))
+@_set_class_marshal_options
 class MessagesRequest:
     model: str
 
@@ -113,7 +134,7 @@ class MessagesRequest:
 
     _: dc.KW_ONLY
 
-    system: ta.Sequence[Content] | None = None
+    system: str | ta.Sequence[Content] | None = None
 
     tools: ta.Sequence[ToolSpec] | None = None
 

ommlds/backends/google/protocol/__init__.py

@@ -0,0 +1,3 @@
+from omlish import marshal as _msh  # noqa
+
+_msh.register_global_module_import('._marshal', __package__)

ommlds/backends/google/protocol/_marshal.py

@@ -0,0 +1,16 @@
+from omlish import lang
+from omlish import marshal as msh
+
+from .types import Value
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    msh.install_standard_factories(
+        *msh.standard_polymorphism_factories(
+            msh.polymorphism_from_subclasses(Value),
+        ),
+    )