omlish 0.0.0.dev222__py3-none-any.whl → 0.0.0.dev223__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev222'
-__revision__ = '6f15b0f3bde72b207c93e58623da4bb444ff4003'
+__version__ = '0.0.0.dev223'
+__revision__ = '383167fabe843d406905492267a5c570dae7cba3'
 
 
 #
@@ -96,14 +96,14 @@ class Project(ProjectBase):
             # 'mysqlclient ~= 2.2',
 
             'aiomysql ~= 0.2',
-            'aiosqlite ~= 0.20',
+            'aiosqlite ~= 0.21',
             'asyncpg ~= 0.30',
 
             'apsw ~= 3.47',
 
             'sqlean.py ~= 3.45',
 
-            'duckdb ~= 1.1',
+            'duckdb ~= 1.2',
         ],
 
         'testing': [

omlish/asyncs/asyncio/subprocesses.py

@@ -3,7 +3,6 @@
 import asyncio.base_subprocess
 import asyncio.subprocess
 import contextlib
-import dataclasses as dc
 import functools
 import logging
 import subprocess
@@ -12,6 +11,8 @@ import typing as ta
 
 from ...lite.check import check
 from ...subprocesses import AbstractAsyncSubprocesses
+from ...subprocesses import SubprocessRun
+from ...subprocesses import SubprocessRunOutput
 from .timeouts import asyncio_maybe_timeout
 
 
@@ -178,41 +179,32 @@ class AsyncioSubprocesses(AbstractAsyncSubprocesses):
 
     #
 
-    @dc.dataclass(frozen=True)
-    class RunOutput:
-        proc: asyncio.subprocess.Process
-        stdout: ta.Optional[bytes]
-        stderr: ta.Optional[bytes]
+    async def run_(self, run: SubprocessRun) -> SubprocessRunOutput[asyncio.subprocess.Process]:
+        kwargs = dict(run.kwargs or {})
 
-    async def run(
-            self,
-            *cmd: str,
-            input: ta.Any = None,  # noqa
-            timeout: ta.Optional[float] = None,
-            check: bool = False,  # noqa
-            capture_output: ta.Optional[bool] = None,
-            **kwargs: ta.Any,
-    ) -> RunOutput:
-        if capture_output:
+        if run.capture_output:
             kwargs.setdefault('stdout', subprocess.PIPE)
             kwargs.setdefault('stderr', subprocess.PIPE)
 
         proc: asyncio.subprocess.Process
-        async with self.popen(*cmd, **kwargs) as proc:
-            stdout, stderr = await self.communicate(proc, input, timeout)
+        async with self.popen(*run.cmd, **kwargs) as proc:
+            stdout, stderr = await self.communicate(proc, run.input, run.timeout)
 
         if check and proc.returncode:
             raise subprocess.CalledProcessError(
                 proc.returncode,
-                cmd,
+                run.cmd,
                 output=stdout,
                 stderr=stderr,
             )
 
-        return self.RunOutput(
-            proc,
-            stdout,
-            stderr,
+        return SubprocessRunOutput(
+            proc=proc,
+
+            returncode=check.isinstance(proc.returncode, int),
+
+            stdout=stdout,
+            stderr=stderr,
         )
 
     #

omlish/dynamic.py

@@ -170,7 +170,7 @@ class Binding(ta.Generic[T]):
         while lag_frame is not None:
             for cur_depth in range(_MAX_HOIST_DEPTH + 1):
                 if lag_frame is None:
-                    break  # type: ignore
+                    break
                 try:
                     lag_hoist = _HOISTED_CODE_DEPTH[lag_frame.f_code]
                 except KeyError:

omlish/funcs/genmachine.py

@@ -49,7 +49,7 @@ class GenMachine(ta.Generic[I, O]):
     @property
     def state(self) -> str | None:
         if self._gen is not None:
-            return self._gen.gi_code.co_qualname
+            return self._gen.gi_code.co_qualname  # type: ignore[attr-defined]
         return None
 
     #

omlish/http/coro/fdio.py

@@ -33,7 +33,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
         self._log_handler = log_handler
 
         self._read_buf = ReadableListBuffer()
-        self._write_buf: IncrementalWriteBuffer | None = None
+        self._write_buf: ta.Optional[IncrementalWriteBuffer] = None
 
         self._coro_srv = CoroHttpServer(
             addr,
@@ -41,7 +41,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
         )
         self._srv_coro: ta.Optional[ta.Generator[CoroHttpServer.Io, ta.Optional[bytes], None]] = self._coro_srv.coro_handle()  # noqa
 
-        self._cur_io: CoroHttpServer.Io | None = None
+        self._cur_io: ta.Optional[CoroHttpServer.Io] = None
         self._next_io()
 
     #
@@ -49,7 +49,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
     def _next_io(self) -> None:  # noqa
         coro = check.not_none(self._srv_coro)
 
-        d: bytes | None = None
+        d: ta.Optional[bytes] = None
         o = self._cur_io
         while True:
             if o is None:

omlish/http/coro/server.py

@@ -496,7 +496,7 @@ class CoroHttpServer:
         if isinstance(parsed, ParseHttpRequestError):
             err = self._build_error(
                 parsed.code,
-                *parsed.message,
+                *([parsed.message] if isinstance(parsed.message, str) else parsed.message),
                 version=parsed.version,
             )
             yield self.ErrorLogIo(err)

omlish/http/handlers.py

@@ -3,6 +3,7 @@
 import abc
 import dataclasses as dc
 import http.server
+import logging
 import typing as ta
 
 from ..sockets.addresses import SocketAddress
@@ -60,3 +61,16 @@ class HttpHandler_(abc.ABC):  # noqa
     @abc.abstractmethod
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
         raise NotImplementedError
+
+
+@dc.dataclass(frozen=True)
+class LoggingHttpHandler(HttpHandler_):
+    handler: HttpHandler
+    log: logging.Logger
+    level: int = logging.INFO
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        self.log.log(self.level, '%r', req)
+        resp = self.handler(req)
+        self.log.log(self.level, '%r', resp)
+        return resp

omlish/http/parsing.py

@@ -246,6 +246,8 @@ class HttpRequestParser:
 
     #
 
+    _TLS_HANDSHAKE_PREFIX = b'\x16'
+
     def coro_parse(self) -> ta.Generator[int, bytes, ParseHttpRequestResult]:
         raw_request_line = yield self._max_line + 1
 
@@ -284,6 +286,17 @@ class HttpRequestParser:
         if not raw_request_line:
             return EmptyParsedHttpResult(**result_kwargs())
 
+        # Detect TLS
+
+        if raw_request_line.startswith(self._TLS_HANDSHAKE_PREFIX):
+            return ParseHttpRequestError(
+                code=http.HTTPStatus.BAD_REQUEST,
+                message='Bad request version (probable TLS handshake)',
+                **result_kwargs(),
+            )
+
+        # Decode line
+
         request_line = raw_request_line.decode('iso-8859-1').rstrip('\r\n')
 
         # Split words

omlish/lite/marshal.py

@@ -422,18 +422,34 @@ class ObjMarshalerManager:
                 return reg
 
             if abc.ABC in ty.__bases__:
-                impls = [ity for ity in deep_subclasses(ty) if abc.ABC not in ity.__bases__]  # type: ignore
-                if all(ity.__qualname__.endswith(ty.__name__) for ity in impls):
-                    ins = {ity: snake_case(ity.__qualname__[:-len(ty.__name__)]) for ity in impls}
-                else:
-                    ins = {ity: ity.__qualname__ for ity in impls}
+                tn = ty.__name__
+                impls: ta.List[ta.Tuple[type, str]] = [  # type: ignore[var-annotated]
+                    (ity, ity.__name__)
+                    for ity in deep_subclasses(ty)
+                    if abc.ABC not in ity.__bases__
+                ]
+
+                if all(itn.endswith(tn) for _, itn in impls):
+                    impls = [
+                        (ity, snake_case(itn[:-len(tn)]))
+                        for ity, itn in impls
+                    ]
+
+                dupe_tns = sorted(
+                    dn
+                    for dn, dc in collections.Counter(itn for _, itn in impls).items()
+                    if dc > 1
+                )
+                if dupe_tns:
+                    raise KeyError(f'Duplicate impl names for {ty}: {dupe_tns}')
+
                 return PolymorphicObjMarshaler.of([
                     PolymorphicObjMarshaler.Impl(
                         ity,
                         itn,
                         rec(ity),
                     )
-                    for ity, itn in ins.items()
+                    for ity, itn in impls
                 ])
 
             if issubclass(ty, enum.Enum):

omlish/specs/irc/messages/base.py

@@ -0,0 +1,49 @@
+import typing as ta
+
+from .... import check
+from .... import dataclasses as dc
+from ....funcs import pairs as fps
+from ..numerics import numerics as nr
+from .formats import MessageFormat
+from .formats import MessageParamsUnpacker
+
+
+##
+
+
+class Message(dc.Case):
+    FORMAT: ta.ClassVar[MessageFormat]
+    REPLIES: ta.ClassVar[ta.Collection[nr.NumericReply]] = ()
+
+
+##
+
+
+def list_pair_params_unpacker(
+        kwarg: str,
+        key_param: str,
+        value_param: str,
+) -> MessageParamsUnpacker:
+    def forward(params: ta.Mapping[str, str]) -> ta.Mapping[str, ta.Any]:
+        out: dict = dict(params)
+        ks = out.pop(key_param)
+        vs = out.pop(value_param, None)
+        if vs is not None:
+            out[kwarg] = list(zip(ks, vs, strict=True))
+        else:
+            out[kwarg] = ks
+        return out
+
+    def backward(kwargs: ta.Mapping[str, ta.Any]) -> ta.Mapping[str, str]:
+        out: dict = dict(kwargs)
+        ts = out.pop(kwarg)
+        is_ts = check.single({isinstance(e, tuple) for e in ts})
+        if is_ts:
+            ks, vs = zip(*ts)
+            out[key_param] = ks
+            out[value_param] = vs
+        else:
+            out[key_param] = ts
+        return out
+
+    return fps.of(forward, backward)

omlish/specs/irc/messages/formats.py

@@ -0,0 +1,92 @@
+import enum
+import typing as ta
+
+from .... import check
+from .... import dataclasses as dc
+from .... import lang
+from ....funcs import pairs as fps
+
+
+MessageParamsUnpacker: ta.TypeAlias = fps.FnPair[
+    ta.Mapping[str, str],  # params
+    ta.Mapping[str, ta.Any],  # kwargs
+]
+
+
+##
+
+
+class MessageFormat(dc.Frozen, final=True):
+    name: str
+
+    class Param(dc.Case):
+        @classmethod
+        def of(cls, obj: ta.Any) -> 'MessageFormat.Param':
+            if isinstance(obj, MessageFormat.Param):
+                return obj
+
+            elif isinstance(obj, str):
+                s = check.non_empty_str(obj)
+
+                optional = False
+                if s.startswith('?'):
+                    optional = True
+                    s = s[1:]
+
+                arity = MessageFormat.KwargParam.Arity.SINGLE
+                if s.startswith('*'):
+                    arity = MessageFormat.KwargParam.Arity.VARIADIC
+                    s = s[1:]
+
+                elif s.startswith(','):
+                    arity = MessageFormat.KwargParam.Arity.COMMA_LIST
+                    s = s[1:]
+
+                return MessageFormat.KwargParam(
+                    s,
+                    optional=optional,
+                    arity=arity,
+                )
+
+            else:
+                raise TypeError(obj)
+
+    class KwargParam(Param):
+        name: str = dc.xfield(validate=lang.is_ident)
+
+        optional: bool = False
+
+        class Arity(enum.Enum):
+            SINGLE = enum.auto()  # <foo>
+            VARIADIC = enum.auto()  # <foo>{ <foo>}
+            COMMA_LIST = enum.auto()  # <foo>{,<foo>}
+
+        arity: Arity = Arity.SINGLE
+
+    class LiteralParam(Param):
+        text: str
+
+    params: ta.Sequence[Param]
+
+    _: dc.KW_ONLY
+
+    unpack_params: MessageParamsUnpacker | None = None
+
+    @dc.init
+    def _validate_params(self) -> None:
+        kws = [p for p in self.params if isinstance(p, MessageFormat.KwargParam)]
+        check.unique(p.name for p in kws)
+        check.state(all(p.arity is not MessageFormat.KwargParam.Arity.VARIADIC for p in kws[:-1]))
+
+    @classmethod
+    def of(
+            cls,
+            name: str,
+            *params: ta.Any,
+            **kwargs: ta.Any,
+    ) -> 'MessageFormat':
+        return cls(
+            name,
+            [MessageFormat.Param.of(p) for p in params],
+            **kwargs,
+        )