omlish 0.0.0.dev272__tar.gz → 0.0.0.dev274__tar.gz

{omlish-0.0.0.dev272/omlish.egg-info → omlish-0.0.0.dev274}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev272
+Version: 0.0.0.dev274
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/README.rst

@@ -3,7 +3,24 @@ It's like my previous python monorepo-ey thing `omnibus
 
 Core packages begin with ``om``, scratch app is in ``app``, temp / dump code is in ``x``.
 
-Core packages installable from git via:
+----
+
+The core packages are:
+
+omlish
+  core foundational code
+omdev
+  development utilities
+omserv
+  production web server
+ominfra
+  infrastructure and cloud code
+ommlx
+  ml / ai code
+
+----
+
+Core packages installable from pypi, or from git via:
 
 .. code-block::
 

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/.manifests.json

@@ -323,7 +323,7 @@
     "module": ".secrets.pwgen",
     "attr": "_CLI_MODULE",
     "file": "omlish/secrets/pwgen.py",
-    "line": 75,
+    "line": 78,
     "value": {
       "$omdev.cli.types.CliModule": {
         "cmd_name": "pwgen",

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev272'
-__revision__ = '77ed49b2a8b3f746064a52c4b81e1c02dba03a40'
+__version__ = '0.0.0.dev274'
+__revision__ = '198dbdd7a7fd13d7d9a6f0f3642a26adc79535ff'
 
 
 #

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/collections/identity.py

@@ -1,4 +1,3 @@
-import contextlib
 import operator as op
 import typing as ta
 import weakref
@@ -17,6 +16,7 @@ V = ta.TypeVar('V')
 class IdentityWrapper(ta.Generic[T]):
     def __init__(self, value: T) -> None:
         super().__init__()
+
         self._value = value
 
     def __repr__(self) -> str:
@@ -39,6 +39,7 @@ class IdentityWrapper(ta.Generic[T]):
 class IdentityKeyDict(ta.MutableMapping[K, V]):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__()
+
         self._dict: dict[int, tuple[K, V]] = {}
         for k, v in lang.yield_dict_init(*args, **kwargs):
             self[k] = v
@@ -75,6 +76,7 @@ class IdentityKeyDict(ta.MutableMapping[K, V]):
 class IdentitySet(ta.MutableSet[T]):
     def __init__(self, init: ta.Iterable[T] | None = None) -> None:
         super().__init__()
+
         self._dict: dict[int, T] = {}
         if init is not None:
             for item in init:
@@ -94,8 +96,10 @@ class IdentitySet(ta.MutableSet[T]):
         self._dict[id(item)] = item
 
     def discard(self, item: T) -> None:
-        with contextlib.suppress(KeyError):
+        try:
             del self._dict[id(item)]
+        except KeyError:
+            pass
 
     def update(self, items: ta.Iterable[T]) -> None:
         for item in items:
@@ -111,7 +115,26 @@ class IdentitySet(ta.MutableSet[T]):
         return iter(self._dict.values())
 
 
-class IdentityWeakSet(weakref.WeakSet):
-    def __init__(self, init=None):
+class IdentityWeakSet(ta.MutableSet[T]):
+    def __init__(self, init: ta.Iterable[T] | None = None) -> None:
         super().__init__()
-        self.data = IdentitySet(init)  # type: ignore
+
+        self._dict: weakref.WeakValueDictionary[int, T] = weakref.WeakValueDictionary()
+
+    def add(self, value):
+        self._dict[id(value)] = value
+
+    def discard(self, value):
+        try:
+            del self._dict[id(value)]
+        except KeyError:
+            pass
+
+    def __contains__(self, x):
+        return id(x) in self._dict
+
+    def __len__(self):
+        return len(self._dict)
+
+    def __iter__(self):
+        return self._dict.values()

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/dataclasses/impl/api.py

@@ -103,6 +103,7 @@ def dataclass(  # noqa
         cache_hash=MISSING,
         generic_init=MISSING,
         override=MISSING,
+        repr_id=MISSING,
 ):
     def wrap(cls):
         pkw = dict(
@@ -126,6 +127,7 @@ def dataclass(  # noqa
             cache_hash=cache_hash,
             generic_init=generic_init,
             override=override,
+            repr_id=repr_id,
         )))
         pex = ParamsExtras(**epk)
 
@@ -175,6 +177,7 @@ def make_dataclass(  # noqa
         cache_hash=MISSING,
         generic_init=MISSING,
         override=MISSING,
+        repr_id=MISSING,
 ):
     if namespace is None:
         namespace = {}
@@ -236,6 +239,7 @@ def make_dataclass(  # noqa
         cache_hash=cache_hash,
         generic_init=generic_init,
         override=override,
+        repr_id=repr_id,
     )
 
 
@@ -249,6 +253,7 @@ def extra_params(  # noqa
         cache_hash=MISSING,
         generic_init=MISSING,
         override=MISSING,
+        repr_id=MISSING,
 ):
     def inner(cls):
         if PARAMS_ATTR in cls.__dict__:
@@ -266,6 +271,7 @@ def extra_params(  # noqa
             cache_hash=cache_hash,
             generic_init=generic_init,
             override=override,
+            repr_id=repr_id,
         ))
 
         return cls

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/dataclasses/impl/params.py

