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

omlish/logs/protocol.py

@@ -0,0 +1,176 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import abc
+import logging
+import sys
+import typing as ta
+
+from .callers import LoggingCaller
+
+
+LogLevel = int  # ta.TypeAlias
+
+
+##
+
+
+class Logging(ta.Protocol):
+    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        ...
+
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        ...
+
+    #
+
+    def debug(self, msg: str, *args, **kwargs) -> None:
+        ...
+
+    def info(self, msg: str, *args, **kwargs) -> None:
+        ...
+
+    def warning(self, msg: str, *args, **kwargs) -> None:
+        ...
+
+    def error(self, msg: str, *args, **kwargs) -> None:
+        ...
+
+    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+        ...
+
+    def critical(self, msg: str, *args, **kwargs) -> None:
+        ...
+
+    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+        ...
+
+
+##
+
+
+class AbstractLogging(abc.ABC):
+    @ta.final
+    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        return self.is_enabled_for(level)
+
+    def is_enabled_for(self, level: LogLevel) -> bool:  # noqa
+        return level >= self.getEffectiveLevel()
+
+    @ta.final
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        return self.get_effective_level()
+
+    @abc.abstractmethod
+    def get_effective_level(self) -> LogLevel:  # noqa
+        raise NotImplementedError
+
+    #
+
+    def debug(self, msg: str, *args, **kwargs) -> None:
+        if self.is_enabled_for(logging.DEBUG):
+            self.log(logging.DEBUG, msg, args, **kwargs)
+
+    def info(self, msg: str, *args, **kwargs) -> None:
+        if self.is_enabled_for(logging.INFO):
+            self.log(logging.INFO, msg, args, **kwargs)
+
+    def warning(self, msg: str, *args, **kwargs) -> None:
+        if self.is_enabled_for(logging.WARNING):
+            self.log(logging.WARNING, msg, args, **kwargs)
+
+    def error(self, msg: str, *args, **kwargs) -> None:
+        if self.is_enabled_for(logging.ERROR):
+            self.log(logging.ERROR, msg, args, **kwargs)
+
+    def exception(self, msg: str, *args, exc_info=True, **kwargs) -> None:
+        self.error(msg, *args, exc_info=exc_info, **kwargs)
+
+    def critical(self, msg: str, *args, **kwargs) -> None:
+        if self.is_enabled_for(logging.CRITICAL):
+            self.log(logging.CRITICAL, msg, args, **kwargs)
+
+    def log(self, level: LogLevel, msg: str, *args, **kwargs) -> None:
+        if not isinstance(level, int):
+            raise TypeError('Level must be an integer.')
+        if self.is_enabled_for(level):
+            self._log(level, msg, args, **kwargs)
+
+    @abc.abstractmethod
+    def _log(
+            self,
+            level: int,
+            msg: str,
+            args: ta.Any,
+            *,
+            exc_info: ta.Any = None,
+            extra: ta.Any = None,
+            stack_info: bool = False,
+    ) -> None:
+        raise NotImplementedError
+
+
+##
+
+
+class NopLogging(AbstractLogging):
+    def get_effective_level(self) -> LogLevel:
+        return logging.CRITICAL + 1
+
+    def _log(self, *args: ta.Any, **kwargs: ta.Any) -> None:
+        pass
+
+
+##
+
+
+class StdlibLogging(AbstractLogging):
+    def __init__(self, underlying: logging.Logger) -> None:
+        super().__init__()
+
+        if not isinstance(underlying, logging.Logger):
+            raise TypeError(underlying)
+
+        self._underlying = underlying
+
+    #
+
+    def is_enabled_for(self, level: int) -> bool:  # noqa
+        return self._underlying.isEnabledFor(level)
+
+    def get_effective_level(self) -> int:  # noqa
+        return self._underlying.getEffectiveLevel()
+
+    #
+
+    def _log(
+            self,
+            level: int,
+            msg: str,
+            args: ta.Any,
+            *,
+            exc_info: ta.Any = None,
+            extra: ta.Any = None,
+            stack_info: bool = False,
+    ) -> None:
+        caller = LoggingCaller.find(stack_info)
+
+        if exc_info:
+            if isinstance(exc_info, BaseException):
+                exc_info = (type(exc_info), exc_info, exc_info.__traceback__)
+            elif not isinstance(exc_info, tuple):
+                exc_info = sys.exc_info()
+
+        record = self._underlying.makeRecord(
+            name=self._underlying.name,
+            level=level,
+            fn=caller.filename,
+            lno=caller.lineno,
+            msg=msg,
+            args=args,
+            exc_info=exc_info,
+            func=caller.func,
+            extra=extra,
+            sinfo=caller.sinfo,
+        )
+
+        self._underlying.handle(record)

