omlish 0.0.0.dev19__py3-none-any.whl → 0.0.0.dev21__py3-none-any.whl

omlish/lite/logs.py

@@ -69,8 +69,8 @@ class JsonLogFormatter(logging.Formatter):
 STANDARD_LOG_FORMAT_PARTS = [
     ('asctime', '%(asctime)-15s'),
     ('process', 'pid=%(process)-6s'),
-    ('thread', 'tid=%(thread)-10x'),
-    ('levelname', '%(levelname)-8s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
     ('name', '%(name)s'),
     ('separator', '::'),
     ('message', '%(message)s'),

omlish/lite/marshal.py

@@ -232,8 +232,10 @@ _OBJ_MARSHALER_GENERIC_MAPPING_TYPES: ta.Dict[ta.Any, type] = {
 
 _OBJ_MARSHALER_GENERIC_ITERABLE_TYPES: ta.Dict[ta.Any, type] = {
     **{t: t for t in (list, tuple, set, frozenset)},
-    **{t: frozenset for t in (collections.abc.Set, collections.abc.MutableSet)},
-    **{t: tuple for t in (collections.abc.Sequence, collections.abc.MutableSequence)},
+    collections.abc.Set: frozenset,
+    collections.abc.MutableSet: set,
+    collections.abc.Sequence: tuple,
+    collections.abc.MutableSequence: list,
 }
 
 

omlish/marshal/__init__.py

@@ -48,6 +48,10 @@ from .global_ import (  # noqa
     unmarshal,
 )
 
+from .helpers import (  # noqa
+    update_fields_metadata,
+)
+
 from .objects import (  # noqa
     FieldMetadata,
     ObjectMetadata,

omlish/marshal/dataclasses.py

@@ -31,10 +31,19 @@ def get_dataclass_metadata(ty: type) -> ObjectMetadata:
     ) or ObjectMetadata()
 
 
-def get_field_infos(ty: type, opts: col.TypeMap[Option] = col.TypeMap()) -> ta.Sequence[FieldInfo]:
+def get_field_infos(
+        ty: type,
+        opts: col.TypeMap[Option] = col.TypeMap(),
+) -> ta.Sequence[FieldInfo]:
     dc_md = get_dataclass_metadata(ty)
     dc_naming = dc_md.field_naming or opts.get(Naming)
 
+    fi_defaults = {
+        k: v
+        for k, v in dc.asdict(dc_md.field_defaults).items()
+        if v is not None
+    }
+
     type_hints = ta.get_type_hints(ty)
 
     ret: list[FieldInfo] = []
@@ -44,7 +53,8 @@ def get_field_infos(ty: type, opts: col.TypeMap[Option] = col.TypeMap()) -> ta.S
         else:
             um_name = field.name
 
-        kw = dict(
+        kw = dict(fi_defaults)
+        kw.update(
             name=field.name,
             type=type_hints[field.name],
             metadata=FieldMetadata(),
@@ -54,7 +64,10 @@ def get_field_infos(ty: type, opts: col.TypeMap[Option] = col.TypeMap()) -> ta.S
         )
 
         if (fmd := field.metadata.get(FieldMetadata)) is not None:
-            kw.update(metadata=fmd)
+            kw.update(
+                metadata=fmd,
+                omit_if=fmd.omit_if,
+            )
 
             if fmd.name is not None:
                 kw.update(

omlish/marshal/helpers.py

@@ -0,0 +1,22 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .objects import FieldMetadata
+
+
+T = ta.TypeVar('T')
+
+
+def update_fields_metadata(
+        fields: ta.Iterable[str] | None = None,
+        **kwargs: ta.Any,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(a: str, f: dc.Field) -> dc.Field:
+        return dc.update_field_metadata(f, {
+            FieldMetadata: dc.replace(
+                f.metadata.get(FieldMetadata, FieldMetadata()),
+                **kwargs,
+            ),
+        })
+
+    return dc.update_fields(inner, fields)

omlish/marshal/objects.py

@@ -22,18 +22,13 @@ from .values import Value
 ##
 
 
-@dc.dataclass(frozen=True)
-class ObjectMetadata:
-    field_naming: Naming | None = None
-
-    unknown_field: str | None = None
-
-
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class FieldMetadata:
     name: str | None = None
     alts: ta.Iterable[str] | None = None
 
+    omit_if: ta.Callable[[ta.Any], bool] | None = None
+
     marshaler: Marshaler | None = None
     marshaler_factory: MarshalerFactory | None = None
 
@@ -41,18 +36,30 @@ class FieldMetadata:
     unmarshaler_factory: UnmarshalerFactory | None = None
 
 
+@dc.dataclass(frozen=True, kw_only=True)
+class ObjectMetadata:
+    field_naming: Naming | None = None
+
+    unknown_field: str | None = None
+
+    field_defaults: FieldMetadata = FieldMetadata()
+
+
 ##
 
 
-@dc.dataclass(frozen=True)
+@dc.dataclass(frozen=True, kw_only=True)
 class FieldInfo:
     name: str
     type: ta.Any
-    metadata: FieldMetadata
 
     marshal_name: str
     unmarshal_names: ta.Sequence[str]
 
+    metadata: FieldMetadata = FieldMetadata()
+
+    omit_if: ta.Callable[[ta.Any], bool] | None = None
+
 
 ##
 
@@ -63,15 +70,20 @@ class ObjectMarshaler(Marshaler):
     unknown_field: str | None = None
 
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        ret = {
-            fi.marshal_name: m.marshal(ctx, getattr(o, fi.name))
-            for fi, m in self.fields
-        }
+        ret = {}
+        for fi, m in self.fields:
+            v = getattr(o, fi.name)
+            if fi.omit_if is not None and fi.omit_if(v):
+                continue
+            ret[fi.marshal_name] = m.marshal(ctx, v)
+
         if self.unknown_field is not None:
             if (ukf := getattr(o, self.unknown_field)):
                 if (dks := set(ret) & set(ukf)):
                     raise KeyError(f'Unknown field keys duplicate fields: {dks!r}')
+
             ret.update(ukf)  # FIXME: marshal?
+
         return ret
 
 
@@ -89,18 +101,25 @@ class ObjectUnmarshaler(Unmarshaler):
         u: ta.Any
         kw: dict[str, ta.Any] = {}
         ukf: dict[str, ta.Any] | None = None
+
         if self.unknown_field is not None:
             kw[self.unknown_field] = ukf = {}
+
         for k, mv in ma.items():
             ks = check.isinstance(k, str)
+
             try:
                 fi, u = self.fields_by_unmarshal_name[ks]
+
             except KeyError:
                 if ukf is not None:
                     ukf[ks] = mv  # FIXME: unmarshal?
                     continue
                 raise
+
             if fi.name in kw:
                 raise KeyError(f'Duplicate keys for field {fi.name!r}: {ks!r}')
+
             kw[fi.name] = u.unmarshal(ctx, mv)
+
         return self.cls(**kw)

omlish/multiprocessing.py

@@ -9,6 +9,7 @@ import time
 import typing as ta
 
 from . import check
+from . import lang
 from . import libc
 
 
@@ -18,21 +19,47 @@ T = ta.TypeVar('T')
 ##
 
 
+@ta.runtime_checkable
+class ValueProxy(ta.Protocol[T]):
+    # value = property(get, set)
+
+    def get(self) -> T:
+        ...
+
+    def set(self, value: T) -> None:
+        ...
+
+
+@dc.dataclass()
+@lang.protocol_check(ValueProxy)
+class DummyValueProxy(ValueProxy[T]):
+    value: T
+
+    def get(self) -> T:
+        return self.value
+
+    def set(self, value: T) -> None:
+        self.value = value
+
+
+##
+
+
 @dc.dataclass(frozen=True, kw_only=True)
 class SpawnExtras:
-    fds: ta.AbstractSet[int] | None = None
+    pass_fds: ta.AbstractSet[int] | None = None
     deathsig: int | None = None
 
 
 class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
     def __init__(self, process_obj: 'ExtrasSpawnProcess', *, extras: SpawnExtras) -> None:
         self.__extras = extras
-        self.__extra_fds = extras.fds
+        self.__pass_fds = extras.pass_fds
         super().__init__(process_obj)
 
     def _launch(self, process_obj: 'ExtrasSpawnProcess') -> None:
-        if self.__extra_fds:
-            for fd in self.__extra_fds:
+        if self.__pass_fds:
+            for fd in self.__pass_fds:
                 self.duplicate_for_child(fd)
             self._extra_fds = None
 
@@ -75,6 +102,11 @@ class Deathpact(abc.ABC):
         raise NotImplementedError
 
 
+class NopDeathpact(Deathpact):
+    def poll(self) -> None:
+        pass
+
+
 #
 
 

omlish/specs/jsonschema/keywords/__init__.py

@@ -0,0 +1,42 @@
+from .base import (  # noqa
+    Keyword,
+    Keywords,
+)
+
+from .core import (  # noqa
+    CoreKeyword,
+    Id,
+    Ref,
+    SchemaKeyword,
+)
+
+from .metadata import (  # noqa
+    Description,
+    MetadataKeyword,
+    Title,
+)
+
+from .parse import (  # noqa
+    parse_keyword,
+    parse_keywords,
+)
+
+from .render import (  # noqa
+    render_keyword,
+    render_keywords,
+)
+
+from .validation import (  # noqa
+    ExclusiveMaximum,
+    ExclusiveMinimum,
+    Items,
+    MaxItems,
+    Maximum,
+    MinItems,
+    Minimum,
+    Properties,
+    Required,
+    Type,
+    UniqueItems,
+    ValidationKeyword,
+)

omlish/specs/jsonschema/keywords/base.py

@@ -0,0 +1,86 @@
+import operator
+import typing as ta
+
+from omlish import cached
+from omlish import check
+from omlish import collections as col
+from omlish import dataclasses as dc
+from omlish import lang
+
+
+KeywordT = ta.TypeVar('KeywordT', bound='Keyword')
+
+
+##
+
+
+class Keyword(lang.Abstract, lang.PackageSealed):
+    tag: ta.ClassVar[str]
+
+    def __init_subclass__(cls, *, tag: str | None = None, **kwargs: ta.Any) -> None:
+        super().__init_subclass__(**kwargs)
+        check.not_in('tag', dir(cls))
+        if not lang.is_abstract_class(cls):
+            check.issubclass(cls, lang.Final)
+            cls.tag = check.non_empty_str(tag)
+        else:
+            check.none(tag)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Keywords(lang.Final):
+    lst: ta.Sequence[Keyword]
+
+    @cached.property
+    @dc.init
+    def by_type(self) -> ta.Mapping[type[Keyword], Keyword]:
+        return col.unique_map_by(type, self.lst, strict=True)  # noqa
+
+    @cached.property
+    @dc.init
+    def by_tag(self) -> ta.Mapping[str, Keyword]:
+        return col.unique_map_by(operator.attrgetter('tag'), self.lst, strict=True)  # noqa
+
+    def __getitem__(self, item: type[KeywordT] | str) -> KeywordT:
+        if isinstance(item, type):
+            return self.by_type[item]  # noqa
+        elif isinstance(item, str):
+            return self.by_tag[item]
+        else:
+            raise TypeError(item)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BooleanKeyword(Keyword, lang.Abstract):
+    b: bool
+
+
+@dc.dataclass(frozen=True)
+class NumberKeyword(Keyword, lang.Abstract):
+    n: int | float
+
+
+@dc.dataclass(frozen=True)
+class StrKeyword(Keyword, lang.Abstract):
+    s: str
+
+
+@dc.dataclass(frozen=True)
+class StrOrStrsKeyword(Keyword, lang.Abstract):
+    ss: str | ta.Sequence[str]
+
+
+@dc.dataclass(frozen=True)
+class KeywordsKeyword(Keyword, lang.Abstract):
+    kw: Keywords
+
+
+@dc.dataclass(frozen=True)
+class StrToKeywordsKeyword(Keyword, lang.Abstract):
+    m: ta.Mapping[str, Keywords]

omlish/specs/jsonschema/keywords/core.py

@@ -0,0 +1,26 @@
+from omlish import lang
+
+from .base import Keyword
+from .base import StrKeyword
+
+
+##
+
+
+class CoreKeyword(Keyword, lang.Abstract):
+    pass
+
+
+##
+
+
+class Id(StrKeyword, CoreKeyword, lang.Final, tag='$id'):
+    pass
+
+
+class SchemaKeyword(StrKeyword, CoreKeyword, lang.Final, tag='$schema'):
+    pass
+
+
+class Ref(StrKeyword, CoreKeyword, lang.Final, tag='$ref'):
+    pass

omlish/specs/jsonschema/keywords/metadata.py

@@ -0,0 +1,22 @@
+from omlish import lang
+
+from .base import Keyword
+from .base import StrKeyword
+
+
+##
+
+
+class MetadataKeyword(Keyword, lang.Abstract):
+    pass
+
+
+##
+
+
+class Title(StrKeyword, MetadataKeyword, lang.Final, tag='title'):
+    pass
+
+
+class Description(StrKeyword, MetadataKeyword, lang.Final, tag='description'):
+    pass

omlish/specs/jsonschema/keywords/parse.py

@@ -0,0 +1,69 @@
+import operator
+import typing as ta
+
+from omlish import check
+from omlish import collections as col
+from omlish import lang
+
+from . import core  # noqa
+from . import metadata  # noqa
+from . import validation  # noqa
+from .base import BooleanKeyword
+from .base import Keyword
+from .base import Keywords
+from .base import KeywordsKeyword
+from .base import NumberKeyword
+from .base import StrKeyword
+from .base import StrOrStrsKeyword
+from .base import StrToKeywordsKeyword
+
+
+KeywordT = ta.TypeVar('KeywordT', bound=Keyword)
+
+
+##
+
+
+KEYWORD_TYPES_BY_TAG: ta.Mapping[str, type[Keyword]] = col.unique_map_by(  # noqa
+    operator.attrgetter('tag'),
+    (cls for cls in lang.deep_subclasses(Keyword) if not lang.is_abstract_class(cls)),
+    strict=True,
+)
+
+
+def parse_keyword(cls: type[KeywordT], v: ta.Any) -> KeywordT:
+    if issubclass(cls, BooleanKeyword):
+        return cls(check.isinstance(v, bool))  # type: ignore
+
+    elif issubclass(cls, NumberKeyword):
+        return cls(check.isinstance(v, (int, float)))  # type: ignore
+
+    elif issubclass(cls, StrKeyword):
+        return cls(check.isinstance(v, str))  # type: ignore
+
+    elif issubclass(cls, StrOrStrsKeyword):
+        ss: str | ta.Sequence[str]
+        if isinstance(v, str):
+            ss = v
+        elif isinstance(v, ta.Iterable):
+            ss = col.seq_of(check.of_isinstance(str))(v)
+        else:
+            raise TypeError(v)
+        return cls(ss)  # type: ignore
+
+    elif issubclass(cls, KeywordsKeyword):
+        return cls(parse_keywords(v))  # type: ignore
+
+    elif issubclass(cls, StrToKeywordsKeyword):
+        return cls({k: parse_keywords(mv) for k, mv in v.items()})  # type: ignore
+
+    else:
+        raise TypeError(cls)
+
+
+def parse_keywords(dct: ta.Mapping[str, ta.Any]) -> Keywords:
+    lst: list[Keyword] = []
+    for k, v in dct.items():
+        cls = KEYWORD_TYPES_BY_TAG[k]
+        lst.append(parse_keyword(cls, v))
+    return Keywords(lst)

omlish/specs/jsonschema/keywords/render.py

@@ -0,0 +1,47 @@
+import typing as ta
+
+from .base import BooleanKeyword
+from .base import Keyword
+from .base import Keywords
+from .base import KeywordsKeyword
+from .base import NumberKeyword
+from .base import StrKeyword
+from .base import StrOrStrsKeyword
+from .base import StrToKeywordsKeyword
+
+
+def render_keyword(kw: Keyword) -> dict[str, ta.Any]:
+    if isinstance(kw, BooleanKeyword):
+        return {kw.tag: kw.b}
+
+    elif isinstance(kw, NumberKeyword):
+        return {kw.tag: kw.n}
+
+    elif isinstance(kw, StrKeyword):
+        return {kw.tag: kw.s}
+
+    elif isinstance(kw, StrOrStrsKeyword):
+        if isinstance(kw.ss, str):
+            return {kw.tag: kw.ss}
+        else:
+            return {kw.tag: list(kw.ss)}
+
+    elif isinstance(kw, KeywordsKeyword):
+        return {kw.tag: render_keywords(kw.kw)}
+
+    elif isinstance(kw, StrToKeywordsKeyword):
+        return {kw.tag: {k: render_keywords(v) for k, v in kw.m.items()}}
+
+    else:
+        raise TypeError(kw)
+
+
+def render_keywords(kws: Keywords) -> dict[str, ta.Any]:
+    dct: dict[str, ta.Any] = {}
+    for kw in kws.lst:
+        kwd = render_keyword(kw)
+        [(tag, val)] = kwd.items()
+        if tag in dct:
+            raise KeyError(tag)
+        dct[tag] = val
+    return dct

omlish/specs/jsonschema/keywords/validation.py

@@ -0,0 +1,68 @@
+from omlish import lang
+
+from .base import BooleanKeyword
+from .base import Keyword
+from .base import KeywordsKeyword
+from .base import NumberKeyword
+from .base import StrOrStrsKeyword
+from .base import StrToKeywordsKeyword
+
+
+##
+
+
+class ValidationKeyword(Keyword, lang.Abstract):
+    pass
+
+
+##
+
+
+class Type(StrOrStrsKeyword, ValidationKeyword, lang.Final, tag='type'):
+    pass
+
+
+class Items(KeywordsKeyword, ValidationKeyword, lang.Final, tag='items'):
+    pass
+
+
+class Required(StrOrStrsKeyword, ValidationKeyword, lang.Final, tag='required'):
+    pass
+
+
+class Properties(StrToKeywordsKeyword, ValidationKeyword, lang.Final, tag='properties'):
+    pass
+
+
+##
+
+
+class MaxItems(NumberKeyword, ValidationKeyword, lang.Final, tag='maxItems'):
+    pass
+
+
+class MinItems(NumberKeyword, ValidationKeyword, lang.Final, tag='minItems'):
+    pass
+
+
+class UniqueItems(BooleanKeyword, ValidationKeyword, lang.Final, tag='uniqueItems'):
+    pass
+
+
+#
+
+
+class Maximum(NumberKeyword, ValidationKeyword, lang.Final, tag='maximum'):
+    pass
+
+
+class ExclusiveMaximum(NumberKeyword, ValidationKeyword, lang.Final, tag='exclusiveMaximum'):
+    pass
+
+
+class Minimum(NumberKeyword, ValidationKeyword, lang.Final, tag='minimum'):
+    pass
+
+
+class ExclusiveMinimum(NumberKeyword, ValidationKeyword, lang.Final, tag='exclusiveMinimum'):
+    pass

omlish/specs/jsonschema/types.py

@@ -0,0 +1,21 @@
+import enum
+import typing as ta
+
+
+class JsonType(enum.Enum):
+    NULL = enum.auto()
+    BOOLEAN = enum.auto()
+    OBJECT = enum.auto()
+    ARRAY = enum.auto()
+    NUMBER = enum.auto()
+    STRING = enum.auto()
+
+
+TYPE_SETS_BY_JSON_TYPE: ta.Mapping[JsonType, ta.AbstractSet[type]] = {
+    JsonType.NULL: {type(None)},
+    JsonType.BOOLEAN: {bool},
+    JsonType.OBJECT: {dict},
+    JsonType.ARRAY: {list},
+    JsonType.NUMBER: {int, float},
+    JsonType.STRING: {str},
+}