@@ -93,6 +93,7 @@ class ParamsExtras(lang.Final):
     cache_hash: bool = False
     generic_init: bool = False
     override: bool = False
+    repr_id: bool = False
 
 
 DEFAULT_PARAMS_EXTRAS = ParamsExtras()

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/dataclasses/impl/reflect.py

@@ -149,16 +149,20 @@ class ClassInfo:
     def generic_mro_lookup(self) -> ta.Mapping[type, rfl.Type]:
         return col.make_map(((check.not_none(rfl.get_concrete_type(g)), g) for g in self.generic_mro), strict=True)
 
+    def generic_replaced_field_type(self, fn: str) -> rfl.Type:
+        f = self.fields[fn]
+        fo = self.field_owners[f.name]
+        go = self.generic_mro_lookup[fo]
+        tvr = rfl.get_type_var_replacements(go)
+        fty = rfl.type_(f.type)
+        rty = rfl.replace_type_vars(fty, tvr, update_aliases=True)
+        return rty
+
     @cached.property
     def generic_replaced_field_types(self) -> ta.Mapping[str, rfl.Type]:
         ret: dict[str, ta.Any] = {}
         for f in self.fields.values():
-            fo = self.field_owners[f.name]
-            go = self.generic_mro_lookup[fo]
-            tvr = rfl.get_type_var_replacements(go)
-            fty = rfl.type_(f.type)
-            rty = rfl.replace_type_vars(fty, tvr, update_aliases=True)
-            ret[f.name] = rty
+            ret[f.name] = self.generic_replaced_field_type(f.name)
         return ret
 
     @cached.property

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/dataclasses/impl/repr.py

@@ -12,11 +12,17 @@ from .utils import set_new_attribute
 def repr_fn(
         fields: ta.Sequence[dc.Field],
         globals: Namespace,  # noqa
+        *,
+        repr_id: bool = False,
 ) -> ta.Callable:
     locals: dict[str, ta.Any] = {}  # noqa
 
     fields = sorted(fields, key=lambda f: get_field_extras(f).repr_priority or 0)
 
+    prefix_src = '{self.__class__.__qualname__}'
+    if repr_id:
+        prefix_src += '@{hex(id(self))[2:]}'
+
     if any(get_field_extras(f).repr_fn is not None for f in fields):
         lst: list[str] = []
         for f in fields:
