omlish 0.0.0.dev284__py3-none-any.whl → 0.0.0.dev286__py3-none-any.whl

omlish/dataclasses/tools/repr.py

@@ -0,0 +1,12 @@
+import typing as ta
+
+
+##
+
+
+def opt_repr(o: ta.Any) -> str | None:
+    return repr(o) if o is not None else None
+
+
+def truthy_repr(o: ta.Any) -> str | None:
+    return repr(o) if o else None

omlish/dataclasses/{static.py → tools/static.py}

@@ -8,9 +8,9 @@ import copy
 import dataclasses as dc
 import typing as ta
 
-from .. import lang
-from ..lite.dataclasses import is_immediate_dataclass
-from .impl.api import dataclass
+from ... import lang
+from ...lite.dataclasses import is_immediate_dataclass
+from ..api.classes.decorator import dataclass
 
 
 ##
@@ -122,6 +122,27 @@ class Static(lang.Abstract):
                     # Use a default_factory to allow unsafe (mutable) values.
                     new_fld.default_factory = (lambda v2: lambda: v2)(v)  # noqa
 
+                # FIXME
+                from ..api.fields.metadata import _ExtraFieldParamsMetadata  # noqa
+                from ..specs import FieldSpec
+                try:
+                    x_fs = fld.metadata[FieldSpec]
+                except KeyError:
+                    pass
+                else:
+                    n_md = {
+                        k: v
+                        for k, v in fld.metadata.items()
+                        if k not in (FieldSpec, _ExtraFieldParamsMetadata)
+                    }
+                    n_md[_ExtraFieldParamsMetadata] = {
+                        fs_f.name: getattr(x_fs, fs_f.name)
+                        for fs_f in dc.fields(FieldSpec)  # noqa
+                        if fs_f not in dc.Field.__slots__  # type: ignore[attr-defined]
+                        and fs_f.name not in ('default', 'default_factory')
+                    }
+                    new_fld.metadata = n_md  # type: ignore[assignment]
+
                 setattr(cls, fld.name, new_fld)
                 new_anns[fld.name] = fld.type
 
@@ -144,7 +165,7 @@ class Static(lang.Abstract):
                     )
 
         # Explicitly forbid dc transforms that rebuild the class, such as slots.
-        if (dc_cls := dataclass(cls, frozen=True)) is not cls:
+        if (dc_cls := dataclass(frozen=True)(cls)) is not cls:
             raise TypeError(dc_cls)
 
         dc_flds = dc.fields(cls)  # type: ignore[arg-type]  # noqa

omlish/dataclasses/utils.py

@@ -1,153 +1,98 @@
+import ast
 import collections
-import dataclasses as dc
+import functools
 import types
 import typing as ta
 
 from .. import check
-from .impl.metadata import METADATA_ATTR
-from .impl.metadata import UserMetadata
-from .impl.params import DEFAULT_FIELD_EXTRAS
-from .impl.params import FieldExtras
-from .impl.params import get_field_extras
 
 
 T = ta.TypeVar('T')
 
-
-##
-
-
-def opt_repr(o: ta.Any) -> str | None:
-    return repr(o) if o is not None else None
-
-
-def truthy_repr(o: ta.Any) -> str | None:
-    return repr(o) if o else None
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
 
 
 ##
 
 
-def fields_dict(cls_or_instance: ta.Any) -> dict[str, dc.Field]:
-    return {f.name: f for f in dc.fields(cls_or_instance)}
+def repr_round_trip_value(v: T) -> T:
+    r = repr(v)
+    v2 = ast.literal_eval(r)
+    if v != v2:
+        raise ValueError(v)
+    return v2
 
 
 ##
 
 
-class field_modifier:  # noqa
-    def __init__(self, fn: ta.Callable[[dc.Field], dc.Field]) -> None:
-        super().__init__()
-        self.fn = fn
+def set_qualname(cls: type, value: T) -> T:
+    if isinstance(value, types.FunctionType):
+        value.__qualname__ = f'{cls.__qualname__}.{value.__name__}'
+    return value
 
-    def __ror__(self, other: T) -> T:
-        return self(other)
 
-    def __call__(self, f: T) -> T:
-        return check.isinstance(self.fn(check.isinstance(f, dc.Field)), dc.Field)  # type: ignore
+def set_new_attribute(cls: type, name: str, value: ta.Any) -> bool:
+    if name in cls.__dict__:
+        return True
+    set_qualname(cls, value)
+    setattr(cls, name, value)
+    return False
 
 
-def chain_metadata(*mds: ta.Mapping) -> types.MappingProxyType:
-    return types.MappingProxyType(collections.ChainMap(*mds))  # type: ignore  # noqa
+##
 
 
-def update_class_metadata(cls: type[T], *args: ta.Any) -> type[T]:
-    check.isinstance(cls, type)
-    setattr(cls, METADATA_ATTR, md := getattr(cls, METADATA_ATTR, {}))
-    md.setdefault(UserMetadata, []).extend(args)
-    return cls
+class SealableRegistry(ta.Generic[K, V]):
+    def __init__(self) -> None:
+        super().__init__()
 
