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

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
@@ -65,6 +67,10 @@ from .polymorphism import (  # noqa
     polymorphism_from_subclasses,
 )
 
+from .primitives import (  # noqa
+    PRIMITIVE_TYPES,
+)
+
 from .registries import (  # noqa
     Registry,
 )

omlish/marshal/base64.py

@@ -1,3 +1,7 @@
+"""
+FIXME:
+ - don't base64 by default, only for json-esque targets
+"""
 import base64
 import typing as ta
 

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/marshal/primitives.py

@@ -9,6 +9,9 @@ from .base import Unmarshaler
 from .values import Value
 
 
+##
+
+
 PRIMITIVE_TYPES: tuple[type, ...] = (
     bool,
     int,
@@ -19,6 +22,9 @@ PRIMITIVE_TYPES: tuple[type, ...] = (
 )
 
 
+##
+
+
 class PrimitiveMarshalerUnmarshaler(Marshaler, Unmarshaler):
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
         if isinstance(o, PRIMITIVE_TYPES):

omlish/marshal/standard.py

@@ -27,6 +27,8 @@ from .optionals import OptionalMarshalerFactory
 from .optionals import OptionalUnmarshalerFactory
 from .primitives import PRIMITIVE_MARSHALER_FACTORY
 from .primitives import PRIMITIVE_UNMARSHALER_FACTORY
+from .unions import PrimitiveUnionMarshalerFactory
+from .unions import PrimitiveUnionUnmarshalerFactory
 from .uuids import UUID_MARSHALER_FACTORY
 from .uuids import UUID_UNMARSHALER_FACTORY
 
@@ -37,6 +39,7 @@ from .uuids import UUID_UNMARSHALER_FACTORY
 STANDARD_MARSHALER_FACTORIES: list[MarshalerFactory] = [
     PRIMITIVE_MARSHALER_FACTORY,
     OptionalMarshalerFactory(),
+    PrimitiveUnionMarshalerFactory(),
     DataclassMarshalerFactory(),
     EnumMarshalerFactory(),
     NUMBERS_MARSHALER_FACTORY,
@@ -66,6 +69,7 @@ def new_standard_marshaler_factory() -> MarshalerFactory:
 STANDARD_UNMARSHALER_FACTORIES: list[UnmarshalerFactory] = [
     PRIMITIVE_UNMARSHALER_FACTORY,
     OptionalUnmarshalerFactory(),
+    PrimitiveUnionUnmarshalerFactory(),
     DataclassUnmarshalerFactory(),
     EnumUnmarshalerFactory(),
     NUMBERS_UNMARSHALER_FACTORY,

omlish/marshal/unions.py

@@ -0,0 +1,101 @@
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import matchfns as mfs
+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
+
+
+##
+
+
+class MatchUnionMarshaler(Marshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        try:
+            m = self.mmf.match(ctx, o)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(o)  # noqa
+        return m.fn(ctx, o)
+
+
+class MatchUnionUnmarshaler(Unmarshaler):
+    mmf: mfs.MultiMatchFn[[UnmarshalContext, Value], ta.Any]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        try:
+            m = self.mmf.match(ctx, v)
+        except mfs.AmbiguousMatchesError:
+            raise ValueError(v)  # noqa
+        return m.fn(ctx, v)
+
+
+##
+
+
+PRIMITIVE_UNION_TYPES: tuple[type, ...] = (
+    float,
+    int,
+    str,
+)
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshaler(Marshaler):
+    tys: ta.Sequence[type]
+
+    def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionMarshalerFactory(MarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionMarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshaler(Unmarshaler):
+    tys: ta.Sequence[type]
+
+    def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class PrimitiveUnionUnmarshalerFactory(UnmarshalerFactory):
+    tys: ta.Sequence[type] = PRIMITIVE_UNION_TYPES
+
+    def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
+        return isinstance(rty, rfl.Union) and all(a in self.tys for a in rty.args)
+
+    def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
+        args = check.isinstance(rty, rfl.Union).args
+        return PrimitiveUnionUnmarshaler([t for t in self.tys if t in args])
+
+
+#
+
+
+PRIMITIVE_UNION_MARSHALER_FACTORY = PrimitiveUnionMarshalerFactory()
+PRIMITIVE_UNION_UNMARSHALER_FACTORY = PrimitiveUnionUnmarshalerFactory()

omlish/matchfns.py

@@ -93,7 +93,7 @@ class MultiMatchFn(MatchFn[P, T]):
     children: ta.Sequence[MatchFn[P, T]]
     strict: bool = False
 
-    def _match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
+    def match(self, *args: P.args, **kwargs: P.kwargs) -> MatchFn[P, T] | None:
         matches = []
         for cur in self.children:
             if cur.guard(*args, **kwargs):
@@ -109,10 +109,10 @@ class MultiMatchFn(MatchFn[P, T]):
             return matches[0]
 
     def guard(self, *args: P.args, **kwargs: P.kwargs) -> bool:
-        return self._match(*args, **kwargs) is not None
+        return self.match(*args, **kwargs) is not None
 
     def fn(self, *args: P.args, **kwargs: P.kwargs) -> T:
-        if (m := self._match(*args, **kwargs)) is None:
+        if (m := self.match(*args, **kwargs)) is None:
             raise MatchGuardError(*args, **kwargs)
         return m.fn(*args, **kwargs)
 

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/sql/__init__.py

@@ -7,3 +7,21 @@ from .asyncs import (  # noqa
     AsyncTransactionLike,
     async_adapt,
 )
+
+from .dbs import (  # noqa
+    DbLoc,
+    DbSpec,
+    DbType,
+    DbTypes,
+    HostDbLoc,
+    UrlDbLoc,
+)
+
+from .exprs import (  # noqa
+    paren,
+)
+
+from .qualifiedname import (  # noqa
+    QualifiedName,
+    qn,
+)

omlish/sql/qualifiedname.py

@@ -0,0 +1,82 @@
+import collections.abc
+import dataclasses as dc
+import typing as ta
+
+
+@dc.dataclass(frozen=True)
+class QualifiedName(ta.Sequence[str]):
+    parts: ta.Sequence[str]
+
+    def __post_init__(self) -> None:
+        if not (
+                self.parts and
+                not isinstance(self.parts, str) and
+                all(self.parts) and
+                all(isinstance(p, str) for p in self.parts)
+        ):
+            raise ValueError(self)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}([{", ".join(map(repr, self.parts))}])'
+
+    @property
+    def dotted(self) -> str:
+        return '.'.join(self.parts)
+
+    def prefixed(self, sz: int) -> tuple[str | None, ...]:
+        if len(self) > sz:
+            raise ValueError(self)
+        return ((None,) * (sz - len(self))) + tuple(self.parts)
+
+    @property
+    def pair(self) -> tuple[str | None, str]:
+        return self.prefixed(2)  # type: ignore
+
+    @property
+    def triple(self) -> tuple[str | None, str | None, str]:
+        return self.prefixed(3)  # type: ignore
+
+    @property
+    def quad(self) -> tuple[str | None, str | None, str | None, str]:
+        return self.prefixed(4)  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[str]:
+        return iter(self.parts)
+
+    def __len__(self) -> int:
+        return len(self.parts)
+
+    def __getitem__(self, idx: int) -> str:  # type: ignore
+        return self.parts[idx]
+
+    @classmethod
+    def of_dotted(cls, dotted: str) -> 'QualifiedName':
+        return cls(dotted.split('.'))
+
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Union['QualifiedName', ta.Iterable[str]],
+    ) -> 'QualifiedName':
+        if isinstance(obj, QualifiedName):
+            return obj
+        elif isinstance(obj, str):
+            raise TypeError(obj)
+        elif isinstance(obj, collections.abc.Iterable):
+            return cls(list(obj))
+        else:
+            raise TypeError(obj)
+
+    @classmethod
+    def of_optional(
+            cls,
+            obj: ta.Union['QualifiedName', ta.Iterable[str], None],
+    ) -> ta.Optional['QualifiedName']:
+        if obj is None:
+            return None
+        else:
+            return cls.of(obj)
+
+
+def qn(*args: str) -> QualifiedName:
+    return QualifiedName(args)

omlish/stats.py

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

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

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