omlish 0.0.0.dev1__py3-none-any.whl

omlish/configs/flattening.py

@@ -0,0 +1,147 @@
+import abc
+import typing as ta
+
+from .. import check
+from .. import lang
+
+
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+StrMap = ta.Mapping[str, ta.Any]
+
+
+class _MISSING(lang.Marker):
+    pass
+
+
+class Flattening:
+
+    DEFAULT_DELIMITER = '.'
+    DEFAULT_INDEX_OPEN = '('
+    DEFAULT_INDEX_CLOSE = ')'
+
+    def __init__(
+            self,
+            *,
+            delimiter=DEFAULT_DELIMITER,
+            index_open=DEFAULT_INDEX_OPEN,
+            index_close=DEFAULT_INDEX_CLOSE,
+    ) -> None:
+        super().__init__()
+
+        self._delimiter = check.not_empty(delimiter)
+        self._index_open = check.not_empty(index_open)
+        self._index_close = check.not_empty(index_close)
+
+    def flatten(self, unflattened: StrMap) -> StrMap:
+        def rec(prefix: ta.List[str], value: ta.Any) -> None:
+            if isinstance(value, dict):
+                for k, v in value.items():
+                    rec(prefix + [k], v)
+            elif isinstance(value, list):
+                check.not_empty(prefix)
+                for i, v in enumerate(value):
+                    rec(prefix[:-1] + [f'{prefix[-1]}{self._index_open}{i}{self._index_close}'], v)
+            else:
+                k = self._delimiter.join(prefix)
+                if k in ret:
+                    raise KeyError(k)
+                ret[k] = value
+
+        ret: ta.Dict[str, ta.Any] = {}
+        rec([], unflattened)
+        return ret
+
+    class UnflattenNode(lang.Abstract, ta.Generic[K]):
+
+        @abc.abstractmethod
+        def get(self, key: K) -> ta.Any:
+            raise NotImplementedError
+
+        @abc.abstractmethod
+        def put(self, key: K, value: ta.Any) -> None:
+            raise NotImplementedError
+
+        def setdefault(self, key: K, supplier: ta.Callable[[], V]) -> V:
+            ret = self.get(key)
+            if ret is _MISSING:
+                ret = supplier()
+                self.put(key, ret)
+            return ret
+
+        @abc.abstractmethod
+        def build(self) -> ta.Any:
+            raise NotImplementedError
+
+        @staticmethod
+        def maybe_build(value: ta.Any) -> ta.Any:
+            check.not_none(value)
+            return value.build() if isinstance(value, Flattening.UnflattenNode) else value
+
+    class UnflattenDict(UnflattenNode[str]):
+
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._dict: ta.Dict[str, ta.Any] = {}
+
+        def get(self, key: str) -> ta.Any:
+            return self._dict.get(key, _MISSING)
+
+        def put(self, key: str, value: ta.Any) -> None:
+            check.arg(key not in self._dict)
+            self._dict[key] = value
+
+        def build(self) -> ta.Any:
+            return {k: Flattening.UnflattenNode.maybe_build(v) for k, v in self._dict.items()}
+
+    class UnflattenList(UnflattenNode[int]):
+
+        def __init__(self) -> None:
+            super().__init__()
+
+            self._list: ta.List[ta.Any] = []
+
+        def get(self, key: int) -> ta.Any:
+            check.arg(key >= 0)
+            return self._list[key] if key < len(self._list) else _MISSING
+
+        def put(self, key: int, value: ta.Any) -> None:
+            check.arg(key >= 0)
+            if key >= len(self._list):
+                self._list.extend([_MISSING] * (key - len(self._list) + 1))
+            check.arg(self._list[key] is _MISSING)
+            self._list[key] = value
+
+        def build(self) -> ta.Any:
+            return [Flattening.UnflattenNode.maybe_build(e) for e in self._list]
+
+    def unflatten(self, flattened: StrMap) -> StrMap:
+        root = Flattening.UnflattenDict()
+
+        def split_keys(fkey: str) -> ta.Iterable[ta.Union[str, int]]:
+            for part in fkey.split(self._delimiter):
+                if self._index_open in part:
+                    check.state(part.endswith(self._index_close))
+                    pos = part.index(self._index_open)
+                    yield part[:pos]
+                    for p in part[pos + len(self._index_open):-len(self._index_close)] \
+                            .split(self._index_close + self._index_open):
+                        yield int(p)
+                else:
+                    check.state(')' not in part)
+                    yield part
+
+        for fk, v in flattened.items():
+            node: Flattening.UnflattenNode = root
+            fks = list(split_keys(fk))
+            for key, nkey in zip(fks, fks[1:]):
+                if isinstance(nkey, str):
+                    node = node.setdefault(key, Flattening.UnflattenDict)
+                elif isinstance(nkey, int):
+                    node = node.setdefault(key, Flattening.UnflattenList)
+                else:
+                    raise TypeError(key)
+            node.put(fks[-1], v)
+
+        return root.build()

omlish/configs/props.py

@@ -0,0 +1,64 @@
+"""
+TODO:
+ - \\uXXXX
+"""
+import re
+import typing as ta
+
+
+_NORMALIZE_PATTERN = re.compile(r'\\([:=\s])')
+_ESCAPE_PATTERN = re.compile(r'([=:\s])')
+_SEPARATOR_PATTERN = re.compile(r'(?<!\\)[=:]')
+
+
+def normalize(atom: str) -> str:
+    return _NORMALIZE_PATTERN.sub(r'\1', atom.strip())
+
+
+def escape(token: str) -> str:
+    return _ESCAPE_PATTERN.sub(r'\\\1', token)
+
+
+def parse_line(line: str) -> ta.Optional[ta.Tuple[str, str]]:
+    if line and not (line.startswith('#') or line.startswith('!')):
+        match = _SEPARATOR_PATTERN.search(line)
+        if match:
+            return normalize(line[:match.start()]), normalize(line[match.end():])
+        else:
+            space_sep = line.find(' ')
+            if space_sep == -1:
+                return normalize(line), ''
+            else:
+                return normalize(line[:space_sep]), normalize(line[space_sep:])
+    return None
+
+
+def coalesce_lines(lines: ta.Iterable[str]) -> ta.Generator[str, None, None]:
+    line_iter = iter(lines)
+    try:
+        buffer = ''
+        while True:
+            line = next(line_iter)
+            if line.strip().endswith('\\'):
+                buffer += line.strip()[:-1]
+            else:
+                if buffer:
+                    buffer += line.rstrip()
+                else:
+                    buffer = line.strip()
+                try:
+                    yield buffer
+                finally:
+                    buffer = ''
+    except StopIteration:
+        pass
+
+
+def parse_lines(lines: ta.Iterable[str]) -> ta.Dict[str, str]:
+    props = {}
+    for line in coalesce_lines(lines):
+        kv_pair = parse_line(line)
+        if kv_pair:
+            key, value = kv_pair
+            props[key] = value
+    return props

omlish/dataclasses/__init__.py

@@ -0,0 +1,83 @@
+from dataclasses import (  # noqa
+    FrozenInstanceError,
+
+    MISSING,
+    KW_ONLY,
+
+    InitVar,
+    Field,
+
+    field,
+
+    dataclass,
+    make_dataclass,
+
+    fields,
+
+    is_dataclass,
+
+    # asdict,
+    # astuple,
+
+    # replace,
+)
+
+from .impl.api import (  # noqa
+    field as xfield,
+
+    dataclass as xdataclass,
+    make_dataclass as xmake_dataclass,
+
+    extra_params,
+)
+
+from .impl.as_ import (  # noqa
+    asdict,
+    astuple,
+)
+
+from .impl.replace import (  # noqa
+    replace,
+)
+
+
+##
+
+
+globals()['field'] = xfield
+
+globals()['dataclass'] = xdataclass
+globals()['make_dataclass'] = xmake_dataclass
+
+
+##
+
+
+from .impl.exceptions import (  # noqa
+    CheckException,
+)
+
+from .impl.metaclass import (  # noqa
+    DataMeta,
+    Data,
+    Frozen,
+    Box,
+)
+
+from .impl.metadata import (  # noqa
+    get_merged_metadata,
+
+    UserMetadata,
+    metadata,
+
+    Check,
+    check,
+
+    Init,
+    init,
+)
+
+from .impl.reflect import (  # noqa
+    ClassInfo,
+    reflect,
+)

omlish/dataclasses/impl/__init__.py

@@ -0,0 +1,6 @@
+"""
+TODO:
+ - metaclass:
+  - cleanup confer
+ - descriptors - check_type/validators don't handle setters lol
+"""

omlish/dataclasses/impl/api.py