+        self._dct: dict[K, V] = {}
+        self._sealed = False
 
-def update_field_metadata(f: dc.Field, nmd: ta.Mapping) -> dc.Field:
-    check.isinstance(f, dc.Field)
-    f.metadata = chain_metadata(nmd, f.metadata)
-    return f
+    def seal(self) -> None:
+        self._sealed = True
 
+    def __setitem__(self, k: K, v: V) -> None:
+        check.state(not self._sealed)
+        check.not_in(k, self._dct)
+        self._dct[k] = v
 
-def update_field_extras(f: dc.Field, *, unless_non_default: bool = False, **kwargs: ta.Any) -> dc.Field:
-    fe = get_field_extras(f)
-    return update_field_metadata(f, {
-        FieldExtras: dc.replace(fe, **{
-            k: v
-            for k, v in kwargs.items()
-            if not unless_non_default or v != getattr(DEFAULT_FIELD_EXTRAS, k)
-        }),
-    })
+    def __getitem__(self, k: K) -> V:
+        self.seal()
+        return self._dct[k]
 
+    def items(self) -> ta.Iterator[tuple[K, V]]:
+        self.seal()
+        return iter(self._dct.items())
 
-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:
-                try:
-                    v = cls.__dict__[a]
-                except KeyError:
-                    v = dc.field()
-                else:
-                    if not isinstance(v, dc.Field):
-                        v = dc.field(default=v)
-                setattr(cls, a, fn(a, v))
+##
 
-        return cls
 
-    check.not_isinstance(fields, str)
+def class_decorator(fn):
+    @functools.wraps(fn)
+    def inner(cls=None, *args, **kwargs):
+        if cls is None:
+            return lambda cls: fn(cls, *args, **kwargs)  # noqa
+        return fn(cls, *args, **kwargs)
     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 shallow_astuple(o: ta.Any) -> tuple[ta.Any, ...]:
-    return tuple(getattr(o, f.name) for f in dc.fields(o))
+_EMPTY_MAPPING_PROXY: ta.Mapping = types.MappingProxyType({})
 
 
-def shallow_asdict(o: ta.Any) -> dict[str, ta.Any]:
-    return {f.name: getattr(o, f.name) for f in dc.fields(o)}
-
-
-##
-
-
-def deep_replace(o: T, *args: str | ta.Callable[[ta.Any], ta.Mapping[str, ta.Any]]) -> T:
-    if not args:
-        return o
-    elif len(args) == 1:
-        return dc.replace(o, **args[0](o))  # type: ignore
+def chain_mapping_proxy(*ms: ta.Mapping) -> types.MappingProxyType:
+    m: ta.Any
+    if len(ms) > 1:
+        m = collections.ChainMap(*ms)  # type: ignore[arg-type]
+    elif ms:
+        [m] = ms
     else:
-        return dc.replace(o, **{args[0]: deep_replace(getattr(o, args[0]), *args[1:])})  # type: ignore
-
-
-##
-
-
-def iter_items(obj: ta.Any) -> ta.Iterator[tuple[str, ta.Any]]:
-    for f in dc.fields(obj):
-        yield (f.name, getattr(obj, f.name))
-
-
-def iter_keys(obj: ta.Any) -> ta.Iterator[str]:
-    for f in dc.fields(obj):
-        yield f.name
-
+        m = _EMPTY_MAPPING_PROXY
 
-def iter_values(obj: ta.Any) -> ta.Iterator[ta.Any]:
-    for f in dc.fields(obj):
-        yield getattr(obj, f.name)
+    return types.MappingProxyType(m)

omlish/diag/__init__.py

@@ -17,10 +17,10 @@ Debuggers
 
 CPU Profilers
  - cProfile - https://docs.python.org/3/library/profile.html
- - pyinstrument - https://github.com/joerick/pyinstrument
- - py-pspy - https://github.com/benfred/py-spy
- - austin-dist - https://github.com/P403n1x87/austin
- - yappi - https://github.com/sumerc/yappi
+ - yappi - https://github.com/sumerc/yappi - tracing
+ - pyinstrument - https://github.com/joerick/pyinstrument - pretty
+ - py-spy - https://github.com/benfred/py-spy - busted on mac
+ - austin-dist - https://github.com/P403n1x87/austin - old
 
 Memory Profilers
  - tracemalloc - https://docs.python.org/3/library/tracemalloc.html