omlish/secrets/__init__.py

@@ -1,24 +0,0 @@
-from .secrets import (  # noqa
-    CachingSecrets,
-    CompositeSecrets,
-    EMPTY_SECRETS,
-    EmptySecrets,
-    EnvVarSecrets,
-    FnSecrets,
-    LoggingSecrets,
-    MappingSecrets,
-    Secret,
-    SecretRef,
-    SecretRefOrStr,
-    Secrets,
-    secret_field,
-    secret_repr,
-)
-
-
-##
-
-
-from ..lang.imports import _register_conditional_import  # noqa
-
-_register_conditional_import('..marshal', '.marshal', __package__)

omlish/secrets/all.py

@@ -0,0 +1,16 @@
+from .secrets import (  # noqa
+    CachingSecrets,
+    CompositeSecrets,
+    EMPTY_SECRETS,
+    EmptySecrets,
+    EnvVarSecrets,
+    FnSecrets,
+    LoggingSecrets,
+    MappingSecrets,
+    Secret,
+    SecretRef,
+    SecretRefOrStr,
+    Secrets,
+    secret_field,
+    secret_repr,
+)

omlish/secrets/secrets.py

@@ -335,3 +335,9 @@ class EnvVarSecrets(Secrets):
             return dct.pop(ekey)
         else:
             return dct[ekey]
+
+
+##
+
+
+lang.imports._register_conditional_import('..marshal', '.marshal', __package__)  # noqa

omlish/sockets/addresses.py

@@ -2,11 +2,10 @@
 # @omlish-lite
 """
 TODO:
- - SocketClientAddress family / tuple pairs
-  + codification of https://docs.python.org/3/library/socket.html#socket-families
+ - codification of https://docs.python.org/3/library/socket.html#socket-families
 """
 import dataclasses as dc
-import socket
+import socket as socket_
 import typing as ta
 
 
@@ -20,34 +19,56 @@ SocketAddress = ta.Any
 class SocketAddressInfoArgs:
     host: ta.Optional[str]
     port: ta.Union[str, int, None]
-    family: socket.AddressFamily = socket.AddressFamily.AF_UNSPEC
+    family: socket_.AddressFamily = socket_.AddressFamily.AF_UNSPEC
     type: int = 0
     proto: int = 0
-    flags: socket.AddressInfo = socket.AddressInfo(0)
+    flags: socket_.AddressInfo = socket_.AddressInfo(0)
 
 
 @dc.dataclass(frozen=True)
 class SocketAddressInfo:
-    family: socket.AddressFamily
+    family: socket_.AddressFamily
     type: int
     proto: int
     canonname: ta.Optional[str]
     sockaddr: SocketAddress
 
 
+class SocketFamilyAndAddress(ta.NamedTuple):
+    family: socket_.AddressFamily
+    address: SocketAddress
+
+
 def get_best_socket_family(
         host: ta.Optional[str],
         port: ta.Union[str, int, None],
-        family: ta.Union[int, socket.AddressFamily] = socket.AddressFamily.AF_UNSPEC,
-) -> ta.Tuple[socket.AddressFamily, SocketAddress]:
+        family: ta.Union[int, socket_.AddressFamily] = socket_.AddressFamily.AF_UNSPEC,
+) -> SocketFamilyAndAddress:
     """https://github.com/python/cpython/commit/f289084c83190cc72db4a70c58f007ec62e75247"""
 
