omlish 0.0.0.dev1__py3-none-any.whl

omlish/marshal/optionals.py

@@ -0,0 +1,49 @@
+import dataclasses as dc
+import typing as ta
+
+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)
+class OptionalMarshaler(Marshaler):
+    e: Marshaler
+
+    def marshal(self, ctx: MarshalContext, o: ta.Optional[ta.Any]) -> Value:
+        if o is None:
+            return None
+        return self.e.marshal(ctx, o)
+
+
+class OptionalMarshalerFactory(MarshalerFactory):
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        if isinstance(rty, rfl.Union) and rty.is_optional:
+            if (e := ctx.make(rty.without_none())) is None:
+                return None  # type: ignore
+            return OptionalMarshaler(e)
+        return None
+
+
+@dc.dataclass(frozen=True)
+class OptionalUnmarshaler(Unmarshaler):
+    e: Unmarshaler
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Optional[ta.Any]:
+        if v is None:
+            return None
+        return self.e.unmarshal(ctx, v)
+
+
+class OptionalUnmarshalerFactory(UnmarshalerFactory):
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        if isinstance(rty, rfl.Union) and rty.is_optional:
+            if (e := ctx.make(rty.without_none())) is None:
+                return None  # type: ignore
+            return OptionalUnmarshaler(e)
+        return None

omlish/marshal/polymorphism.py

@@ -0,0 +1,147 @@
+"""
+TODO:
+ - auto-gen from __subclasses__ if abstract
+  - cfg: unless prefixed with _ or abstract
+ - auto-name
+"""
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import lang
+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 .naming import Naming
+from .naming import translate_name
+from .values import Value
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Impl:
+    ty: type
+    tag: str
+    alts: ta.AbstractSet[str] = frozenset()
+
+
+class Polymorphism:
+    def __init__(self, ty: type, impls: ta.Iterable[Impl]) -> None:
+        super().__init__()
+        self._ty = ty
+        self._impls = list(impls)
+
+        by_ty: dict[type, Impl] = {}
+        by_tag: dict[str, Impl] = {}
+        for i in self._impls:
+            if not issubclass(i.ty, ty) or i.ty in by_ty:
+                raise TypeError(i.ty, ty)
+            if i.tag in by_tag:
+                raise NameError(i.tag)
+            for a in i.alts:
+                if a in by_tag:
+                    raise NameError(a)
+            by_ty[i.ty] = i
+            by_tag[i.tag] = i
+            for a in i.alts:
+                by_tag[a] = i
+        self._by_ty = by_ty
+        self._by_tag = by_tag
+
+    @property
+    def ty(self) -> type:
+        return self._ty
+
+    @property
+    def impls(self) -> ta.Sequence[Impl]:
+        return self._impls
+
+    @property
+    def by_ty(self) -> ta.Mapping[type, Impl]:
+        return self._by_ty
+
+    @property
+    def by_tag(self) -> ta.Mapping[str, Impl]:
+        return self._by_tag
+
+
+def polymorphism_from_subclasses(ty: type, *, naming: Naming | None = None) -> Polymorphism:
+    dct: dict[str, Impl] = {}
+    seen: set[type] = set()
+    todo: list[type] = [ty]
+    while todo:
+        cur = todo.pop()
+        seen.add(cur)
+        if not lang.is_abstract_class(cur):
+            nam = cur.__name__
+            if naming is not None:
+                nam = translate_name(nam, naming)
+            if nam in dct:
+                raise KeyError(f'Duplicate name: {nam}')
+            dct[nam] = Impl(
+                cur,
+                nam,
+            )
+        todo.extend(nxt for nxt in cur.__subclasses__() if nxt not in seen)
+    return Polymorphism(ty, dct.values())
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismMarshaler(Marshaler):
+    m: ta.Mapping[type, tuple[str, Marshaler]]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Optional[ta.Any]) -> Value:
+        tag, m = self.m[type(o)]
+        return {tag: m.marshal(ctx, o)}
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismMarshalerFactory(MarshalerFactory):
+    p: Polymorphism
+
+    def __call__(self, ctx: MarshalContext, rty: rfl.Type) -> ta.Optional[Marshaler]:
+        if rty is self.p.ty:
+            return PolymorphismMarshaler({
+                i.ty: (i.tag, ctx.make(i.ty))
+                for i in self.p.impls
+            })
+        return None
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismUnmarshaler(Unmarshaler):
+    m: ta.Mapping[str, Unmarshaler]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Optional[ta.Any]:
+        ma = check.isinstance(v, collections.abc.Mapping)
+        [(tag, iv)] = ma.items()
+        u = self.m[tag]  # type: ignore
+        return u.unmarshal(ctx, iv)  # type: ignore
+
+
+@dc.dataclass(frozen=True)
+class PolymorphismUnmarshalerFactory(UnmarshalerFactory):
+    p: Polymorphism
+
+    def __call__(self, ctx: UnmarshalContext, rty: rfl.Type) -> ta.Optional[Unmarshaler]:
+        if rty is self.p.ty:
+            return PolymorphismUnmarshaler({
+                t: u
+                for i in self.p.impls
+                for u in [ctx.make(i.ty)]
+                for t in [i.tag, *i.alts]
+            })
+        return None

