omlish 0.0.0.dev223__tar.gz → 0.0.0.dev224__tar.gz

{omlish-0.0.0.dev223/omlish.egg-info → omlish-0.0.0.dev224}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev223
+Version: 0.0.0.dev224
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev223 → omlish-0.0.0.dev224}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev223'
-__revision__ = '383167fabe843d406905492267a5c570dae7cba3'
+__version__ = '0.0.0.dev224'
+__revision__ = '0980d15b9ba0f06f68cf7bdb68fbc8626696075f'
 
 
 #

{omlish-0.0.0.dev223 → omlish-0.0.0.dev224}/omlish/http/handlers.py

@@ -63,14 +63,65 @@ class HttpHandler_(abc.ABC):  # noqa
         raise NotImplementedError
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 class LoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
     log: logging.Logger
-    level: int = logging.INFO
+    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-0.0.0.dev224/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-0.0.0.dev224/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-0.0.0.dev224/omlish/secrets/tempssl.py

@@ -0,0 +1,72 @@
+# @omlish-lite
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+import os.path
+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
+
+
+class TempSslCert(ta.NamedTuple):
+    cert: SslCert
+    temp_dir: str
+
+
+@dc.dataclass(frozen=True)
+class TempSslCertGenerator:
+    @cached_nullary
+    def temp_dir(self) -> str:
+        return tempfile.mkdtemp()
+
+    @cached_nullary
+    def make_run(self) -> SubprocessRun:
+        return SubprocessRun.of(
+            'openssl',
+            'req',
+            '-x509',
+            '-newkey', 'rsa:2048',
+
+            '-keyout', 'key.pem',
+            '-out', 'cert.pem',
+
+            '-days', '365',
+
+            '-nodes',
+
+            '-subj', '/CN=localhost',
+            '-addext', 'subjectAltName = DNS:localhost,IP:127.0.0.1',
+
+            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-0.0.0.dev223 → omlish-0.0.0.dev224}/omlish/subprocesses.py

@@ -265,6 +265,25 @@ class SubprocessRun:
     capture_output: ta.Optional[bool] = None
     kwargs: ta.Optional[ta.Mapping[str, ta.Any]] = None
 
+    @classmethod
+    def of(
+            cls,
+            *cmd: str,
+            input: ta.Any = None,  # noqa
+            timeout: ta.Optional[float] = None,
+            check: bool = False,
+            capture_output: ta.Optional[bool] = None,
+            **kwargs: ta.Any,
+    ) -> 'SubprocessRun':
+        return cls(
+            cmd=cmd,
+            input=input,
+            timeout=timeout,
+            check=check,
+            capture_output=capture_output,
+            kwargs=kwargs,
+        )
+
 
 @dc.dataclass(frozen=True)
 class SubprocessRunOutput(ta.Generic[T]):

{omlish-0.0.0.dev223 → omlish-0.0.0.dev224/omlish.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: omlish
-Version: 0.0.0.dev223
+Version: 0.0.0.dev224
 Summary: omlish
 Author: wrmsr
 License: BSD-3-Clause

{omlish-0.0.0.dev223 → omlish-0.0.0.dev224}/omlish.egg-info/SOURCES.txt

@@ -442,6 +442,7 @@ omlish/lite/resources.py
 omlish/lite/runtime.py
 omlish/lite/secrets.py
 omlish/lite/strings.py
+omlish/lite/timing.py
 omlish/lite/types.py
 omlish/lite/typing.py
 omlish/logs/__init__.py
@@ -457,6 +458,7 @@ omlish/logs/noisy.py
 omlish/logs/protocol.py
 omlish/logs/proxy.py
 omlish/logs/standard.py
+omlish/logs/timing.py
 omlish/logs/utils.py
 omlish/manifests/__init__.py
 omlish/manifests/load.py

{omlish-0.0.0.dev223 → omlish-0.0.0.dev224}/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.dev223'
+version = '0.0.0.dev224'
 classifiers = [
     'License :: OSI Approved :: BSD License',
     'Development Status :: 2 - Pre-Alpha',

omlish-0.0.0.dev223/omlish/secrets/tempssl.py

@@ -1,50 +0,0 @@
-# @omlish-lite
-# ruff: noqa: UP006 UP007
-import os.path
-import subprocess
-import tempfile
-import typing as ta
-
-from .ssl import SslCert
-
-
-class TempSslCert(ta.NamedTuple):
-    cert: SslCert
-    temp_dir: str
-
-
-def generate_temp_localhost_ssl_cert() -> TempSslCert:
-    temp_dir = tempfile.mkdtemp()
-
-    proc = subprocess.run(
-        [
-            'openssl',
-            'req',
-            '-x509',
-            '-newkey', 'rsa:2048',
-
-            '-keyout', 'key.pem',
-            '-out', 'cert.pem',
-
-            '-days', '365',
-
-            '-nodes',
-
-            '-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,
-    )