omlish 0.0.0.dev148__py3-none-any.whl → 0.0.0.dev150__py3-none-any.whl

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

@@ -1,4 +1,5 @@
 # ruff: noqa: UP006 UP007
+# @omlish-lite
 # PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 # --------------------------------------------
 #
@@ -62,11 +63,9 @@ 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 ..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
@@ -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,9 +1,10 @@
 # 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
 
 

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

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

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

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

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/{lite → io}/fdio/corohttp.py

@@ -2,15 +2,12 @@
 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 ...http.coroserver import CoroHttpServer
+from ...http.handlers import HttpHandler
+from ...lite.check import check
+from ...lite.socket import SocketAddress
+from ..buffers import IncrementalWriteBuffer
+from ..buffers import ReadableListBuffer
 from .handlers import SocketFdioHandler
 
 
@@ -25,7 +22,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             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)
 
@@ -49,7 +46,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
@@ -82,7 +79,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
 
@@ -103,7 +100,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:
@@ -119,12 +116,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 → io}/fdio/handlers.py

@@ -3,8 +3,8 @@ import abc
 import socket
 import typing as ta
 
-from ..check import check_not_none
-from ..socket import SocketAddress
+from ...lite.check import check
+from ...lite.socket import SocketAddress
 
 
 class FdioHandler(abc.ABC):
@@ -55,7 +55,7 @@ class SocketFdioHandler(FdioHandler, abc.ABC):
         self._sock: ta.Optional[socket.socket] = sock
 
     def fd(self) -> int:
-        return check_not_none(self._sock).fileno()
+        return check.not_none(self._sock).fileno()
 
     @property
     def closed(self) -> bool:

omlish/lite/asyncio/subprocesses.py

@@ -8,10 +8,7 @@ import subprocess
 import sys
 import typing as ta
 
-from ..check import check_equal
-from ..check import check_isinstance
-from ..check import check_not_none
-from ..check import check_single
+from ..check import check
 from ..logs import log
 from ..subprocesses import DEFAULT_SUBPROCESS_TRY_EXCEPTIONS
 from ..subprocesses import prepare_subprocess_invocation
@@ -36,7 +33,7 @@ async def asyncio_subprocess_popen(
     if shell:
         fac = functools.partial(
             asyncio.create_subprocess_shell,
-            check_single(cmd),
+            check.single(cmd),
         )
     else:
         fac = functools.partial(
@@ -76,7 +73,7 @@ class AsyncioProcessCommunicator:
         self._proc = proc
         self._loop = loop
 
-        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check_isinstance(
+        self._transport: asyncio.base_subprocess.BaseSubprocessTransport = check.isinstance(
             proc._transport,  # type: ignore  # noqa
             asyncio.base_subprocess.BaseSubprocessTransport,
         )
@@ -86,7 +83,7 @@ class AsyncioProcessCommunicator:
         return self._loop.get_debug()
 
     async def _feed_stdin(self, input: bytes) -> None:  # noqa
-        stdin = check_not_none(self._proc.stdin)
+        stdin = check.not_none(self._proc.stdin)
         try:
             if input is not None:
                 stdin.write(input)
@@ -110,13 +107,13 @@ class AsyncioProcessCommunicator:
         return None
 
     async def _read_stream(self, fd: int) -> bytes:
-        transport: ta.Any = check_not_none(self._transport.get_pipe_transport(fd))
+        transport: ta.Any = check.not_none(self._transport.get_pipe_transport(fd))
 
         if fd == 2:
-            stream = check_not_none(self._proc.stderr)
+            stream = check.not_none(self._proc.stderr)
         else:
-            check_equal(fd, 1)
-            stream = check_not_none(self._proc.stdout)
+            check.equal(fd, 1)
+            stream = check.not_none(self._proc.stdout)
 
         if self._debug:
             name = 'stdout' if fd == 1 else 'stderr'
@@ -236,7 +233,7 @@ async def asyncio_subprocess_check_output(
         **kwargs,
     )
 
-    return check_not_none(stdout)
+    return check.not_none(stdout)
 
 
 async def asyncio_subprocess_check_output_str(*args: str, **kwargs: ta.Any) -> str: