ommlds 0.0.0.dev452__tar.gz → 0.0.0.dev454__tar.gz

{ommlds-0.0.0.dev452/ommlds.egg-info → ommlds-0.0.0.dev454}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev452
+Version: 0.0.0.dev454
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev452
-Requires-Dist: omlish==0.0.0.dev452
+Requires-Dist: omdev==0.0.0.dev454
+Requires-Dist: omlish==0.0.0.dev454
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

ommlds-0.0.0.dev454/ommlds/minichain/_marshal.py

@@ -0,0 +1,67 @@
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+from omlish import reflect as rfl
+from omlish.typedvalues.marshal import build_typed_values_marshaler
+from omlish.typedvalues.marshal import build_typed_values_unmarshaler
+
+from .json import JsonValue
+
+
+##
+
+
+@dc.dataclass()
+class _TypedValuesFieldMarshalerFactory(msh.MarshalerFactory):
+    tvs_rty: rfl.Type
+
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        return lambda: build_typed_values_marshaler(ctx, self.tvs_rty)
+
+
+@dc.dataclass()
+class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactory):
+    tvs_rty: rfl.Type
+
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        return lambda: build_typed_values_unmarshaler(ctx, self.tvs_rty)
+
+
+##
+
+
+class MarshalJsonValue(lang.NotInstantiable, lang.Final):
+    pass
+
+
+class _JsonValueMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not MarshalJsonValue:
+            return None
+        return lambda: msh.NopMarshalerUnmarshaler()
+
+
+class _JsonValueUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if rty is not MarshalJsonValue:
+            return None
+        return lambda: msh.NopMarshalerUnmarshaler()
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    msh.register_global_config(
+        JsonValue,
+        msh.ReflectOverride(MarshalJsonValue),
+        identity=True,
+    )
+
+    msh.install_standard_factories(
+        _JsonValueMarshalerFactory(),
+        _JsonValueUnmarshalerFactory(),
+    )

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/_typedvalues.py

@@ -74,12 +74,10 @@ def _tv_field_metadata(
                 omit_if=operator.not_,
             ),
             marshaler_factory=msh.FuncMarshalerFactory(
-                lambda ctx, rty: True,
-                lambda ctx, rty: _marshal._TypedValuesFieldMarshalerFactory(tvs_rty)(ctx, rty),  # noqa
+                lambda ctx, rty: _marshal._TypedValuesFieldMarshalerFactory(tvs_rty).make_marshaler(ctx, rty),  # noqa
             ),
             unmarshaler_factory=msh.FuncUnmarshalerFactory(
-                lambda ctx, rty: True,
-                lambda ctx, rty: _marshal._TypedValuesFieldUnmarshalerFactory(tvs_rty)(ctx, rty),  # noqa
+                lambda ctx, rty: _marshal._TypedValuesFieldUnmarshalerFactory(tvs_rty).make_unmarshaler(ctx, rty),  # noqa
             ),
         ),
     }

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/content/_marshal.py

@@ -6,7 +6,6 @@ from omlish import check
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .images import ImageContent  # noqa
 from .json import JsonContent  # noqa
@@ -53,10 +52,11 @@ class _ContentMarshaler(msh.Marshaler):
             raise TypeError(o)
 
 
-class _ContentMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _ContentMarshaler(ctx.make(ExtendedContent))
+class _ContentMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
+            return None
+        return lambda: _ContentMarshaler(ctx.make(ExtendedContent))
 
 
 @dc.dataclass(frozen=True)
@@ -74,10 +74,11 @@ class _ContentUnmarshaler(msh.Unmarshaler):
             raise TypeError(v)
 
 
-class _ContentUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _ContentUnmarshaler(ctx.make(ExtendedContent))
+class _ContentUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (rty is MarshalContent or rty == _MARSHAL_CONTENT_UNION_RTY):
+            return None
+        return lambda: _ContentUnmarshaler(ctx.make(ExtendedContent))
 
 
 ##
@@ -104,10 +105,11 @@ class _CanContentMarshaler(msh.Marshaler):
         return self.c.marshal(ctx, check.isinstance(o, CONTENT_RUNTIME_TYPES))
 
 
-class _CanContentMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _CanContentMarshaler(ctx.make(Content))
+class _CanContentMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+            return None
+        return lambda: _CanContentMarshaler(ctx.make(Content))
 
 
 @dc.dataclass(frozen=True)
@@ -118,10 +120,11 @@ class _CanContentUnmarshaler(msh.Unmarshaler):
         return self.c.unmarshal(ctx, v)
 
 
-class _CanContentUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _CanContentUnmarshaler(ctx.make(Content))
+class _CanContentUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not (rty is MarshalCanContent or rty == _MARSHAL_CAN_CONTENT_UNION_RTY):
+            return None
+        return lambda: _CanContentUnmarshaler(ctx.make(Content))
 
 
 ##

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/content/materialize.py

@@ -112,7 +112,7 @@ class ContentMaterializer:
         finally:
             self._cur_depth -= 1
 
-    @dispatch.method
+    @dispatch.method()
     def _materialize(self, o: CanContent) -> Content:
         raise TypeError(o)
 

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/content/transforms/interleave.py

@@ -33,7 +33,7 @@ class ContentInterleaver:
             cs = lang.interleave(cs, separator)
         return list(cs)
 
-    @dispatch.method
+    @dispatch.method()
     def interleave(self, c: Content) -> Content:
         return c
 

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/content/transforms/squeeze.py

@@ -22,7 +22,7 @@ class ContentSqueezer:
 
         self._strip_strings = strip_strings
 
-    @dispatch.method
+    @dispatch.method()
     def squeeze(self, c: Content) -> ta.Iterable[SingleContent]:
         raise TypeError(c)
 

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/content/transforms/stringify.py

@@ -24,7 +24,7 @@ class ContentStringWriter:
 
         self._out = out
 
-    @dispatch.method
+    @dispatch.method()
     def write(self, c: Content) -> None:
         raise TypeError(c)
 

ommlds-0.0.0.dev454/ommlds/minichain/llms/_marshal.py

@@ -0,0 +1,57 @@
+"""
+TODO:
+ - can this for reuse
+"""
+import typing as ta
+
+from omlish import check
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+from omlish import reflect as rfl
+
+from .tokens import Tokens
+
+
+##
+
+
+class TokensMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not Tokens:
+            return None
+
+        dc_rfl = dc.reflect(Tokens)
+        dc_f = check.single(dc_rfl.fields.values())
+        v_rty = rfl.type_(dc_f.type)
+        v_m = ctx.make(v_rty)
+        f_n = dc_f.name
+
+        def inner() -> msh.Marshaler:
+            return msh.WrappedMarshaler(lambda _, o: getattr(o, f_n), v_m)
+
+        return inner
+
+
+class TokensUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if rty is not Tokens:
+            return None
+
+        dc_rfl = dc.reflect(Tokens)
+        dc_f = check.single(dc_rfl.fields.values())
+        v_rty = rfl.type_(dc_f.type)
+        v_u = ctx.make(v_rty)
+
+        def inner() -> msh.Unmarshaler:
+            return msh.WrappedUnmarshaler(lambda _, v: Tokens(v), v_u)
+
+        return inner
+
+
+@lang.static_init
+def _install_standard_marshaling() -> None:
+    msh.install_standard_factories(
+        TokensMarshalerFactory(),
+        TokensUnmarshalerFactory(),
+    )

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/services/_marshal.py

@@ -57,26 +57,30 @@ class _RequestResponseMarshaler(msh.Marshaler):
         }
 
 
-class _RequestResponseMarshalerFactory(msh.SimpleMarshalerFactory):
-    def guard(self, ctx: msh.MarshalContext, rty: rfl.Type) -> bool:
-        return _is_rr_rty(rty)
+class _RequestResponseMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if not _is_rr_rty(rty):
+            return None
 
