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

omlish/http/coro/server/fdio.py

@@ -9,6 +9,7 @@ from ....io.fdio.handlers import SocketFdioHandler
 from ....lite.check import check
 from ....sockets.addresses import SocketAddress
 from ...handlers import HttpHandler
+from ..io import CoroHttpIo
 from .server import CoroHttpServer
 
 
@@ -24,7 +25,7 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             *,
             read_size: int = 0x10000,
             write_size: int = 0x10000,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpIo.AnyLogIo], None]] = None,
     ) -> None:
         check.state(not sock.getblocking())
 
@@ -44,13 +45,13 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
         )
         self._srv_coro: ta.Optional[
             ta.Generator[
-                CoroHttpServer.Io,
+                CoroHttpIo.Io,
                 ta.Optional[bytes],
                 CoroHttpServer.CoroHandleResult,
             ],
         ] = self._coro_srv.coro_handle()
 
-        self._cur_io: ta.Optional[CoroHttpServer.Io] = None
+        self._cur_io: ta.Optional[CoroHttpIo.Io] = None
         self._next_io()
 
     #
@@ -73,22 +74,22 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
                     o = None
                     break
 
-            if isinstance(o, CoroHttpServer.AnyLogIo):
+            if isinstance(o, CoroHttpIo.AnyLogIo):
                 if self._log_handler is not None:
                     self._log_handler(self._coro_srv, o)
                 o = None
 
-            elif isinstance(o, CoroHttpServer.ReadIo):
+            elif isinstance(o, CoroHttpIo.ReadIo):
                 if (d := self._read_buf.read(o.sz)) is None:
                     break
                 o = None
 
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
+            elif isinstance(o, CoroHttpIo.ReadLineIo):
                 if (d := self._read_buf.read_until(b'\n')) is None:
                     break
                 o = None
 
-            elif isinstance(o, CoroHttpServer.WriteIo):
+            elif isinstance(o, CoroHttpIo.WriteIo):
                 check.none(self._write_buf)
                 self._write_buf = IncrementalWriteBuffer(o.data, write_size=self._write_size)
                 break
@@ -122,11 +123,11 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
 
         self._read_buf.feed(buf)
 
-        if isinstance(self._cur_io, CoroHttpServer.AnyReadIo):
+        if isinstance(self._cur_io, CoroHttpIo.AnyReadIo):
             self._next_io()
 
     def on_writable(self) -> None:
-        check.isinstance(self._cur_io, CoroHttpServer.WriteIo)
+        check.isinstance(self._cur_io, CoroHttpIo.WriteIo)
         wb = check.not_none(self._write_buf)
         while wb.rem > 0:
             def send(d: bytes) -> int:

omlish/http/coro/server/server.py

@@ -61,7 +61,6 @@ import textwrap
 import time
 import typing as ta
 
-from ....lite.abstract import Abstract
 from ....lite.check import check
 from ....sockets.addresses import SocketAddress
 from ...handlers import HttpHandler
@@ -75,9 +74,10 @@ from ...parsing import ParsedHttpRequest
 from ...parsing import ParseHttpRequestError
 from ...versions import HttpProtocolVersion
 from ...versions import HttpProtocolVersions
+from ..io import CoroHttpIo
 
 
-CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
+CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']  # ta.TypeAlias
 
 
 ##
@@ -380,48 +380,21 @@ class CoroHttpServer:
 
     #
 
-    class Io(Abstract):
-        pass
-
-    #
-
-    class AnyLogIo(Io):
-        pass
-
     @dc.dataclass(frozen=True)
-    class ParsedRequestLogIo(AnyLogIo):
+    class ParsedRequestLogIo(CoroHttpIo.AnyLogIo):
         request: ParsedHttpRequest
 
     @dc.dataclass(frozen=True)
-    class ErrorLogIo(AnyLogIo):
+    class ErrorLogIo(CoroHttpIo.AnyLogIo):
         error: 'CoroHttpServer.Error'
 
     #
 
-    class AnyReadIo(Io):  # noqa
-        pass
-
-    @dc.dataclass(frozen=True)
-    class ReadIo(AnyReadIo):
-        sz: int
-
-    @dc.dataclass(frozen=True)
-    class ReadLineIo(AnyReadIo):
-        sz: int
-
-    #
-
-    @dc.dataclass(frozen=True)
-    class WriteIo(Io):
-        data: bytes
-
-    #
-
     @dc.dataclass(frozen=True)
     class CoroHandleResult:
         close_reason: ta.Literal['response', 'internal', None] = None
 
-    def coro_handle(self) -> ta.Generator[Io, ta.Optional[bytes], CoroHandleResult]:
+    def coro_handle(self) -> ta.Generator[CoroHttpIo.Io, ta.Optional[bytes], CoroHandleResult]:
         return self._coro_run_handler(self._coro_handle_one())
 
     class Close(Exception):  # noqa
@@ -430,20 +403,20 @@ class CoroHttpServer:
     def _coro_run_handler(
             self,
             gen: ta.Generator[
-                ta.Union[AnyLogIo, AnyReadIo, _Response],
+                ta.Union[CoroHttpIo.AnyLogIo, CoroHttpIo.AnyReadIo, _Response],
                 ta.Optional[bytes],
                 None,
             ],
-    ) -> ta.Generator[Io, ta.Optional[bytes], CoroHandleResult]:
+    ) -> ta.Generator[CoroHttpIo.Io, ta.Optional[bytes], CoroHandleResult]:
         i: ta.Optional[bytes]
         o: ta.Any = next(gen)
         while True:
             try:
-                if isinstance(o, self.AnyLogIo):
+                if isinstance(o, CoroHttpIo.AnyLogIo):
                     i = None
                     yield o
 
-                elif isinstance(o, self.AnyReadIo):
+                elif isinstance(o, CoroHttpIo.AnyReadIo):
                     i = check.isinstance((yield o), bytes)
 
                 elif isinstance(o, self._Response):
@@ -451,10 +424,10 @@ class CoroHttpServer:
 
                     r = self._preprocess_response(o)
                     hb = self._build_response_head_bytes(r)
-                    check.none((yield self.WriteIo(hb)))
+                    check.none((yield CoroHttpIo.WriteIo(hb)))
 
                     for b in self._yield_response_data(r):
-                        yield self.WriteIo(b)
+                        yield CoroHttpIo.WriteIo(b)
 
                     o.close()
                     if o.close_connection:
@@ -482,7 +455,7 @@ class CoroHttpServer:
                 raise
 
     def _coro_handle_one(self) -> ta.Generator[
-        ta.Union[AnyLogIo, AnyReadIo, _Response],
+        ta.Union[CoroHttpIo.AnyLogIo, CoroHttpIo.AnyReadIo, _Response],
         ta.Optional[bytes],
         None,
     ]:
@@ -492,7 +465,7 @@ class CoroHttpServer:
         sz = next(gen)
         while True:
             try:
-                line = check.isinstance((yield self.ReadLineIo(sz)), bytes)
+                line = check.isinstance((yield CoroHttpIo.ReadLineIo(sz)), bytes)
                 sz = gen.send(line)
             except StopIteration as e:
                 parsed = e.value
@@ -531,7 +504,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 CoroHttpIo.ReadIo(int(cl))), bytes)
         else:
             request_data = None
 

omlish/http/coro/server/sockets.py

@@ -7,6 +7,7 @@ from ....lite.check import check
 from ....sockets.addresses import SocketAddress
 from ....sockets.handlers import SocketHandler_
 from ....sockets.io import SocketIoPair
+from ..io import CoroHttpIo
 from .server import CoroHttpServer
 from .server import CoroHttpServerFactory
 
@@ -20,7 +21,7 @@ class CoroHttpServerSocketHandler(SocketHandler_):
             server_factory: CoroHttpServerFactory,
             *,
             keep_alive: bool = False,
-            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpServer.AnyLogIo], None]] = None,
+            log_handler: ta.Optional[ta.Callable[[CoroHttpServer, CoroHttpIo.AnyLogIo], None]] = None,
     ) -> None:
         super().__init__()
 
@@ -49,18 +50,18 @@ class CoroHttpServerSocketHandler(SocketHandler_):
 
         o = next(gen)
         while True:
-            if isinstance(o, CoroHttpServer.AnyLogIo):
+            if isinstance(o, CoroHttpIo.AnyLogIo):
                 i = None
                 if self._log_handler is not None:
                     self._log_handler(server, o)
 
-            elif isinstance(o, CoroHttpServer.ReadIo):
-                i = fp.r.read(o.sz)
+            elif isinstance(o, CoroHttpIo.ReadIo):
+                i = fp.r.read(check.not_none(o.sz))
 
-            elif isinstance(o, CoroHttpServer.ReadLineIo):
+            elif isinstance(o, CoroHttpIo.ReadLineIo):
                 i = fp.r.readline(o.sz)
 
-            elif isinstance(o, CoroHttpServer.WriteIo):
+            elif isinstance(o, CoroHttpIo.WriteIo):
                 i = None
                 fp.w.write(o.data)
                 fp.w.flush()

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)

omlish/http/flasky/cvs.py

@@ -0,0 +1,59 @@
+import contextlib
+import contextvars
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+
+
+if ta.TYPE_CHECKING:
+    from .app import AppRunner
+    from .requests import Request
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+@dc.dataclass()
+class CvLookupError(LookupError):
+    cv: 'Cv'
+
+
+@ta.final
+class Cv(ta.Generic[T]):
+    def __init__(self, name: str) -> None:
+        self._name = name
+        self._var: contextvars.ContextVar[T] = contextvars.ContextVar(name)
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._name!r})'
+
+    def get(self) -> T:
+        try:
+            return self._var.get()
+        except LookupError:
+            raise CvLookupError(self) from None
+
+    @contextlib.contextmanager
+    def set(self, new: T) -> ta.Iterator[None]:
+        tok = self._var.set(new)
+        try:
+            yield
+        finally:
+            self._var.reset(tok)
+
+
+##
+
+
+def _cv(name: str) -> Cv:
+    return Cv(f'{__name__}.Cvs.{name}')
+
+
+class Cvs(lang.Namespace, lang.Final):
+    APP_RUNNER: Cv['AppRunner'] = _cv('APP_RUNNER')
+
+    REQUEST: Cv['Request'] = _cv('REQUEST')

omlish/http/flasky/requests.py

@@ -0,0 +1,20 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ._compat import compat
+from .types import ImmutableMultiDict
+
+
+##
+
+
+@compat
+@dc.dataclass(frozen=True, kw_only=True)
+class Request:
+    path: str
+    method: str
+
+    form: ImmutableMultiDict[str, str] | None = None
+
+    def get_json(self) -> ta.Any:
+        raise NotImplementedError

omlish/http/flasky/responses.py

@@ -0,0 +1,23 @@
+import http
+import typing as ta
+
+from ... import dataclasses as dc
+from ._compat import compat
+
+
+ResponseData: ta.TypeAlias = str | ta.Iterable[str] | bytes | ta.Iterable[bytes]
+ResponseStatus: ta.TypeAlias = int | str | http.HTTPStatus
+ResponseHeaders: ta.TypeAlias = ta.Mapping[str, str | ta.Iterable[str]] | ta.Iterable[tuple[str, str]]
+
+
+##
+
+
+@compat
+@dc.dataclass(frozen=True)
+class Response:
+    response: ResponseData | None = None
+    status: ResponseStatus | None = None
+    headers: ResponseHeaders | None = None
+    mimetype: str | None = None
+    content_type: str | None = None

omlish/http/flasky/routes.py

@@ -0,0 +1,23 @@
+import typing as ta
+
+from ... import cached
+from ... import dataclasses as dc
+
+
+##
+
+
+class RouteKey(ta.NamedTuple):
+    rule: str
+    method: str
+
+
+@dc.dataclass(frozen=True, kw_only=True)
+class Route:
+    rule: str
+    endpoint: str
+    methods: frozenset[str]
+
+    @cached.property
+    def keys(self) -> frozenset[RouteKey]:
+        return frozenset(RouteKey(self.rule, m) for m in self.methods)