@@ -0,0 +1,260 @@
+import collections.abc
+import dataclasses as dc
+import keyword
+import sys
+import types
+import typing as ta
+
+from ... import check as check_
+from .internals import PARAMS_ATTR
+from .internals import Params
+from .main import process_class
+from .metadata import METADATA_ATTR
+from .metadata import Metadata
+from .params import FieldExtras
+from .params import Params12
+from .params import ParamsExtras
+
+
+MISSING = dc.MISSING
+
+IS_12 = sys.version_info[1] >= 12
+
+
+def field(
+        default=MISSING,
+        *,
+        default_factory=MISSING,
+        init=True,
+        repr=True,
+        hash=None,
+        compare=True,
+        metadata=None,
+        kw_only=MISSING,
+
+        coerce: ta.Optional[ta.Callable[[ta.Any], ta.Any]] = None,
+        check: ta.Optional[ta.Callable[[ta.Any], bool]] = None,
+        check_type: ta.Optional[bool] = None,
+        override: bool = False,
+):  # -> dc.Field
+    if default is not MISSING and default_factory is not MISSING:
+        raise ValueError('cannot specify both default and default_factory')
+
+    fx = FieldExtras(
+        coerce=coerce,
+        check=check,
+        check_type=check_type,
+        override=override,
+    )
+
+    md: ta.Mapping = {FieldExtras: fx}
+    if metadata is not None:
+        md = collections.ChainMap(md, check_.isinstance(metadata, collections.abc.Mapping))  # type: ignore
+
+    return dc.Field(
+        default,
+        default_factory,  # noqa
+        init,
+        repr,
+        hash,
+        compare,
+        types.MappingProxyType(md),
+        kw_only,  # noqa
+    )
+
+
+def _strip_missing_values(d):
+    return {k: v for k, v in d.items() if v is not MISSING}
+
+
+def dataclass(
+        cls=None,
+        /,
+        *,
+        init=True,
+        repr=True,
+        eq=True,
+        order=False,
+        unsafe_hash=False,
+        frozen=False,
+        match_args=True,
+        kw_only=False,
+        slots=False,
+        weakref_slot=False,
+
+        metadata=None,
+
+        reorder=MISSING,
+        cache_hash=MISSING,
+        generic_init=MISSING,
+):
+    def wrap(cls):
+        pkw = dict(
+            init=init,
+            repr=repr,
+            eq=eq,
+            order=order,
+            unsafe_hash=unsafe_hash,
+            frozen=frozen,
+        )
+        p12kw = dict(
+            match_args=match_args,
+            kw_only=kw_only,
+            slots=slots,
+            weakref_slot=weakref_slot,
+        )
+
+        dmd = cls.__dict__.get(METADATA_ATTR)
+
+        epk = dict(dmd.get(_ExtraParamsKwargs, ()) if dmd is not None else ())
+        epk.update(_strip_missing_values(dict(
+            reorder=reorder,
+            cache_hash=cache_hash,
+            generic_init=generic_init,
+        )))
+        pex = ParamsExtras(**epk)
+
+        mmd: dict = {
+            ParamsExtras: pex,
+        }
+
+        if IS_12:
+            pkw.update(p12kw)
+        else:
+            mmd[Params12] = Params12(**p12kw)
+
+        md: Metadata = mmd
+        cmds = []
+        if metadata is not None:
+            cmds.append(check_.isinstance(metadata, collections.abc.Mapping))
+        if dmd is not None:
+            cmds.append(dmd)
+        if cmds:
+            md = collections.ChainMap(md, *cmds)  # type: ignore
+
+        setattr(cls, PARAMS_ATTR, Params(**pkw))
+        setattr(cls, METADATA_ATTR, types.MappingProxyType(md))
+
+        return process_class(cls)
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)
+
+
+def make_dataclass(
+        cls_name,
+        fields,
+        *,
+        bases=(),
+        namespace=None,
+        init=True,
+        repr=True,
+        eq=True,
+        order=False,
+        unsafe_hash=False,
+        frozen=False,
+        match_args=True,
+        kw_only=False,
+        slots=False,
+        weakref_slot=False,
+        module=None,
+
+        reorder=MISSING,
+        cache_hash=MISSING,
+        generic_init=MISSING,
+):
+    if namespace is None:
+        namespace = {}
+
+    seen = set()
+    annotations = {}
+    defaults = {}
+    for item in fields:
+        if isinstance(item, str):
+            name = item
+            tp = 'typing.Any'
+        elif len(item) == 2:
+            name, tp, = item
+        elif len(item) == 3:
+            name, tp, spec = item
+            defaults[name] = spec
+        else:
+            raise TypeError(f'Invalid field: {item!r}')
+        if not isinstance(name, str) or not name.isidentifier():
+            raise TypeError(f'Field names must be valid identifiers: {name!r}')
+        if keyword.iskeyword(name):
+            raise TypeError(f'Field names must not be keywords: {name!r}')
+        if name in seen:
+            raise TypeError(f'Field name duplicated: {name!r}')
+
+        seen.add(name)
+        annotations[name] = tp
+
+    def exec_body_callback(ns):
+        ns.update(namespace)
+        ns.update(defaults)
+        ns['__annotations__'] = annotations
+
+    cls = types.new_class(cls_name, bases, {}, exec_body_callback)
+
+    if module is None:
+        try:
+            module = sys._getframemodulename(1) or '__main__'  # type: ignore  # noqa
+        except AttributeError:
+            try:
+                module = sys._getframe(1).f_globals.get('__name__', '__main__')  # noqa
+            except (AttributeError, ValueError):
+                pass
+    if module is not None:
+        cls.__module__ = module
+
+    return dataclass(
+        cls,
+        init=init,
+        repr=repr,
+        eq=eq,
+        order=order,
+        unsafe_hash=unsafe_hash,
+        frozen=frozen,
+        match_args=match_args,
+        kw_only=kw_only,
+        slots=slots,
+        weakref_slot=weakref_slot,
+
+        reorder=reorder,
+        cache_hash=cache_hash,
+        generic_init=generic_init,
+    )
+
+
+class _ExtraParamsKwargs:
+    pass
+
+
+def extra_params(
+        *,
+        reorder=MISSING,
+        cache_hash=MISSING,
+        generic_init=MISSING,
+):
+    def inner(cls):
+        if PARAMS_ATTR in cls.__dict__:
+            raise TypeError(cls)
+        try:
+            md = cls.__dict__[METADATA_ATTR]
+        except KeyError:
+            md = {}
+            setattr(cls, METADATA_ATTR, md)
+        if _ExtraParamsKwargs in md:
+            raise TypeError(cls)
+
+        md[_ExtraParamsKwargs] = _strip_missing_values(dict(
+            reorder=reorder,
+            cache_hash=cache_hash,
+            generic_init=generic_init,
+        ))
+
+        return cls
+    return inner