@@ -29,12 +35,12 @@ def repr_fn(
         src = [
             'l = []',
             *lst,
-            'return f"{self.__class__.__qualname__}({", ".join(l)})"',
+            f'return f"{prefix_src}({{", ".join(l)}})"',
         ]
 
     else:
         src = [
-            'return f"{self.__class__.__qualname__}(' +
+            f'return f"{prefix_src}(' +
             ', '.join([f'{f.name}={{self.{f.name}!r}}' for f in fields]) +
             ')"',
         ]
@@ -56,4 +62,5 @@ class ReprProcessor(Processor):
             return
 
         flds = [f for f in self._info.instance_fields if f.repr]
-        set_new_attribute(self._cls, '__repr__', repr_fn(flds, self._info.globals))  # noqa
+        rfn = repr_fn(flds, self._info.globals, repr_id=self._info.params_extras.repr_id)
+        set_new_attribute(self._cls, '__repr__', rfn)  # noqa

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/marshal/objects/dataclasses.py

@@ -72,9 +72,14 @@ def get_dataclass_field_infos(
         else:
             um_name = field.name
 
+        fmd: FieldMetadata | None = field.metadata.get(FieldMetadata)
+
         f_ty: ta.Any
-        if (cpx := dc_rf.cls_params_extras) is not None and cpx.generic_init:
-            f_ty = dc_rf.generic_replaced_field_annotations[field.name]
+        if (
+                ((cpx := dc_rf.cls_params_extras) is not None and cpx.generic_init) or
+                (fmd is not None and fmd.options.generic_replace)
+        ):
+            f_ty = rfl.to_annotation(dc_rf.generic_replaced_field_type(field.name))
         else:
             f_ty = type_hints[field.name]
 
@@ -91,7 +96,7 @@ def get_dataclass_field_infos(
         )
 
         has_set_name = False
-        if (fmd := field.metadata.get(FieldMetadata)) is not None:
+        if fmd is not None:
             fi_kw.update(
                 metadata=fmd,
             )

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/marshal/objects/metadata.py

@@ -22,6 +22,8 @@ class FieldOptions:
 
     embed: bool = False
 
+    generic_replace: bool = False
+
     no_marshal: bool = False
     no_unmarshal: bool = False
 

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/all.py

@@ -14,3 +14,11 @@ from .secrets import (  # noqa
     secret_field,
     secret_repr,
 )
+
+
+##
+
+
+from ..lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('..marshal', '.marshal', __package__)

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/marshal.py

@@ -16,6 +16,9 @@ from .secrets import SecretRef
 from .secrets import SecretRefOrStr
 
 
+##
+
+
 class StrOrSecretRefMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
     def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
         if isinstance(o, str):

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/pwgen.py

@@ -16,6 +16,9 @@ import string
 import typing as ta
 
 
+##
+
+
 CHAR_CLASSES: ta.Mapping[str, str] = {
     'lower': string.ascii_lowercase,
     'upper': string.ascii_uppercase,

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/pwhash.py

@@ -27,6 +27,9 @@ import hmac
 import secrets
 
 
+##
+
+
 SALT_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
 DEFAULT_PBKDF2_ITERATIONS = 600_000
 

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/ssl.py

@@ -3,6 +3,9 @@
 import dataclasses as dc
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class SslCert:
     key_file: str

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/subprocesses.py

@@ -9,6 +9,9 @@ import tempfile
 import typing as ta
 
 
+##
+
+
 class SubprocessFileInput(ta.NamedTuple):
     file_path: str
     pass_fds: ta.Sequence[int]

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/secrets/tempssl.py

@@ -12,6 +12,9 @@ from ..subprocesses.run import SubprocessRunOutput
 from .ssl import SslCert
 
 
+##
+
+
 class TempSslCert(ta.NamedTuple):
     cert: SslCert
     temp_dir: str

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/typedvalues/__init__.py

@@ -23,3 +23,11 @@ from .values import (  # noqa
 
     ScalarTypedValue,
 )
+
+
+##
+
+
+from ..lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('..marshal', '.marshal', __package__)

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/typedvalues/accessor.py

@@ -23,6 +23,13 @@ UniqueTypedValueU = ta.TypeVar('UniqueTypedValueU', bound='UniqueTypedValue')
 
 
 class TypedValuesAccessor(lang.Abstract, ta.Generic[TypedValueT]):
+    def __iter__(self):
+        raise TypeError(
+            'TypedValuesAccessor does not implement __iter__ - it is reserved for implementation by subclasses.',
+        )
+
+    #
+
     @ta.final
     def __contains__(self, cls: type[TypedValueU]) -> bool:
         raise NotImplementedError

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/typedvalues/collection.py

@@ -29,23 +29,27 @@ class TypedValues(
     ta.Generic[TypedValueT],
 ):
     def __init__(self, *tvs: TypedValueT, override: bool = False) -> None:
+        if hasattr(self, '_lst'):
+            # When __new__ returns the empty singleton __init__ will still be called.
+            return
+
         super().__init__()
 
         tmp: list = []
         udct: dict = {}
         for tv in tvs:
             if isinstance(tv, UniqueTypedValue):
-                uoc = tv._unique_typed_value_cls  # noqa
+                utvc = tv._unique_typed_value_cls  # noqa
                 if not override:
                     try:
-                        exu = udct[uoc]
+                        exu = udct[utvc]
                     except KeyError:
                         pass
                     else:
-                        raise DuplicateUniqueTypedValueError(uoc, tv, check.single(exu))
-                ulst = udct.setdefault(uoc, [])
+                        raise DuplicateUniqueTypedValueError(utvc, tv, check.single(exu))
+                ulst = udct.setdefault(utvc, [])
                 ulst.append(tv)
-                tmp.append((tv, len(ulst)))
+                tmp.append((utvc, tv, ulst, len(ulst)))
             elif isinstance(tv, TypedValue):
                 tmp.append(tv)
             else:
@@ -53,15 +57,15 @@ class TypedValues(
 
         lst: list = []
         dct: dict = {}
-        for tv in tmp:
-            if isinstance(tv, tuple):
-                uo, idx = tv  # type: ignore
-                ulst = udct[uo._unique_typed_value_cls]  # noqa
+        for obj in tmp:
+            if isinstance(obj, tuple):
+                utvc, tv, ulst, idx = obj
                 if idx == len(ulst):
-                    lst.append(uo)
-                    dct[uo._unique_typed_value_cls] = uo  # noqa
-                    dct[type(uo)] = uo
+                    lst.append(tv)
+                    dct[utvc] = tv
+                    dct[type(tv)] = tv
             else:
+                tv = obj
                 lst.append(tv)
                 dct.setdefault(type(tv), []).append(tv)
 
@@ -70,10 +74,34 @@ class TypedValues(
 
         self._any_dct: dict[type, ta.Sequence[ta.Any]] = {}
 
+    #
+
+    _EMPTY: ta.ClassVar['TypedValues']
+
+    @classmethod
+    def empty(cls) -> 'TypedValues':
+        return cls._EMPTY
+
+    def __new__(cls, *tvs, **kwargs):  # noqa
+        if not tvs:
+            try:
+                return cls._EMPTY
+            except AttributeError:
+                pass
+        return super().__new__(cls)
+
+    #
+
+    def with_(self, *tvs, override: bool = False) -> 'TypedValues':
+        return TypedValues(*self._lst, *tvs, override=override)
+
     def without(self, *tys: type) -> ta.Iterator[TypedValueT]:
         for o in self._lst:
-            if not isinstance(o, tys):
-                yield o
+            if isinstance(o, tys):
+                continue
+            yield o
+
+    #
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({", ".join(map(repr, self._lst))})'
@@ -122,3 +150,6 @@ class TypedValues(
         ret = [tv for tv in self if isinstance(tv, cls)]
         self._any_dct[cls] = ret
         return ret
+
+
+TypedValues._EMPTY = TypedValues()  # noqa

omlish-0.0.0.dev274/omlish/typedvalues/marshal.py

@@ -0,0 +1,139 @@
+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 omlish.funcs import match as mfs
+
+from .collection import TypedValues
+from .values import ScalarTypedValue
+from .values import TypedValue
+
+
+##
+
+
+def _build_typed_value_poly(rty: rfl.Type) -> msh.Polymorphism:
+    ty: type[TypedValue] = check.issubclass(check.isinstance(rty, type), TypedValue)
+    check.state(lang.is_abstract_class(ty))
+    return msh.polymorphism_from_subclasses(
+        ty,
+        naming=msh.Naming.SNAKE,
+        strip_suffix='auto',
+    )
+
+
+class TypedValueMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, type) and
+        issubclass(rty, ScalarTypedValue) and
+        not lang.is_abstract_class(rty)
+    ))
+    def _build_scalar(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        dc_rfl = dc.reflect(check.isinstance(rty, type))
+        v_rty = check.single(dc_rfl.generic_replaced_field_annotations.values())
+        v_m = ctx.make(v_rty)
+        return msh.WrappedMarshaler(lambda _, o: o.v, v_m)
+
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, type) and
+        issubclass(rty, TypedValue) and
+        lang.is_abstract_class(rty)
+    ))
+    def _build_abstract(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        return msh.make_polymorphism_marshaler(
+            _build_typed_value_poly(rty).impls,
+            msh.WrapperTypeTagging(),
+            ctx,
+        )
+
+
+class TypedValueUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, type) and
+        issubclass(rty, ScalarTypedValue) and
+        not lang.is_abstract_class(rty)
+    ))
+    def _build_scalar(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        rty = check.isinstance(rty, type)
+        dc_rfl = dc.reflect(rty)
+        v_rty = check.single(dc_rfl.generic_replaced_field_annotations.values())
+        v_u = ctx.make(v_rty)
+        return msh.WrappedUnmarshaler(lambda _, v: rty(v), v_u)
+
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, type) and
+        issubclass(rty, TypedValue) and
+        lang.is_abstract_class(rty)
+    ))
+    def _build_abstract(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        return msh.make_polymorphism_unmarshaler(
+            _build_typed_value_poly(rty).impls,
+            msh.WrapperTypeTagging(),
+            ctx,
+        )
+
+
+##
+
+
+def _build_typed_values_impls(rty: rfl.Type) -> msh.Impls:
+    gty = check.isinstance(rty, rfl.Generic)
+    check.is_(gty.cls, TypedValues)
+
+    opt_cls_set: set[type[TypedValue]] = set()
+
+    todo = [check.single(gty.args)]
+    seen = set()
+    while todo:
+        cur = todo.pop()
+        if cur in seen:
+            continue
+        seen.add(cur)
+
+        if isinstance(cur, rfl.Union):
+            todo.extend(cur.args)
+        else:
+            opt_cls_set.add(check.issubclass(check.isinstance(cur, type), TypedValue))
+
+    opt_impls: list[msh.Impl] = []
+    for opt_cls in opt_cls_set:
+        opt_impls.extend(_build_typed_value_poly(opt_cls).impls)
+
+    return msh.Impls(opt_impls)
+
+
+class TypedValuesMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
+    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        opt_m = msh.make_polymorphism_marshaler(
+            msh.Impls(_build_typed_values_impls(rty)),
+            msh.WrapperTypeTagging(),
+            ctx,
+        )
+        return msh.IterableMarshaler(opt_m)
+
+
+class TypedValuesUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: isinstance(rty, rfl.Generic) and rty.cls is TypedValues)
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        opt_u = msh.make_polymorphism_unmarshaler(
+            msh.Impls(_build_typed_values_impls(rty)),
+            msh.WrapperTypeTagging(),
+            ctx,
+        )
+        return msh.IterableUnmarshaler(lambda it: TypedValues(*it), opt_u)  # noqa
+
+
+##
+
+
+@lang.static_init
+def _install_standard_marshalling() -> None:
+    msh.install_standard_factories(
+        TypedValueMarshalerFactory(),
+        TypedValueUnmarshalerFactory(),
+
+        TypedValuesMarshalerFactory(),
+        TypedValuesUnmarshalerFactory(),
+    )

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish/typedvalues/values.py

