omlish 0.0.0.dev219__py3-none-any.whl → 0.0.0.dev221__py3-none-any.whl

omlish/graphs/trees.py

@@ -10,6 +10,7 @@ from .. import cached
 from .. import check
 from .. import collections as col
 from .. import lang
+from ..algorithm import all as alg
 
 
 T = ta.TypeVar('T')
@@ -194,7 +195,7 @@ class BasicTreeAnalysis(ta.Generic[NodeT]):
         else:
             e, d = lang.identity, lang.identity
         tsd = {e(n): {e(p)} for n, p in parents_by_node.items()}
-        ts = list(col.mut_toposort(tsd))
+        ts = list(alg.mut_toposort(tsd))
         root = d(check.single(ts[0]))
 
         return cls(

omlish/http/coro/server.py

@@ -205,6 +205,10 @@ class CoroHttpServer:
                     return h
             return None
 
+        def close(self) -> None:
+            if isinstance(d := self.data, HttpHandlerResponseStreamedData):
+                d.close()
+
     #
 
     def _build_response_head_bytes(self, a: _Response) -> bytes:
@@ -417,12 +421,20 @@ class CoroHttpServer:
     #
 
     def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], None]:
-        while True:
-            gen = self.coro_handle_one()
+        return self._coro_run_handler(self._coro_handle_one())
 
-            o = next(gen)
-            i: ta.Optional[bytes]
-            while True:
+    def _coro_run_handler(
+            self,
+            gen: ta.Generator[
+                ta.Union[AnyLogIo, AnyReadIo, _Response],
+                ta.Optional[bytes],
+                None,
+            ],
+    ) -> ta.Generator[Io, ta.Optional[bytes], None]:
+        i: ta.Optional[bytes]
+        o: ta.Any = next(gen)
+        while True:
+            try:
                 if isinstance(o, self.AnyLogIo):
                     i = None
                     yield o
@@ -440,8 +452,13 @@ class CoroHttpServer:
                     for b in self._yield_response_data(r):
                         yield self.WriteIo(b)
 
+                    o.close()
+                    if o.close_connection:
+                        break
+                    o = None
+
                 else:
-                    raise TypeError(o)
+                    raise TypeError(o)  # noqa
 
                 try:
                     o = gen.send(i)
@@ -450,7 +467,13 @@ class CoroHttpServer:
                 except StopIteration:
                     break
 