omlish/dataclasses/impl/as_.py

@@ -0,0 +1,76 @@
+import copy
+import dataclasses as dc
+
+from .internals import is_dataclass_instance
+from .internals import ATOMIC_TYPES
+
+
+def asdict(obj, *, dict_factory=dict):
+    if not is_dataclass_instance(obj):  # noqa
+        raise TypeError("asdict() should be called on dataclass instances")
+    return _asdict_inner(obj, dict_factory)
+
+
+def _asdict_inner(obj, dict_factory):
+    if type(obj) in ATOMIC_TYPES:
+        return obj
+
+    elif is_dataclass_instance(obj):
+        l = []
+        for f in dc.fields(obj):
+            value = _asdict_inner(getattr(obj, f.name), dict_factory)
+            l.append((f.name, value))
+        return dict_factory(l)
+
+    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
+        return type(obj)(*[_asdict_inner(v, dict_factory) for v in obj])
+
+    elif isinstance(obj, (list, tuple)):
+        return type(obj)(_asdict_inner(v, dict_factory) for v in obj)
+
+    elif isinstance(obj, dict):
+        if hasattr(type(obj), 'default_factory'):
+            d = type(obj)(getattr(obj, 'default_factory'))
+            for k, v in obj.items():
+                d[_asdict_inner(k, dict_factory)] = _asdict_inner(v, dict_factory)
+            return d
+        return type(obj)((_asdict_inner(k, dict_factory), _asdict_inner(v, dict_factory)) for k, v in obj.items())
+
+    else:
+        return copy.deepcopy(obj)
+
+
+def astuple(obj, *, tuple_factory=tuple):
+    if not is_dataclass_instance(obj):
+        raise TypeError("astuple() should be called on dataclass instances")
+    return _astuple_inner(obj, tuple_factory)
+
+
+def _astuple_inner(obj, tuple_factory):
+    if type(obj) in ATOMIC_TYPES:
+        return obj
+
+    elif is_dataclass_instance(obj):
+        l = []
+        for f in dc.fields(obj):
+            value = _astuple_inner(getattr(obj, f.name), tuple_factory)
+            l.append(value)
+        return tuple_factory(l)
+
+    elif isinstance(obj, tuple) and hasattr(obj, '_fields'):
+        return type(obj)(*[_astuple_inner(v, tuple_factory) for v in obj])
+
+    elif isinstance(obj, (list, tuple)):
+        return type(obj)(_astuple_inner(v, tuple_factory) for v in obj)
+
+    elif isinstance(obj, dict):
+        obj_type = type(obj)
+        if hasattr(obj_type, 'default_factory'):
+            d = obj_type(getattr(obj, 'default_factory'))
+            for k, v in obj.items():
+                d[_astuple_inner(k, tuple_factory)] = _astuple_inner(v, tuple_factory)
+            return d
+        return obj_type((_astuple_inner(k, tuple_factory), _astuple_inner(v, tuple_factory)) for k, v in obj.items())
+
+    else:
+        return copy.deepcopy(obj)

omlish/dataclasses/impl/exceptions.py

@@ -0,0 +1,2 @@
+class CheckException(Exception):
+    pass