-    def fn(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
         if isinstance(rty, type):
             rty = rfl.type_(rfl.get_orig_class(rty))
-        if isinstance(rty, rfl.Generic):
-            v_rty, tv_rty = rty.args
-        else:
-            # FIXME: ...
-            raise TypeError(rty)
-        v_m: msh.Marshaler | None = None
-        if not isinstance(v_rty, ta.TypeVar):
-            v_m = ctx.make(v_rty)
-        return _RequestResponseMarshaler(
-            rty,
-            _get_tv_fld(rty),
-            v_m,
-        )
+
+        def inner() -> msh.Marshaler:
+            if isinstance(rty, rfl.Generic):
+                v_rty, tv_rty = rty.args
+            else:
+                # FIXME: ...
+                raise TypeError(rty)
+            v_m: msh.Marshaler | None = None
+            if not isinstance(v_rty, ta.TypeVar):
+                v_m = ctx.make(v_rty)
+            return _RequestResponseMarshaler(
+                rty,
+                _get_tv_fld(rty),
+                v_m,
+            )
+
+        return inner
 
 
 #
@@ -108,26 +112,29 @@ class _RequestResponseUnmarshaler(msh.Unmarshaler):
         return cty(v, tvs)  # type: ignore
 
 
-class _RequestResponseUnmarshalerFactory(msh.SimpleUnmarshalerFactory):
-    def guard(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> bool:
-        return _is_rr_rty(rty)
-
-    def fn(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        if isinstance(rty, rfl.Generic):
-            v_rty, tv_rty = rty.args
-        else:
-            # FIXME: ...
-            raise TypeError(rty)
-        tv_types_set = check.isinstance(tv_rty, rfl.Union).args
-        tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
-        tv_u = ctx.make(tv_ta)
-        v_u = ctx.make(v_rty)
-        return _RequestResponseUnmarshaler(
-            rty,
-            _get_tv_fld(rty),
-            v_u,
-            tv_u,
-        )
+class _RequestResponseUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if not _is_rr_rty(rty):
+            return None
+
+        def inner() -> msh.Unmarshaler:
+            if isinstance(rty, rfl.Generic):
+                v_rty, tv_rty = rty.args
+            else:
+                # FIXME: ...
+                raise TypeError(rty)
+            tv_types_set = check.isinstance(tv_rty, rfl.Union).args
+            tv_ta = tv.TypedValues[ta.Union[*tv_types_set]]  # type: ignore
+            tv_u = ctx.make(tv_ta)
+            v_u = ctx.make(v_rty)
+            return _RequestResponseUnmarshaler(
+                rty,
+                _get_tv_fld(rty),
+                v_u,
+                tv_u,
+            )
+
+        return inner
 
 
 ##

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds/minichain/vectors/_marshal.py

@@ -9,7 +9,6 @@ from omlish import check
 from omlish import lang
 from omlish import marshal as msh
 from omlish import reflect as rfl
-from omlish.funcs import match as mfs
 
 from .types import Vector
 
@@ -25,10 +24,11 @@ class _VectorMarshaler(msh.Marshaler):
         return self.et.marshal(ctx, list(map(float, check.isinstance(o, Vector))))
 
 
-class _VectorMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Vector)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return _VectorMarshaler(ctx.make(ta.Sequence[float]))
+class _VectorMarshalerFactory(msh.MarshalerFactory):
+    def make_marshaler(self, ctx: msh.MarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Marshaler] | None:
+        if rty is not Vector:
+            return None
+        return lambda: _VectorMarshaler(ctx.make(ta.Sequence[float]))
 
 
 @dc.dataclass(frozen=True)
@@ -39,10 +39,11 @@ class _VectorUnmarshaler(msh.Unmarshaler):
         return Vector(self.et.unmarshal(ctx, v))
 
 
-class _VectorUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is Vector)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return _VectorUnmarshaler(ctx.make(ta.Sequence[float]))
+class _VectorUnmarshalerFactory(msh.UnmarshalerFactory):
+    def make_unmarshaler(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> ta.Callable[[], msh.Unmarshaler] | None:
+        if rty is not Vector:
+            return None
+        return lambda: _VectorUnmarshaler(ctx.make(ta.Sequence[float]))
 
 
 ##

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454/ommlds.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommlds
-Version: 0.0.0.dev452
+Version: 0.0.0.dev454
 Summary: ommlds
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,8 +14,8 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omdev==0.0.0.dev452
-Requires-Dist: omlish==0.0.0.dev452
+Requires-Dist: omdev==0.0.0.dev454
+Requires-Dist: omlish==0.0.0.dev454
 Provides-Extra: all
 Requires-Dist: llama-cpp-python~=0.3; extra == "all"
 Requires-Dist: mlx~=0.29; extra == "all"

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/ommlds.egg-info/requires.txt

@@ -1,5 +1,5 @@
-omdev==0.0.0.dev452
-omlish==0.0.0.dev452
+omdev==0.0.0.dev454
+omlish==0.0.0.dev454
 
 [all]
 llama-cpp-python~=0.3

{ommlds-0.0.0.dev452 → ommlds-0.0.0.dev454}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev452'
+version = '0.0.0.dev454'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',
@@ -24,8 +24,8 @@ classifiers = [
 ]
 description = 'ommlds'
 dependencies = [
-    'omdev == 0.0.0.dev452',
-    'omlish == 0.0.0.dev452',
+    'omdev == 0.0.0.dev454',
+    'omlish == 0.0.0.dev454',
 ]
 
 [project.optional-dependencies]

ommlds-0.0.0.dev452/ommlds/minichain/_marshal.py

@@ -1,66 +0,0 @@
-from omlish import dataclasses as dc
-from omlish import lang
-from omlish import marshal as msh
-from omlish import reflect as rfl
-from omlish.funcs import match as mfs
-from omlish.typedvalues.marshal import build_typed_values_marshaler
-from omlish.typedvalues.marshal import build_typed_values_unmarshaler
-
-from .json import JsonValue
-
-
-##
-
-
-@dc.dataclass()
-class _TypedValuesFieldMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    tvs_rty: rfl.Type
-
-    @mfs.simple(lambda _, ctx, rty: True)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return build_typed_values_marshaler(ctx, self.tvs_rty)
-
-
-@dc.dataclass()
-class _TypedValuesFieldUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    tvs_rty: rfl.Type
-
-    @mfs.simple(lambda _, ctx, rty: True)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return build_typed_values_unmarshaler(ctx, self.tvs_rty)
-
-
-##
-
-
-class MarshalJsonValue(lang.NotInstantiable, lang.Final):
-    pass
-
-
-class _JsonValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalJsonValue)
-    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        return msh.NopMarshalerUnmarshaler()
-
-
-class _JsonValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
-    @mfs.simple(lambda _, ctx, rty: rty is MarshalJsonValue)
-    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        return msh.NopMarshalerUnmarshaler()
-
-
-##
-
-
-@lang.static_init
-def _install_standard_marshaling() -> None:
-    msh.register_global_config(
-        JsonValue,
-        msh.ReflectOverride(MarshalJsonValue),
-        identity=True,
-    )
-
-    msh.install_standard_factories(
-        _JsonValueMarshalerFactory(),
-        _JsonValueUnmarshalerFactory(),
-    )

ommlds-0.0.0.dev452/ommlds/minichain/llms/_marshal.py

@@ -1,49 +0,0 @@
-"""
-TODO:
- - can this for reuse
-"""
-from omlish import check
-from omlish import dataclasses as dc
-from omlish import lang
-from omlish import marshal as msh
-from omlish import reflect as rfl
-
-from .tokens import Tokens
-
-
-##
-
-
-class TokensMarshalerFactory(msh.SimpleMarshalerFactory):
-    def guard(self, ctx: msh.MarshalContext, rty: rfl.Type) -> bool:
-        return rty is Tokens
-
-    def fn(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
-        rty = check.isinstance(check.is_(rty, Tokens), type)
-        dc_rfl = dc.reflect(rty)
-        dc_f = check.single(dc_rfl.fields.values())
-        v_rty = rfl.type_(dc_f.type)
-        v_m = ctx.make(v_rty)
-        f_n = dc_f.name
-        return msh.WrappedMarshaler(lambda _, o: getattr(o, f_n), v_m)
-
-
-class TokensUnmarshalerFactory(msh.SimpleUnmarshalerFactory):
-    def guard(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> bool:
-        return rty is Tokens
-
-    def fn(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
-        rty = check.isinstance(check.is_(rty, Tokens), type)
-        dc_rfl = dc.reflect(rty)
-        dc_f = check.single(dc_rfl.fields.values())
-        v_rty = rfl.type_(dc_f.type)
-        v_u = ctx.make(v_rty)
-        return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
-
-
-@lang.static_init
-def _install_standard_marshaling() -> None:
-    msh.install_standard_factories(
-        TokensMarshalerFactory(),
-        TokensUnmarshalerFactory(),
-    )