@@ -14,6 +14,9 @@ class TypedValue(lang.Abstract):
     pass
 
 
+##
+
+
 class UniqueTypedValue(TypedValue, lang.Abstract):
     _unique_typed_value_cls: ta.ClassVar[type[TypedValue]]
 
@@ -29,6 +32,9 @@ class UniqueTypedValue(TypedValue, lang.Abstract):
                 raise TypeError(f'Class already has _unique_typed_value_cls: {cls}')
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(generic_init=True)
 class ScalarTypedValue(TypedValue, lang.Abstract, ta.Generic[T]):
@@ -36,3 +42,9 @@ class ScalarTypedValue(TypedValue, lang.Abstract, ta.Generic[T]):
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self.v!r})'
+
+    def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+
+        if UniqueTypedValue in (mro := cls.__mro__) and mro.index(ScalarTypedValue) > mro.index(UniqueTypedValue):
+            raise TypeError(f'Class {cls} must have UniqueTypedValue before ScalarTypedValue in mro')

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev272
+Version: 0.0.0.dev274
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev272 → omlish-0.0.0.dev274}/omlish.egg-info/SOURCES.txt

@@ -791,4 +791,5 @@ omlish/typedvalues/accessor.py
 omlish/typedvalues/collection.py
 omlish/typedvalues/generic.py
 omlish/typedvalues/holder.py
+omlish/typedvalues/marshal.py
 omlish/typedvalues/values.py