omlish 0.0.0.dev132__py3-none-any.whl → 0.0.0.dev177__py3-none-any.whl

omlish/{lite/fdio/corohttp.py → http/coro/fdio.py}

@@ -1,19 +1,18 @@
+# ruff: noqa: UP006 UP007
+# @omlish-lite
 import socket
 import typing as ta
 
-from ..check import check_isinstance
-from ..check import check_none
-from ..check import check_not_none
-from ..check import check_state
-from ..http.coroserver import CoroHttpServer
-from ..http.handlers import HttpHandler
-from ..io import IncrementalWriteBuffer
-from ..io import ReadableListBuffer
-from ..socket import SocketAddress
-from .handlers import SocketFdIoHandler
+from ...io.buffers import IncrementalWriteBuffer
+from ...io.buffers import ReadableListBuffer
+from ...io.fdio.handlers import SocketFdioHandler
+from ...lite.check import check
+from ...lite.socket import SocketAddress
+from ..handlers import HttpHandler
+from .server import CoroHttpServer
 
 
-class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
+class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
     def __init__(
             self,
             addr: SocketAddress,
@@ -22,14 +21,16 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
             *,
             read_size: int = 0x10000,
             write_size: int = 0x10000,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
     ) -> None:
-        check_state(not sock.getblocking())
+        check.state(not sock.getblocking())
 
         super().__init__(addr, sock)
 
         self._handler = handler
         self._read_size = read_size
         self._write_size = write_size
+        self._log_handler = log_handler
 
         self._read_buf = ReadableListBuffer()
         self._write_buf: IncrementalWriteBuffer | None = None
@@ -46,7 +47,7 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
     #
 
     def _next_io(self) -> None:  # noqa
-        coro = check_not_none(self._srv_coro)
+        coro = check.not_none(self._srv_coro)
 
         d: bytes | None = None
         o = self._cur_io
@@ -64,7 +65,8 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
                     break
 
             if isinstance(o, CoroHttpServer.AnyLogIo):
-                print(o)
+                if self._log_handler is not None:
+                    self._log_handler(self._coro_srv, o)
                 o = None
 
             elif isinstance(o, CoroHttpServer.ReadIo):
@@ -78,7 +80,7 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
                 o = None
 
             elif isinstance(o, CoroHttpServer.WriteIo):
-                check_none(self._write_buf)
+                check.none(self._write_buf)
                 self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
                 break
 
@@ -99,7 +101,7 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
 
     def on_readable(self) -> None:
         try:
-            buf = check_not_none(self._sock).recv(self._read_size)
+            buf = check.not_none(self._sock).recv(self._read_size)
         except BlockingIOError:
             return
         except ConnectionResetError:
@@ -115,12 +117,12 @@ class CoroHttpServerConnectionFdIoHandler(SocketFdIoHandler):
             self._next_io()
 
     def on_writable(self) -> None:
-        check_isinstance(self._cur_io, CoroHttpServer.WriteIo)
-        wb = check_not_none(self._write_buf)
+        check.isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        wb = check.not_none(self._write_buf)
         while wb.rem > 0:
             def send(d: bytes) -> int:
                 try:
-                    return check_not_none(self._sock).send(d)
+                    return check.not_none(self._sock).send(d)
                 except ConnectionResetError:
                     self.close()
                     return 0

omlish/{lite/http/coroserver.py → http/coro/server.py}

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #
@@ -62,20 +63,18 @@ import textwrap
 import time
 import typing as ta
 
