omlish 0.0.0.dev23__py3-none-any.whl → 0.0.0.dev24__py3-none-any.whl

omlish/genmachine.py

@@ -1,5 +1,6 @@
 """
-https://github.com/pytransitions/transitions
+See:
+ - https://github.com/pytransitions/transitions
 """
 import typing as ta
 

omlish/graphs/trees.py

@@ -190,7 +190,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         e: ta.Any
         d: ta.Any
         if identity:
-            e, d = id, col.unique_map(((id(n), n) for n, _ in pairs), strict=True)
+            e, d = id, col.make_map(((id(n), n) for n, _ in pairs), strict=True)
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}

omlish/lang/__init__.py

@@ -79,7 +79,7 @@ from .descriptors import (  # noqa
     unwrap_func,
     unwrap_func_with_partials,
     unwrap_method_descriptors,
-    update_wrapper_except_dict,
+    update_wrapper,
 )
 
 from .exceptions import (  # noqa
@@ -154,6 +154,18 @@ from .objects import (  # noqa
     super_meta,
 )
 
+from .resolving import (  # noqa
+    Resolvable,
+    ResolvableClassNameError,
+    get_cls_fqcn,
+    get_fqcn_cls,
+)
+
+from .resources import (  # noqa
+    RelativeResource,
+    get_relative_resources,
+)
+
 from .strings import (  # noqa
     BOOL_FALSE_STRINGS,
     BOOL_STRINGS,

omlish/lang/cached.py

@@ -220,7 +220,7 @@ def cached_function(fn=None, **kwargs):  # noqa
 ##
 
 
-class _CachedProperty:
+class _CachedProperty(property):
     def __init__(
             self,
             fn,
@@ -229,9 +229,9 @@ class _CachedProperty:
             ignore_if=lambda _: False,
             clear_on_init=False,
     ):
-        super().__init__()
         if isinstance(fn, property):
             fn = fn.fget
+        super().__init__(fn)
         self._fn = fn
         self._ignore_if = ignore_if
         self._name = name
@@ -265,6 +265,9 @@ class _CachedProperty:
             return
         raise TypeError(self._name)
 
+    def __delete__(self, instance):
+        raise TypeError
+
 
 def cached_property(fn=None, **kwargs):  # noqa
     if fn is None:

omlish/lang/descriptors.py

@@ -91,21 +91,38 @@ def unwrap_func_with_partials(fn: ta.Callable) -> tuple[ta.Callable, list[functo
 ##
 
 
-WRAPPER_UPDATES_EXCEPT_DICT = tuple(a for a in functools.WRAPPER_UPDATES if a != '__dict__')
+def update_wrapper(
+        wrapper: T,
+        wrapped: ta.Any,
+        assigned: ta.Iterable[str] = functools.WRAPPER_ASSIGNMENTS,
+        updated: ta.Iterable[str] = functools.WRAPPER_UPDATES,
+        *,
+        filter: ta.Iterable[str] | None = None,  # noqa
+        getattr: ta.Callable = getattr,  # noqa
+        setattr: ta.Callable = setattr,  # noqa
+) -> T:
+    if filter:
+        if isinstance(filter, str):
+            filter = [filter]  # noqa
+        assigned = tuple(a for a in assigned if a not in filter)
+        updated = tuple(a for a in updated if a not in filter)
+
+    for attr in assigned:
+        try:
+            value = getattr(wrapped, attr)
+        except AttributeError:
+            pass
+        else:
+            setattr(wrapper, attr, value)
+
+    for attr in updated:
+        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
 
+    # Issue #17482: set __wrapped__ last so we don't inadvertently copy it from the wrapped function when updating
+    # __dict__
+    setattr(wrapper, '__wrapped__', wrapped)
 
-def update_wrapper_except_dict(
-        wrapper,
-        wrapped,
-        assigned=functools.WRAPPER_ASSIGNMENTS,
-        updated=WRAPPER_UPDATES_EXCEPT_DICT,
-):
-    return functools.update_wrapper(
-        wrapper,
-        wrapped,
-        assigned=assigned,
-        updated=updated,
-    )
+    return wrapper
 
 
 ##
@@ -118,7 +135,7 @@ class _decorator_descriptor:  # noqa
     if not _DECORATOR_HANDLES_UNBOUND_METHODS:
         def __init__(self, wrapper, fn):
             self._wrapper, self._fn = wrapper, fn
-            update_wrapper_except_dict(self, fn)
+            update_wrapper(self, fn, filter='__dict__')
 
         def __get__(self, instance, owner=None):
             return functools.update_wrapper(functools.partial(self._wrapper, fn := self._fn.__get__(instance, owner)), fn)  # noqa
@@ -127,7 +144,7 @@ class _decorator_descriptor:  # noqa
         def __init__(self, wrapper, fn):
             self._wrapper, self._fn = wrapper, fn
             self._md = _has_method_descriptor(fn)
-            update_wrapper_except_dict(self, fn)
+            update_wrapper(self, fn, filter='__dict__')
 
         def __get__(self, instance, owner=None):
             fn = self._fn.__get__(instance, owner)
@@ -157,7 +174,7 @@ class _decorator_descriptor:  # noqa
 class _decorator:  # noqa
     def __init__(self, wrapper):
         self._wrapper = wrapper
-        update_wrapper_except_dict(self, wrapper)
+        update_wrapper(self, wrapper, filter='__dict__')
 
     def __repr__(self):
         return f'{self.__class__.__name__}<{self._wrapper}>'

omlish/lang/resources.py

@@ -0,0 +1,60 @@
+import functools
+import importlib.resources
+import os.path
+import typing as ta
+
+
+class RelativeResource(ta.NamedTuple):
+    name: str
+    is_file: bool
+    read_bytes: ta.Callable[[], bytes]
+
+
+def get_relative_resources(
+        prefix: str | None = None,
+        *,
+        globals: ta.Mapping[str, ta.Any] | None = None,  # noqa
+        package: str | None = None,
+        file: str | None = None,
+) -> ta.Mapping[str, RelativeResource]:
+    if globals is not None:
+        if not package:
+            package = globals.get('__package__')
+        if not file:
+            file = globals.get('__file__')
+
+    lst: list[RelativeResource] = []
+
+    if package:
+        anchor = package
+        if prefix:
+            anchor += '.' + prefix.replace(os.sep, '.')
+
+        for pf in importlib.resources.files(anchor).iterdir():
+            lst.append(RelativeResource(
+                name=pf.name,
+                is_file=pf.is_file(),
+                read_bytes=pf.read_bytes if pf.is_file() else None,  # type: ignore
+            ))
+
+    elif file:
+        path = os.path.dirname(file)
+        if prefix:
+            path = os.path.join(path, prefix.replace('.', os.sep))
+
+        def _read_file(fp: str) -> bytes:
+            with open(fp, 'rb') as f:
+                return f.read()
+
+        for ff in os.listdir(path):
+            ff = os.path.join(path, ff)
+            lst.append(RelativeResource(
+                name=os.path.basename(ff),
+                is_file=os.path.isfile(ff),
+                read_bytes=functools.partial(_read_file, ff),
+            ))
+
+    else:
+        raise RuntimeError('no package or file specified')
+
+    return {r.name: r for r in lst}

omlish/lite/logs.py

@@ -97,13 +97,134 @@ class StandardLogFormatter(logging.Formatter):
 ##
 
 
+class ProxyLogFilterer(logging.Filterer):
+    def __init__(self, underlying: logging.Filterer) -> None:  # noqa
+        self._underlying = underlying
+
+    @property
+    def underlying(self) -> logging.Filterer:
+        return self._underlying
+
+    @property
+    def filters(self):
+        return self._underlying.filters
+
+    @filters.setter
+    def filters(self, filters):
+        self._underlying.filters = filters
+
+    def addFilter(self, filter):  # noqa
+        self._underlying.addFilter(filter)
+
+    def removeFilter(self, filter):  # noqa
+        self._underlying.removeFilter(filter)
+
+    def filter(self, record):
+        return self._underlying.filter(record)
+
+
+class ProxyLogHandler(ProxyLogFilterer, logging.Handler):
+    def __init__(self, underlying: logging.Handler) -> None:  # noqa
+        ProxyLogFilterer.__init__(self, underlying)
+
+    _underlying: logging.Handler
+
+    @property
+    def underlying(self) -> logging.Handler:
+        return self._underlying
+
+    def get_name(self):
+        return self._underlying.get_name()
+
+    def set_name(self, name):
+        self._underlying.set_name(name)
+
+    @property
+    def name(self):
+        return self._underlying.name
+
+    @property
+    def level(self):
+        return self._underlying.level
+
+    @level.setter
+    def level(self, level):
+        self._underlying.level = level
+
+    @property
+    def formatter(self):
+        return self._underlying.formatter
+
+    @formatter.setter
+    def formatter(self, formatter):
+        self._underlying.formatter = formatter
+
+    def createLock(self):
+        self._underlying.createLock()
+
+    def acquire(self):
+        self._underlying.acquire()
+
+    def release(self):
+        self._underlying.release()
+
+    def setLevel(self, level):
+        self._underlying.setLevel(level)
+
+    def format(self, record):
+        return self._underlying.format(record)
+
+    def emit(self, record):
+        self._underlying.emit(record)
+
+    def handle(self, record):
+        return self._underlying.handle(record)
+
+    def setFormatter(self, fmt):
+        self._underlying.setFormatter(fmt)
+
+    def flush(self):
+        self._underlying.flush()
+
+    def close(self):
+        self._underlying.close()
+
+    def handleError(self, record):
+        self._underlying.handleError(record)
+
+
+##
+
+
+class StandardLogHandler(ProxyLogHandler):
+    pass
+
+
+##
+
+
 def configure_standard_logging(
         level: ta.Union[int, str] = logging.INFO,
         *,
         json: bool = False,
-) -> logging.Handler:
+        target: ta.Optional[logging.Logger] = None,
+        no_check: bool = False,
+) -> ta.Optional[StandardLogHandler]:
+    if target is None:
+        target = logging.root
+
+    #
+
+    if not no_check:
+        if any(isinstance(h, StandardLogHandler) for h in list(target.handlers)):
+            return None
+
+    #
+
     handler = logging.StreamHandler()
 
+    #
+
     formatter: logging.Formatter
     if json:
         formatter = JsonLogFormatter()
@@ -111,11 +232,19 @@ def configure_standard_logging(
         formatter = StandardLogFormatter(StandardLogFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
     handler.setFormatter(formatter)
 
+    #
+
     handler.addFilter(TidLogFilter())
 
-    logging.root.addHandler(handler)
+    #
+
+    target.addHandler(handler)
+
+    #
 
     if level is not None:
-        logging.root.setLevel(level)
+        target.setLevel(level)
+
+    #
 
-    return handler
+    return StandardLogHandler(handler)

omlish/logs/__init__.py

@@ -4,8 +4,6 @@ from .configs import (  # noqa
 
 from .formatters import (  # noqa
     ColorLogFormatter,
-    JsonLogFormatter,
-    StandardLogFormatter,
 )
 
 from .handlers import (  # noqa
@@ -15,3 +13,20 @@ from .handlers import (  # noqa
 from .utils import (  # noqa
     error_logging,
 )
+
+
+##
+
+
+from ..lite.logs import (  # noqa
+    TidLogFilter,
+    JsonLogFormatter,
+
+    STANDARD_LOG_FORMAT_PARTS,
+    StandardLogFormatter,
+
+    ProxyLogFilterer,
+    ProxyLogHandler,
+
+    StandardLogHandler,
+)

omlish/logs/configs.py

@@ -2,6 +2,7 @@ import dataclasses as dc
 import logging
 import typing as ta
 
+from ..lite.logs import StandardLogHandler
 from ..lite.logs import configure_standard_logging as configure_lite_standard_logging
 from .noisy import silence_noisy_loggers
 
@@ -34,12 +35,23 @@ def configure_standard_logging(
         level: ta.Any = None,
         *,
         json: bool = False,
-) -> logging.Handler:
+        target: logging.Logger | None = None,
+        no_check: bool = False,
+) -> StandardLogHandler | None:
     handler = configure_lite_standard_logging(
         level,
         json=json,
+        target=target,
+        no_check=no_check,
     )
 
+    if handler is None:
+        return None
+
+    #
+
     silence_noisy_loggers()
 
+    #
+
     return handler

omlish/logs/formatters.py

@@ -3,7 +3,6 @@ import logging
 import typing as ta
 
 from .. import term
-from ..lite.logs import JsonLogFormatter  # noqa
 from ..lite.logs import StandardLogFormatter
 
 

omlish/marshal/__init__.py

@@ -49,7 +49,9 @@ from .global_ import (  # noqa
 )
 
 from .helpers import (  # noqa
+    update_field_metadata,
     update_fields_metadata,
+    update_object_metadata,
 )
 
 from .objects import (  # noqa

omlish/marshal/helpers.py

@@ -2,11 +2,24 @@ import typing as ta
 
 from .. import dataclasses as dc
 from .objects import FieldMetadata
+from .objects import ObjectMetadata
 
 
 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, {
+            FieldMetadata: dc.replace(
+                f.metadata.get(FieldMetadata, FieldMetadata()),
+                **kwargs,
+            ),
+        })
+    return inner
+
+
 def update_fields_metadata(
         fields: ta.Iterable[str] | None = None,
         **kwargs: ta.Any,
@@ -20,3 +33,17 @@ def update_fields_metadata(
         })
 
     return dc.update_fields(inner, fields)
+
+
+def update_object_metadata(
+        cls: type | None = None,
+        **kwargs: ta.Any,
+):
+    def inner(cls):
+        return dc.update_class_metadata(cls, ObjectMetadata(**kwargs))
+
+    if cls is not None:
+        inner(cls)
+        return cls
+    else:
+        return inner

omlish/specs/jsonschema/keywords/base.py

@@ -37,12 +37,12 @@ class Keywords(lang.Final):
     @cached.property
     @dc.init
     def by_type(self) -> ta.Mapping[type[Keyword], Keyword]:
-        return col.unique_map_by(type, self.lst, strict=True)  # noqa
+        return col.make_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
+        return col.make_map_by(operator.attrgetter('tag'), self.lst, strict=True)  # noqa
 
     def __getitem__(self, item: type[KeywordT] | str) -> KeywordT:
         if isinstance(item, type):

omlish/specs/jsonschema/keywords/parse.py

@@ -24,7 +24,7 @@ KeywordT = ta.TypeVar('KeywordT', bound=Keyword)
 ##
 
 
-KEYWORD_TYPES_BY_TAG: ta.Mapping[str, type[Keyword]] = col.unique_map_by(  # noqa
+KEYWORD_TYPES_BY_TAG: ta.Mapping[str, type[Keyword]] = col.make_map_by(  # noqa
     operator.attrgetter('tag'),
     (cls for cls in lang.deep_subclasses(Keyword) if not lang.is_abstract_class(cls)),
     strict=True,

omlish/stats.py

@@ -2,6 +2,7 @@
 TODO:
  - reservoir
  - dep tdigest?
+ - struct-of-arrays backed SamplingHistogram
 """
 import bisect
 import collections

{omlish-0.0.0.dev23.dist-info → omlish-0.0.0.dev24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev23
+Version: 0.0.0.dev24
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause