omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/http/clients/sync.py

@@ -5,11 +5,13 @@ import contextlib
 import dataclasses as dc
 import typing as ta
 
+from ...io.readers import BufferedBytesReader
 from ...lite.abstract import Abstract
-from ...lite.dataclasses import dataclass_maybe_post_init
 from ...lite.dataclasses import dataclass_shallow_asdict
+from .base import BaseHttpClient
 from .base import BaseHttpResponse
 from .base import BaseHttpResponseT
+from .base import HttpClientContext
 from .base import HttpRequest
 from .base import HttpResponse
 from .base import HttpStatusError
@@ -25,22 +27,21 @@ HttpClientT = ta.TypeVar('HttpClientT', bound='HttpClient')
 @ta.final
 @dc.dataclass(frozen=True)  # kw_only=True
 class StreamHttpResponse(BaseHttpResponse):
-    class Stream(ta.Protocol):
-        def read(self, /, n: int = -1) -> bytes: ...
+    _stream: ta.Optional[BufferedBytesReader] = None
 
-    @ta.final
-    class _NullStream:
-        def read(self, /, n: int = -1) -> bytes:
-            raise TypeError
+    @property
+    def stream(self) -> 'BufferedBytesReader':
+        if (st := self._stream) is None:
+            raise TypeError('No data')
+        return st
 
-    stream: Stream = _NullStream()
+    @property
+    def has_data(self) -> bool:
+        return self._stream is not None
 
-    _closer: ta.Optional[ta.Callable[[], None]] = None
+    #
 
-    def __post_init__(self) -> None:
-        dataclass_maybe_post_init(super())
-        if isinstance(self.stream, StreamHttpResponse._NullStream):
-            raise TypeError(self.stream)
+    _closer: ta.Optional[ta.Callable[[], None]] = None
 
     def __enter__(self: StreamHttpResponseT) -> StreamHttpResponseT:
         return self
@@ -50,13 +51,13 @@ class StreamHttpResponse(BaseHttpResponse):
 
     def close(self) -> None:
         if (c := self._closer) is not None:
-            c()
+            c()  # noqa
 
 
 #
 
 
-def close_response(resp: BaseHttpResponse) -> None:
+def close_http_client_response(resp: BaseHttpResponse) -> None:
     if isinstance(resp, HttpResponse):
         pass
 
@@ -68,7 +69,7 @@ def close_response(resp: BaseHttpResponse) -> None:
 
 
 @contextlib.contextmanager
-def closing_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
+def closing_http_client_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
     if isinstance(resp, HttpResponse):
         yield resp
         return
@@ -81,15 +82,14 @@ def closing_response(resp: BaseHttpResponseT) -> ta.Iterator[BaseHttpResponseT]:
         raise TypeError(resp)
 
 
-def read_response(resp: BaseHttpResponse) -> HttpResponse:
+def read_http_client_response(resp: BaseHttpResponse) -> HttpResponse:
     if isinstance(resp, HttpResponse):
         return resp
 
     elif isinstance(resp, StreamHttpResponse):
-        data = resp.stream.read()
         return HttpResponse(**{
-            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('stream', '_closer')},
-            'data': data,
+            **{k: v for k, v in dataclass_shallow_asdict(resp).items() if k not in ('_stream', '_closer')},
+            **({'data': resp.stream.readall()} if resp.has_data else {}),
         })
 
     else:
@@ -99,7 +99,7 @@ def read_response(resp: BaseHttpResponse) -> HttpResponse:
 ##
 
 
-class HttpClient(Abstract):
+class HttpClient(BaseHttpClient, Abstract):
     def __enter__(self: HttpClientT) -> HttpClientT:
         return self
 
@@ -110,21 +110,27 @@ class HttpClient(Abstract):
             self,
             req: HttpRequest,
             *,
+            context: ta.Optional[HttpClientContext] = None,
             check: bool = False,
     ) -> HttpResponse:
-        with closing_response(self.stream_request(
+        with closing_http_client_response(self.stream_request(
                 req,
+                context=context,
                 check=check,
         )) as resp:
-            return read_response(resp)
+            return read_http_client_response(resp)
 
     def stream_request(
             self,
             req: HttpRequest,
             *,
+            context: ta.Optional[HttpClientContext] = None,
             check: bool = False,
     ) -> StreamHttpResponse:
-        resp = self._stream_request(req)
+        if context is None:
+            context = HttpClientContext()
+
+        resp = self._stream_request(context, req)
 
         try:
             if check and not resp.is_success:
@@ -132,14 +138,14 @@ class HttpClient(Abstract):
                     cause = resp.underlying
                 else:
                     cause = None
-                raise HttpStatusError(read_response(resp)) from cause  # noqa
+                raise HttpStatusError(read_http_client_response(resp)) from cause  # noqa
 
         except Exception:
-            close_response(resp)
+            close_http_client_response(resp)
             raise
 
         return resp
 
     @abc.abstractmethod
-    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
+    def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> StreamHttpResponse:
         raise NotImplementedError

omlish/http/clients/syncasync.py

@@ -0,0 +1,49 @@
+# ruff: noqa: UP043 UP045
+# @omlish-lite
+import dataclasses as dc
+
+from .asyncs import AsyncHttpClient
+from .asyncs import AsyncStreamHttpResponse
+from .base import HttpClientContext
+from .base import HttpRequest
+from .sync import HttpClient
+from .sync import StreamHttpResponse
+
+
+##
+
+
+class SyncAsyncHttpClient(AsyncHttpClient):
+    def __init__(self, client: HttpClient) -> None:
+        super().__init__()
+
+        self._client = client
+
+    @dc.dataclass(frozen=True)
+    class _StreamAdapter:
+        ul: StreamHttpResponse
+
+        async def read1(self, n: int = -1, /) -> bytes:
+            return self.ul.stream.read1(n)
+
+        async def read(self, n: int = -1, /) -> bytes:
+            return self.ul.stream.read(n)
+
+        async def readall(self) -> bytes:
+            return self.ul.stream.readall()
+
+        async def close(self) -> None:
+            self.ul.close()
+
+    async def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> AsyncStreamHttpResponse:
+        resp = self._client.stream_request(req, context=ctx)
+        return AsyncStreamHttpResponse(
+            status=resp.status,
+            headers=resp.headers,
+            request=req,
+            underlying=resp,
+            **(dict(  # type: ignore
+                _stream=(adapter := self._StreamAdapter(resp)),
+                _closer=adapter.close,
+            ) if resp.has_data else {}),
+        )

omlish/http/clients/urllib.py

@@ -1,10 +1,14 @@
+# ruff: noqa: UP043 UP045
+# @omlish-lite
 import http.client
 import typing as ta
 import urllib.error
 import urllib.request
 
+from ...io.buffers import ReadableListBuffer
 from ..headers import HttpHeaders
 from .base import DEFAULT_ENCODING
+from .base import HttpClientContext
 from .base import HttpClientError
 from .base import HttpRequest
 from .sync import HttpClient
@@ -39,7 +43,7 @@ class UrllibHttpClient(HttpClient):
             data=d,
         )
 
-    def _stream_request(self, req: HttpRequest) -> StreamHttpResponse:
+    def _stream_request(self, ctx: HttpClientContext, req: HttpRequest) -> StreamHttpResponse:
         try:
             resp = urllib.request.urlopen(  # noqa
                 self._build_request(req),
@@ -53,7 +57,6 @@ class UrllibHttpClient(HttpClient):
                     headers=HttpHeaders(e.headers.items()),
                     request=req,
                     underlying=e,
-                    stream=e,  # noqa
                     _closer=e.close,
                 )
 
@@ -70,7 +73,7 @@ class UrllibHttpClient(HttpClient):
                 headers=HttpHeaders(resp.headers.items()),
                 request=req,
                 underlying=resp,
-                stream=resp,
+                _stream=ReadableListBuffer().new_buffered_reader(resp),
                 _closer=resp.close,
             )
 

omlish/http/coro/client/connection.py

@@ -116,10 +116,10 @@ class CoroHttpClientConnection:
     _http_version = 11
     _http_version_str = 'HTTP/1.1'
 
-    http_port: ta.ClassVar[int] = 80
-    https_port: ta.ClassVar[int] = 443
+    HTTP_PORT: ta.ClassVar[int] = 80
+    HTTPS_PORT: ta.ClassVar[int] = 443
 
-    default_port = http_port
+    DEFAULT_PORT: ta.ClassVar[int] = HTTP_PORT
 
     class _NOT_SET:  # noqa
         def __new__(cls, *args, **kwargs):  # noqa
@@ -139,6 +139,7 @@ class CoroHttpClientConnection:
             source_address: ta.Optional[str] = None,
             block_size: int = 8192,
             auto_open: bool = True,
+            default_port: ta.Optional[int] = None,
     ) -> None:
         super().__init__()
 
@@ -146,6 +147,9 @@ class CoroHttpClientConnection:
         self._source_address = source_address
         self._block_size = block_size
         self._auto_open = auto_open
+        if default_port is None:
+            default_port = self.DEFAULT_PORT
+        self._default_port = default_port
 
         self._connected = False
         self._buffer: ta.List[bytes] = []
@@ -162,6 +166,10 @@ class CoroHttpClientConnection:
 
         CoroHttpClientValidation.validate_host(self._host)
 
+    @property
+    def http_version(self) -> int:
+        return self._http_version
+
     #
 
     def _get_hostport(self, host: str, port: ta.Optional[int]) -> ta.Tuple[str, int]:
@@ -173,12 +181,12 @@ class CoroHttpClientConnection:
                     port = int(host[i + 1:])
                 except ValueError:
                     if host[i + 1:] == '':  # http://foo.com:/ == http://foo.com/
-                        port = self.default_port
+                        port = self._default_port
                     else:
                         raise CoroHttpClientErrors.InvalidUrlError(f"non-numeric port: '{host[i + 1:]}'") from None
                 host = host[:i]
             else:
-                port = self.default_port
+                port = self._default_port
 
         if host and host[0] == '[' and host[-1] == ']':
             host = host[1:-1]
@@ -286,6 +294,7 @@ class CoroHttpClientConnection:
                 source_address=self._source_address,
                 **(dict(timeout=self._timeout) if self._timeout is not self._NOT_SET else {}),
             ),
+            server_hostname=self._tunnel_host if self._tunnel_host else self._host,
         )))
 
         self._connected = True
@@ -526,7 +535,7 @@ class CoroHttpClientConnection:
                     if ':' in host:
                         host_enc = self._strip_ipv6_iface(host_enc)
 
-                    if port == self.default_port:
+                    if port == self._default_port:
                         self.put_header('Host', host_enc)
                     else:
                         self.put_header('Host', f"{host_enc.decode('ascii')}:{port}")

omlish/http/coro/io.py

@@ -37,6 +37,8 @@ class CoroHttpIo:
         args: ta.Tuple[ta.Any, ...]
         kwargs: ta.Optional[ta.Dict[str, ta.Any]] = None
 
+        server_hostname: ta.Optional[str] = None
+
     #
 
     class CloseIo(Io):

omlish/http/flasky/__init__.py

@@ -0,0 +1,40 @@
+from .api import (  # noqa
+    Api,
+)
+
+from .app import (  # noqa
+    AppRunParams,
+    AppRunner,
+
+    ViewFunc,
+    BeforeRequestFunc,
+    AfterRequestFunc,
+    App,
+)
+
+from .cvs import (  # noqa
+    CvLookupError,
+
+    Cvs,
+)
+
+from .requests import (  # noqa
+    Request,
+)
+
+from .responses import (  # noqa
+    ResponseData,
+    ResponseStatus,
+    ResponseHeaders,
+
+    Response,
+)
+
+from .routes import (  # noqa
+    RouteKey,
+    Route,
+)
+
+from .types import (  # noqa
+    ImmutableMultiDict,
+)

omlish/http/flasky/_compat.py

@@ -0,0 +1,2 @@
+def compat(obj):
+    return obj

omlish/http/flasky/api.py

@@ -0,0 +1,82 @@
+import threading
+import typing as ta
+
+from ... import lang
+from ._compat import compat
+from .app import App
+from .cvs import Cvs
+from .requests import Request
+from .responses import Response
+
+
+##
+
+
+class Api:
+    def __init__(
+            self,
+            *,
+            base_app_cls: type[App] = App,
+    ) -> None:
+        super().__init__()
+
+        self._base_app_cls = base_app_cls
+
+        self._lock = threading.RLock()
+
+    @property
+    def _cls_name_repr(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}'
+
+    def __repr__(self) -> str:
+        return f'{self._cls_name_repr}()'
+
+    ##
+    # app cls
+
+    _app_cls: type[App]
+
+    @property
+    def app_cls(self) -> type[App]:
+        try:
+            return self._app_cls
+        except AttributeError:
+            pass
+
+        with self._lock:
+            try:
+                return self._app_cls
+            except AttributeError:
+                pass
+
+            self._app_cls = lang.new_type(  # noqa
+                f'{self._base_app_cls.__name__}<{self._cls_name_repr}>',
+                (self._base_app_cls,),
+                {'_api': self},
+            )
+
+            return self._app_cls
+
+    @property
+    @compat
+    def Flask(self) -> type[App]:  # noqa
+        return self.app_cls
+
+    ##
+    # helpers
+
+    def abort(self, code: int | Response, *args: ta.Any, **kwargs: ta.Any) -> ta.NoReturn:
+        raise NotImplementedError
+
+    ##
+    # cv's
+
+    @property
+    @compat
+    def request(self) -> Request:
+        return Cvs.REQUEST.get()
+
+    ##
+    # type aliases - must be last
+
+    Response = Response

omlish/http/flasky/app.py