omlish/marshal/primitives.py

@@ -0,0 +1,43 @@
+import typing as ta
+
+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 .factories import TypeMapFactory
+from .values import Value
+
+
+PRIMITIVE_TYPES: tuple[type, ...] = (
+    bool,
+    int,
+    float,
+    str,
+    bytes,
+    type(None),
+)
+
+
+class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        if isinstance(o, PRIMITIVE_TYPES):
+            return o  # type: ignore
+        raise TypeError(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        if isinstance(v, PRIMITIVE_TYPES):
+            return v
+        raise TypeError(v)
+
+
+PRIMITIVE_MARSHALER_UNMARSHALER = PrimitiveMarshalerUnmarshaler()
+
+PRIMITIVE_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({  # noqa
+    t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
+})
+
+PRIMITIVE_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({  # noqa
+    t: PRIMITIVE_MARSHALER_UNMARSHALER for t in PRIMITIVE_TYPES
+})

omlish/marshal/registries.py

@@ -0,0 +1,57 @@
+import abc
+import dataclasses as dc
+import threading
+import typing as ta
+
+from .. import check
+from .. import reflect as rfl
+
+
+class RegistryItem(abc.ABC):
+    pass
+
+
+RegistryItemT = ta.TypeVar('RegistryItemT', bound=RegistryItem)
+
+
+@dc.dataclass(frozen=True)
+class _TypeRegistry:
+    rty: rfl.Type
+    items: list[RegistryItem] = dc.field(default_factory=list)
+    item_lists_by_ty: dict[type[RegistryItem], list[RegistryItem]] = dc.field(default_factory=dict)
+
+    def add(self, *items: RegistryItem) -> None:
+        for i in items:
+            self.items.append(i)
+            self.item_lists_by_ty.setdefault(type(i), []).append(i)
+
+
+class Registry:
+    def __init__(self) -> None:
+        super().__init__()
+        self._mtx = threading.Lock()
+        self._dct: dict[rfl.Type, _TypeRegistry] = {}
+        self._ps: ta.Sequence['Registry'] = []
+
+    def register(self, rty: rfl.Type, *items: RegistryItem) -> 'Registry':
+        check.isinstance(rty, rfl.TYPES)
+        with self._mtx:
+            if (sr := self._dct.get(rty)) is None:
+                sr = self._dct[rty] = _TypeRegistry(rty)
+            sr.add(*items)
+        return self
+
+    def get(self, rty: rfl.Type) -> ta.Sequence[RegistryItem]:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            return self._dct[rty].items
+        except KeyError:
+            return ()
+
+    def get_of(self, rty: rfl.Type, item_ty: type[RegistryItemT]) -> ta.Sequence[RegistryItemT]:
+        check.isinstance(rty, rfl.TYPES)
+        try:
+            sr = self._dct[rty]
+        except KeyError:
+            return ()
+        return sr.item_lists_by_ty.get(item_ty, ())  # type: ignore

omlish/marshal/standard.py

@@ -0,0 +1,80 @@
+from .any import ANY_MARSHALER_FACTORY
+from .any import ANY_UNMARSHALER_FACTORY
+from .base import MarshalerFactory
+from .base import RecursiveMarshalerFactory
+from .base import RecursiveUnmarshalerFactory
+from .base import UnmarshalerFactory
+from .base64 import BASE64_MARSHALER_FACTORY
+from .base64 import BASE64_UNMARSHALER_FACTORY
+from .dataclasses import DataclassMarshalerFactory
+from .dataclasses import DataclassUnmarshalerFactory
+from .datetimes import DATETIME_MARSHALER_FACTORY
+from .datetimes import DATETIME_UNMARSHALER_FACTORY
+from .enums import EnumMarshalerFactory
+from .enums import EnumUnmarshalerFactory
+from .factories import CompositeFactory
+from .factories import TypeCacheFactory
+from .iterables import IterableMarshalerFactory
+from .iterables import IterableUnmarshalerFactory
+from .mappings import MappingMarshalerFactory
+from .mappings import MappingUnmarshalerFactory
+from .optionals import OptionalMarshalerFactory
+from .optionals import OptionalUnmarshalerFactory
+from .primitives import PRIMITIVE_MARSHALER_FACTORY
+from .primitives import PRIMITIVE_UNMARSHALER_FACTORY
+from .uuids import UUID_MARSHALER_FACTORY
+from .uuids import UUID_UNMARSHALER_FACTORY
+
+
+##
+
+
+STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
+    PRIMITIVE_MARSHALER_FACTORY,
+    OptionalMarshalerFactory(),
+    DataclassMarshalerFactory(),
+    EnumMarshalerFactory(),
+    UUID_MARSHALER_FACTORY,
+    BASE64_MARSHALER_FACTORY,
+    DATETIME_MARSHALER_FACTORY,
+    MappingMarshalerFactory(),
+    IterableMarshalerFactory(),
+    ANY_MARSHALER_FACTORY,
+]
+
+
+def new_standard_marshaler_factory() -> MarshalerFactory:
+    return TypeCacheFactory(  # noqa
+        RecursiveMarshalerFactory(
+            CompositeFactory(
+                *STANDARD_MARSHALER_FACTORIES
+            )
+        )
+    )
+
+
+##
+
+
+STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
+    PRIMITIVE_UNMARSHALER_FACTORY,
+    OptionalUnmarshalerFactory(),
+    DataclassUnmarshalerFactory(),
+    EnumUnmarshalerFactory(),
+    UUID_UNMARSHALER_FACTORY,
+    BASE64_UNMARSHALER_FACTORY,
+    DATETIME_UNMARSHALER_FACTORY,
+    MappingUnmarshalerFactory(),
+    IterableUnmarshalerFactory(),
+    ANY_UNMARSHALER_FACTORY,
+]
+
+
+def new_standard_unmarshaler_factory() -> UnmarshalerFactory:
+    return TypeCacheFactory(  # noqa
+        RecursiveUnmarshalerFactory(
+            CompositeFactory(
+                *STANDARD_UNMARSHALER_FACTORIES
+            )
+        )
+    )

