omlish 0.0.0.dev227__py3-none-any.whl → 0.0.0.dev229__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev227'
-__revision__ = '2faa3e7f9120edd3e6dd79fad6401fd87d89f5cf'
+__version__ = '0.0.0.dev229'
+__revision__ = '646f2d8caaef32d279a6ebcfd121449752fbae93'
 
 
 #
@@ -79,7 +79,7 @@ class Project(ProjectBase):
         ],
 
         'secrets': [
-            'cryptography ~= 43.0',
+            'cryptography ~= 44.0',
         ],
 
         'sqlalchemy': [

omlish/diag/lsof.py

@@ -2,9 +2,6 @@
 # @omlish-lite
 """
 https://man7.org/linux/man-pages/man8/lsof.8.html
-
-Included in the process set are fields that identify the command, the process group IDentification (PGID) number, the
-task (thread) ID (TID), and the user ID (UID) number or login name.
 """
 import dataclasses as dc
 import enum
@@ -215,8 +212,7 @@ LsofItem._DEFAULT_PREFIXES = ''.join(LsofItem._FIELDS_BY_PREFIX)  # noqa
 
 
 @dc.dataclass(frozen=True)
-class \
-        LsofCommand(SubprocessRunnable[ta.List[LsofItem]]):
+class LsofCommand(SubprocessRunnable[ta.List[LsofItem]]):
     pid: ta.Optional[int] = None
     file: ta.Optional[str] = None
 
@@ -242,6 +238,9 @@ class \
         return LsofItem.from_prefix_lines(lines)
 
 
+##
+
+
 if __name__ == '__main__':
     def _main() -> None:
         argparse = __import__('argparse')

omlish/diag/ps.py

@@ -12,6 +12,9 @@ from ..subprocesses.run import SubprocessRunOutput
 from ..subprocesses.sync import subprocesses
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class PsItem:
     pid: int
@@ -43,6 +46,9 @@ class PsCommand(SubprocessRunnable):
         )
 
 
+##
+
+
 def get_ps_item(pid: int, timeout: ta.Optional[Timeout] = None) -> PsItem:
     return PsCommand(pid).run(subprocesses, timeout=timeout)
 