-    def coro_handle_one(self) -> ta.Generator[
+            except Exception:  # noqa
+                if hasattr(o, 'close'):
+                    o.close()
+
+                raise
+
+    def _coro_handle_one(self) -> ta.Generator[
         ta.Union[AnyLogIo, AnyReadIo, _Response],
         ta.Optional[bytes],
         None,
@@ -530,28 +553,34 @@ class CoroHttpServer:
             yield self._build_error_response(err)
             return
 
-        # Build internal response
+        try:
+            # Build internal response
 
-        response_headers = handler_response.headers or {}
-        response_data = handler_response.data
+            response_headers = handler_response.headers or {}
+            response_data = handler_response.data
 
-        headers: ta.List[CoroHttpServer._Header] = [
-            *self._make_default_headers(),
-        ]
+            headers: ta.List[CoroHttpServer._Header] = [
+                *self._make_default_headers(),
+            ]
 
-        for k, v in response_headers.items():
-            headers.append(self._Header(k, v))
+            for k, v in response_headers.items():
+                headers.append(self._Header(k, v))
 
-        if handler_response.close_connection and 'Connection' not in headers:
-            headers.append(self._Header('Connection', 'close'))
+            if handler_response.close_connection and 'Connection' not in headers:
+                headers.append(self._Header('Connection', 'close'))
 
-        yield self._Response(
-            version=parsed.version,
-            code=http.HTTPStatus(handler_response.status),
-            headers=headers,
-            data=response_data,
-            close_connection=handler_response.close_connection,
-        )
+            yield self._Response(
+                version=parsed.version,
+                code=http.HTTPStatus(handler_response.status),
+                headers=headers,
+                data=response_data,
+                close_connection=handler_response.close_connection,
+            )
+
+        except Exception:  # noqa
+            handler_response.close()
+
+            raise
 
 
 ##

omlish/http/{simple.py → coro/simple.py}

@@ -5,23 +5,23 @@ import contextlib
 import functools
 import typing as ta
 
-from ..lite.check import check
-from ..sockets.addresses import SocketAndAddress
-from ..sockets.bind import CanSocketBinder
-from ..sockets.bind import SocketBinder
-from ..sockets.server.handlers import ExecutorSocketServerHandler
-from ..sockets.server.handlers import SocketHandlerSocketServerHandler
-from ..sockets.server.handlers import SocketServerHandler
-from ..sockets.server.handlers import SocketWrappingSocketServerHandler
-from ..sockets.server.handlers import StandardSocketServerHandler
-from ..sockets.server.server import SocketServer
-from ..sockets.server.threading import ThreadingSocketServerHandler
-from .coro.server import CoroHttpServer
-from .coro.server import CoroHttpServerSocketHandler
-from .handlers import HttpHandler
-from .parsing import HttpRequestParser
-from .versions import HttpProtocolVersion
-from .versions import HttpProtocolVersions
+from ...lite.check import check
+from ...sockets.addresses import SocketAndAddress
+from ...sockets.bind import CanSocketBinder
+from ...sockets.bind import SocketBinder
+from ...sockets.server.handlers import ExecutorSocketServerHandler
+from ...sockets.server.handlers import SocketHandlerSocketServerHandler
+from ...sockets.server.handlers import SocketServerHandler
+from ...sockets.server.handlers import SocketWrappingSocketServerHandler
+from ...sockets.server.handlers import StandardSocketServerHandler
+from ...sockets.server.server import SocketServer
+from ...sockets.server.threading import ThreadingSocketServerHandler
+from ..handlers import HttpHandler
+from ..parsing import HttpRequestParser
+from ..versions import HttpProtocolVersion
+from ..versions import HttpProtocolVersions
+from .server import CoroHttpServer
+from .server import CoroHttpServerSocketHandler
 
 
 if ta.TYPE_CHECKING:

omlish/http/handlers.py

@@ -33,12 +33,20 @@ class HttpHandlerResponse:
     data: ta.Optional[HttpHandlerResponseData] = None
     close_connection: ta.Optional[bool] = None
 
+    def close(self) -> None:
+        if isinstance(d := self.data, HttpHandlerResponseStreamedData):
+            d.close()
+
 
 @dc.dataclass(frozen=True)
 class HttpHandlerResponseStreamedData:
     iter: ta.Iterable[bytes]
     length: ta.Optional[int] = None
 
+    def close(self) -> None:
+        if hasattr(d := self.iter, 'close'):
+            d.close()  # noqa
+
 
 class HttpHandlerError(Exception):
     pass

omlish/io/fileno.py

@@ -0,0 +1,11 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import dataclasses as dc
+
+
+@dc.dataclass(frozen=True)
+class Fileno:
+    fd: int
+
+    def fileno(self) -> int:
+        return self.fd

omlish/lang/__init__.py

@@ -6,11 +6,12 @@ from .cached import (  # noqa
 
 from .classes import (  # noqa
     Abstract,
+    AbstractTypeError,
     AnySensitive,
     Callable,
     Descriptor,
     Final,
-    FinalError,
+    FinalTypeError,
     LazySingleton,
     Marker,
     Namespace,
@@ -26,6 +27,7 @@ from .classes import (  # noqa
     SimpleMetaDict,
     Singleton,
     Virtual,
+    get_abstract_methods,
     is_abstract,
     is_abstract_class,
     is_abstract_method,
@@ -52,6 +54,7 @@ from .cmp import (  # noqa
 
 from .contextmanagers import (  # noqa
     AsyncContextManager,
+    AsyncExitStacked,
     ContextManaged,
     ContextManager,
     ContextWrapped,

omlish/lang/cached.py

@@ -158,7 +158,6 @@ class _CachedFunction(ta.Generic[T]):
 
 
 class _CachedFunctionDescriptor(_CachedFunction[T]):
-
     def __init__(
             self,
             fn: ta.Callable[P, T],

omlish/lang/classes/__init__.py

@@ -1,5 +1,7 @@
 from .abstract import (  # noqa
     Abstract,
+    AbstractTypeError,
+    get_abstract_methods,
     is_abstract,
     is_abstract_class,
     is_abstract_method,
@@ -10,7 +12,7 @@ from .abstract import (  # noqa
 from .restrict import (  # noqa
     AnySensitive,
     Final,
-    FinalError,
+    FinalTypeError,
     NoBool,
     NotInstantiable,
     NotPicklable,

omlish/lang/classes/abstract.py

@@ -11,6 +11,8 @@ _ABSTRACT_METHODS_ATTR = '__abstractmethods__'
 _IS_ABSTRACT_METHOD_ATTR = '__isabstractmethod__'
 _FORCE_ABSTRACT_ATTR = '__forceabstract__'
 
+_INTERNAL_ABSTRACT_ATTRS = frozenset([_FORCE_ABSTRACT_ATTR])
+
 
 def make_abstract(obj: T) -> T:
     if callable(obj):
@@ -27,6 +29,10 @@ def make_abstract(obj: T) -> T:
         return obj
 
 
+class AbstractTypeError(TypeError):
+    pass
+
+
 class Abstract(abc.ABC):  # noqa
     __slots__ = ()
 
@@ -50,7 +56,7 @@ class Abstract(abc.ABC):  # noqa
                 ams.update(set(getattr(b, _ABSTRACT_METHODS_ATTR, [])) - seen)
                 seen.update(dir(b))
             if ams:
-                raise TypeError(
+                raise AbstractTypeError(
                     f'Cannot subclass abstract class {cls.__name__} with abstract methods: '
                     f'{", ".join(map(str, sorted(ams)))}',
                 )
@@ -78,6 +84,13 @@ def is_abstract(obj: ta.Any) -> bool:
     return is_abstract_method(obj) or is_abstract_class(obj)
 
 
+def get_abstract_methods(cls: type, *, include_internal: bool = False) -> frozenset[str]:
+    ms = frozenset(getattr(cls, _ABSTRACT_METHODS_ATTR))
+    if not include_internal:
+        ms -= _INTERNAL_ABSTRACT_ATTRS
+    return ms
+
+
 def unabstract_class(
         members: ta.Iterable[str | tuple[str, ta.Any]],
 ):  # -> ta.Callable[[type[T]], type[T]]:

omlish/lang/classes/restrict.py

@@ -9,7 +9,7 @@ from .abstract import is_abstract
 ##
 
 
-class FinalError(TypeError):
+class FinalTypeError(TypeError):
     def __init__(self, _type: type) -> None:
         super().__init__()
 
@@ -28,11 +28,11 @@ class Final(Abstract):
         abstracts: set[ta.Any] = set()
         for base in cls.__bases__:
             if base is Abstract:
-                raise FinalError(base)
+                raise FinalTypeError(base)
             elif base is Final:
                 continue
             elif Final in base.__mro__:
-                raise FinalError(base)
+                raise FinalTypeError(base)
             else:
                 abstracts.update(getattr(base, '__abstractmethods__', []))
 
@@ -40,9 +40,9 @@ class Final(Abstract):
             try:
                 v = cls.__dict__[a]
             except KeyError:
-                raise FinalError(a) from None
+                raise FinalTypeError(a) from None
             if is_abstract(v):
-                raise FinalError(a)
+                raise FinalTypeError(a)
 
 
 ##

omlish/lang/classes/virtual.py

@@ -28,7 +28,6 @@ def _make_not_instantiable():
 
 
 class _VirtualMeta(abc.ABCMeta):
-
     def __new__(mcls, name, bases, namespace):
         if 'Virtual' not in globals():
             return super().__new__(mcls, name, bases, namespace)

omlish/lang/clsdct.py

@@ -36,7 +36,6 @@ def get_caller_cls_dct(offset: int = 0) -> ta.MutableMapping[str, ta.Any]:
 
 
 class ClassDctFn:
-
     def __init__(self, fn: ta.Callable, offset: int | None = None, *, wrap=True) -> None:
         super().__init__()
 

omlish/lang/contextmanagers.py

@@ -19,7 +19,6 @@ T = ta.TypeVar('T')
 
 
 class ContextManaged:
-
     def __enter__(self) -> ta.Self:
         return self
 
@@ -33,7 +32,6 @@ class ContextManaged:
 
 
 class NopContextManaged(ContextManaged):
-
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
@@ -42,7 +40,6 @@ NOP_CONTEXT_MANAGED = NopContextManaged()
 
 
 class NopContextManager:
-
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         raise TypeError
 
@@ -57,7 +54,6 @@ NOP_CONTEXT_MANAGER = NopContextManager()
 
 
 class ContextManager(abc.ABC, ta.Generic[T]):
-
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
@@ -87,7 +83,6 @@ class ContextManager(abc.ABC, ta.Generic[T]):
 
 
 class AsyncContextManager(abc.ABC, ta.Generic[T]):
-
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
 
@@ -191,7 +186,6 @@ def attr_setting(obj, attr, val, *, default=None):  # noqa
 
 
 class ExitStacked:
-
     @property
     def _exit_stack(self) -> contextlib.ExitStack:
         try:
@@ -229,7 +223,6 @@ class ExitStacked:
 
 
 class AsyncExitStacked:
-
     @property
     def _exit_stack(self) -> contextlib.AsyncExitStack:
         try:
@@ -276,7 +269,6 @@ ContextWrappable: ta.TypeAlias = ta.ContextManager | str | ta.Callable[..., ta.C
 
 
 class ContextWrapped:
-
     def __init__(self, fn: ta.Callable, cm: str | ContextWrappable) -> None:
         super().__init__()
 

omlish/lang/descriptors.py

@@ -197,7 +197,6 @@ decorator = _decorator
 
 
 class AccessForbiddenError(Exception):
-
     def __init__(self, name: str | None = None, *args: ta.Any, **kwargs: ta.Any) -> None:
         super().__init__(*((name,) if name is not None else ()), *args, **kwargs)  # noqa
         self.name = name

omlish/lang/maybes.py

@@ -11,7 +11,6 @@ class ValueNotPresentException(BaseException):
 
 
 class Maybe(abc.ABC, ta.Generic[T]):
-
     @property
     @abc.abstractmethod
     def present(self) -> bool:

omlish/lang/objects.py

@@ -140,9 +140,7 @@ def dir_dict(o: ta.Any) -> dict[str, ta.Any]:
 
 
 class SimpleProxy(ta.Generic[T]):
-
     class Descriptor:
-
         def __init__(self, attr: str) -> None:
             super().__init__()
             self._attr = attr

omlish/secrets/ssl.py

@@ -0,0 +1,9 @@
+# @omlish-lite
+# ruff: noqa: UP006 UP007
+import dataclasses as dc
+
+
+@dc.dataclass(frozen=True)
+class SslCert:
+    key_file: str
+    cert_file: str

omlish/secrets/tempssl.py

@@ -0,0 +1,50 @@
+# @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,
+    )

omlish/sockets/bind.py

@@ -2,7 +2,10 @@
 # @omlish-lite
 """
 TODO:
+ - def parse: (<bind>)?:<port>, unix://, fd://
+ - unix chown/chgrp
  - DupSocketBinder
+ - udp
 """
 import abc
 import dataclasses as dc
@@ -20,6 +23,7 @@ from omlish.sockets.addresses import SocketAndAddress
 
 SocketBinderT = ta.TypeVar('SocketBinderT', bound='SocketBinder')
 SocketBinderConfigT = ta.TypeVar('SocketBinderConfigT', bound='SocketBinder.Config')
+
 CanSocketBinderConfig = ta.Union['SocketBinder.Config', int, ta.Tuple[str, int], str]  # ta.TypeAlias
 CanSocketBinder = ta.Union['SocketBinder', CanSocketBinderConfig]  # ta.TypeAlias
 
@@ -308,7 +312,8 @@ class UnixSocketBinder(SocketBinder):
 
         if self._config.unlink:
             try:
-                os.unlink(self._config.file)
+                if stat.S_ISSOCK(os.stat(self._config.file).st_mode):
+                    os.unlink(self._config.file)
             except FileNotFoundError:
                 pass
 

omlish/sockets/server/server.py

@@ -2,10 +2,12 @@
 # ruff: noqa: UP006 UP007
 import abc
 import contextlib
+import logging
 import selectors
 import threading
 import typing as ta
 
+from ..addresses import SocketAndAddress
 from ..bind import SocketBinder
 from ..io import close_socket_immediately
 from .handlers import SocketServerHandler
@@ -15,12 +17,15 @@ from .handlers import SocketServerHandler
 
 
 class SocketServer(abc.ABC):
+    _DEFAULT_LOGGER = logging.getLogger('.'.join([__name__, 'SocketServer']))
+
     def __init__(
             self,
             binder: SocketBinder,
             handler: SocketServerHandler,
             *,
-            on_error: ta.Optional[ta.Callable[[BaseException], None]] = None,
+            on_error: ta.Optional[ta.Callable[[BaseException, ta.Optional[SocketAndAddress]], None]] = None,
+            error_logger: ta.Optional[logging.Logger] = _DEFAULT_LOGGER,
             poll_interval: float = .5,
             shutdown_timeout: ta.Optional[float] = None,
     ) -> None:
@@ -29,6 +34,7 @@ class SocketServer(abc.ABC):
         self._binder = binder
         self._handler = handler
         self._on_error = on_error
+        self._error_logger = error_logger
         self._poll_interval = poll_interval
         self._shutdown_timeout = shutdown_timeout
 
@@ -46,6 +52,15 @@ class SocketServer(abc.ABC):
 
     #
 
+    def _handle_error(self, exc: BaseException, conn: ta.Optional[SocketAndAddress] = None) -> None:
+        if (error_logger := self._error_logger) is not None:
+            error_logger.exception('Error in socket server: %r', conn)
+
+        if (on_error := self._on_error) is not None:
+            on_error(exc, conn)
+
+    #
+
     class SelectorProtocol(ta.Protocol):
         def register(self, *args, **kwargs) -> None:
             raise NotImplementedError
@@ -100,8 +115,7 @@ class SocketServer(abc.ABC):
                             conn = self._binder.accept()
 
                         except OSError as exc:
-                            if (on_error := self._on_error) is not None:
-                                on_error(exc)
+                            self._handle_error(exc)
 
                             return
 
@@ -109,8 +123,7 @@ class SocketServer(abc.ABC):
                             self._handler(conn)
 
                         except Exception as exc:  # noqa
-                            if (on_error := self._on_error) is not None:
-                                on_error(exc)
+                            self._handle_error(exc, conn)
 
                             close_socket_immediately(conn.socket)
 

omlish/specs/irc/format/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2016-2021 Daniel Oaks
+Copyright (c) 2018-2021 Shivaram Lingamneni
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted,
+provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+THIS SOFTWARE.