omlish/marshal/utils.py

@@ -0,0 +1,23 @@
+import typing as ta
+
+
+T = ta.TypeVar('T')
+
+
+class _Proxy(ta.Generic[T]):
+    __obj: ta.Optional[T] = None
+
+    @property
+    def _obj(self) -> T:
+        if self.__obj is None:
+            raise TypeError('recursive proxy not set')
+        return self.__obj
+
+    def _set_obj(self, obj: T) -> None:
+        if self.__obj is not None:
+            raise TypeError('recursive proxy already set')
+        self.__obj = obj
+
+    @classmethod
+    def _new(cls):
+        return (p := cls()), p._set_obj

omlish/marshal/uuids.py

@@ -0,0 +1,29 @@
+import re
+import uuid
+
+from .. import check
+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 .factories import TypeMapFactory
+from .values import Value
+
+
+PATTERN = re.compile(r'([0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12})|([0-9A-Fa-f]{32})')
+
+
+class UuidMarshalerUnmarshaler(Marshaler, Unmarshaler):
+    def marshal(self, ctx: MarshalContext, o: uuid.UUID) -> Value:
+        return str(o)
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> uuid.UUID:
+        return uuid.UUID(check.isinstance(v, str).replace('-', ''))
+
+
+UUID_MARSHALER_UNMARSHALER = UuidMarshalerUnmarshaler()
+
+UUID_MARSHALER_FACTORY: MarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})
+UUID_UNMARSHALER_FACTORY: UnmarshalerFactory = TypeMapFactory({uuid.UUID: UUID_MARSHALER_UNMARSHALER})

omlish/marshal/values.py

@@ -0,0 +1,30 @@
+"""
+Null
+Bool
+Int
+Float
+Number
+String
+Bytes
+Array
+Object
+Any
+"""
+import typing as ta
+
+
+Value = ta.Union[
+    None,
+
+    bool,
+    int,
+    float,
+    # Number,
+    str,
+    bytes,
+
+    list,  # list[Value],
+    dict,  # dict[str, Value],
+
+    # ta.Any,
+]

omlish/math.py

@@ -0,0 +1,184 @@
+import functools
+import struct
+import typing as ta
+
+
+##
+
+
+def isclose(a: float, b: float, *, rel_tol: float = 1e-09, abs_tol: float = 0.0) -> float:
+    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+
+
+def get_bit(bit: int, value: int) -> int:
+    return (value >> bit) & 1
+
+
+def get_bits(bits_from: int, num_bits: int, value: int) -> int:
+    return (value & ((1 << (bits_from + num_bits)) - 1)) >> bits_from
+
+
+def set_bit(bit: int, bit_value: int, value: int) -> int:
+    if bit_value:
+        return value | (1 << bit)
+    else:
+        return value & ~(1 << bit)
+
+
+def set_bits(bits_from: int, num_bits: int, bits_value: int, value: int) -> int:
+    return value & ~(((1 << num_bits) - 1) << bits_from) | (bits_value << bits_from)
+
+
+def float_to_bytes(f: float) -> bytes:
+    return struct.pack('>f', f)
+
+
+def bytes_to_float(b: bytes) -> float:
+    return struct.unpack('>f', b)[0]
+
+
+##
+
+
+def _gen_scalar_proxy_method(name):
+    def inner(self, *args, **kwargs):
+        return self.__class__(orig(self, *args, **kwargs))
+
+    orig = getattr(int, name)
+    return functools.wraps(orig)(inner)
+
+
+def _gen_tuple_proxy_method(name):
+    def inner(self, *args, **kwargs):
+        return tuple(map(self.__class__, orig(self, *args, **kwargs)))
+
+    orig = getattr(int, name)
+    return functools.wraps(orig)(inner)
+
+
+class FixedWidthInt(int):
+
+    BITS: ta.ClassVar[int]
+    SIGNED: ta.ClassVar[bool]
+
+    MIN: ta.ClassVar[int]
+    MAX: ta.ClassVar[int]
+
+    MASK: ta.ClassVar[int]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__()
+
+        if not isinstance(cls.BITS, int):
+            raise TypeError(cls.BITS)
+
+        if cls.SIGNED:
+            cls.MIN = -(1 << (cls.BITS - 1))
+            cls.MAX = (1 << (cls.BITS - 1)) - 1
+        else:
+            cls.MIN = 0
+            cls.MAX = (1 << cls.BITS) - 1
+
+        cls.MASK = (1 << cls.BITS) - 1
+
+    @classmethod
+    def clamp(cls, value):
+        return ((value - cls.MIN) & cls.MASK) + cls.MIN
+
+    def __new__(cls, value, *args, **kwargs):
+        return super().__new__(cls, cls.clamp(value))
+
+    SCALAR_PROXY_METHODS = {
+        '__abs__',
+        '__add__',
+        '__and__',
+        '__floordiv__',
+        '__invert__',
+        '__lshift__',
+        '__mod__',
+        '__mul__',
+        '__neg__',
+        '__or__',
+        '__pos__',
+        '__pow__',
+        '__radd__',
+        '__rand__',
+        '__rfloordiv__',
+        '__rlshift__',
+        '__rmod__',
+        '__rmul__',
+        '__ror__',
+        '__rpow__',
+        '__rrshift__',
+        '__rshift__',
+        '__rsub__',
+        '__rtruediv__',
+        '__rxor__',
+        '__sub__',
+        '__truediv__',
+        '__xor__',
+    }
+
+    TUPLE_PROXY_METHODS = {
+        '__divmod__',
+        '__rdivmod__',
+    }
+
+    for _proxy_name in SCALAR_PROXY_METHODS:
+        locals()[_proxy_name] = _gen_scalar_proxy_method(_proxy_name)
+    for _proxy_name in TUPLE_PROXY_METHODS:
+        locals()[_proxy_name] = _gen_tuple_proxy_method(_proxy_name)
+    del _proxy_name
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({int(self)})'
+
+
+class Int8(FixedWidthInt):
+    BITS = 8
+    SIGNED = True
+
+
+class Int16(FixedWidthInt):
+    BITS = 16
+    SIGNED = True
+
+
+class Int32(FixedWidthInt):
+    BITS = 32
+    SIGNED = True
+
+
+class Int64(FixedWidthInt):
+    BITS = 64
+    SIGNED = True
+
+
+class Int128(FixedWidthInt):
+    BITS = 128
+    SIGNED = True
+
+
+class Uint8(FixedWidthInt):
+    BITS = 8
+    SIGNED = False
+
+
+class Uint16(FixedWidthInt):
+    BITS = 16
+    SIGNED = False
+
+
+class Uint32(FixedWidthInt):
+    BITS = 32
+    SIGNED = False
+
+
+class Uint64(FixedWidthInt):
+    BITS = 64
+    SIGNED = False
+
+
+class Uint128(FixedWidthInt):
+    BITS = 128
+    SIGNED = False

omlish/os.py

@@ -0,0 +1,32 @@
+import contextlib
+import shutil
+import tempfile
+import typing as ta
+
+
+@contextlib.contextmanager
+def tmp_dir(
+        root_dir: ta.Optional[str] = None,
+        cleanup: bool = True,
+        **kwargs: ta.Any
+) -> ta.Iterator[str]:
+    path = tempfile.mkdtemp(dir=root_dir, **kwargs)
+    try:
+        yield path
+    finally:
+        if cleanup:
+            shutil.rmtree(path, ignore_errors=True)
+
+
+@contextlib.contextmanager
+def tmp_file(
+        root_dir: ta.Optional[str] = None,
+        cleanup: bool = True,
+        **kwargs: ta.Any
+) -> ta.Iterator[tempfile._TemporaryFileWrapper]:  # noqa
+    with tempfile.NamedTemporaryFile(dir=root_dir, delete=False, **kwargs) as f:
+        try:
+            yield f
+        finally:
+            if cleanup:
+                shutil.rmtree(f.name, ignore_errors=True)