-from ..check import check_isinstance
-from ..check import check_none
-from ..check import check_not_none
-from ..socket import SocketAddress
-from ..socket import SocketHandler
-from .handlers import HttpHandler
-from .handlers import HttpHandlerRequest
-from .handlers import UnsupportedMethodHttpHandlerError
-from .parsing import EmptyParsedHttpResult
-from .parsing import HttpRequestParser
-from .parsing import ParsedHttpRequest
-from .parsing import ParseHttpRequestError
-from .versions import HttpProtocolVersion
-from .versions import HttpProtocolVersions
+from ...lite.check import check
+from ...lite.socket import SocketAddress
+from ...lite.socket import SocketHandler
+from ..handlers import HttpHandler
+from ..handlers import HttpHandlerRequest
+from ..handlers import UnsupportedMethodHttpHandlerError
+from ..parsing import EmptyParsedHttpResult
+from ..parsing import HttpRequestParser
+from ..parsing import ParsedHttpRequest
+from ..parsing import ParseHttpRequestError
+from ..versions import HttpProtocolVersion
+from ..versions import HttpProtocolVersions
 
 
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
@@ -406,13 +405,13 @@ class CoroHttpServer:
                     yield o
 
                 elif isinstance(o, self.AnyReadIo):
-                    i = check_isinstance((yield o), bytes)
+                    i = check.isinstance((yield o), bytes)
 
                 elif isinstance(o, self._Response):
                     i = None
                     r = self._preprocess_response(o)
                     b = self._build_response_bytes(r)
-                    check_none((yield self.WriteIo(b)))
+                    check.none((yield self.WriteIo(b)))
 
                 else:
                     raise TypeError(o)
@@ -435,7 +434,7 @@ class CoroHttpServer:
         sz = next(gen)
         while True:
             try:
-                line = check_isinstance((yield self.ReadLineIo(sz)), bytes)
+                line = check.isinstance((yield self.ReadLineIo(sz)), bytes)
                 sz = gen.send(line)
             except StopIteration as e:
                 parsed = e.value
@@ -454,11 +453,11 @@ class CoroHttpServer:
             yield self._build_error_response(err)
             return
 
-        parsed = check_isinstance(parsed, ParsedHttpRequest)
+        parsed = check.isinstance(parsed, ParsedHttpRequest)
 
         # Log
 
-        check_none((yield self.ParsedRequestLogIo(parsed)))
+        check.none((yield self.ParsedRequestLogIo(parsed)))
 
         # Handle CONTINUE
 
@@ -474,7 +473,7 @@ class CoroHttpServer:
 
         request_data: ta.Optional[bytes]
         if (cl := parsed.headers.get('Content-Length')) is not None:
-            request_data = check_isinstance((yield self.ReadIo(int(cl))), bytes)
+            request_data = check.isinstance((yield self.ReadIo(int(cl))), bytes)
         else:
             request_data = None
 
@@ -482,7 +481,7 @@ class CoroHttpServer:
 
         handler_request = HttpHandlerRequest(
             client_address=self._client_address,
-            method=check_not_none(parsed.method),
+            method=check.not_none(parsed.method),
             path=parsed.path,
             headers=parsed.headers,
             data=request_data,

omlish/{lite/http → http}/handlers.py

@@ -1,13 +1,14 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import dataclasses as dc
 import http.server
 import typing as ta
 
-from ..socket import SocketAddress
+from ..lite.socket import SocketAddress
 from .parsing import HttpHeaders
 
 
-HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']
+HttpHandler = ta.Callable[['HttpHandlerRequest'], 'HttpHandlerResponse']  # ta.TypeAlias
 
 
 @dc.dataclass(frozen=True)

omlish/{lite/http → http}/parsing.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #

omlish/http/sessions.py

@@ -8,9 +8,9 @@ import time
 import typing as ta
 import zlib
 
-from .. import fnpairs as fpa
 from .. import lang
 from .. import secrets as sec
+from ..funcs import pairs as fpa
 from .cookies import dump_cookie
 from .cookies import parse_cookie
 from .json import JSON_TAGGER

omlish/{lite/http → http}/versions.py

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 import typing as ta
 
 

omlish/inject/managed.py

@@ -14,9 +14,9 @@ from .injector import create_injector
 
 
 if ta.TYPE_CHECKING:
-    from .. import asyncs as _asyncs
+    from ..asyncs import all as _asyncs
 else:
-    _asyncs = lang.proxy_import('..asyncs', __package__)
+    _asyncs = lang.proxy_import('..asyncs.all', __package__)
 
 
 T = ta.TypeVar('T')

omlish/io/__init__.py

@@ -1,3 +0,0 @@
-from ..lite.io import (  # noqa
-    DelimitingBuffer,
-)

omlish/{lite/io.py → io/buffers.py}

@@ -1,11 +1,10 @@
 # ruff: noqa: UP007
+# @omlish-lite
 import io
 import typing as ta
 
-from .check import check_isinstance
-from .check import check_non_empty
-from .check import check_not_none
-from .strings import attr_repr
+from ..lite.check import check
+from ..lite.strings import attr_repr
 
 
 class DelimitingBuffer:
@@ -39,7 +38,7 @@ class DelimitingBuffer:
     ) -> None:
         super().__init__()
 
