omlish 0.0.0.dev74__tar.gz → 0.0.0.dev76__tar.gz

{omlish-0.0.0.dev74/omlish.egg-info → omlish-0.0.0.dev76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: omlish
-Version: 0.0.0.dev74
+Version: 0.0.0.dev76
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause
@@ -38,7 +38,7 @@ Requires-Dist: pg8000~=1.31; extra == "all"
 Requires-Dist: pymysql~=1.1; extra == "all"
 Requires-Dist: aiomysql~=0.2; extra == "all"
 Requires-Dist: aiosqlite~=0.20; extra == "all"
-Requires-Dist: asyncpg~=0.29; python_version < "3.13" and extra == "all"
+Requires-Dist: asyncpg~=0.30; python_version < "3.13" and extra == "all"
 Requires-Dist: apsw~=3.46; extra == "all"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "all"
 Requires-Dist: duckdb~=1.1; extra == "all"
@@ -84,7 +84,7 @@ Requires-Dist: pg8000~=1.31; extra == "sqldrivers"
 Requires-Dist: pymysql~=1.1; extra == "sqldrivers"
 Requires-Dist: aiomysql~=0.2; extra == "sqldrivers"
 Requires-Dist: aiosqlite~=0.20; extra == "sqldrivers"
-Requires-Dist: asyncpg~=0.29; python_version < "3.13" and extra == "sqldrivers"
+Requires-Dist: asyncpg~=0.30; python_version < "3.13" and extra == "sqldrivers"
 Requires-Dist: apsw~=3.46; extra == "sqldrivers"
 Requires-Dist: sqlean.py~=3.45; python_version < "3.13" and extra == "sqldrivers"
 Requires-Dist: duckdb~=1.1; extra == "sqldrivers"

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/.manifests.json

@@ -47,6 +47,18 @@
       }
     }
   },