@@ -59,6 +65,9 @@ def get_ps_lineage(pid: int, timeout: ta.Optional[Timeout] = None) -> ta.List[Ps
     return ret
 
 
+##
+
+
 if __name__ == '__main__':
     def _main() -> None:
         print(get_ps_lineage(os.getpid()))

omlish/lite/timeouts.py

@@ -50,7 +50,7 @@ class Timeout(abc.ABC):
 
     @classmethod
     def _now(cls) -> float:
-        return time.time()
+        return time.monotonic()
 
     #
 

omlish/marshal/__init__.py

@@ -42,14 +42,11 @@ from .forbidden import (  # noqa
 from .global_ import (  # noqa
     GLOBAL_REGISTRY,
 
+    global_marshaler_factory,
     marshal,
-    unmarshal,
-)
 
-from .helpers import (  # noqa
-    update_field_metadata,
-    update_fields_metadata,
-    update_object_metadata,
+    global_unmarshaler_factory,
+    unmarshal,
 )
 
 from .naming import (  # noqa
@@ -62,31 +59,59 @@ from .nop import (  # noqa
     NopMarshalerUnmarshaler,
 )
 
-from .objects import (  # noqa
+from .objects.helpers import (  # noqa
+    update_field_metadata,
+    update_fields_metadata,
+    update_object_metadata,
+)
+
+from .objects.marshal import (  # noqa
+    ObjectMarshaler,
+    SimpleObjectMarshalerFactory,
+)
+
+from .objects.metadata import (  # noqa
     FieldInfo,
     FieldInfos,
     FieldMetadata,
     FieldOptions,
-    ObjectMarshaler,
     ObjectMetadata,
     ObjectSpecials,
+)
+
+from .objects.unmarshal import (  # noqa
     ObjectUnmarshaler,
-    SimpleObjectMarshalerFactory,
     SimpleObjectUnmarshalerFactory,
 )
 
-from .polymorphism import (  # noqa
+from .polymorphism.marshal import (  # noqa
+    PolymorphismMarshalerFactory,
+    make_polymorphism_marshaler,
+)
+
+from .polymorphism.metadata import (  # noqa
     Impl,
     Impls,
     Polymorphism,
-    PolymorphismMarshalerFactory,
+    polymorphism_from_subclasses,
+)
+
+from .polymorphism.unions import (  # noqa
+    PRIMITIVE_UNION_TYPES,
+    PolymorphismUnionMarshalerFactory,
+    PolymorphismUnionUnmarshalerFactory,
+    PrimitiveUnionMarshaler,
+    PrimitiveUnionMarshalerFactory,
+    PrimitiveUnionUnmarshaler,
+    PrimitiveUnionUnmarshalerFactory,
+)
+
+from .polymorphism.unmarshal import (  # noqa
     PolymorphismUnmarshalerFactory,
-    make_polymorphism_marshaler,
     make_polymorphism_unmarshaler,
-    polymorphism_from_subclasses,
 )
 
-from .primitives import (  # noqa
+from .singular.primitives import (  # noqa
     PRIMITIVE_TYPES,
 )
 
@@ -102,16 +127,6 @@ from .standard import (  # noqa
     new_standard_unmarshaler_factory,
 )
 
-from .unions import (  # noqa
-    PRIMITIVE_UNION_TYPES,
-    PolymorphismUnionMarshalerFactory,
-    PolymorphismUnionUnmarshalerFactory,
-    PrimitiveUnionMarshaler,
-    PrimitiveUnionMarshalerFactory,
-    PrimitiveUnionUnmarshaler,
-    PrimitiveUnionUnmarshalerFactory,
-)
-
 from .values import (  # noqa
     Value,
 )

omlish/marshal/{iterables.py → composite/iterables.py}

@@ -7,16 +7,16 @@ import dataclasses as dc
 import functools
 import typing as ta
 
-from .. import check
-from .. import reflect as rfl
-from ..funcs import match as mfs
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactoryMatchClass
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactoryMatchClass
-from .values import Value
+from ... import check
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactoryMatchClass
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactoryMatchClass
+from ..values import Value
 
 
 DEFAULT_ITERABLE_CONCRETE_TYPES: dict[type[collections.abc.Iterable], type[collections.abc.Iterable]] = {

omlish/marshal/{literals.py → composite/literals.py}

@@ -1,15 +1,15 @@
 import dataclasses as dc
 import typing as ta
 
-from .. import check
-from .. import reflect as rfl
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .values import Value
+from ... import check
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..values import Value
 
 
 @dc.dataclass(frozen=True)

omlish/marshal/{mappings.py → composite/mappings.py}

@@ -2,16 +2,16 @@ import collections.abc
 import dataclasses as dc
 import typing as ta
 
-from .. import check
-from .. import reflect as rfl
-from ..funcs import match as mfs
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactoryMatchClass
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactoryMatchClass
-from .values import Value
+from ... import check
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactoryMatchClass
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactoryMatchClass
+from ..values import Value
 
 
 DEFAULT_MAPPING_CONCRETE_TYPES: dict[type[collections.abc.Mapping], type[collections.abc.Mapping]] = {

omlish/marshal/{maybes.py → composite/maybes.py}

@@ -5,17 +5,17 @@ TODO:
 import dataclasses as dc
 import typing as ta
 
-from .. import check
-from .. import lang
-from .. import reflect as rfl
-from ..funcs import match as mfs
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactoryMatchClass
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactoryMatchClass
-from .values import Value
+from ... import check
+from ... import lang
+from ... import reflect as rfl
+from ...funcs import match as mfs
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactoryMatchClass
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactoryMatchClass
+from ..values import Value
 
 
 @dc.dataclass(frozen=True)

omlish/marshal/{newtypes.py → composite/newtypes.py}

@@ -1,11 +1,11 @@
-from .. import check
-from .. import reflect as rfl
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
+from ... import check
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
 
 
 class NewtypeMarshalerFactory(MarshalerFactory):

omlish/marshal/{optionals.py → composite/optionals.py}

@@ -1,15 +1,15 @@
 import dataclasses as dc
 import typing as ta
 
-from .. import check
-from .. import reflect as rfl
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .values import Value
+from ... import check
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..values import Value
 
 
 @dc.dataclass(frozen=True)

omlish/marshal/objects/__init__.py

@@ -0,0 +1,7 @@
+"""
+TODO:
+ - cfg naming
+ - adapters for dataclasses / namedtuples / user objects (as configured)
+ - mro-merge ObjectMetadata
+ - key ordering override - like slice, -1 means last
+"""

omlish/marshal/{dataclasses.py → objects/dataclasses.py}

@@ -4,30 +4,30 @@ TODO:
 """
 import typing as ta
 
-from .. import check
-from .. import collections as col
-from .. import dataclasses as dc
-from .. import lang
-from .. import reflect as rfl
-from ..lite import marshal as lm
-from .base import MarshalContext
-from .base import Marshaler
-from .base import MarshalerFactory
-from .base import Option
-from .base import UnmarshalContext
-from .base import Unmarshaler
-from .base import UnmarshalerFactory
-from .naming import Naming
-from .naming import translate_name
-from .objects import DEFAULT_FIELD_OPTIONS
-from .objects import FIELD_OPTIONS_KWARGS
-from .objects import FieldInfo
-from .objects import FieldInfos
-from .objects import FieldMetadata
-from .objects import FieldOptions
-from .objects import ObjectMarshaler
-from .objects import ObjectMetadata
-from .objects import ObjectUnmarshaler
+from ... import check
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ...lite import marshal as lm
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import Option
+from ..base import UnmarshalContext
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..naming import Naming
+from ..naming import translate_name
+from .marshal import ObjectMarshaler
+from .metadata import DEFAULT_FIELD_OPTIONS
+from .metadata import FIELD_OPTIONS_KWARGS
+from .metadata import FieldInfo
+from .metadata import FieldInfos
+from .metadata import FieldMetadata
+from .metadata import FieldOptions
+from .metadata import ObjectMetadata
+from .unmarshal import ObjectUnmarshaler
 
 
 ##

omlish/marshal/{helpers.py → objects/helpers.py}

@@ -1,13 +1,16 @@
 import typing as ta
 
-from .. import dataclasses as dc
-from .objects import FieldMetadata
-from .objects import ObjectMetadata
+from ... import dataclasses as dc
+from .metadata import FieldMetadata
+from .metadata import ObjectMetadata
 
 
 T = ta.TypeVar('T')
 
 
+##
+
+
 def update_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
     @dc.field_modifier
     def inner(f: dc.Field) -> dc.Field:

omlish/marshal/objects/marshal.py

@@ -0,0 +1,108 @@
+import collections.abc
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import reflect as rfl
+from ..base import MarshalContext
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..values import Value
+from .metadata import FieldInfo
+from .metadata import FieldInfos
+from .metadata import ObjectSpecials
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ObjectMarshaler(Marshaler):
+    fields: ta.Sequence[tuple[FieldInfo, Marshaler]]
+
+    _: dc.KW_ONLY
+
+    specials: ObjectSpecials = ObjectSpecials()
+
+    attr_getter: ta.Callable[[ta.Any, str], ta.Any] | None = None
+
+    @classmethod
+    def make(
+            cls,
+            ctx: MarshalContext,
+            fis: FieldInfos,
+            **kwargs: ta.Any,
+    ) -> Marshaler:
+        fields = [
+            (fi, ctx.make(fi.type))
+            for fi in fis
+        ]
+
+        return cls(
+            fields,
+            **kwargs,
+        )
+
+    #
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        if (attr_getter := self.attr_getter) is None:
+            attr_getter = getattr
+
+        ret: dict[str, ta.Any] = {}
+        for fi, m in self.fields:
+            v = attr_getter(o, fi.name)
+
+            if fi.options.omit_if is not None and fi.options.omit_if(v):
+                continue
+
+            if fi.name in self.specials.set:
+                continue
+
+            mn = fi.marshal_name
+            if mn is None:
+                continue
+
+            mv = m.marshal(ctx, v)
+
+            if fi.options.embed:
+                for ek, ev in check.isinstance(mv, collections.abc.Mapping).items():
+                    ret[mn + check.non_empty_str(ek)] = ev
+
+            else:
+                ret[mn] = mv
+
+        if self.specials.unknown is not None:
+            if (ukf := attr_getter(o, self.specials.unknown)):
+                if (dks := set(ret) & set(ukf)):
+                    raise KeyError(f'Unknown field keys duplicate fields: {dks!r}')
+
+            ret.update(ukf)  # FIXME: marshal?
+
+        return ret
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class SimpleObjectMarshalerFactory(MarshalerFactory):
+    dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
+
+    _: dc.KW_ONLY
+
+    specials: ObjectSpecials = ObjectSpecials()
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, type) and rty in self.dct
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        ty = check.isinstance(rty, type)
+
+        fis = FieldInfos(self.dct[ty])
+
+        return ObjectMarshaler.make(
+            ctx,
+            fis,
+            specials=self.specials,
+        )

omlish/marshal/objects/metadata.py

@@ -0,0 +1,124 @@
+import typing as ta
+
+from ... import cached
+from ... import collections as col
+from ... import dataclasses as dc
+from ... import lang
+from ..base import Marshaler
+from ..base import MarshalerFactory
+from ..base import Unmarshaler
+from ..base import UnmarshalerFactory
+from ..naming import Naming
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldOptions:
+    omit_if: ta.Callable[[ta.Any], bool] | None = None
+
+    default: lang.Maybe[ta.Any] = dc.xfield(default=lang.empty(), check_type=lang.Maybe)
+
+    embed: bool = False
+
+    no_marshal: bool = False
+    no_unmarshal: bool = False
+
+
+DEFAULT_FIELD_OPTIONS = FieldOptions()
+FIELD_OPTIONS_KWARGS: frozenset[str] = frozenset(dc.fields_dict(FieldOptions).keys())
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldMetadata:
+    name: str | None = None
+    alts: ta.Iterable[str] | None = None
+
+    options: FieldOptions = DEFAULT_FIELD_OPTIONS
+
+    marshaler: Marshaler | None = dc.xfield(None, check_type=(Marshaler, None))
+    marshaler_factory: MarshalerFactory | None = None
+
+    unmarshaler: Unmarshaler | None = dc.xfield(None, check_type=(Unmarshaler, None))
+    unmarshaler_factory: UnmarshalerFactory | None = None
+
+    def update(self, **kwargs: ta.Any) -> 'FieldMetadata':
+        okw = {k: v for k, v in kwargs.items() if k in FIELD_OPTIONS_KWARGS}
+        mkw = {k: v for k, v in kwargs.items() if k not in FIELD_OPTIONS_KWARGS}
+        return dc.replace(
+            self,
+            **(dict(options=dc.replace(self.options, **okw)) if okw else {}),
+            **mkw,
+        )
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ObjectMetadata:
+    field_naming: Naming | None = None
+
+    unknown_field: str | None = None
+    source_field: str | None = None
+
+    @cached.property
+    def specials(self) -> 'ObjectSpecials':
+        return ObjectSpecials(
+            unknown=self.unknown_field,
+            source=self.source_field,
+        )
+
+    field_defaults: FieldMetadata = FieldMetadata()
+
+    ignore_unknown: bool = False
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class ObjectSpecials:
+    unknown: str | None = None
+    source: str | None = None
+
+    @cached.property
+    def set(self) -> frozenset[str]:
+        return frozenset(v for v in dc.asdict(self).values() if v is not None)
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class FieldInfo:
+    name: str
+    type: ta.Any
+
+    marshal_name: str | None
+    unmarshal_names: ta.Sequence[str]
+
+    metadata: FieldMetadata = FieldMetadata()
+
+    options: FieldOptions = FieldOptions()
+
+
+@dc.dataclass(frozen=True)
+class FieldInfos:
+    lst: ta.Sequence[FieldInfo]
+
+    def __iter__(self) -> ta.Iterator[FieldInfo]:
+        return iter(self.lst)
+
+    def __len__(self) -> int:
+        return len(self.lst)
+
+    @cached.property
+    @dc.init
+    def by_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((fi.name, fi) for fi in self), strict=True)
+
+    @cached.property
+    @dc.init
+    def by_marshal_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((fi.marshal_name, fi) for fi in self if fi.marshal_name is not None), strict=True)
+
+    @cached.property
+    @dc.init
+    def by_unmarshal_name(self) -> ta.Mapping[str, FieldInfo]:
+        return col.make_map(((n, fi) for fi in self for n in fi.unmarshal_names), strict=True)