-    infos = socket.getaddrinfo(
+    infos = socket_.getaddrinfo(
         host,
         port,
         family,
-        type=socket.SOCK_STREAM,
-        flags=socket.AI_PASSIVE,
+        type=socket_.SOCK_STREAM,
+        flags=socket_.AI_PASSIVE,
     )
     ai = SocketAddressInfo(*next(iter(infos)))
-    return ai.family, ai.sockaddr
+    return SocketFamilyAndAddress(ai.family, ai.sockaddr)
+
+
+class SocketAndAddress(ta.NamedTuple):
+    socket: socket_.socket
+    address: SocketAddress
+
+    def wrap_socket(self, fn: ta.Callable[[socket_.socket], socket_.socket]):
+        return self._replace(socket=fn(self.socket))
+
+    @classmethod
+    def socket_wrapper(
+            cls,
+            fn: ta.Callable[[socket_.socket], socket_.socket],
+    ) -> ta.Callable[['SocketAndAddress'], 'SocketAndAddress']:
+        def inner(conn):
+            return conn.wrap_socket(fn)
+        return inner

omlish/sockets/bind.py

@@ -0,0 +1,333 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+"""
+TODO:
+ - DupSocketBinder
+"""
+import abc
+import dataclasses as dc
+import errno
+import os
+import socket as socket_
+import stat
+import typing as ta
+
+from omlish.lite.check import check
+from omlish.lite.dataclasses import dataclass_maybe_post_init
+from omlish.sockets.addresses import SocketAddress
+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
+
+
+##
+
+
+class SocketBinder(abc.ABC, ta.Generic[SocketBinderConfigT]):
+    @dc.dataclass(frozen=True)
+    class Config:
+        listen_backlog: int = 5
+
+        allow_reuse_address: bool = True
+        allow_reuse_port: bool = True
+
+        set_inheritable: bool = False
+
+        #
+
+        @classmethod
+        def of(cls, obj: CanSocketBinderConfig) -> 'SocketBinder.Config':
+            if isinstance(obj, SocketBinder.Config):
+                return obj
+
+            elif isinstance(obj, int):
+                return TcpSocketBinder.Config(
+                    port=obj,
+                )
+
+            elif isinstance(obj, tuple):
+                host, port = obj
+                return TcpSocketBinder.Config(
+                    host=host,
+                    port=port,
+                )
+
+            elif isinstance(obj, str):
+                return UnixSocketBinder.Config(
+                    file=obj,
+                )
+
+            else:
+                raise TypeError(obj)
+
+    #
+
+    def __init__(self, config: SocketBinderConfigT) -> None:
+        super().__init__()
+
+        self._config = config
+
+    #
+
+    @classmethod
+    def of(cls, obj: CanSocketBinder) -> 'SocketBinder':
+        if isinstance(obj, SocketBinder):
+            return obj
+
+        config: SocketBinder.Config
+        if isinstance(obj, SocketBinder.Config):
+            config = obj
+
+        else:
+            config = SocketBinder.Config.of(obj)
+
+        if isinstance(config, TcpSocketBinder.Config):
+            return TcpSocketBinder(config)
+
+        elif isinstance(config, UnixSocketBinder.Config):
+            return UnixSocketBinder(config)
+
+        else:
+            raise TypeError(config)
+
+    #
+
+    class Error(RuntimeError):
+        pass
+
+    class NotBoundError(Error):
+        pass
+
+    class AlreadyBoundError(Error):
+        pass
+
+    #
+
+    @property
+    @abc.abstractmethod
+    def address_family(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def address(self) -> SocketAddress:
+        raise NotImplementedError
+
+    #
+
+    _socket: socket_.socket
+
+    @property
+    def is_bound(self) -> bool:
+        return hasattr(self, '_socket')
+
+    @property
+    def socket(self) -> socket_.socket:
+        try:
+            return self._socket
+        except AttributeError:
+            raise self.NotBoundError from None
+
+    _name: str
+
+    @property
+    def name(self) -> str:
+        try:
+            return self._name
+        except AttributeError:
+            raise self.NotBoundError from None
+
+    _port: ta.Optional[int]
+
+    @property
+    def port(self) -> ta.Optional[int]:
+        try:
+            return self._port
+        except AttributeError:
+            raise self.NotBoundError from None
+
+    #
+
+    def fileno(self) -> int:
+        return self.socket.fileno()
+
+    #
+
+    def __enter__(self: SocketBinderT) -> SocketBinderT:
+        self.bind()
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+
+    #
+
+    def _init_socket(self) -> None:
+        if hasattr(self, '_socket'):
+            raise self.AlreadyBoundError
+
+        socket = socket_.socket(self.address_family, socket_.SOCK_STREAM)
+        self._socket = socket
+
+        if self._config.allow_reuse_address and hasattr(socket_, 'SO_REUSEADDR'):
+            socket.setsockopt(socket_.SOL_SOCKET, socket_.SO_REUSEADDR, 1)
+
+        # Since Linux 6.12.9, SO_REUSEPORT is not allowed on other address families than AF_INET/AF_INET6.
+        if (
+                self._config.allow_reuse_port and hasattr(socket_, 'SO_REUSEPORT') and
+                self.address_family in (socket_.AF_INET, socket_.AF_INET6)
+        ):
+            try:
+                socket.setsockopt(socket_.SOL_SOCKET, socket_.SO_REUSEPORT, 1)
+            except OSError as err:
+                if err.errno not in (errno.ENOPROTOOPT, errno.EINVAL):
+                    raise
+
+        if self._config.set_inheritable and hasattr(socket, 'set_inheritable'):
+            socket.set_inheritable(True)
+
+    def _pre_bind(self) -> None:
+        pass
+
+    def _post_bind(self) -> None:
+        pass
+
+    def bind(self) -> None:
+        self._init_socket()
+
+        self._pre_bind()
+
+        self.socket.bind(self.address)
+
+        self._post_bind()
+
+        check.state(all(hasattr(self, a) for a in ('_socket', '_name', '_port')))
+
+    #
+
+    def close(self) -> None:
+        if hasattr(self, '_socket'):
+            self._socket.close()
+
+    #
+
+    def listen(self) -> None:
+        self.socket.listen(self._config.listen_backlog)
+
+    @abc.abstractmethod
+    def accept(self, socket: ta.Optional[socket_.socket] = None) -> SocketAndAddress:
+        raise NotImplementedError
+
+
+##
+
+
+class TcpSocketBinder(SocketBinder):
+    @dc.dataclass(frozen=True)
+    class Config(SocketBinder.Config):
+        DEFAULT_HOST: ta.ClassVar[str] = 'localhost'
+        host: str = DEFAULT_HOST
+
+        port: int = 0
+
+        def __post_init__(self) -> None:
+            dataclass_maybe_post_init(super())
+            check.non_empty_str(self.host)
+            check.isinstance(self.port, int)
+            check.arg(self.port > 0)
+
+    def __init__(self, config: Config) -> None:
+        super().__init__(check.isinstance(config, self.Config))
+
+        self._address = (config.host, config.port)
+
+    #
+
+    address_family = socket_.AF_INET
+
+    @property
+    def address(self) -> SocketAddress:
+        return self._address
+
+    #
+
+    def _post_bind(self) -> None:
+        super()._post_bind()
+
+        host, port, *_ = self.socket.getsockname()
+
+        self._name = socket_.getfqdn(host)
+        self._port = port
+
+    #
+
+    def accept(self, socket: ta.Optional[socket_.socket] = None) -> SocketAndAddress:
+        if socket is None:
+            socket = self.socket
+
+        conn, client_address = socket.accept()
+        return SocketAndAddress(conn, client_address)
+
+
+##
+
+
+class UnixSocketBinder(SocketBinder):
+    @dc.dataclass(frozen=True)
+    class Config(SocketBinder.Config):
+        file: str = ''
+
+        unlink: bool = False
+
+        def __post_init__(self) -> None:
+            dataclass_maybe_post_init(super())
+            check.non_empty_str(self.file)
+
+    def __init__(self, config: Config) -> None:
+        super().__init__(check.isinstance(config, self.Config))
+
+        self._address = config.file
+
+    #
+
+    address_family = socket_.AF_UNIX
+
+    @property
+    def address(self) -> SocketAddress:
+        return self._address
+
+    #
+
+    def _pre_bind(self) -> None:
+        super()._pre_bind()
+
+        if self._config.unlink:
+            try:
+                os.unlink(self._config.file)
+            except FileNotFoundError:
+                pass
+
+    def _post_bind(self) -> None:
+        super()._post_bind()
+
+        name = self.socket.getsockname()
+
+        os.chmod(name, stat.S_IRWXU | stat.S_IRWXG)  # noqa
+
+        self._name = name
+        self._port = None
+
+    #
+
+    def accept(self, sock: ta.Optional[socket_.socket] = None) -> SocketAndAddress:
+        if sock is None:
+            sock = self.socket
+
+        conn, _ = sock.accept()
+        client_address = ('', 0)
+        return SocketAndAddress(conn, client_address)

omlish/sockets/handlers.py

@@ -4,27 +4,16 @@ import abc
 import typing as ta
 
 from .addresses import SocketAddress
+from .io import SocketIoPair  # noqa
 
 
-SocketHandlerFactory = ta.Callable[[SocketAddress, ta.BinaryIO, ta.BinaryIO], 'SocketHandler']
+SocketHandler = ta.Callable[[SocketAddress, 'SocketIoPair'], None]  # ta.TypeAlias
 
 
 ##
 
 
-class SocketHandler(abc.ABC):
-    def __init__(
-            self,
-            client_address: SocketAddress,
-            rfile: ta.BinaryIO,
-            wfile: ta.BinaryIO,
-    ) -> None:
-        super().__init__()
-
-        self._client_address = client_address
-        self._rfile = rfile
-        self._wfile = wfile
-
+class SocketHandler_(abc.ABC):  # noqa
     @abc.abstractmethod
-    def handle(self) -> None:
+    def __call__(self, addr: SocketAddress, f: SocketIoPair) -> None:
         raise NotImplementedError