omlish 0.0.0.dev216__py3-none-any.whl → 0.0.0.dev218__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/marshal/dataclasses.py

@@ -9,6 +9,7 @@ from .. import collections as col
 from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
+from ..lite import marshal as lm
 from .base import MarshalContext
 from .base import Marshaler
 from .base import MarshalerFactory
@@ -96,6 +97,31 @@ def get_field_infos(
                     unmarshal_names=col.unique([fmd.name, *(fmd.alts or ())]),
                 )
 
+        else:
+            try:
+                lfk = field.metadata[lm.OBJ_MARSHALER_FIELD_KEY]
+            except KeyError:
+                pass
+            else:
+                if lfk is not None:
+                    check.non_empty_str(lfk)
+                    has_set_name = True
+                    fi_kw.update(
+                        marshal_name=lfk,
+                        unmarshal_names=[lfk],
+                    )
+                else:
+                    fo_kw.update(
+                        no_marshal=True,
+                        no_unmarshal=True,
+                    )
+
+            if (lon := field.metadata.get(lm.OBJ_MARSHALER_OMIT_IF_NONE)) is not None:
+                if check.isinstance(lon, bool):
+                    fo_kw.update(
+                        omit_if=lang.is_none,
+                    )
+
         if fo_kw.get('embed') and not has_set_name:
             fi_kw.update(
                 marshal_name=fi_kw['marshal_name'] + '_',

omlish/sockets/addresses.py

@@ -2,8 +2,7 @@
 # @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
@@ -35,11 +34,16 @@ class SocketAddressInfo:
     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]:
+) -> SocketFamilyAndAddress:
     """https://github.com/python/cpython/commit/f289084c83190cc72db4a70c58f007ec62e75247"""
 
     infos = socket.getaddrinfo(
@@ -50,4 +54,9 @@ def get_best_socket_family(
         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

omlish/sockets/bind.py

@@ -0,0 +1,332 @@
+# 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')
+
+
+##
+
+
+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 new(
+                cls,
+                target: ta.Union[
+                    int,
+                    ta.Tuple[str, int],
+                    str,
+                ],
+        ) -> 'SocketBinder.Config':
+            if isinstance(target, int):
+                return TcpSocketBinder.Config(
+                    port=target,
+                )
+
+            elif isinstance(target, tuple):
+                host, port = target
+                return TcpSocketBinder.Config(
+                    host=host,
+                    port=port,
+                )
+
+            elif isinstance(target, str):
+                return UnixSocketBinder.Config(
+                    file=target,
+                )
+
+            else:
+                raise TypeError(target)
+
+    #
+
+    def __init__(self, config: SocketBinderConfigT) -> None:
+        super().__init__()
+
+        self._config = config
+
+    #
+
+    @classmethod
+    def new(cls, target: ta.Any) -> 'SocketBinder':
+        config: SocketBinder.Config
+        if isinstance(target, SocketBinder.Config):
+            config = target
+
+        else:
+            config = SocketBinder.Config.new(target)
+
+        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

@@ -1,30 +1,12 @@
 # ruff: noqa: UP006 UP007
 # @omlish-lite
-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
-
-    @abc.abstractmethod
-    def handle(self) -> None:
-        raise NotImplementedError

omlish/sockets/io.py

@@ -0,0 +1,69 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
+import io
+import socket
+import typing as ta
+
+
+##
+
+
+class SocketWriter(io.BufferedIOBase):
+    """
+    Simple writable BufferedIOBase implementation for a socket
+
+    Does not hold data in a buffer, avoiding any need to call flush().
+    """
+
+    def __init__(self, sock):
+        super().__init__()
+
+        self._sock = sock
+
+    def writable(self):
+        return True
+
+    def write(self, b):
+        self._sock.sendall(b)
+        with memoryview(b) as view:
+            return view.nbytes
+
+    def fileno(self):
+        return self._sock.fileno()
+
+
+class SocketIoPair(ta.NamedTuple):
+    r: ta.BinaryIO
+    w: ta.BinaryIO
+
+    @classmethod
+    def from_socket(
+            cls,
+            sock: socket.socket,
+            *,
+            r_buf_size: int = -1,
+            w_buf_size: int = 0,
+    ) -> 'SocketIoPair':
+        rf: ta.Any = sock.makefile('rb', r_buf_size)
+
+        if w_buf_size:
+            wf: ta.Any = SocketWriter(sock)
+        else:
+            wf = sock.makefile('wb', w_buf_size)
+
+        return cls(rf, wf)
+
+
+##
+
+
+def close_socket_immediately(sock: socket.socket) -> None:
+    try:
+        # Explicitly shutdown. socket.close() merely releases the socket and waits for GC to perform the actual close.
+        sock.shutdown(socket.SHUT_WR)
+
+    except OSError:
+        # Some platforms may raise ENOTCONN here
+        pass
+
+    sock.close()