+  {
+    "module": ".secrets.pwgen",
+    "attr": "_CLI_MODULE",
+    "file": "omlish/secrets/pwgen.py",
+    "line": 75,
+    "value": {
+      "$omdev.cli.types.CliModule": {
+        "cmd_name": "pwgen",
+        "mod_name": "omlish.secrets.pwgen"
+      }
+    }
+  },
   {
     "module": ".specs.jmespath.__main__",
     "attr": "_CLI_MODULE",

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev74'
-__revision__ = '002d07c8f9579e6b60584c9b2c6c05cd6b7219af'
+__version__ = '0.0.0.dev76'
+__revision__ = 'f7a91a7adb0b3e2018caef9de1ec592d87644c60'
 
 
 #
@@ -97,7 +97,7 @@ class Project(ProjectBase):
 
             'aiomysql ~= 0.2',
             'aiosqlite ~= 0.20',
-            'asyncpg ~= 0.29; python_version < "3.13"',
+            'asyncpg ~= 0.30; python_version < "3.13"',
 
             'apsw ~= 3.46',
 

omlish-0.0.0.dev76/omlish/dataclasses/impl/exceptions.py

@@ -0,0 +1,50 @@
+import types
+import typing as ta
+
+
+class ValidationError(Exception):
+    pass
+
+
+def _hands_off_repr(obj: ta.Any) -> str:
+    return f'{obj.__class__.__qualname__}@{hex(id(obj))[2:]}'
+
+
+def _fn_repr(fn: ta.Callable) -> str:
+    if (co := getattr(fn, '__code__', None)) is None or not isinstance(co, types.CodeType):
+        return repr(fn)
+
+    if not (co_filename := co.co_filename):
+        return repr(fn)
+
+    return f'{fn!r} ({co_filename}:{co.co_firstlineno})'
+
+
+class FieldValidationError(ValidationError):
+    def __init__(
+            self,
+            obj: ta.Any,
+            field: str,
+            fn: ta.Callable,
+            value: ta.Any,
+    ) -> None:
+        super().__init__(
+            f'{self.__class__.__name__} '
+            f'for field {field!r} '
+            f'on object {_hands_off_repr(obj)} '
+            f'in validator {_fn_repr(fn)} '
+            f'with value {value!r}',
+        )
+
+        self.obj = obj
+        self.field = field
+        self.fn = fn
+        self.value = value
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({", ".join([
+            f"obj={_hands_off_repr(self.obj)}",
+            f"field={self.field!r}",
+            f"fn={_fn_repr(self.fn)}",
+            f"value={self.value!r}",
+        ])})'

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/dataclasses/impl/fields.py

@@ -8,6 +8,7 @@ import typing as ta
 
 from ... import check as check_
 from ... import lang
+from .exceptions import FieldValidationError
 from .internals import FIELDS_ATTR
 from .internals import FieldType
 from .internals import is_classvar
@@ -29,6 +30,23 @@ MISSING = dc.MISSING
 ##
 
 
+def raise_field_validation_error(
+        obj: ta.Any,
+        field: str,
+        fn: ta.Callable,
+        value: ta.Any,
+):
+    raise FieldValidationError(
+        obj,
+        field,
+        fn,
+        value,
+    )
+
+
+##
+
+
 def field_type(f: dc.Field) -> FieldType:
     if (ft := getattr(f, '_field_type')) is not None:
         return FieldType(ft)
@@ -193,7 +211,10 @@ def field_init(
     if fx.validate is not None:
         cn = f'__dataclass_validate__{f.name}__'
         locals[cn] = fx.validate
-        lines.append(f'if not {cn}({value}): raise __dataclass_FieldValidationError__({f.name})')
+        lines.append(
+            f'if not {cn}({value}): '
+            f'__dataclass_raise_field_validation_error__({self_name}, {f.name!r}, {cn}, {value})',
+        )
 
     if fx.check_type:
         cn = f'__dataclass_check_type__{f.name}__'

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/dataclasses/impl/init.py

@@ -3,11 +3,11 @@ import inspect
 import typing as ta
 
 from ... import lang
-from .exceptions import FieldValidationError
 from .exceptions import ValidationError
 from .fields import field_init
 from .fields import field_type
 from .fields import has_default
+from .fields import raise_field_validation_error
 from .internals import HAS_DEFAULT_FACTORY
 from .internals import POST_INIT_NAME
 from .internals import FieldType
@@ -101,7 +101,7 @@ class InitBuilder:
             '__dataclass_builtins_isinstance__': isinstance,
             '__dataclass_builtins_TypeError__': TypeError,
             '__dataclass_ValidationError__': ValidationError,
-            '__dataclass_FieldValidationError__': FieldValidationError,
+            '__dataclass_raise_field_validation_error__': raise_field_validation_error,
         })
 
         body_lines: list[str] = []

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/formats/yaml.py

@@ -118,7 +118,7 @@ class NodeWrappingConstructorMixin:
         yield omap
         uomap = next(gen)
         lang.exhaust(gen)
-        for key, value in uomap:  # type: ignore
+        for key, value in uomap:
             omap.append(NodeWrapped((key, value), node))
 
     def construct_yaml_omap(self, node):

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/graphs/dags.py

@@ -80,7 +80,7 @@ class Subdag(ta.Generic[U]):
     ) -> None:
         super().__init__()
 
-        self._dag: Dag[U] = check.isinstance(dag, Dag)  # type: ignore
+        self._dag: Dag[U] = check.isinstance(dag, Dag)
         self._targets = set(targets)
         self._ignored = set(ignored or []) - self._targets
 

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/graphs/domination.py

@@ -195,7 +195,7 @@ class _ImmediateDominanceComputer(ta.Generic[V]):
     def __init__(self, dfs: _Dfs[V]) -> None:
         super().__init__()
 
-        self._dfs: _Dfs[V] = check.isinstance(dfs, _Dfs)  # type: ignore
+        self._dfs: _Dfs[V] = check.isinstance(dfs, _Dfs)
 
         self._ancestor: dict[V, V] = {}
         self._semi = dict(self._dfs.semi)

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/http/__init__.py

@@ -40,3 +40,9 @@ from .json import (  # noqa
     json_dumps,
     json_loads,
 )
+
+from .multipart import (  # noqa
+    MultipartData,
+    MultipartEncoder,
+    MultipartField,
+)

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/http/clients.py