-        self._delimiters = frozenset(check_isinstance(d, int) for d in delimiters)
+        self._delimiters = frozenset(check.isinstance(d, int) for d in delimiters)
         self._keep_ends = keep_ends
         self._max_size = max_size
 
@@ -70,7 +69,7 @@ class DelimitingBuffer:
         return r
 
     def _append_and_reset(self, chunk: bytes) -> bytes:
-        buf = check_not_none(self._buf)
+        buf = check.not_none(self._buf)
         if not buf.tell():
             return chunk
 
@@ -192,7 +191,7 @@ class IncrementalWriteBuffer:
     ) -> None:
         super().__init__()
 
-        check_non_empty(data)
+        check.not_empty(data)
         self._len = len(data)
         self._write_size = write_size
 
@@ -207,11 +206,11 @@ class IncrementalWriteBuffer:
         return self._len - self._pos
 
     def write(self, fn: ta.Callable[[bytes], int]) -> int:
-        lst = check_non_empty(self._lst)
+        lst = check.not_empty(self._lst)
 
         t = 0
         for i, d in enumerate(lst):  # noqa
-            n = fn(check_non_empty(d))
+            n = fn(check.not_empty(d))
             if not n:
                 break
             t += n

omlish/io/compress/__init__.py

@@ -0,0 +1,9 @@
+"""
+TODO:
+ - zipfile?
+ - tarfile?
+ - lzf?
+ - blosc?
+ - python-lzo?
+ - zfp -> fp8?
+"""

omlish/io/compress/abc.py

@@ -0,0 +1,104 @@
+"""
+https://docs.python.org/3/library/bz2.html#bz2.BZ2Compressor
+https://docs.python.org/3/library/zlib.html#zlib.decompressobj
+https://docs.python.org/3/library/lzma.html#lzma.LZMADecompressor
+"""
+import abc
+
+
+##
+
+
+class CompressorObject(abc.ABC):
+    @abc.abstractmethod
+    def compress(self, data: bytes) -> bytes:
+        """
+        Provide data to the compressor object. Returns a chunk of compressed data if possible, or an empty byte string
+        otherwise.
+
+        When you have finished providing data to the compressor, call the flush() method to finish the compression
+        process.
+        """
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def flush(self) -> bytes:
+        """
+        Finish the compression process. Returns the compressed data left in internal buffers.
+
+        The compressor object may not be used after this method has been called.
+        """
+
+        raise NotImplementedError
+
+
+##
+
+
+class DecompressorObject(abc.ABC):
+    @property
+    @abc.abstractmethod
+    def unused_data(self) -> bytes:
+        """
+        Data found after the end of the compressed stream.
+
+        If this attribute is accessed before the end of the stream has been reached, its value will be b''.
+        """
+
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def eof(self) -> bool:
+        """True if the end-of-stream marker has been reached."""
+
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def decompress(self, data: bytes, *max_length: int) -> bytes:
+        """
+        Decompress data, returning a bytes object containing the uncompressed data corresponding to at least part of the
+        data in string. This data should be concatenated to the output produced by any preceding calls to the
+        decompress() method. Some of the input data may be preserved in internal buffers for later processing.
+
+        If the optional parameter max_length is non-zero then the return value will be no longer than max_length.
+        """
+
+        raise NotImplementedError
+
+
+class NeedsInputDecompressorObject(DecompressorObject):
+    """
+    Used by:
+     - bz2.BZ2Decompressor
+     - lzma.LZMADecompressor
+    """
+
+    @property
+    @abc.abstractmethod
+    def needs_input(self) -> bool:
+        """
+        False if the decompress() method can provide more decompressed data before requiring new uncompressed input.
+        """
+
+        raise NotImplementedError
+
+
+class UnconsumedTailDecompressorObject(DecompressorObject):
+    """
+    Used by:
+     - zlib.decompressobj
+    """
+
+    @property
+    @abc.abstractmethod
+    def unconsumed_tail(self) -> bytes:
+        """
+        A bytes object that contains any data that was not consumed by the last decompress() call because it exceeded
+        the limit for the uncompressed data buffer. This data has not yet been seen by the zlib machinery, so you must
+        feed it (possibly with further data concatenated to it) back to a subsequent decompress() method call in order
+        to get correct output.
+        """
+
+        raise NotImplementedError

