rsgiadapter 0.0.3__py3-none-any.whl

rsgiadapter/__init__.py

@@ -0,0 +1,5 @@
+from .asgi import ASGIToRSGI
+
+__all__ = ["ASGIToRSGI"]
+
+__version__ = "0.0.3"

rsgiadapter/asgi.py

@@ -0,0 +1,216 @@
+import asyncio
+import logging
+from os import PathLike, environ
+from typing import AsyncGenerator, TYPE_CHECKING, Union
+
+from asgiref.compatibility import guarantee_single_callable
+
+from .constant import EventTypeEnum
+
+if TYPE_CHECKING:
+    from .protocol import (
+        ASGIScope,
+        RSGIHTTPProtocol,
+        RSGIHTTPScope,
+        RSGIWebsocketProtocol,
+        RSGIWebsocketScope,
+    )
+from .response import BodyIter, Response
+
+logger = logging.getLogger("rsgiadapter")
+if environ.get("RSGI_ADAPTER_DEBUG", "0") == "1":
+    logger.setLevel(logging.DEBUG)
+
+DEFAULT_ASGI_VERSION = "3.0"
+DEFAULT_SPEC_VERSION = "2.3"
+
+
+class ASGIToRSGI:
+
+    def __init__(
+        self,
+        asgi_application,
+        asgi_version=DEFAULT_ASGI_VERSION,
+        spec_version=DEFAULT_SPEC_VERSION,
+    ):
+        self.asgi_application = asgi_application
+        self.asgi_version = asgi_version
+        self.spec_version = spec_version
+
+    async def __call__(self, scope, protocol):
+        await ASGIToRSGIAdapter(
+            self.asgi_application, self.asgi_version, self.spec_version
+        )(scope, protocol)
+
+
+class ASGIToRSGIAdapter:
+    def __init__(
+        self,
+        asgi_app,
+        asgi_version=DEFAULT_ASGI_VERSION,
+        spec_version=DEFAULT_SPEC_VERSION,
+    ):
+        self.asgi_app = asgi_app
+        self.asgi_version = asgi_version
+        self.spec_version = spec_version
+        self.event_status = EventTypeEnum.HTTP_REQUEST
+
+        self.state = {}
+        self.response_started = False
+        self.response_content_length = None
+
+    async def yield_body(
+        self, protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"]
+    ) -> AsyncGenerator:
+        """
+        Asynchronously yields messages from the given rsgi `protocol`.
+
+        Args:
+            protocol (RSGIHTTPProtocol | RSGIWebsocketProtocol): RSGIHTTPProtocol or RSGIWebsocketProtocol instance.
+
+        Yields:
+            Any: The next message from the rsgi protocol.
+
+        """
+        async for msg in protocol:
+            yield msg
+
+    def make_asgi_scope(
+        self, scope: Union["RSGIHTTPScope", "RSGIWebsocketScope"]
+    ) -> "ASGIScope":
+        """
+        Generates an ASGI scope based on RSGI scope, extracting relevant information,
+        such as versions, protocol, HTTP version, server details, client details, scheme,
+        method, path, query string, headers, and state.
+
+        Args:
+            scope (Union["RSGIHTTPScope", "RSGIWebsocketScope"]): The scope object containing the necessary information.
+
+        Returns:
+            dict: A dictionary representing the ASGI scope with version details
+
+        Raises:
+            ValueError: If the scope is None
+        """
+        if not scope:
+            raise ValueError("Scope cannot be None")
+
+        asgi_version = self.asgi_version
+        spec_version = self.spec_version
+        proto = scope.proto
+        http_version = scope.http_version
+        server = scope.server.split(":") if scope.server else []
+        client = scope.client.split(":") if scope.client else []
+        scheme = scope.scheme
+        method = scope.method
+        path = scope.path
+        raw_path = path.encode("latin-1") if path else b""
+        query_string = (
+            scope.query_string.encode("latin-1") if scope.query_string else b""
+        )
+        headers = (
+            [
+                (k.encode("latin-1"), v.encode("latin-1"))
+                for k, v in scope.headers.items()
+            ]
+            if scope.headers
+            else []
+        )
+
+        return {
+            "asgi": {"version": asgi_version, "spec_version": spec_version},
+            "extensions": {"http.response.pathsend": {}},
+            "type": proto,
+            "http_version": http_version,
+            "server": server,
+            "client": client,
+            "scheme": scheme,
+            "method": method,
+            "path": path,
+            "raw_path": raw_path,
+            "query_string": query_string,
+            "headers": headers,
+            "root_path": "",
+            "state": self.state,
+        }
+
+    async def __call__(
+        self,
+        scope: Union["RSGIHTTPScope", "RSGIWebsocketScope"],
+        protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"],
+    ):
+        asgi_scope = self.make_asgi_scope(scope)
+        send_queue = asyncio.Queue()
+        asgi_body = self.yield_body(protocol)
+
+        async def receive():
+            try:
+                return {
+                    "type": self.event_status,
+                    "body": await anext(asgi_body),
+                    "more_body": True,
+                }
+            except StopAsyncIteration:
+                return {
+                    "type": self.event_status,
+                    "body": b"",
+                    "more_body": False,
+                }
+
+        async def send(msg):
+            if msg.get("more_body", None) is False:
+                self.event_status = EventTypeEnum.HTTP_DISCONNECT
+            await send_queue.put(msg)
+
+        try:
+            await guarantee_single_callable(self.asgi_app)(asgi_scope, receive, send)
+        except asyncio.CancelledError:
+            logger.debug("ASGI app cancelled")
+        except Exception:
+            logger.debug("ASGI app raised an exception", exc_info=True)
+        response = await self.get_response(send_queue)
+
+        await self.perform_response(protocol, response)
+
+    async def get_response(self, send_queue: asyncio.Queue):
+        response = Response(
+            status=None, headers=[], body=BodyIter(), path=None, stream=None, type=None
+        )
+        while not send_queue.empty():
+            message = await send_queue.get()
+            if message["type"] == EventTypeEnum.HTTP_RESP_START:
+                response.status = message["status"]
+                response.headers = [
+                    (k.decode(), v.decode()) for k, v in message["headers"]
+                ]
+            elif message["type"] == EventTypeEnum.HTTP_RESP_BODY:
+                response.body.append(message["body"])
+            elif message["type"] == EventTypeEnum.PATH_SEND:
+                response.path = message["path"]
+                response.type = EventTypeEnum.PATH_SEND
+        return response
+
+    async def perform_response(
+        self,
+        protocol: Union["RSGIHTTPProtocol", "RSGIWebsocketProtocol"],
+        response: Response,
+    ) -> None:
+        if response.path is not None and isinstance(response.path, (str, PathLike)):
+            protocol.response_file(
+                status=response.status, headers=response.headers, file=response.path
+            )
+            return
+        if len(response.body) > 1:
+            trx = protocol.response_stream(
+                status=response.status,
+                headers=response.headers,
+            )
+            async for chunk in response.body:
+                await trx.send_bytes(chunk)
+        else:
+            protocol.response_bytes(
+                status=response.status,
+                headers=response.headers,
+                body=b"".join(response.get_body()),
+            )
+            response.clear_body()