omlish/inject/impl/origins.py

@@ -26,7 +26,7 @@ ORIGIN_IGNORED_PACKAGES = frozenset([
     lang.functions.__name__,
 
     dc.__name__,
-    dc.impl.__name__,  # noqa
+    *[m for m in sys.modules if m.startswith(dc.__name__ + '.')],
 ])
 
 

omlish/lang/cached/function.py

@@ -151,11 +151,12 @@ def _make_cache_key_maker(
 
 
 class _CachedFunction(ta.Generic[T], Abstract):
-    @dc.dataclass(frozen=True)
+    @dc.dataclass(frozen=True, kw_only=True)
     class Opts:
         map_maker: ta.Callable[[], ta.MutableMapping] = dict
         lock: DefaultLockable = None
         transient: bool = False
+        no_wrapper_update: bool = False
 
     def __init__(
             self,
@@ -175,7 +176,8 @@ class _CachedFunction(ta.Generic[T], Abstract):
         self._lock = default_lock(opts.lock, False)() if opts.lock is not None else None
         self._values = values if values is not None else opts.map_maker()
         self._value_fn = value_fn if value_fn is not None else fn
-        functools.update_wrapper(self, fn)
+        if not self._opts.no_wrapper_update:
+            functools.update_wrapper(self, fn)
 
     @property
     def _fn(self):

omlish/lang/maybes.py

@@ -1,6 +1,9 @@
 import abc
 import typing as ta
 
+from ..lite.maybes import Maybe as _LiteMaybe
+from ..lite.maybes import as_maybe as _as_lite_maybe
+
 
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
@@ -123,6 +126,9 @@ class _Maybe(Maybe[T], tuple):
         raise exception_supplier()
 
 
+#
+
+
 def just(v: T) -> Maybe[T]:
     return tuple.__new__(_Maybe, (v,))  # noqa
 
@@ -138,3 +144,14 @@ def maybe(o: T | None) -> Maybe[T]:
     if o is None:
         return _empty  # noqa
     return just(o)
+
+
+##
+
+
+@_as_lite_maybe.register
+def _(obj: Maybe) -> _LiteMaybe:
+    if obj.present:
+        return _LiteMaybe.just(obj.must())
+    else:
+        return _LiteMaybe.empty()

omlish/lite/maybes.py

@@ -1,10 +1,14 @@
 import abc
+import functools
 import typing as ta
 
 
 T = ta.TypeVar('T')
 
 
+##
+
+
 class Maybe(ta.Generic[T]):
     @property
     @abc.abstractmethod
@@ -43,3 +47,16 @@ class _Maybe(Maybe[T], tuple):
 
 
 Maybe._empty = tuple.__new__(_Maybe, ())  # noqa
+
+
+##
+
+
+@functools.singledispatch
+def as_maybe(obj: ta.Any) -> Maybe:
+    raise TypeError(obj)
+
+
+@as_maybe.register
+def _(obj: Maybe) -> Maybe:
+    return obj

omlish/marshal/objects/dataclasses.py

@@ -34,11 +34,7 @@ from .unmarshal import ObjectUnmarshaler
 
 
 def get_dataclass_metadata(ty: type) -> ObjectMetadata:
-    return check.opt_single(
-        e
-        for e in dc.get_merged_metadata(ty).get(dc.UserMetadata, [])
-        if isinstance(e, ObjectMetadata)
-    ) or ObjectMetadata()
+    return check.single(dc.reflect(ty).spec.metadata_by_type.get(ObjectMetadata) or [ObjectMetadata()])
 
 
 def get_dataclass_field_infos(
@@ -76,10 +72,10 @@ def get_dataclass_field_infos(
 
         f_ty: ta.Any
         if (
-                ((cpx := dc_rfl.cls_params_extras) is not None and cpx.generic_init) or
+                dc_rfl.spec.generic_init or
                 (fmd is not None and fmd.options.generic_replace)
         ):
-            f_ty = rfl.to_annotation(dc_rfl.generic_replaced_field_type(field.name))
+            f_ty = rfl.to_annotation(dc_rfl.fields_inspection.generic_replaced_field_type(field.name))
         else:
             f_ty = type_hints[field.name]
 

omlish/marshal/objects/helpers.py

@@ -14,7 +14,7 @@ T = ta.TypeVar('T')
 def update_field_metadata(**kwargs: ta.Any) -> dc.field_modifier:
     @dc.field_modifier
     def inner(f: dc.Field) -> dc.Field:
-        return dc.update_field_metadata(f, {
+        return dc.set_field_metadata(f, {
             FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
     return inner
@@ -25,7 +25,7 @@ def update_fields_metadata(
         **kwargs: ta.Any,
 ) -> ta.Callable[[type[T]], type[T]]:
     def inner(a: str, f: dc.Field) -> dc.Field:
-        return dc.update_field_metadata(f, {
+        return dc.set_field_metadata(f, {
             FieldMetadata: f.metadata.get(FieldMetadata, FieldMetadata()).update(**kwargs),
         })
 
@@ -37,7 +37,7 @@ def update_object_metadata(
         **kwargs: ta.Any,
 ):
     def inner(cls):
-        return dc.update_class_metadata(cls, ObjectMetadata(**kwargs))
+        return dc.append_class_metadata(cls, ObjectMetadata(**kwargs))
 
     if cls is not None:
         inner(cls)

omlish/secrets/marshal.py

@@ -44,7 +44,7 @@ class StrOrSecretRefMarshalerUnmarshaler(msh.Marshaler, msh.Unmarshaler):
 def marshal_secret_field(f: dc.Field) -> dc.Field:
     """Mostly obsolete with auto-registration below."""
 
-    return dc.update_field_metadata(f, {
+    return dc.set_field_metadata(f, {
         msh.FieldMetadata: dc.replace(
             f.metadata.get(msh.FieldMetadata, msh.FieldMetadata()),
             marshaler=StrOrSecretRefMarshalerUnmarshaler(),

omlish/secrets/secrets.py

@@ -79,7 +79,7 @@ def secret_repr(o: SecretRefOrStr | None) -> str | None:
 
 @dc.field_modifier
 def secret_field(f: dc.Field) -> dc.Field:
-    return dc.update_field_extras(
+    return dc.update_extra_field_params(
         f,
         repr_fn=secret_repr,
         unless_non_default=True,

omlish/sql/queries/base.py

@@ -29,7 +29,7 @@ class Node(
     lang.Abstract,
     eq=False,
     confer=frozenset([
-        *dc.get_metaclass_params(dc.Frozen).confer,
+        *dc.get_metaclass_spec(dc.Frozen).confer,
         'eq',
     ]),
 ):

omlish/text/minja.py

@@ -5,12 +5,14 @@ TODO:
  - raw
  - blocks / inheritance
 """
+import dataclasses as dc
 import io
 import re
 import typing as ta
 
 from ..lite.cached import cached_nullary
 from ..lite.check import check
+from ..lite.maybes import Maybe
 
 
 ##
@@ -29,6 +31,34 @@ class MinjaTemplate:
 ##
 
 
+@dc.dataclass(frozen=True)
+class MinjaTemplateParam:
+    name: str
+    default: Maybe[ta.Any] = Maybe.empty()
+
+    def __post_init__(self) -> None:
+        check.arg(self.name.isidentifier())
+
+    @classmethod
+    def of(cls, obj: ta.Union[str, 'MinjaTemplateParam']) -> 'MinjaTemplateParam':
+        if isinstance(obj, MinjaTemplateParam):
+            return obj
+        elif isinstance(obj, str):
+            return MinjaTemplateParam.new(obj)
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def new(cls, name: str, *defaults: ta.Any) -> 'MinjaTemplateParam':
+        dfl: Maybe[ta.Any]
+        if defaults:
+            [dv] = defaults
+            dfl = Maybe.just(dv)
+        else:
+            dfl = Maybe.empty()
+        return cls(name, dfl)
+
+
 class MinjaTemplateCompiler:
     """
     Compiles a template string into a Python function. The returned function takes a dictionary 'context' and returns
@@ -43,23 +73,28 @@ class MinjaTemplateCompiler:
     - {# comment #}: Ignored completely.
     """
 
-    DEFAULT_INDENT: str = '  '
+    DEFAULT_INDENT: str = ' ' * 4
 
     def __init__(
             self,
             src: str,
-            args: ta.Sequence[str],
+            params: ta.Sequence[ta.Union[str, MinjaTemplateParam]],
             *,
             indent: str = DEFAULT_INDENT,
     ) -> None:
         super().__init__()
 
+        check.not_isinstance(params, str)
+
         self._src = check.isinstance(src, str)
-        self._args = check.not_isinstance(args, str)
+        self._params = [
+            MinjaTemplateParam.of(p)
+            for p in params
+        ]
+        check.unique(p.name for p in self._params)
         self._indent_str: str = check.non_empty_str(indent)
 
         self._stack: ta.List[ta.Literal['for', 'if']] = []
-        self._lines: ta.List[str] = []
 
     #
 
@@ -124,41 +159,63 @@ class MinjaTemplateCompiler:
 
     _RENDER_FN_NAME = '__render'
 
+    class Rendered(ta.NamedTuple):
+        src: str
+        ns: ta.Dict[str, ta.Any]
+
     @cached_nullary
-    def render(self) -> ta.Tuple[str, ta.Mapping[str, ta.Any]]:
+    def render(self) -> Rendered:
+        lines: ta.List[str] = []
+
+        ns: ta.Dict[str, ta.Any] = {
+            '__StringIO': io.StringIO,
+        }
+
         parts = self._split_tags(self._src)
 
-        self._lines.append(f'def {self._RENDER_FN_NAME}({", ".join(self._args)}):')
-        self._lines.append(self._indent('__output = __StringIO()'))
+        if not self._params:
+            lines.append(f'def {self._RENDER_FN_NAME}():')
+        else:
+            lines.append(f'def {self._RENDER_FN_NAME}(')
+            for p in self._params:
+                if p.default.present:
+                    check.not_in(p.name, ns)
+                    ns[p.name] = p.default.must()
+                    lines.append(self._indent(f'{p.name}={p.name},'))
+                else:
+                    lines.append(self._indent(f'{p.name},'))
+            lines.append('):')
+
+        lines.append(self._indent('__output = __StringIO()'))
 
         for g, s in parts:
             if g == '{':
                 expr = s.strip()
-                self._lines.append(self._indent(f'__output.write(str({expr}))'))
+                lines.append(self._indent(f'__output.write(str({expr}))'))
 
             elif g == '%':
                 stmt = s.strip()
 
                 if stmt.startswith('for '):
-                    self._lines.append(self._indent(stmt + ':'))
+                    lines.append(self._indent(stmt + ':'))
                     self._stack.append('for')
                 elif stmt.startswith('endfor'):
                     check.equal(self._stack.pop(), 'for')
 
                 elif stmt.startswith('if '):
-                    self._lines.append(self._indent(stmt + ':'))
+                    lines.append(self._indent(stmt + ':'))
                     self._stack.append('if')
                 elif stmt.startswith('elif '):
                     check.equal(self._stack[-1], 'if')
-                    self._lines.append(self._indent(stmt + ':', -1))
+                    lines.append(self._indent(stmt + ':', -1))
                 elif stmt.strip() == 'else':
                     check.equal(self._stack[-1], 'if')
-                    self._lines.append(self._indent('else:', -1))
+                    lines.append(self._indent('else:', -1))
                 elif stmt.startswith('endif'):
                     check.equal(self._stack.pop(), 'if')
 
                 else:
-                    self._lines.append(self._indent(stmt))
+                    lines.append(self._indent(stmt))
 
             elif g == '#':
                 pass
@@ -166,20 +223,16 @@ class MinjaTemplateCompiler:
             elif not g:
                 if s:
                     safe_text = s.replace('"""', '\\"""')
-                    self._lines.append(self._indent(f'__output.write("""{safe_text}""")'))
+                    lines.append(self._indent(f'__output.write("""{safe_text}""")'))
 
             else:
                 raise KeyError(g)
 
         check.empty(self._stack)
 
-        self._lines.append(self._indent('return __output.getvalue()'))
-
-        ns = {
-            '__StringIO': io.StringIO,
-        }
+        lines.append(self._indent('return __output.getvalue()'))
 
-        return ('\n'.join(self._lines), ns)
+        return self.Rendered('\n'.join(lines), ns)
 
     #
 
@@ -200,12 +253,12 @@ class MinjaTemplateCompiler:
 
     @cached_nullary
     def compile(self) -> MinjaTemplate:
-        render_src, render_ns = self.render()
+        rendered = self.render()
 
         render_fn = self._make_fn(
             self._RENDER_FN_NAME,
-            render_src,
-            render_ns,
+            rendered.src,
+            rendered.ns,
         )
 
         return MinjaTemplate(render_fn)
@@ -214,8 +267,11 @@ class MinjaTemplateCompiler:
 ##
 
 
-def compile_minja_template(src: str, args: ta.Sequence[str] = ()) -> MinjaTemplate:
-    return MinjaTemplateCompiler(src, args).compile()
+def compile_minja_template(
+        src: str,
+        params: ta.Sequence[ta.Union[str, MinjaTemplateParam]] = (),
+) -> MinjaTemplate:
+    return MinjaTemplateCompiler(src, params).compile()
 
 
 def render_minja_template(src: str, **kwargs: ta.Any) -> str: