omlish 0.0.0.dev19__tar.gz → 0.0.0.dev20__tar.gz

{omlish-0.0.0.dev19/omlish.egg-info → omlish-0.0.0.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev19
+Version: 0.0.0.dev20
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -38,7 +38,7 @@ Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
 Requires-Dist: asyncpg~=0.29; python_version < "3.13" and extra == "all"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
-Requires-Dist: duckdb~=1.0; extra == "all"
+Requires-Dist: duckdb~=1.1; extra == "all"
 Requires-Dist: pytest~=8.0; extra == "all"
 Provides-Extra: async
 Requires-Dist: anyio~=4.4; extra == "async"
@@ -74,6 +74,6 @@ Requires-Dist: aiosqlite~=0.20; extra == "sql"
 Requires-Dist: asyncpg~=0.29; python_version < "3.13" and extra == "sql"
 Provides-Extra: sqlx
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqlx"
-Requires-Dist: duckdb~=1.0; extra == "sqlx"
+Requires-Dist: duckdb~=1.1; extra == "sqlx"
 Provides-Extra: testing
 Requires-Dist: pytest~=8.0; extra == "testing"

omlish-0.0.0.dev20/README.rst

@@ -0,0 +1,10 @@
+It's like my previous python monorepo-ey thing `omnibus
+<https://github.com/wrmsr/omnibus/tree/wrmsr_exp_split>`_... ish.
+
+Core packages begin with ``om``, scratch app is in ``app``, temp / dump code is in ``x``.
+
+Core packages installable from git via:
+
+.. code-block::
+
+  pip install 'git+https://github.com/wrmsr/omlish@master#subdirectory=.pkg/<pkg>'

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev19'
-__revision__ = '509bb451054d2d955e55cbcf1f271a9166a904eb'
+__version__ = '0.0.0.dev20'
+__revision__ = '56a3421b375112818e306f2c17d467c7aac1d26b'
 
 
 #
@@ -88,7 +88,7 @@ class Project(ProjectBase):
         'sqlx': [
             'sqlean.py ~= 3.45; python_version < "3.13"',
 
-            'duckdb ~= 1.0',
+            'duckdb ~= 1.1',
         ],
 
         'testing': [

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/asyncs/anyio.py

@@ -23,6 +23,7 @@ async def killer(shutdown: anyio.Event, sleep_s: float) -> None:
     shutdown.set()
 
 """  # noqa
+import dataclasses as dc
 import signal
 import typing as ta
 
@@ -44,6 +45,12 @@ StapledByteStream: ta.TypeAlias = anyio.streams.stapled.StapledByteStream
 StapledObjectStream: ta.TypeAlias = anyio.streams.stapled.StapledObjectStream
 
 
+@dc.dataclass(eq=False)
+class MemoryStapledObjectStream(StapledObjectStream[T]):
+    send_stream: MemoryObjectSendStream[T]
+    receive_stream: MemoryObjectReceiveStream[T]
+
+
 ##
 
 
@@ -143,8 +150,8 @@ def split_memory_object_streams(
     return tup
 
 
-def create_stapled_memory_object_stream(max_buffer_size: float = 0) -> StapledObjectStream:
-    return StapledObjectStream(*anyio.create_memory_object_stream(max_buffer_size))
+def create_stapled_memory_object_stream(max_buffer_size: float = 0) -> MemoryStapledObjectStream:
+    return MemoryStapledObjectStream(*anyio.create_memory_object_stream(max_buffer_size))
 
 
 # FIXME: https://github.com/python/mypy/issues/15238
@@ -158,9 +165,9 @@ def create_memory_object_stream[T](max_buffer_size: float = 0) -> tuple[
 
 def staple_memory_object_stream(
         *args: anyio.create_memory_object_stream[T],
-) -> StapledObjectStream[T]:
+) -> MemoryStapledObjectStream[T]:
     send, receive = args
-    return StapledObjectStream(
+    return MemoryStapledObjectStream(
         check.isinstance(send, MemoryObjectSendStream),  # type: ignore
         check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
     )
@@ -168,9 +175,9 @@ def staple_memory_object_stream(
 
 # FIXME: https://github.com/python/mypy/issues/15238
 # FIXME: https://youtrack.jetbrains.com/issues?q=tag:%20%7BPEP%20695%7D
-def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> StapledObjectStream[T]:
+def staple_memory_object_stream2[T](max_buffer_size: float = 0) -> MemoryStapledObjectStream[T]:
     send, receive = anyio.create_memory_object_stream[T](max_buffer_size)
-    return StapledObjectStream(
+    return MemoryStapledObjectStream(
         check.isinstance(send, MemoryObjectSendStream),  # type: ignore
         check.isinstance(receive, MemoryObjectReceiveStream),  # type: ignore
     )

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/dataclasses/__init__.py

@@ -96,4 +96,6 @@ from .utils import (  # noqa
     opt_repr,
     update_field_extras,
     update_field_metadata,
+    update_fields,
+    update_fields_metadata,
 )

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/dataclasses/impl/metadata.py

@@ -70,5 +70,6 @@ class Init(lang.Marker):
     pass
 
 
-def init(fn: ta.Callable[..., None]) -> None:
+def init(fn: ta.Callable):
     _append_cls_md(Init, fn)
+    return fn

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/dataclasses/utils.py

@@ -12,6 +12,9 @@ from .impl.params import get_field_extras
 T = ta.TypeVar('T')
 
 
+#
+
+
 def maybe_post_init(sup: ta.Any) -> bool:
     try:
         fn = sup.__post_init__
@@ -21,10 +24,16 @@ def maybe_post_init(sup: ta.Any) -> bool:
     return True
 
 
+#
+
+
 def opt_repr(o: ta.Any) -> str | None:
     return repr(o) if o is not None else None
 
 
+#
+
+
 class field_modifier:  # noqa
     def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
         super().__init__()
@@ -58,6 +67,42 @@ def update_field_extras(f: dc.Field, *, unless_non_default: bool = False, **kwar
     })
 
 
+def update_fields(
+        fn: ta.Callable[[str, dc.Field], dc.Field],
+        fields: ta.Iterable[str] | None = None,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(cls):
+        if fields is None:
+            for a, v in list(cls.__dict__.items()):
+                if isinstance(v, dc.Field):
+                    setattr(cls, a, fn(a, v))
+
+        else:
+            for a in fields:
+                v = cls.__dict__[a]
+                if not isinstance(v, dc.Field):
+                    v = dc.field(default=v)
+                setattr(cls, a, fn(a, v))
+
+        return cls
+
+    check.not_isinstance(fields, str)
+    return inner
+
+
+def update_fields_metadata(
+        nmd: ta.Mapping,
+        fields: ta.Iterable[str] | None = None,
+) -> ta.Callable[[type[T]], type[T]]:
+    def inner(a: str, f: dc.Field) -> dc.Field:
+        return update_field_metadata(f, nmd)
+
+    return update_fields(inner, fields)
+
+
+#
+
+
 def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
     if not args:
         return o

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/fnpairs.py

@@ -449,7 +449,7 @@ class Toml(ObjectStr_):
 #
 
 
-@_register_extension('cpkl')
+@_register_extension('clpkl')
 @dc.dataclass(frozen=True)
 class Cloudpickle(ObjectBytes_):
     protocol: int | None = None

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/formats/json.py

@@ -13,6 +13,7 @@ from .. import lang
 if ta.TYPE_CHECKING:
     import orjson as _orjson
     import ujson as _ujson
+
 else:
     _orjson = lang.proxy_import('orjson')
     _ujson = lang.proxy_import('ujson')

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/lang/descriptors.py

@@ -125,11 +125,13 @@ class _decorator_descriptor:  # noqa
 
         def __get__(self, instance, owner=None):
             fn = self._fn.__get__(instance, owner)
+
             if self._md or instance is not None:
                 @functools.wraps(fn)
                 def inner(*args, **kwargs):
                     return self._wrapper(fn, *args, **kwargs)
                 return inner
+
             else:
                 @functools.wraps(fn)
                 def outer(this, *args, **kwargs):

{omlish-0.0.0.dev19 → omlish-0.0.0.dev20}/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-0.0.0.dev19 → omlish-0.0.0.dev20}/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-0.0.0.dev19 → omlish-0.0.0.dev20}/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-0.0.0.dev20/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-0.0.0.dev19 → omlish-0.0.0.dev20}/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-0.0.0.dev19 → omlish-0.0.0.dev20}/omlish/multiprocessing.py

@@ -9,6 +9,7 @@ import time
 import typing as ta
 
 from . import check
+from . import lang
 from . import libc
 
 
@@ -18,6 +19,32 @@ 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
@@ -75,6 +102,11 @@ class Deathpact(abc.ABC):
         raise NotImplementedError
 
 
+class NopDeathpact(Deathpact):
+    def poll(self) -> None:
+        pass
+
+
 #
 
 

omlish-0.0.0.dev20/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-0.0.0.dev20/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-0.0.0.dev20/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-0.0.0.dev20/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