attp-sdk 0.1.0__tar.gz

attp_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.3
+Name: attp-sdk
+Version: 0.1.0
+Summary: attp-sdk
+Author: Zahcoder34
+Author-email: Zakhriw@gmail.com
+Requires-Python: >=3.11,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: ascender-framework (>=2.0.4,<3.0.0)
+Requires-Dist: attp-core (>=0.2.4,<0.3.0)
+Requires-Dist: msgpack (>=1.1.2,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Ascender Framework Project
+
+## Overview
+
+This project is built using the **Ascender Framework**, a structured FastAPI-based framework designed for modular and scalable applications.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+Ensure you have the following dependencies installed:
+
+- **Python 3.11 or higher**
+- **Poetry** (for dependency management)
+- **pip** (Python's package manager)
+
+### Installation
+
+1. **Install Poetry** (if not already installed):
+
+   ```bash
+   pip install poetry
+   ```
+
+2. **Configure Poetry to use virtual environments**:
+
+   ```bash
+   poetry config virtualenvs.create true
+   ```
+
+3. **Install project dependencies**:
+
+   ```bash
+   poetry install
+   ```
+
+4. **Run development server**:
+    
+    ```bash
+    ascender run serve
+    ```
+
+If everything works, you're done!

attp_sdk-0.1.0/README.md

@@ -0,0 +1,45 @@
+# Ascender Framework Project
+
+## Overview
+
+This project is built using the **Ascender Framework**, a structured FastAPI-based framework designed for modular and scalable applications.
+
+---
+
+## Getting Started
+
+### Prerequisites
+
+Ensure you have the following dependencies installed:
+
+- **Python 3.11 or higher**
+- **Poetry** (for dependency management)
+- **pip** (Python's package manager)
+
+### Installation
+
+1. **Install Poetry** (if not already installed):
+
+   ```bash
+   pip install poetry
+   ```
+
+2. **Configure Poetry to use virtual environments**:
+
+   ```bash
+   poetry config virtualenvs.create true
+   ```
+
+3. **Install project dependencies**:
+
+   ```bash
+   poetry install
+   ```
+
+4. **Run development server**:
+    
+    ```bash
+    ascender run serve
+    ```
+
+If everything works, you're done!

attp_sdk-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "attp-sdk"
+version = "0.1.0"
+description = "attp-sdk"
+authors = [
+    {name = "Zahcoder34",email = "Zakhriw@gmail.com"},
+    {name = "AscenderTeam",email = "team@ascender.space"},
+]
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+dependencies = [
+    "ascender-framework (>=2.0.4,<3.0.0)",
+    "attp-core (>=0.2.4,<0.3.0)",
+    "msgpack (>=1.1.2,<2.0.0)",
+]
+
+[tool.poetry]
+package-mode = true
+packages = [
+    { include = "attp", from = "src" }
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

attp_sdk-0.1.0/src/attp/__init__.py

@@ -0,0 +1,8 @@
+from attp.decorators import AttpCall, AttpErrorHandler, AttpEvent, AttpLifecycle
+from .providers import provideAttp
+from .types.frame import AttpFrameDTO
+from .types.context import AttpContext
+from .shared.objects.stream import StreamObject
+
+
+__all__ = ["provideAttp", "AttpFrameDTO", "AttpContext", "StreamObject", "AttpCall", "AttpEvent", "AttpLifecycle", "AttpErrorHandler"]

attp_sdk-0.1.0/src/attp/client/__init__.py

@@ -0,0 +1,6 @@
+from .authenticator import ConnectionAuthenticator
+from .configs import ServiceDiscoveryConfigs, AttpClientConfigs
+from .service_discovery import ServiceDiscovery
+from .session_driver import ClientSessionDriver
+
+__all__ = ["ConnectionAuthenticator", "ServiceDiscoveryConfigs", "AttpClientConfigs", "ServiceDiscovery", "ClientSessionDriver"]

attp_sdk-0.1.0/src/attp/client/authenticator.py

@@ -0,0 +1,84 @@
+import hashlib
+import hmac
+import os
+import secrets
+import time
+from typing import Any, Mapping
+
+from attp.shared.secrets import resolve_secret_if_ref, parse_secret_ref, SecretRef
+
+
+class ConnectionAuthenticator:
+    def __init__(
+        self, 
+        conn_uri: str, 
+        namespace: str,
+        authorization: Any | None = None,
+        data: Any | None = None
+    ) -> None:
+        self.authorization = authorization
+        self.conn_uri = conn_uri
+        self.namespace = namespace
+        self.data = data
+        self.AUTH_TIMEOUT = float(os.getenv("ATTP_CLIENT_CONNECTION_TIMEOUT", 10))
+    
+    async def authenticate(self):
+        """
+        Method is invoked when authentication process starts.
+        Usually server requires protocol authentication, and the connection authenticator signs the 
+        """
+        return resolve_secret_if_ref(self.authorization)
+    
+    async def send_hello(self):
+        """
+        Method is invoked only after authentication, to send the `data` given on `__init__` to the remote peer.
+        This method is mandatory for handshake part, for future authentications, it 
+        """
+        return self.data
+
+
+class HmacConnectionAuthenticator(ConnectionAuthenticator):
+    def __init__(
+        self,
+        conn_uri: str,
+        namespace: str,
+        *,
+        secret: str | SecretRef | Mapping[str, Any],
+        node_id: str | None = None,
+        key_id: str | None = None,
+        ttl_seconds: int = 30,
+        max_clock_skew: int = 5,
+    ) -> None:
+        super().__init__(conn_uri, namespace, authorization=None, data=None)
+        self._secret_ref = parse_secret_ref(secret)
+        if self._secret_ref is None:
+            raise TypeError("secret must be a string or secret reference.")
+
+        self.node_id = node_id or os.getenv("ATTP_NODE_ID") or "node"
+        self.key_id = key_id
+        self.ttl_seconds = ttl_seconds
+        self.max_clock_skew = max_clock_skew
+        self.AUTH_TIMEOUT = float(
+            os.getenv("ATTP_CLIENT_CONNECTION_TIMEOUT", ttl_seconds + max_clock_skew + 5)
+        )
+
+    def _sign(self, ts: int, nonce: str) -> str:
+        secret = self._secret_ref.resolve() # type: ignore
+        message = f"{self.namespace}:{self.node_id}:{ts}:{nonce}".encode("utf-8")
+        return hmac.new(secret.encode("utf-8"), message, hashlib.sha256).hexdigest()
+
+    async def authenticate(self):
+        ts = int(time.time())
+        nonce = secrets.token_hex(16)
+        sig = self._sign(ts, nonce)
+
+        payload = {
+            "alg": "HS256",
+            "ts": ts,
+            "nonce": nonce,
+            "sig": sig,
+            "node_id": self.node_id,
+        }
+        if self.key_id:
+            payload["kid"] = self.key_id
+        return payload

attp_sdk-0.1.0/src/attp/client/configs.py

@@ -0,0 +1,32 @@
+from typing import Any, Callable
+from ascender.common import BaseDTO
+from pydantic import Field
+
+from attp.client.authenticator import ConnectionAuthenticator
+from attp.shared.limits import AttpLimits
+
+
+class AttpClientConfigs(BaseDTO):
+    model_config = {"arbitrary_types_allowed": True}
+    
+    remote_uri: str # attp://host:port
+    namespace: str = "default"
+    data: Any | None = None
+    authorization: Any | None = None
+    auth: Any | None = None
+    capabilities: list[str] = Field(default_factory=lambda: ["schema/msgpack", "streaming"])
+
+
+class ServiceDiscoveryConfigs(BaseDTO):
+    model_config = {"arbitrary_types_allowed": True}
+    
+    peers: list[str | AttpClientConfigs]
+    limits: AttpLimits
+    authenticator: (
+        ConnectionAuthenticator
+        | type[ConnectionAuthenticator]
+        | Callable[[AttpClientConfigs], ConnectionAuthenticator]
+        | None
+    ) = None
+    reconnection: bool = True
+    max_retries: int = 20

attp_sdk-0.1.0/src/attp/client/service_discovery.py

@@ -0,0 +1,107 @@
+import asyncio
+from logging import Logger
+from typing import Annotated
+
+from ascender.core import Inject
+from attp.client.authenticator import ConnectionAuthenticator
+from attp.client.configs import AttpClientConfigs, ServiceDiscoveryConfigs
+from attp.client.session_driver import ClientSessionDriver
+from attp.server.session_driver import ServerSessionDriver
+from attp.shared.lifecycle_service import LifecycleService
+
+from attp_core.rs_api import AttpClientSession, PyAttpMessage
+
+from attp.shared.multireceiver import AttpMultiReceiver
+from attp.shared.namespaces.dispatcher import NamespaceDispatcher
+from attp.shared.objects.dispatcher import AttpFrameDispatcher
+from attp.shared.sessions.driver import AttpSessionDriver
+
+
+class ServiceDiscovery(LifecycleService):
+    def __init__(
+        self, 
+        configs: ServiceDiscoveryConfigs, 
+        namespaces: NamespaceDispatcher,
+        dispatcher: AttpFrameDispatcher,
+        logger: Annotated[Logger, Inject("ASC_LOGGER")]
+    ) -> None:
+        super().__init__()
+        self.configs = configs
+        
+        self.multireceiver = AttpMultiReceiver[tuple[AttpSessionDriver, PyAttpMessage]](lambda d: d[0].namespace, fanout_global=True, auto_create=True)
+        self.namespaces = namespaces
+        self.dispatcher = dispatcher
+        
+        self.conlock = asyncio.Lock()
+        
+        self.logger = logger
+        self.is_active = False
+    
+    def activate(self):
+        if not self.is_active:
+            self.logger.info("Activating service discovery...")
+            self.is_active = True
+    
+    async def start_initial_connections(self):
+        for peer in self.configs.peers:
+            if isinstance(peer, str):
+                peer = AttpClientConfigs(remote_uri=peer)
+
+            authenticator = self.configs.authenticator
+            if isinstance(authenticator, type) and issubclass(authenticator, ConnectionAuthenticator):
+                authenticator = authenticator(peer.remote_uri, peer.namespace)
+            elif callable(authenticator):
+                authenticator = authenticator(peer)
+            try:
+                await self.initiate_connection(peer, conn_authenticator=authenticator)
+            except Exception as exc:
+                self.logger.error(
+                    "[cyan]ATTP[/] ┆ Failed to connect to peer %s (%s)",
+                    peer.remote_uri,
+                    exc,
+                )
+    
+    async def on_startup(self):
+        asyncio.create_task(self.start_initial_connections())
+    
+    async def on_shutdown(self):
+        self.dispatcher.stop_all()
+    
+    async def on_session_termination(self, session_driver: ClientSessionDriver):
+        try:
+            self.namespaces.remove_session(session_driver.namespace, session_driver)
+            self.logger.info("[cyan]ATTP[/] ┆ Session (%s) disconnected.", session_driver.session_id or "unknown")
+
+        except ValueError:
+            self.logger.info("[cyan]ATTP[/] ┆ Session (%s) disconnected before being registered", session_driver._session or "unknown")
+
+    
+    async def initiate_connection(self, config: AttpClientConfigs, conn_authenticator: ConnectionAuthenticator | None = None):
+        client = AttpClientSession(config.remote_uri, limits=self.configs.limits.to_model())
+
+        client = await client.connect(max_retries=self.configs.max_retries)
+
+        if not client.session:
+            raise ConnectionError("Failed to connect to the server.")
+        
+        driver = ClientSessionDriver(client.session, on_termination=self.on_session_termination)
+        
+        if not conn_authenticator:
+            authenticator = ConnectionAuthenticator(config.remote_uri, config.namespace, config.authorization, config.data)
+        else:
+            authenticator = conn_authenticator
+        
+        try:
+            namespace, _ = await driver.start(config.capabilities, authenticator)
+        except TimeoutError:
+            self.logger.error("[cyan]ATTP[/] ┆ Session (%s) %s failed to authenticate, flushing the connection!", client.session.peername, client.session.session_id)
+            await driver.close()
+            del driver
+            return
+        
+        async with self.conlock:
+            self.namespaces.add_session(namespace, driver)
+            receiver = self.multireceiver.receiver(namespace)
+            self.dispatcher.start(receiver)
+        
+        await driver.listen(receiver)

attp_sdk-0.1.0/src/attp/client/session_driver.py

@@ -0,0 +1,120 @@
+import asyncio
+import os
+import traceback
+from typing import Annotated
+from ascender.core import inject
+from typing_extensions import Doc
+from attp.client.authenticator import ConnectionAuthenticator
+from attp.shared.namespaces.router import AttpRouter
+from attp.shared.sessions.additional_mixins import EnhancedFrameTransmitterMixin, StreamingFrameTransmitterMixin
+from attp.shared.sessions.driver import SessionTerminatorMixin
+
+from attp_core.rs_api import PyAttpMessage, AttpCommand
+
+from attp.types.exceptions.attp_exception import AttpException
+from attp.types.exceptions.protocol_error import ProtocolError
+from attp.types.frames.accepted import IAcceptedDTO
+from attp.types.frames.auth import IAuthDTO
+from attp.types.frames.ready import IReadyDTO
+
+
+class ClientSessionDriver(
+    SessionTerminatorMixin,
+    EnhancedFrameTransmitterMixin,
+    StreamingFrameTransmitterMixin
+):
+    connection_estabilished_at: Annotated[str | None, Doc("Last connection time according to server's timezone in an ISO-format.")]
+    authenticator: ConnectionAuthenticator
+    router: AttpRouter = inject(AttpRouter)
+    
+    async def start(self, capabilities: list, conn_authenticator: ConnectionAuthenticator):
+        asyncio.create_task(self.start_listener())
+        self._role = "client"
+        self._capabilities = capabilities
+        self._namespace = conn_authenticator.namespace
+        if os.getenv("ATTP_AUTH_DEBUG") == "1":
+            log = getattr(self.logger, "info", None)
+            if callable(log):
+                log(
+                    "[cyan]ATTP[/] ┆ Sending AUTH namespace=%s",
+                    conn_authenticator.namespace,
+                )
+        await self.send_frame(
+            PyAttpMessage(
+                route_id=1, 
+                command_type=AttpCommand.AUTH, 
+                correlation_id=None, 
+                payload=IAuthDTO(
+                    namespace=conn_authenticator.namespace, 
+                    data=await conn_authenticator.authenticate()
+                ).mpd(),
+                version=self.version_bytes()
+            )
+        )
+        self.authenticator = conn_authenticator
+        try:
+            await asyncio.wait_for(self.auth_flag.wait(), timeout=conn_authenticator.AUTH_TIMEOUT)
+        except asyncio.TimeoutError:
+            raise TimeoutError("Authentication timed out for session {}".format(self.session_id))
+        
+        return self.namespace, self.session_id
+    
+    async def _on_event(self, events: list[PyAttpMessage]):
+        self.logger.debug(f"[cyan]ATTP[/] ┆ Received a new message from session {self.session_id}")
+        
+        for event in events:
+            if event.route_id == 0 and event.command_type == AttpCommand.READY:
+                try:
+                    if not event.payload:
+                        continue
+                    if os.getenv("ATTP_AUTH_DEBUG") == "1":
+                        log = getattr(self.logger, "info", None)
+                        if callable(log):
+                            log("[cyan]ATTP[/] ┆ READY received")
+                    self._enqueue_incoming(event)
+                    await self._register_connection(IAcceptedDTO.mps(event.payload))
+                except Exception as e:
+                    traceback.print_exc()
+                    # TODO: Implement error reporting
+                    await self.handle_disconnect()
+                    return
+            
+            elif event.command_type == AttpCommand.DISCONNECT:
+                await self.handle_disconnect()
+                return
+            elif event.command_type == AttpCommand.ERR:
+                self._enqueue_incoming(event)
+                return
+            else:
+                if self.is_authenticated:
+                    self._enqueue_incoming(event)
+
+    async def _register_connection(self, frame: IAcceptedDTO):
+        super()._register_connection(frame)
+        try:
+            print("RRR", frame.routes)
+            self.router.include_remote_routes(self.namespace, frame.routes, "client")
+        except ProtocolError as e:
+            await self.send_error(0, exception=AttpException(400, message=str(e), detail=traceback.format_exc(), fatal=True))
+            await self.close()
+            return
+        
+        self.auth_flag.set()
+        self.connection_estabilished_at = frame.server_time
+        
+        routes = self.router.get_routes(namespace=self.namespace)
+        print("CLIENT REGISTERING ROUTES:", routes)
+
+        await self.send_frame(
+            PyAttpMessage(
+                route_id=0, 
+                command_type=AttpCommand.READY, 
+                correlation_id=None, 
+                payload=IReadyDTO(
+                    data=self.authenticator.data,
+                    caps=self.capabilities,
+                    routes=routes
+                ).mpd(),
+                version=self.version_bytes()
+            )
+        )

attp_sdk-0.1.0/src/attp/decorators/__init__.py

@@ -0,0 +1,6 @@
+from .attp_call import AttpCall
+from .attp_event import AttpEvent
+from .attp_handler import AttpErrorHandler
+from .attp_lifecycle import AttpLifecycle
+
+__all__ = ["AttpCall", "AttpEvent", "AttpErrorHandler", "AttpLifecycle"]

attp_sdk-0.1.0/src/attp/decorators/attp_call.py

@@ -0,0 +1,15 @@
+from typing import Any, Callable
+from ascender.core import ControllerDecoratorHook, inject
+
+from attp.shared.namespaces.router import AttpRouter
+
+
+class AttpCall(ControllerDecoratorHook):
+    router: AttpRouter = inject(AttpRouter)
+    
+    def __init__(self, pattern: str, namespace: str = "default") -> None:
+        self.pattern = pattern
+        self.namespace = namespace
+    
+    def on_load(self, callable: Callable[..., Any]):
+        self.router.add_route("message", self.pattern, callable, namespace=self.namespace)

attp_sdk-0.1.0/src/attp/decorators/attp_event.py

@@ -0,0 +1,20 @@
+from typing import Any, Callable
+from ascender.core import ControllerDecoratorHook, inject
+
+from attp.shared.namespaces.router import AttpRouter
+
+
+class AttpEvent(ControllerDecoratorHook):
+    
+    router: AttpRouter = inject(AttpRouter)
+    
+    def __init__(
+        self, 
+        pattern: str, 
+        namespace: str = "default"
+    ) -> None:
+        self.pattern = pattern
+        self.namespace = namespace
+    
+    def on_load(self, callable: Callable[..., Any]):
+        self.router.add_event(self.pattern, callable, namespace=self.namespace)

attp_sdk-0.1.0/src/attp/decorators/attp_handler.py

@@ -0,0 +1,15 @@
+from typing import Any, Callable
+from ascender.core import ControllerDecoratorHook, inject
+
+from attp.shared.namespaces.router import AttpRouter
+
+
+class AttpErrorHandler(ControllerDecoratorHook):
+    router: AttpRouter = inject(AttpRouter)
+    
+    def __init__(self, pattern: str, namespace: str = "default") -> None:
+        self.pattern = pattern
+        self.namespace = namespace
+    
+    def on_load(self, callable: Callable[..., Any]):
+        self.router.add_error_handler(self.pattern, callable, namespace=self.namespace)

attp_sdk-0.1.0/src/attp/decorators/attp_lifecycle.py

@@ -0,0 +1,19 @@
+from typing import Any, Callable, Literal
+from ascender.core import ControllerDecoratorHook, inject
+
+from attp.client.service_discovery import ServiceDiscovery
+from attp.server.attp_server import AttpServer
+from attp.shared.namespaces.router import AttpRouter
+
+
+class AttpLifecycle(ControllerDecoratorHook):
+    router: AttpRouter = inject(AttpRouter)
+    
+    def __init__(self, event: Literal["connect", "disconnect"], namespace: str = "default") -> None:
+        self.event = event
+        self.namespace = namespace
+    
+    def on_load(self, callable: Callable[..., Any]):
+        inject(AttpServer).activate()
+        inject(ServiceDiscovery).activate()
+        self.router.add_route(self.event, self.event, callable, namespace=self.namespace) # type: ignore

attp_sdk-0.1.0/src/attp/loadbalancer/__init__.py

@@ -0,0 +1,7 @@
+from .balancer import AttpLoadBalancer
+from .configs import BalancerConfigs
+from .abc.cacher import StrategyCacher
+from .abc.candidate import Candidate
+from .abc.strategy import BalancingStrategy
+
+__all__ = ["AttpLoadBalancer", "BalancerConfigs", "StrategyCacher", "Candidate", "BalancingStrategy"]

attp_sdk-0.1.0/src/attp/loadbalancer/abc/cacher.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Any, TypeVar
+
+
+T = TypeVar("T")
+
+
+class StrategyCacher(ABC):
+    
+    @abstractmethod
+    async def store(self, key: str, value: Any) -> Any:
+        ...
+    
+    @abstractmethod
+    async def get(self, key: str, *, expected_type: type[T] | None = None) -> T | Any:
+        ...
+
+    @abstractmethod
+    async def increment(self, key: str, *, delta: int = 1, initial: int = 0) -> int:
+        ...
+    
+    async def keys(self):
+        raise NotImplementedError

attp_sdk-0.1.0/src/attp/loadbalancer/abc/candidate.py

@@ -0,0 +1,7 @@
+from typing import TypeAlias
+
+from attp.server.session_driver import ServerSessionDriver
+from attp.shared.sessions.driver import AttpSessionDriver
+
+
+Candidate: TypeAlias = AttpSessionDriver | ServerSessionDriver

attp_sdk-0.1.0/src/attp/loadbalancer/abc/strategy.py

@@ -0,0 +1,22 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from attp.loadbalancer.abc.cacher import StrategyCacher
+from attp.loadbalancer.abc.candidate import Candidate
+from attp.shared.utils.qsequence import QSequence
+
+
+class BalancingStrategy(ABC):
+    name: str
+    
+    @abstractmethod
+    def __init__(
+        self, 
+        configs: Any,
+        cacher: StrategyCacher,
+    ) -> None:
+        ...
+    
+    @abstractmethod
+    async def balance(self, default: Candidate, candidates: QSequence[Candidate]) -> Candidate:
+        pass