@@ -1,5 +1,6 @@
 """
 TODO:
+ - httpx catch
  - check=False
  - return non-200 HttpResponses
  - async
@@ -202,10 +203,14 @@ class HttpxHttpClient(HttpClient):
 ##
 
 
-def client() -> HttpClient:
+def _default_client() -> HttpClient:
     return UrllibHttpClient()
 
 
+def client() -> HttpClient:
+    return _default_client()
+
+
 def request(
         url: str,
         method: str | None = None,
@@ -217,6 +222,8 @@ def request(
 
         check: bool = False,
 
+        client: HttpClient | None = None,
+
         **kwargs: ta.Any,
 ) -> HttpResponse:
     req = HttpRequest(
@@ -231,9 +238,16 @@ def request(
         **kwargs,
     )
 
-    with client() as cli:
+    def do(cli: HttpClient) -> HttpResponse:
         return cli.request(
             req,
 
             check=check,
         )
+
+    if client is not None:
+        return do(client)
+
+    else:
+        with _default_client() as cli:
+            return do(cli)

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/http/headers.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - handle secrets (but they're strs..)
+"""
 import typing as ta
 
 from .. import cached

omlish-0.0.0.dev76/omlish/http/multipart.py

@@ -0,0 +1,82 @@
+"""
+https://datatracker.ietf.org/doc/html/rfc7578
+"""
+import dataclasses as dc
+import io
+import typing as ta
+
+from .. import cached
+
+
+MultipartData: ta.TypeAlias = ta.Any  # bytes | file
+
+
+@dc.dataclass(frozen=True)
+class MultipartField:
+    data: MultipartData
+    name: bytes | None = None
+    file_name: bytes | None = None
+    headers: ta.Sequence[tuple[bytes, bytes]] | None = None
+
+
+class MultipartEncoder:
+    def __init__(
+            self,
+            fields: ta.Sequence[MultipartField],
+            *,
+            boundary: bytes | None = None,
+    ) -> None:
+        super().__init__()
+        self._fields = fields
+        self._boundary = boundary or b'----WebKitFormBoundary7MA4YWxkTrZu0gW'
+
+    class _Line(ta.NamedTuple):
+        data: MultipartData
+        sz: int
+
+    @cached.function
+    def _lines(self) -> ta.Sequence[_Line]:
+        l: list[MultipartEncoder._Line] = []
+
+        def add(d: MultipartData) -> None:
+            if isinstance(d, bytes):
+                sz = len(d)
+            else:
+                raise TypeError(d)
+            l.append(MultipartEncoder._Line(d, sz))
+
+        for f in self._fields:
+            add(b'--%s' % (self._boundary,))
+            ps = [b'form-data']
+            if f.name is not None:
+                ps.append(b'name="%s"' % (f.name,))
+            if f.file_name is not None:
+                ps.append(b'filename="%s"' % (f.file_name,))
+            add(b'Content-Disposition: ' + b'; '.join(ps))
+            for hk, hv in f.headers or ():
+                add(b'%s: %s' % (hk, hv))
+            add(b'')
+            add(f.data)
+
+        add(b'--%s--' % (self._boundary,))
+
+        return l
+
+    @cached.function
+    def content_type(self) -> bytes:
+        return b'multipart/form-data; boundary=%s' % (self._boundary,)
+
+    @cached.function
+    def content_length(self) -> int:
+        return sum(l.sz + 2 for l in self._lines())
+
+    @cached.function
+    def content(self) -> bytes:
+        buf = io.BytesIO()
+        for l in self._lines():
+            if isinstance(l.data, bytes):
+                buf.write(l.data)
+            else:
+                raise TypeError(l.data)
+            buf.write(b'\r\n')
+        return buf.getvalue()

omlish-0.0.0.dev76/omlish/http/sse.py

