omlish 0.0.0.dev23__py3-none-any.whl → 0.0.0.dev25__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/lang/typing.py

@@ -14,6 +14,9 @@ import typing as ta
 Ty = ta.TypeVar('Ty', bound=type)
 
 T = ta.TypeVar('T')
+T_co = ta.TypeVar('T_co', covariant=True)
+T_contra = ta.TypeVar('T_contra', contravariant=True)
+
 A0 = ta.TypeVar('A0')
 A1 = ta.TypeVar('A1')
 A2 = ta.TypeVar('A2')
@@ -133,3 +136,32 @@ class Func3(ta.Generic[A0, A1, A2, T]):
 
     def __call__(self, a0: A0, a1: A1, a2: A2) -> T:
         return self.fn(a0, a1, a2)
+
+
+##
+
+
+class SequenceNotStr(ta.Protocol[T_co]):
+    """
+    https://github.com/python/mypy/issues/11001
+    https://github.com/python/typing/issues/256#issuecomment-1442633430
+    https://github.com/hauntsaninja/useful_types/blob/735ef9dd0b55b35b118ef630d5a0f3618ecedbff/useful_types/__init__.py#L285
+    """
+
+    @ta.overload
+    def __getitem__(self, index: ta.SupportsIndex, /) -> T_co: ...
+
+    @ta.overload
+    def __getitem__(self, index: slice, /) -> ta.Sequence[T_co]: ...  # noqa
+
+    def __contains__(self, value: object, /) -> bool: ...
+
+    def __len__(self) -> int: ...
+
+    def __iter__(self) -> ta.Iterator[T_co]: ...
+
+    def index(self, value: ta.Any, start: int = 0, stop: int = ..., /) -> int: ...
+
+    def count(self, value: ta.Any, /) -> int: ...
+
+    def __reversed__(self) -> ta.Iterator[T_co]: ...

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/specs/jsonschema/schemas/draft202012/metaschema.json

@@ -0,0 +1,58 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/schema",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core and Validation specifications meta-schema",
+    "allOf": [
+        {"$ref": "meta/core"},
+        {"$ref": "meta/applicator"},
+        {"$ref": "meta/unevaluated"},
+        {"$ref": "meta/validation"},
+        {"$ref": "meta/meta-data"},
+        {"$ref": "meta/format-annotation"},
+        {"$ref": "meta/content"}
+    ],
+    "type": ["object", "boolean"],
+    "$comment": "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+    "properties": {
+        "definitions": {
+            "$comment": "\"definitions\" has been replaced by \"$defs\".",
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "deprecated": true,
+            "default": {}
+        },
+        "dependencies": {
+            "$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+            "type": "object",
+            "additionalProperties": {
+                "anyOf": [
+                    { "$dynamicRef": "#meta" },
+                    { "$ref": "meta/validation#/$defs/stringArray" }
+                ]
+            },
+            "deprecated": true,
+            "default": {}
+        },
+        "$recursiveAnchor": {
+            "$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+            "$ref": "meta/core#/$defs/anchorString",
+            "deprecated": true
+        },
+        "$recursiveRef": {
+            "$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+            "$ref": "meta/core#/$defs/uriReferenceString",
+            "deprecated": true
+        }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/applicator.json

@@ -0,0 +1,48 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/applicator",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Applicator vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "prefixItems": { "$ref": "#/$defs/schemaArray" },
+        "items": { "$dynamicRef": "#meta" },
+        "contains": { "$dynamicRef": "#meta" },
+        "additionalProperties": { "$dynamicRef": "#meta" },
+        "properties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "patternProperties": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "propertyNames": { "format": "regex" },
+            "default": {}
+        },
+        "dependentSchemas": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" },
+            "default": {}
+        },
+        "propertyNames": { "$dynamicRef": "#meta" },
+        "if": { "$dynamicRef": "#meta" },
+        "then": { "$dynamicRef": "#meta" },
+        "else": { "$dynamicRef": "#meta" },
+        "allOf": { "$ref": "#/$defs/schemaArray" },
+        "anyOf": { "$ref": "#/$defs/schemaArray" },
+        "oneOf": { "$ref": "#/$defs/schemaArray" },
+        "not": { "$dynamicRef": "#meta" }
+    },
+    "$defs": {
+        "schemaArray": {
+            "type": "array",
+            "minItems": 1,
+            "items": { "$dynamicRef": "#meta" }
+        }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/content.json

@@ -0,0 +1,17 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/content",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Content vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "contentEncoding": { "type": "string" },
+        "contentMediaType": { "type": "string" },
+        "contentSchema": { "$dynamicRef": "#meta" }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/core.json

@@ -0,0 +1,51 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/core",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Core vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "$id": {
+            "$ref": "#/$defs/uriReferenceString",
+            "$comment": "Non-empty fragments not allowed.",
+            "pattern": "^[^#]*#?$"
+        },
+        "$schema": { "$ref": "#/$defs/uriString" },
+        "$ref": { "$ref": "#/$defs/uriReferenceString" },
+        "$anchor": { "$ref": "#/$defs/anchorString" },
+        "$dynamicRef": { "$ref": "#/$defs/uriReferenceString" },
+        "$dynamicAnchor": { "$ref": "#/$defs/anchorString" },
+        "$vocabulary": {
+            "type": "object",
+            "propertyNames": { "$ref": "#/$defs/uriString" },
+            "additionalProperties": {
+                "type": "boolean"
+            }
+        },
+        "$comment": {
+            "type": "string"
+        },
+        "$defs": {
+            "type": "object",
+            "additionalProperties": { "$dynamicRef": "#meta" }
+        }
+    },
+    "$defs": {
+        "anchorString": {
+            "type": "string",
+            "pattern": "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        "uriString": {
+            "type": "string",
+            "format": "uri"
+        },
+        "uriReferenceString": {
+            "type": "string",
+            "format": "uri-reference"
+        }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/format-annotation.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-annotation",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for annotation results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/format-assertion.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/format-assertion",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/format-assertion": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Format vocabulary meta-schema for assertion results",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/format.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://json-schema.org/draft/2019-09/meta/format",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2019-09/vocab/format": true
+    },
+    "$recursiveAnchor": true,
+
+    "title": "Format vocabulary meta-schema",
+    "type": ["object", "boolean"],
+    "properties": {
+        "format": { "type": "string" }
+    }
+}

omlish/specs/jsonschema/schemas/draft202012/vocabularies/meta-data.json

@@ -0,0 +1,37 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://json-schema.org/draft/2020-12/meta/meta-data",
+    "$vocabulary": {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+    },
+    "$dynamicAnchor": "meta",
+
+    "title": "Meta-data vocabulary meta-schema",
+
+    "type": ["object", "boolean"],
+    "properties": {
+        "title": {
+            "type": "string"
+        },
+        "description": {
+            "type": "string"
+        },
+        "default": true,
+        "deprecated": {
+            "type": "boolean",
+            "default": false
+        },
+        "readOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "writeOnly": {
+            "type": "boolean",
+            "default": false
+        },
+        "examples": {
+            "type": "array",
+            "items": true
+        }
+    }
+}