@@ -0,0 +1,203 @@
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ._compat import compat
+from .cvs import Cvs
+from .responses import Response
+from .routes import Route
+from .routes import RouteKey
+
+
+if ta.TYPE_CHECKING:
+    from .api import Api
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class AppRunParams:
+    app: 'App'
+
+    port: int | None = None
+
+
+AppRunner: ta.TypeAlias = ta.Callable[[AppRunParams], None]
+
+
+##
+
+
+ViewFunc: ta.TypeAlias = ta.Callable[[], str]
+
+BeforeRequestFunc: ta.TypeAlias = ta.Callable[[], Response | None]
+AfterRequestFunc: ta.TypeAlias = ta.Callable[[ta.Any], ta.Any]
+
+
+#
+
+
+class App:
+    _api: ta.ClassVar['Api']
+
+    def __init__(
+            self,
+            import_name: str,
+    ) -> None:
+        check.not_none(self._api)
+
+        super().__init__()
+
+        self._import_name = check.non_empty_str(import_name)
+
+        self._routes: set[Route] = set()
+        self._routes_by_key: dict[RouteKey, Route] = {}
+
+        self._view_funcs_by_endpoint: dict[str, ViewFunc] = {}
+
+        self._before_request_funcs: list[BeforeRequestFunc] = []
+        self._after_request_funcs: list[AfterRequestFunc] = []
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}@{id(self):x}({self._import_name!r})'
+
+    @property
+    def import_name(self) -> str:
+        return self._import_name
+
+    ##
+    # routing
+
+    @property
+    def routes(self) -> ta.AbstractSet[Route]:
+        return self._routes
+
+    @property
+    def routes_by_key(self) -> ta.Mapping[RouteKey, Route]:
+        return self._routes_by_key
+
+    @property
+    def view_funcs_by_endpoint(self) -> ta.Mapping[str, ViewFunc]:
+        return self._view_funcs_by_endpoint
+
+    @compat
+    def get(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('GET', rule, **options)
+
+    @compat
+    def post(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('POST', rule, **options)
+
+    @compat
+    def put(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('PUT', rule, **options)
+
+    @compat
+    def delete(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('DELETE', rule, **options)
+
+    @compat
+    def patch(self, rule: str, **options: ta.Any) -> ta.Callable[[T], T]:
+        return self._method_route('PATCH', rule, **options)
+
+    def _method_route(
+            self,
+            method: str,
+            rule: str,
+            **options: ta.Any,
+    ) -> ta.Callable[[T], T]:
+        return self.route(
+            rule,
+            methods=[method],
+            **options,
+        )
+
+    @compat
+    def route(
+            self,
+            rule: str,
+            **options: ta.Any,
+    ) -> ta.Callable[[T], T]:
+        def inner(fn):
+            endpoint = options.pop('endpoint', None)
+            self.add_url_rule(rule, endpoint, fn, **options)
+            return fn
+
+        return inner
+
+    @compat
+    def add_url_rule(
+            self,
+            rule: str,
+            endpoint: str | None = None,
+            view_func: ViewFunc | None = None,
+            *,
+            methods: ta.Iterable[str] | None = None,
+    ) -> None:
+        check.arg(check.non_empty_str(rule).startswith('/'))
+
+        if endpoint is None:
+            endpoint = check.not_none(view_func).__name__
+
+        if methods is None:
+            methods = ['GET']
+        else:
+            methods = [check.non_empty_str(m) for m in check.not_isinstance(methods, str)]
+        methods = check.not_empty([s.upper() for s in methods])
+
+        #
+
+        route = Route(
+            rule=rule,
+            endpoint=endpoint,
+            methods=frozenset(methods),
+        )
+
+        #
+
+        for rk in route.keys:
+            check.not_in(rk, self._routes_by_key)
+
+        if view_func is not None:
+            check.not_in(endpoint, self._view_funcs_by_endpoint)
+
+        #
+
+        self._routes.add(route)
+        for rk in route.keys:
+            self._routes_by_key[rk] = route
+
+        if view_func is not None:
+            self._view_funcs_by_endpoint[endpoint] = view_func
+
+    ##
+    # hooks
+
+    @property
+    def before_request_funcs(self) -> ta.Sequence[BeforeRequestFunc]:
+        return self._before_request_funcs
+
+    @property
+    def after_request_funcs(self) -> ta.Sequence[AfterRequestFunc]:
+        return self._after_request_funcs
+
+    def before_request(self, func: T) -> T:  # BeforeRequestFunc
+        self._before_request_funcs.append(ta.cast(BeforeRequestFunc, check.callable(func)))
+        return func
+
+    def after_request(self, func: T) -> T:  # AfterRequestFunc
+        self._after_request_funcs.append(ta.cast(AfterRequestFunc, check.callable(func)))
+        return func
+
+    ##
+    # running
+
+    @compat
+    def run(self, **kwargs: ta.Any) -> None:
+        params = AppRunParams(app=self, **kwargs)
+        runner = Cvs.APP_RUNNER.get()
+        check.not_none(runner)(params)