omlish/io/compress/adapters.py

@@ -0,0 +1,148 @@
+# PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+# --------------------------------------------
+#
+# 1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and the Individual or Organization
+# ("Licensee") accessing and otherwise using this software ("Python") in source or binary form and its associated
+# documentation.
+#
+# 2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive,
+# royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative
+# works, distribute, and otherwise use Python alone or in any derivative version, provided, however, that PSF's License
+# Agreement and PSF's notice of copyright, i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+# 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights Reserved" are retained in Python
+# alone or in any derivative version prepared by Licensee.
+#
+# 3. In the event Licensee prepares a derivative work that is based on or incorporates Python or any part thereof, and
+# wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in
+# any such work a brief summary of the changes made to Python.
+#
+# 4. PSF is making Python available to Licensee on an "AS IS" basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES,
+# EXPRESS OR IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY
+# OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT INFRINGE ANY THIRD PARTY
+# RIGHTS.
+#
+# 5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL
+# DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON, OR ANY DERIVATIVE THEREOF, EVEN IF
+# ADVISED OF THE POSSIBILITY THEREOF.
+#
+# 6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
+#
+# 7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint
+# venture between PSF and Licensee.  This License Agreement does not grant permission to use PSF trademarks or trade
+# name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
+#
+# 8. By copying, installing or otherwise using Python, Licensee agrees to be bound by the terms and conditions of this
+# License Agreement.
+# ~> https://github.com/python/cpython/blob/f19c50a4817ffebb26132182ed8cec6a72342cc0/Lib/_compression.py
+import typing as ta
+
+from ... import check
+from ..generators import BytesSteppedGenerator
+from ..generators import BytesSteppedReaderGenerator
+from .abc import CompressorObject
+from .abc import NeedsInputDecompressorObject
+from .abc import UnconsumedTailDecompressorObject
+
+
+##
+
+
+class CompressorObjectIncrementalAdapter:
+    def __init__(
+            self,
+            factory: ta.Callable[..., CompressorObject],
+    ) -> None:
+        super().__init__()
+
+        self._factory = factory
+
+    def __call__(self) -> BytesSteppedGenerator:
+        compressor = self._factory()
+
+        while True:
+            data = check.isinstance((yield None), bytes)
+            if not data:
+                break
+
+            compressed = compressor.compress(data)
+            if compressed:
+                check.none((yield compressed))
+
+        if (fl := compressor.flush()):
+            check.none((yield fl))
+
+        check.none((yield b''))
+
+
+##
+
+
+class DecompressorObjectIncrementalAdapter:
+    def __init__(
+            self,
+            factory: ta.Callable[..., NeedsInputDecompressorObject | UnconsumedTailDecompressorObject],
+            *,
+            trailing_error: type[BaseException] | tuple[type[BaseException], ...] = (),
+    ) -> None:
+        super().__init__()
+
+        self._factory = factory
+        self._trailing_error = trailing_error
+
+    def __call__(self) -> BytesSteppedReaderGenerator:
+        pos = 0
+
+        data = None  # Default if EOF is encountered
+
+        decompressor = self._factory()
+
+        while True:
+            # Depending on the input data, our call to the decompressor may not return any data. In this case, try again
+            # after reading another block.
+            while True:
+                if decompressor.eof:
+                    rawblock = decompressor.unused_data
+                    if not rawblock:
+                        rawblock = check.isinstance((yield None), bytes)
+                    if not rawblock:
+                        break
+
+                    # Continue to next stream.
+                    decompressor = self._factory()
+
+                    try:
+                        data = decompressor.decompress(rawblock)
+                    except self._trailing_error:
+                        # Trailing data isn't a valid compressed stream; ignore it.
+                        break
+
+                else:
+                    if hasattr(decompressor, 'needs_input'):
+                        if decompressor.needs_input:
+                            rawblock = check.isinstance((yield None), bytes)
+                            if not rawblock:
+                                raise EOFError('Compressed file ended before the end-of-stream marker was reached')
+                        else:
+                            rawblock = b''
+
+                    elif hasattr(decompressor, 'unconsumed_tail'):
+                        if not (rawblock := decompressor.unconsumed_tail):
+                            rawblock = check.isinstance((yield None), bytes)
+                            if not rawblock:
+                                raise EOFError('Compressed file ended before the end-of-stream marker was reached')
+
+                    else:
+                        raise TypeError(decompressor)
+
+                    data = decompressor.decompress(rawblock)
+
+                if data:
+                    break
+
+            if not data:
+                check.none((yield b''))
+                return
+
+            pos += len(data)
+            check.none((yield data))
+            data = None

omlish/io/compress/base.py

@@ -0,0 +1,24 @@
+import abc
+
+from ..generators import BytesSteppedGenerator
+from ..generators import BytesSteppedReaderGenerator
+
+
+class Compression(abc.ABC):
+    @abc.abstractmethod
+    def compress(self, d: bytes) -> bytes:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def decompress(self, d: bytes) -> bytes:
+        raise NotImplementedError
+
+
+class IncrementalCompression(abc.ABC):
+    @abc.abstractmethod
+    def compress_incremental(self) -> BytesSteppedGenerator[None]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def decompress_incremental(self) -> BytesSteppedReaderGenerator[None]:
+        raise NotImplementedError

omlish/io/compress/brotli.py

@@ -0,0 +1,47 @@
+import dataclasses as dc
+import typing as ta
+
+from ... import lang
+from .base import Compression
+from .codecs import make_compression_codec
+from .codecs import make_compression_lazy_loaded_codec
+
+
+if ta.TYPE_CHECKING:
+    import brotli
+else:
+    brotli = lang.proxy_import('brotli')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class BrotliCompression(Compression):
+    mode: int | None = None
+    quality: int | None = None
+    lgwin: int | None = None
+    lgblock: int | None = None
+
+    def compress(self, d: bytes) -> bytes:
+        return brotli.compress(
+            d,
+            **(dict(mode=self.mode) if self.mode is not None else {}),
+            **(dict(mode=self.quality) if self.quality is not None else {}),
+            **(dict(mode=self.lgwin) if self.lgwin is not None else {}),
+            **(dict(mode=self.lgblock) if self.lgblock is not None else {}),
+        )
+
+    def decompress(self, d: bytes) -> bytes:
+        return brotli.decompress(
+            d,
+        )
+
+
+##
+
+
+BROTLI_CODEC = make_compression_codec('brotli', BrotliCompression)
+
+# @omlish-manifest
+_BROTLI_LAZY_CODEC = make_compression_lazy_loaded_codec(__name__, 'BROTLI_CODEC', BROTLI_CODEC)