omlish 0.0.0.dev33__tar.gz → 0.0.0.dev35__tar.gz

{omlish-0.0.0.dev33/omlish.egg-info → omlish-0.0.0.dev35}/PKG-INFO

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

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev33'
-__revision__ = 'd7a0b08ef5d46a2402c157972b3b25f71ed628ca-dirty'
+__version__ = '0.0.0.dev35'
+__revision__ = '09ecafb4e40514a369e0a2cf2cfe90c5c317b186-dirty'
 
 
 #

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/bootstrap/marshal.py

@@ -4,7 +4,7 @@ from .base import Bootstrap
 from .harness import BOOTSTRAP_TYPES_BY_NAME
 
 
-@lang.cached_function
+@lang.static_init
 def _install_standard_marshalling() -> None:
     cfgs_poly = msh.Polymorphism(
         Bootstrap.Config,
@@ -13,6 +13,3 @@ def _install_standard_marshalling() -> None:
 
     msh.STANDARD_MARSHALER_FACTORIES[0:0] = [msh.PolymorphismMarshalerFactory(cfgs_poly)]
     msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [msh.PolymorphismUnmarshalerFactory(cfgs_poly)]
-
-
-_install_standard_marshalling()

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/dataclasses/impl/api.py

@@ -33,7 +33,7 @@ def field(  # noqa
         derive: ta.Callable[..., ta.Any] | None = None,
         coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None,
         validate: ta.Callable[[ta.Any], bool] | None = None,
-        check_type: bool | None = None,
+        check_type: bool | type | None = None,
         override: bool = False,
         repr_fn: ta.Callable[[ta.Any], str | None] | None = None,
         frozen: bool | None = None,

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/dataclasses/impl/fields.py

@@ -193,7 +193,14 @@ def field_init(
 
     if fx.check_type:
         cn = f'__dataclass_check_type__{f.name}__'
-        locals[cn] = f.type
+        if isinstance(fx.check_type, type):
+            ct = fx.check_type
+        # FIXME:
+        # elif info.params_extras.generic_init:
+        #     ct = info.generic_replaced_field_annotations[f.name]
+        else:
+            ct = f.type
+        locals[cn] = ct
         lines.append(
             f'if not __dataclass_builtins_isinstance__({value}, {cn}): '
             f'raise __dataclass_builtins_TypeError__({value}, {cn})',

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/dataclasses/impl/params.py

@@ -45,7 +45,7 @@ class FieldExtras(lang.Final):
     derive: ta.Callable[..., ta.Any] | None = None  # TODO
     coerce: bool | ta.Callable[[ta.Any], ta.Any] | None = None
     validate: ta.Callable[[ta.Any], bool] | None = None
-    check_type: bool | None = None
+    check_type: bool | type | None = None
     override: bool = False
     repr_fn: ta.Callable[[ta.Any], str | None] | None = None
     frozen: bool | None = None  # TODO

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/lang/__init__.py

@@ -1,6 +1,7 @@
 from .cached import (  # noqa
     cached_function,
     cached_property,
+    static_init,
 )
 
 from .classes import (  # noqa

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/lang/cached.py

@@ -17,6 +17,7 @@ from .descriptors import unwrap_func_with_partials
 
 P = ta.ParamSpec('P')
 T = ta.TypeVar('T')
+CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 
 _IGNORE = object()
 
@@ -217,6 +218,12 @@ def cached_function(fn=None, **kwargs):  # noqa
     return _CachedFunctionDescriptor(fn, scope, opts=opts)
 
 
+def static_init(fn: CallableT) -> CallableT:
+    fn = cached_function(fn)
+    fn()
+    return fn
+
+
 ##
 
 

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/lang/classes/simple.py

@@ -68,6 +68,9 @@ class _MarkerMeta(abc.ABCMeta):
 class Marker(NotInstantiable, metaclass=_MarkerMeta):
     """A marker."""
 
+    def __bool__(self):
+        raise TypeError
+
 
 ##
 

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/__init__.py

@@ -88,6 +88,14 @@ from .standard import (  # noqa
     new_standard_unmarshaler_factory,
 )
 
+from .unions import (  # noqa
+    PRIMITIVE_UNION_TYPES,
+    PrimitiveUnionMarshaler,
+    PrimitiveUnionMarshalerFactory,
+    PrimitiveUnionUnmarshaler,
+    PrimitiveUnionUnmarshalerFactory,
+)
+
 from .values import (  # noqa
     Value,
 )

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/base.py

@@ -1,10 +1,11 @@
 """
 TODO:
- - mappings
  - redacted
  - strongly typed MarshalerFactory base class?
  - strongly typed Composite/Cached Marshaler/Unmarshaler factories - footgun
  - streaming? Start/EndObject, etc..
+ - lang.Marker - class name, handle type[Foo]
+  - can't disambiguate from str - can't coexist in bare union
 
 See:
  - https://github.com/python-attrs/cattrs

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/dataclasses.py

@@ -67,6 +67,7 @@ def get_field_infos(
             kw.update(
                 metadata=fmd,
                 omit_if=fmd.omit_if,
+                default=fmd.default,
             )
 
             if fmd.name is not None:
@@ -98,11 +99,14 @@ class DataclassMarshalerFactory(MarshalerFactory):
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         ty = check.isinstance(rty, type)
         check.state(dc.is_dataclass(ty))
+
         dc_md = get_dataclass_metadata(ty)
+
         fields = [
             (fi, _make_field_obj(ctx, fi.type, fi.metadata.marshaler, fi.metadata.marshaler_factory))
             for fi in get_field_infos(ty, ctx.options)
         ]
+
         return ObjectMarshaler(
             fields,
             unknown_field=dc_md.unknown_field,
@@ -119,16 +123,23 @@ class DataclassUnmarshalerFactory(UnmarshalerFactory):
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
         ty = check.isinstance(rty, type)
         check.state(dc.is_dataclass(ty))
+
         dc_md = get_dataclass_metadata(ty)
+
         d: dict[str, tuple[FieldInfo, Unmarshaler]] = {}
+        defaults: dict[str, ta.Any] = {}
         for fi in get_field_infos(ty, ctx.options):
             tup = (fi, _make_field_obj(ctx, fi.type, fi.metadata.unmarshaler, fi.metadata.unmarshaler_factory))
             for un in fi.unmarshal_names:
                 if un in d:
                     raise KeyError(f'Duplicate fields for name {un!r}: {fi.name!r}, {d[un][0].name!r}')
                 d[un] = tup
+            if fi.default.present:
+                defaults[fi.name] = fi.default.must()
+
         return ObjectUnmarshaler(
             ty,
             d,
             unknown_field=dc_md.unknown_field,
+            defaults=defaults,
         )

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/maybes.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - option to coordinate with objects and omit if empty / render unboxed
+"""
 import dataclasses as dc
 import typing as ta
 

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/objects.py

@@ -3,12 +3,16 @@ TODO:
  - cfg naming
  - adapters for dataclasses / namedtuples / user objects (as confitured)
  - mro-merge ObjectMetadata
+ - key ordering override - like slice, -1 means last
+ - dedupe omit_if/default fields on Metadata/Info - FieldOptions prob
+  - impl merge, update helpers:update_fields_metadata
 """
 import collections.abc
 import typing as ta
 
 from .. import check
 from .. import dataclasses as dc
+from .. import lang
 from .. import reflect as rfl
 from .base import MarshalContext
 from .base import Marshaler
@@ -29,6 +33,7 @@ class FieldMetadata:
     alts: ta.Iterable[str] | None = None
 
     omit_if: ta.Callable[[ta.Any], bool] | None = None
+    default: lang.Maybe[ta.Any] = dc.xfield(lang.empty(), check_type=lang.Maybe)
 
     marshaler: Marshaler | None = None
     marshaler_factory: MarshalerFactory | None = None
@@ -60,6 +65,7 @@ class FieldInfo:
     metadata: FieldMetadata = FieldMetadata()
 
     omit_if: ta.Callable[[ta.Any], bool] | None = None
+    default: lang.Maybe[ta.Any] = lang.empty()
 
 
 ##
@@ -68,6 +74,9 @@ class FieldInfo:
 @dc.dataclass(frozen=True)
 class ObjectMarshaler(Marshaler):
     fields: ta.Sequence[tuple[FieldInfo, Marshaler]]
+
+    _: dc.KW_ONLY
+
     unknown_field: str | None = None
 
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
@@ -91,6 +100,9 @@ class ObjectMarshaler(Marshaler):
 @dc.dataclass(frozen=True)
 class SimpleObjectMarshalerFactory(MarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
+
+    _: dc.KW_ONLY
+
     unknown_field: str | None = None
 
     def guard(self, ctx: MarshalContext, rty: rfl.Type) -> bool:
@@ -98,11 +110,14 @@ class SimpleObjectMarshalerFactory(MarshalerFactory):
 
     def fn(self, ctx: MarshalContext, rty: rfl.Type) -> Marshaler:
         ty = check.isinstance(rty, type)
+
         flds = self.dct[ty]
+
         fields = [
             (fi, ctx.make(fi.type))
             for fi in flds
         ]
+
         return ObjectMarshaler(
             fields,
             unknown_field=self.unknown_field,
@@ -116,10 +131,15 @@ class SimpleObjectMarshalerFactory(MarshalerFactory):
 class ObjectUnmarshaler(Unmarshaler):
     cls: type
     fields_by_unmarshal_name: ta.Mapping[str, tuple[FieldInfo, Unmarshaler]]
+
+    _: dc.KW_ONLY
+
     unknown_field: str | None = None
+    defaults: ta.Mapping[str, ta.Any] | None = None
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         ma = check.isinstance(v, collections.abc.Mapping)
+
         u: ta.Any
         kw: dict[str, ta.Any] = {}
         ukf: dict[str, ta.Any] | None = None
@@ -144,12 +164,19 @@ class ObjectUnmarshaler(Unmarshaler):
 
             kw[fi.name] = u.unmarshal(ctx, mv)
 
+        if self.defaults:
+            for dk, dv in self.defaults.items():
+                kw.setdefault(dk, dv)
+
         return self.cls(**kw)
 
 
 @dc.dataclass(frozen=True)
 class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
     dct: ta.Mapping[type, ta.Sequence[FieldInfo]]
+
+    _: dc.KW_ONLY
+
     unknown_field: str | None = None
 
     def guard(self, ctx: UnmarshalContext, rty: rfl.Type) -> bool:
@@ -157,14 +184,24 @@ class SimpleObjectUnmarshalerFactory(UnmarshalerFactory):
 
     def fn(self, ctx: UnmarshalContext, rty: rfl.Type) -> Unmarshaler:
         ty = check.isinstance(rty, type)
+
         flds = self.dct[ty]
+
         fields_by_unmarshal_name = {
             n: (fi, ctx.make(fi.type))
             for fi in flds
             for n in fi.unmarshal_names
         }
+
+        defaults = {
+            fi.name: fi.default.must()
+            for fi in flds
+            if fi.default.present
+        }
+
         return ObjectUnmarshaler(
             ty,
             fields_by_unmarshal_name,
             unknown_field=self.unknown_field,
+            defaults=defaults,
         )

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/marshal/unions.py

@@ -56,7 +56,9 @@ class PrimitiveUnionMarshaler(Marshaler):
     tys: ta.Sequence[type]
 
     def marshal(self, ctx: MarshalContext, o: ta.Any) -> Value:
-        raise NotImplementedError
+        if type(o) not in self.tys:
+            raise TypeError(o)
+        return o
 
 
 @dc.dataclass(frozen=True)
@@ -79,7 +81,9 @@ class PrimitiveUnionUnmarshaler(Unmarshaler):
     tys: ta.Sequence[type]
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
-        raise NotImplementedError
+        if type(v) not in self.tys:
+            raise TypeError(v)
+        return v
 
 
 @dc.dataclass(frozen=True)

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish/secrets/marshal.py

@@ -50,7 +50,7 @@ def marshal_secret_field(f: dc.Field) -> dc.Field:
     })
 
 
-@lang.cached_function
+@lang.static_init
 def _install_standard_marshalling() -> None:
     msh.STANDARD_MARSHALER_FACTORIES[0:0] = [
         msh.ForbiddenTypeMarshalerFactory({Secret}),
@@ -65,6 +65,3 @@ def _install_standard_marshalling() -> None:
             rfl.type_(SecretRefOrStr): StrOrSecretRefMarshalerUnmarshaler(),
         }),
     ]
-
-
-_install_standard_marshalling()

omlish-0.0.0.dev35/omlish/specs/jsonrpc/__init__.py

@@ -0,0 +1,28 @@
+from .errors import (  # noqa
+    CUSTOM_ERROR_BASE,
+    KnownError,
+    KnownErrors,
+)
+
+from .types import (  # noqa
+    Error,
+    Id,
+    NotSpecified,
+    Number,
+    Object,
+    Request,
+    Response,
+    VERSION,
+    error,
+    notification,
+    request,
+    result,
+)
+
+
+##
+
+
+from ...lang.imports import _register_conditional_import  # noqa
+
+_register_conditional_import('...marshal', '.marshal', __package__)

omlish-0.0.0.dev35/omlish/specs/jsonrpc/errors.py

@@ -0,0 +1,20 @@
+from ... import dataclasses as dc
+from ... import lang
+
+
+@dc.dataclass(frozen=True)
+class KnownError:
+    code: int
+    message: str
+    meaning: str
+
+
+class KnownErrors(lang.Namespace):
+    PARSE_ERROR = KnownError(-32700, 'Parse error', 'Invalid JSON was received by the server.')
+    INVALID_REQUEST = KnownError(-32600, 'Invalid Request', 'The JSON sent is not a valid Request object.')
+    METHOD_NOT_FOUND = KnownError(-32601, 'Method not found', 'The method does not exist / is not available.')
+    INVALID_PARAMS = KnownError(-32602, 'Invalid params', 'Invalid method parameter(s).')
+    INTERNAL_ERROR = KnownError(-32603, 'Internal error', 'Internal JSON-RPC error.')
+
+
+CUSTOM_ERROR_BASE = -32000

omlish-0.0.0.dev35/omlish/specs/jsonrpc/marshal.py

@@ -0,0 +1,59 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ... import marshal as msh
+from ... import matchfns as mfs
+from ... import reflect as rfl
+from .types import NotSpecified
+
+
+_NOT_SPECIFIED_RTY = rfl.type_(type[NotSpecified])
+
+
+@dc.dataclass(frozen=True)
+class NotSpecifiedUnionMarshaler(msh.Marshaler):
+    m: msh.Marshaler
+
+    def marshal(self, ctx: msh.MarshalContext, o: ta.Any) -> msh.Value:
+        if o is NotSpecified:
+            raise TypeError(o)
+        return self.m.marshal(ctx, o)
+
+
+class NotSpecifiedUnionMarshalerFactory(msh.MarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, rfl.Union) and
+        not rty.is_optional and
+        _NOT_SPECIFIED_RTY in rty.args
+    ))
+    def _build(self, ctx: msh.MarshalContext, rty: rfl.Type) -> msh.Marshaler:
+        args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
+        nty = rfl.type_(ta.Union[*args])
+        m = ctx.make(nty)
+        return NotSpecifiedUnionMarshaler(m)
+
+
+class NotSpecifiedUnionUnmarshalerFactory(msh.UnmarshalerFactoryMatchClass):
+    @mfs.simple(lambda _, ctx, rty: (
+        isinstance(rty, rfl.Union) and
+        not rty.is_optional and
+        _NOT_SPECIFIED_RTY in rty.args
+    ))
+    def _build(self, ctx: msh.UnmarshalContext, rty: rfl.Type) -> msh.Unmarshaler:
+        args = set(check.isinstance(rty, rfl.Union).args) - {_NOT_SPECIFIED_RTY}
+        nty = rfl.type_(ta.Union[*args])
+        return ctx.make(nty)
+
+
+@lang.static_init
+def _install_standard_marshalling() -> None:
+    msh.STANDARD_MARSHALER_FACTORIES[0:0] = [
+        msh.ForbiddenTypeMarshalerFactory({_NOT_SPECIFIED_RTY}),
+        NotSpecifiedUnionMarshalerFactory(),
+    ]
+    msh.STANDARD_UNMARSHALER_FACTORIES[0:0] = [
+        msh.ForbiddenTypeUnmarshalerFactory({_NOT_SPECIFIED_RTY}),
+        NotSpecifiedUnionUnmarshalerFactory(),
+    ]

omlish-0.0.0.dev35/omlish/specs/jsonrpc/types.py

@@ -0,0 +1,93 @@
+"""
+https://www.jsonrpc.org/specification
+
+TODO:
+ - drop NotSpecified, use lang.Maybe, make marshal do that
+ - server/client impl
+
+See:
+ - https://github.com/python-lsp/python-lsp-jsonrpc
+"""
+import operator
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ... import marshal as msh
+
+
+Number: ta.TypeAlias = int | float
+Object: ta.TypeAlias = ta.Mapping[str, ta.Any]
+Id: ta.TypeAlias = str | Number | None
+
+
+##
+
+
+VERSION = '2.0'
+
+
+class NotSpecified(lang.Marker):
+    pass
+
+
+def is_not_specified(v: ta.Any) -> bool:
+    return v is NotSpecified
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+@msh.update_fields_metadata(['id'], omit_if=is_not_specified, default=lang.just(NotSpecified))
+@msh.update_fields_metadata(['params'], omit_if=operator.not_)
+class Request(lang.Final):
+    id: Id | type[NotSpecified]
+    method: str
+    params: Object | None = None
+
+    jsonrpc: str = dc.field(default=VERSION, kw_only=True)
+    dc.validate(lambda self: self.jsonrpc == VERSION)
+
+
+def request(id: Id, method: str, params: Object | None = None) -> Request:  # noqa
+    return Request(id, method, params)
+
+
+def notification(method: str, params: Object | None = None) -> Request:
+    return Request(NotSpecified, method, params)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+@msh.update_fields_metadata(['result', 'error'], omit_if=is_not_specified)
+class Response(lang.Final):
+    id: Id
+    dc.validate(lambda self: self.id is not NotSpecified)
+
+    _: dc.KW_ONLY
+
+    result: ta.Any = dc.field(default=NotSpecified)
+    error: ta.Union['Error', type[NotSpecified]] = dc.field(default=NotSpecified)
+    dc.validate(lambda self: is_not_specified(self.result) ^ is_not_specified(self.error))
+
+    jsonrpc: str = dc.field(default=VERSION)
+    dc.validate(lambda self: self.jsonrpc == VERSION)
+
+
+def result(id: Id, result: ta.Any) -> Response:  # noqa
+    return Response(id, result=result)
+
+
+@dc.dataclass(frozen=True)
+@msh.update_fields_metadata(['data'], omit_if=is_not_specified)
+class Error(lang.Final):
+    code: int
+    message: str
+    data: ta.Any = NotSpecified
+
+
+def error(id: Id, error: Error) -> Response:  # noqa
+    return Response(id, error=error)

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35/omlish.egg-info}/PKG-INFO

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

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/omlish.egg-info/SOURCES.txt

@@ -268,6 +268,10 @@ omlish/secrets/passwords.py
 omlish/secrets/secrets.py
 omlish/secrets/subprocesses.py
 omlish/specs/__init__.py
+omlish/specs/jsonrpc/__init__.py
+omlish/specs/jsonrpc/errors.py
+omlish/specs/jsonrpc/marshal.py
+omlish/specs/jsonrpc/types.py
 omlish/specs/jsonschema/__init__.py
 omlish/specs/jsonschema/types.py
 omlish/specs/jsonschema/keywords/__init__.py

{omlish-0.0.0.dev33 → omlish-0.0.0.dev35}/pyproject.toml

@@ -12,7 +12,7 @@ authors = [
 urls = {source = 'https://github.com/wrmsr/omlish'}
 license = {text = 'BSD-3-Clause'}
 requires-python = '~=3.12'
-version = '0.0.0.dev33'
+version = '0.0.0.dev35'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',