rsgiadapter/constant.py

@@ -0,0 +1,22 @@
+from enum import StrEnum
+
+
+class EventTypeEnum(StrEnum):
+    """
+    ASGI event types
+    """
+    # http
+    HTTP_REQUEST = "http.request"
+    HTTP_DISCONNECT = "http.disconnect"
+    HTTP_RESP_START = "http.response.start"
+    HTTP_RESP_END = "http.response.end"
+    HTTP_RESP_BODY = "http.response.body"
+
+    # websocket
+    WEBSOCKET_CONNECT = "websocket.connect"
+    WEBSOCKET_DISCONNECT = "websocket.disconnect"
+    WEBSOCKET_RECEIVE = "websocket.receive"
+    WEBSOCKET_SEND = "websocket.send"
+
+    # extensions
+    PATH_SEND = "http.response.pathsend"

rsgiadapter/protocol.py

@@ -0,0 +1,141 @@
+from typing import Any, Dict, Iterable, List, Optional, Tuple, TypedDict, Union
+
+
+class ASGIScope(TypedDict):
+    asgi: Dict[str, str]
+    extensions: Dict[str, Dict[str, Any]]
+    type: str
+    http_version: str
+    server: Iterable[Union[str, int, None]]
+    client: Iterable[Union[str, int, None]]
+    scheme: str
+    method: str
+    path: str
+    raw_path: bytes
+    query_string: bytes
+    headers: Iterable[Tuple[Union[str, bytes], Union[str, bytes]]]
+    root_path: str
+    state: Optional[Dict[str, Any]]
+
+
+class RSGIHTTPScope(object):
+    """RSGI HTTP Scope template, for type hinting"""
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+    authority = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    client = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    headers = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    http_version = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    method = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    path = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    proto = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    query_string = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    rsgi_version = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    scheme = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+    server = property(
+        lambda self: object(), lambda self, v: None, lambda self: None
+    )  # default
+
+
+class RSGIHTTPProtocol(object):
+    """RSGI HTTP Protocol template, for type hinting"""
+
+    proto: str
+    http_version: str
+    rsgi_version: str
+    server: str
+    client: str
+    scheme: str
+    method: str
+    path: str
+    query_string: str
+    headers: List
+    body: bytes
+
+    def response_bytes(self, *args, **kwargs):
+        pass
+
+    def response_empty(self, *args, **kwargs):
+        pass
+
+    def response_file(self, *args, **kwargs):
+        pass
+
+    def response_str(self, *args, **kwargs):
+        pass
+
+    def response_stream(self, *args, **kwargs):
+        pass
+
+    def __aiter__(self, *args, **kwargs):
+        return self
+
+    async def __anext__(self, *args, **kwargs):
+        if self.data:
+            return self.data.pop(0)
+        raise StopAsyncIteration
+
+    def __call__(self, *args, **kwargs):
+        pass
+
+    def __init__(self, *args, **kwargs):
+        self.data = list(args)
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+
+class RSGIWebsocketProtocol(object):
+    def accept(self, *args, **kwargs):
+        pass
+
+    def close(self, *args, **kwargs):
+        pass
+
+    def __init__(self, *args, **kwargs):
+        pass
+
+    @staticmethod
+    def __new__(cls, *args, **kwargs):
+        pass
+
+
+class RSGIWebsocketScope(RSGIHTTPScope):
+    pass

rsgiadapter/response.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple, Union
+
+
+class BodyIter:
+    def __init__(self):
+        self._body = []
+
+    def __len__(self):
+        return len(self._body)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if not self._body:
+            raise StopIteration
+        return self._body.pop(0)
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        if not self._body:
+            raise StopAsyncIteration
+        return self._body.pop(0)
+
+    def append(self, data: Union[Dict[str, Union[bytes, str]], bytes]):
+        self._body.append(data)
+
+    def get_body(self):
+        return self._body
+
+    def clear_body(self):
+        self._body.clear()
+
+
+@dataclass
+class Response:
+    status: Optional[int] = None
+    headers: Union[List[tuple], Tuple[tuple]] = field(default_factory=list)
+    body: BodyIter = field(default_factory=BodyIter)
+    path: Optional[str] = b""
+    stream: Optional[bool] = False
+    type: Optional[str] = None
+
+    def get_body(self):
+        return self.body.get_body()
+
+    def clear_body(self):
+        self.body.clear_body()

rsgiadapter-0.0.3.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.1
+Name: rsgiadapter
+Version: 0.0.3
+Summary: An adapter for asgi to rsgi
+Keywords: asgi,rsgi,adapter,asgi adapter,rsgi adapter,asgi to rsgi,rsgi to asgi,asyncio
+Author-Email: belingud <im.victor@qq.com>
+License: BSD-3-Clause
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Internet
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/belingud/rsgiadapter
+Requires-Python: <4.0,>=3.8
+Requires-Dist: asgiref>=3.8.1
+Description-Content-Type: text/markdown
+
+# rsgiadapter
+
+An Asgi to rsgi adapter.
+
+RSGI Specification ref: https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md
+
+`rsgiadapter` is an adapter for [RSGI](https://github.com/emmett-framework/granian/blob/master/docs/spec/RSGI.md) server run [ASGI](https://asgi.readthedocs.io) application like FastAPI and BlackSheep.
+
+Usage:
+
+`app.py`
+```python
+import granian
+from granian.constants import Interfaces
+from rsgiadapter import ASGIToRSGI
+
+app = None  # Define your asgi application here
+
+rsgi_app = ASGIToRSGI(app)
+
+serve = granian.Granian("app:rsgi_app", interface=Interfaces.RSGI)
+serve.serve()
+
+```
+
+Supported Feature:
+
+- [x] HTTP Request Response
+  - [x] ASGI scope
+  - [x] ASGI receive
+  - [x] ASGI send
+- [x] Extensions
+  - [x] http.response.pathsend
+  - [ ] websocket.http.response
+  - [ ] http.response.push
+  - [ ] http.response.zerocopysend
+  - [ ] http.response.early_hint
+  - [ ] http.response.trailers
+  - [ ] http.response.debug
+- [ ] Lifespan
+  - [ ] lifespan.startup
+  - [ ] lifespan.startup.complete
+  - [ ] lifespan.startup.failed
+  - [ ] lifespan.shutdown
+  - [ ] lifespan.shutdown.complete
+  - [ ] lifespan.shutdown.failed
+
+Ref:
+
+- Granian: https://github.com/emmett-framework/granian

rsgiadapter-0.0.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+rsgiadapter-0.0.3.dist-info/METADATA,sha256=HSgozEkBasFNDfLW2iAv5oYRqdMVQGtMZC_ngl9VM3o,2641
+rsgiadapter-0.0.3.dist-info/WHEEL,sha256=vnE8JVcI2Wz7GRKorsPArnBdnW2SWKWGow5gu5tHlRU,90
+rsgiadapter/__init__.py,sha256=kPmGfqUQeNlzt3vSQMB4u8YmEjLg8mwzuLb1ddCmcoc,78
+rsgiadapter/asgi.py,sha256=-oZFQMjs1v7P_1C9CRxoi4gTetyg02DJjJZWW9hm7cA,7137
+rsgiadapter/constant.py,sha256=nLkVvxviIDx_vnBwIP0yqSAv7CEfV5LRz9Zqh-NEnNE,557
+rsgiadapter/protocol.py,sha256=Oe5BOkAxLgqmcrYoYmrXUPpfgc3LnZUH3Cb0_VPvFL4,3284
+rsgiadapter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rsgiadapter/response.py,sha256=5Z3w957rHUBaozl6sxcQLJhT02wcTD5PytAEmoXrVe8,1169
+rsgiadapter-0.0.3.dist-info/RECORD,,

rsgiadapter-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any