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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev222'
-__revision__ = '6f15b0f3bde72b207c93e58623da4bb444ff4003'
+__version__ = '0.0.0.dev224'
+__revision__ = '0980d15b9ba0f06f68cf7bdb68fbc8626696075f'
 
 
 #
@@ -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,67 @@ 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.DEBUG
+
+    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
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BytesResponseHttpHandler(HttpHandler_):
+    data: bytes
+
+    status: ta.Union[http.HTTPStatus, int] = 200
+    content_type: ta.Optional[str] = 'application/octet-stream'
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    close_connection: bool = True
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        return HttpHandlerResponse(
+            status=self.status,
+            headers={
+                **({'Content-Type': self.content_type} if self.content_type else {}),
+                'Content-Length': str(len(self.data)),
+                **(self.headers or {}),
+            },
+            data=self.data,
+            close_connection=self.close_connection,
+        )
+
+
+@dc.dataclass(frozen=True)
+class StringResponseHttpHandler(HttpHandler_):
+    data: str
+
+    status: ta.Union[http.HTTPStatus, int] = 200
+    content_type: ta.Optional[str] = 'text/plain; charset=utf-8'
+    headers: ta.Optional[ta.Mapping[str, str]] = None
+    close_connection: bool = True
+
+    def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
+        data = self.data.encode('utf-8')
+        return HttpHandlerResponse(
+            status=self.status,
+            headers={
+                **({'Content-Type': self.content_type} if self.content_type else {}),
+                'Content-Length': str(len(data)),
+                **(self.headers or {}),
+            },
+            data=data,
+            close_connection=self.close_connection,
+        )

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/lite/timing.py

@@ -0,0 +1,8 @@
+from ..logs.timing import LogTimingContext
+from ..logs.timing import log_timing_context
+from .logs import log
+
+
+LogTimingContext.DEFAULT_LOG = log
+
+log_timing_context = log_timing_context  # noqa

omlish/logs/timing.py

@@ -0,0 +1,58 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import logging
+import time
+import typing as ta
+
+
+##
+
+
+class LogTimingContext:
+    DEFAULT_LOG: ta.ClassVar[ta.Optional[logging.Logger]] = None
+
+    class _NOT_SPECIFIED:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
+    def __init__(
+            self,
+            description: str,
+            *,
+            log: ta.Union[logging.Logger, ta.Type[_NOT_SPECIFIED], None] = _NOT_SPECIFIED,  # noqa
+            level: int = logging.DEBUG,
+    ) -> None:
+        super().__init__()
+
+        self._description = description
+        if log is self._NOT_SPECIFIED:
+            log = self.DEFAULT_LOG  # noqa
+        self._log: ta.Optional[logging.Logger] = log  # type: ignore
+        self._level = level
+
+    def set_description(self, description: str) -> 'LogTimingContext':
+        self._description = description
+        return self
+
+    _begin_time: float
+    _end_time: float
+
+    def __enter__(self) -> 'LogTimingContext':
+        self._begin_time = time.time()
+
+        if self._log is not None:
+            self._log.log(self._level, f'Begin : {self._description}')  # noqa
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self._end_time = time.time()
+
+        if self._log is not None:
+            self._log.log(
+                self._level,
+                f'End : {self._description} - {self._end_time - self._begin_time:0.2f} s elapsed',
+            )
+
+
+log_timing_context = LogTimingContext

omlish/secrets/tempssl.py

@@ -1,10 +1,14 @@
 # @omlish-lite
 # ruff: noqa: UP006 UP007
+import dataclasses as dc
 import os.path
-import subprocess
 import tempfile
 import typing as ta
 
+from ..lite.cached import cached_nullary
+from ..subprocesses import SubprocessRun
+from ..subprocesses import SubprocessRunOutput
+from ..subprocesses import subprocesses
 from .ssl import SslCert
 
 
@@ -13,11 +17,15 @@ class TempSslCert(ta.NamedTuple):
     temp_dir: str
 
 
-def generate_temp_localhost_ssl_cert() -> TempSslCert:
-    temp_dir = tempfile.mkdtemp()
+@dc.dataclass(frozen=True)
+class TempSslCertGenerator:
+    @cached_nullary
+    def temp_dir(self) -> str:
+        return tempfile.mkdtemp()
 
-    proc = subprocess.run(
-        [
+    @cached_nullary
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
             'openssl',
             'req',
             '-x509',
@@ -32,19 +40,33 @@ def generate_temp_localhost_ssl_cert() -> TempSslCert:
 
             '-subj', '/CN=localhost',
             '-addext', 'subjectAltName = DNS:localhost,IP:127.0.0.1',
-        ],
-        cwd=temp_dir,
-        capture_output=True,
-        check=False,
-    )
-
-    if proc.returncode:
-        raise RuntimeError(f'Failed to generate temp ssl cert: {proc.stderr=}')
-
-    return TempSslCert(
-        SslCert(
-            key_file=os.path.join(temp_dir, 'key.pem'),
-            cert_file=os.path.join(temp_dir, 'cert.pem'),
-        ),
-        temp_dir,
-    )
+
+            cwd=self.temp_dir(),
+            capture_output=True,
+            check=False,
+        )
+
+    def handle_run_output(self, proc: SubprocessRunOutput) -> TempSslCert:
+        if proc.returncode:
+            raise RuntimeError(f'Failed to generate temp ssl cert: {proc.stderr=}')
+
+        key_file = os.path.join(self.temp_dir(), 'key.pem')
+        cert_file = os.path.join(self.temp_dir(), 'cert.pem')
+        for file in [key_file, cert_file]:
+            if not os.path.isfile(file):
+                raise RuntimeError(f'Failed to generate temp ssl cert (file not found): {file}')
+
+        return TempSslCert(
+            SslCert(
+                key_file=key_file,
+                cert_file=cert_file,
+            ),
+            temp_dir=self.temp_dir(),
+        )
+
+    def run(self) -> TempSslCert:
+        return self.handle_run_output(subprocesses.run_(self.make_run()))
+
+
+def generate_temp_localhost_ssl_cert() -> TempSslCert:
+    return TempSslCertGenerator().run()

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,
+        )