@@ -0,0 +1,96 @@
+"""
+TODO:
+ - end-of-line   = ( cr lf / cr / lf )
+"""
+import string
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+class SseDecoderOutput(lang.Abstract):
+    pass
+
+
+@dc.dataclass(frozen=True)
+class SseComment(SseDecoderOutput, lang.Final):
+    data: bytes
+
+
+SseEventId: ta.TypeAlias = bytes
+
+
+@dc.dataclass(frozen=True)
+class SseEvent(SseDecoderOutput, lang.Final):
+    type: bytes
+    data: bytes
+    last_id: SseEventId = dc.xfield(b'', repr_fn=dc.truthy_repr)
+
+
+_DIGIT_BYTES = string.digits.encode('ascii')
+
+
+class SseDecoder:
+    """https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation"""
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._reset()
+        self._last_event_id = b''
+        self._reconnection_time: int | None = None
+
+    _event_type: bytes
+    _data: list[bytes]
+
+    def _reset(self) -> None:
+        self._event_type = b'message'
+        self._data = []
+
+    def _process_field(self, name: bytes, value: bytes) -> None:
+        if name == b'event':
+            self._event_type = value
+
+        elif name == b'data':
+            self._data.append(value)
+
+        elif name == b'id':
+            if 0 not in value:
+                self._last_event_id = value
+
+        elif name == b'retry':
+            if all(c in _DIGIT_BYTES for c in value):
+                self._reconnection_time = int(value)
+
+    def _dispatch_event(self) -> SseEvent:
+        data = b''.join(lang.interleave(self._data, b'\n'))
+
+        e = SseEvent(
+            type=self._event_type,
+            data=data,
+            last_id=self._last_event_id,
+        )
+
+        self._reset()
+
+        return e
+
+    def process_line(self, line: bytes) -> ta.Iterable[SseDecoderOutput]:
+        if b'\r' in line or b'\n' in line:
+            raise ValueError(line)
+
+        if not line:
+            yield self._dispatch_event()
+
+        elif line[0] == b':'[0]:
+            yield SseComment(line)
+
+        elif (c := line.find(b':')) >= 0:
+            d = c + 1
+            if len(line) > d and line[d] == b' '[0]:
+                d += 1
+            self._process_field(line[:c], line[d:])
+
+        else:
+            self._process_field(line, b'')

omlish-0.0.0.dev76/omlish/io.py

@@ -0,0 +1,142 @@
+import dataclasses as dc
+import io
+import typing as ta
+
+from . import check
+
+
+@dc.dataclass(frozen=True)
+class DelimitingBufferError(Exception):
+    buffer: 'DelimitingBuffer'
+
+
+class ClosedDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class FullDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class IncompleteDelimitingBufferError(DelimitingBufferError):
+    pass
+
+
+class DelimitingBuffer:
+    """
+    https://github.com/python-trio/trio/issues/796 :|
+    """
+
+    DEFAULT_DELIMITERS: bytes = b'\n'
+
+    def __init__(
+            self,
+            delimiters: ta.Iterable[int] = DEFAULT_DELIMITERS,
+            *,
+            keep_ends: bool = False,
+            max_size: int | None = None,
+            on_full: ta.Literal['raise', 'yield'] = 'raise',
+            on_incomplete: ta.Literal['raise', 'yield'] = 'yield',
+    ) -> None:
+        super().__init__()
+
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
+        self._keep_ends = keep_ends
+        self._max_size = max_size
+        self._on_full = on_full
+        self._on_incomplete = on_incomplete
+
+        self._buf: io.BytesIO | None = io.BytesIO()
+
+    @property
+    def is_closed(self) -> bool:
+        return self._buf is None
+
+    def tell(self) -> int:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+        return buf.tell()
+
+    def peek(self) -> bytes:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+        return buf.getvalue()
+
+    def _find_delim(self, data: bytes | bytearray, i: int) -> int | None:
+        r = None  # type: int | None
+        for d in self._delimiters:
+            if (p := data.find(d, i)) >= 0:
+                if r is None or p < r:
+                    r = p
+        return r
+
+    def _append_and_reset(self, chunk: bytes) -> bytes:
+        buf = check.not_none(self._buf)
+        if not buf.tell():
+            return chunk
+
+        buf.write(chunk)
+        ret = buf.getvalue()
+        buf.seek(0)
+        return ret
+
+    def feed(self, data: bytes | bytearray) -> ta.Generator[bytes, None, None]:
+        if (buf := self._buf) is None:
+            raise ClosedDelimitingBufferError(self)
+
+        if not data:
+            self._buf = None
+
+            if buf.tell():
+                if self._on_incomplete == 'raise':
+                    raise IncompleteDelimitingBufferError(self)
+
+                elif self._on_incomplete == 'yield':
+                    yield buf.getvalue()
+
+                else:
+                    raise ValueError(f'Unknown on_incomplete value: {self._on_incomplete!r}')
+
+            return
+
+        l = len(data)
+        i = 0
+        while i < l:
+            if (p := self._find_delim(data, i)) is None:
+                break
+
+            n = p + 1
+            if self._keep_ends:
+                p = n
+
+            yield self._append_and_reset(data[i:p])
+
+            i = n
+
+        if i >= l:
+            return
+
+        if self._max_size is None:
+            buf.write(data[i:])
+            return
+
+        while i < l:
+            remaining_data_len = l - i
+            remaining_buf_capacity = self._max_size - buf.tell()
+
+            if remaining_data_len < remaining_buf_capacity:
+                buf.write(data[i:])
+                return
+
+            if self._on_full == 'raise':
+                raise FullDelimitingBufferError(self)
+
+            elif self._on_full == 'yield':
+                p = i + remaining_buf_capacity
+
+                yield self._append_and_reset(data[i:p])
+
+                i = p
+
+            else:
+                raise ValueError(f'Unknown on_full value: {self._on_full!r}')

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/lang/__init__.py

@@ -140,6 +140,7 @@ from .iterables import (  # noqa
     flatmap,
     flatten,
     ilen,
+    interleave,
     itergen,
     peek,
     prodrange,
@@ -161,6 +162,7 @@ from .objects import (  # noqa
     build_mro_dict,
     can_weakref,
     deep_subclasses,
+    dir_dict,
     new_type,
     opt_repr,
     super_meta,

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/lang/iterables.py

@@ -37,6 +37,13 @@ def peek(vs: ta.Iterable[T]) -> tuple[T, ta.Iterator[T]]:
     return v, itertools.chain(iter((v,)), it)
 
 
+def interleave(vs: ta.Iterable[T], d: T) -> ta.Iterable[T]:
+    for i, v in enumerate(vs):
+        if i:
+            yield d
+        yield v
+
+
 Rangeable: ta.TypeAlias = ta.Union[  # noqa
     int,
     tuple[int],

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/lang/objects.py

@@ -129,6 +129,13 @@ def build_mro_dict(
     return dct
 
 
+def dir_dict(o: ta.Any) -> dict[str, ta.Any]:
+    return {
+        a: getattr(o, a)
+        for a in dir(o)
+    }
+
+
 ##
 
 

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/lifecycles/controller.py

@@ -55,7 +55,7 @@ class LifecycleController(Lifecycle, ta.Generic[LifecycleT]):
         return self._state
 
     def add_listener(self, listener: LifecycleListener[LifecycleT]) -> 'LifecycleController':
-        self._listeners.append(check.isinstance(listener, LifecycleListener))  # type: ignore
+        self._listeners.append(check.isinstance(listener, LifecycleListener))
         return self
 
     def _advance(

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/marshal/mappings.py

@@ -53,7 +53,7 @@ class MappingUnmarshaler(Unmarshaler):
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Mapping:
         dct: dict = {}
         for mk, mv in check.isinstance(v, collections.abc.Mapping).items():
-            dct[self.ke.unmarshal(ctx, mk)] = self.ve.unmarshal(ctx, mv)  # type: ignore
+            dct[self.ke.unmarshal(ctx, mk)] = self.ve.unmarshal(ctx, mv)
         return self.ctor(dct)
 
 

{omlish-0.0.0.dev74 → omlish-0.0.0.dev76}/omlish/marshal/numbers.py

@@ -18,7 +18,7 @@ class ComplexMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         real, imag = check.isinstance(v, list)
-        return complex(real, imag)  # type: ignore
+        return complex(real, imag)
 
 
 class DecimalMarshalerUnmarshaler(Marshaler, Unmarshaler):
@@ -35,7 +35,7 @@ class FractionMarshalerUnmarshaler(Marshaler, Unmarshaler):
 
     def unmarshal(self, ctx: UnmarshalContext, v: Value) -> ta.Any:
         num, denom = check.isinstance(v, list)
-        return fractions.Fraction(num, denom)  # type: ignore
+        return fractions.Fraction(num, denom)
 
 
 NUMBERS_MARSHALER_FACTORY = TypeMapMarshalerFactory({