hypern 0.3.11__cp312-cp312-musllinux_1_2_i686.whl

hypern/routing/route.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+import asyncio
+import inspect
+from enum import Enum
+from typing import Any, Callable, Dict, List, Type, Union, get_args, get_origin
+
+import yaml  # type: ignore
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+from hypern.auth.authorization import Authorization
+from hypern.datastructures import HTTPMethod
+from hypern.hypern import FunctionInfo, Request, Router
+from hypern.hypern import Route as InternalRoute
+
+from .dispatcher import dispatch
+
+
+def get_field_type(field):
+    return field.outer_type_
+
+
+def pydantic_to_swagger(model: type[BaseModel] | dict):
+    if isinstance(model, dict):
+        # Handle the case when a dict is passed instead of a Pydantic model
+        schema = {}
+        for name, field_type in model.items():
+            schema[name] = _process_field(name, field_type)
+        return schema
+
+    schema = {
+        model.__name__: {
+            "type": "object",
+            "properties": {},
+        }
+    }
+
+    for name, field in model.model_fields.items():
+        schema[model.__name__]["properties"][name] = _process_field(name, field)
+
+    return schema
+
+
+class SchemaProcessor:
+    @staticmethod
+    def process_union(args: tuple) -> Dict[str, Any]:
+        """Process Union types"""
+        if type(None) in args:
+            inner_type = next(arg for arg in args if arg is not type(None))
+            schema = SchemaProcessor._process_field("", inner_type)
+            schema["nullable"] = True
+            return schema
+        return {"oneOf": [SchemaProcessor._process_field("", arg) for arg in args]}
+
+    @staticmethod
+    def process_enum(annotation: Type[Enum]) -> Dict[str, Any]:
+        """Process Enum types"""
+        return {"type": "string", "enum": [e.value for e in annotation.__members__.values()]}
+
+    @staticmethod
+    def process_primitive(annotation: type) -> Dict[str, str]:
+        """Process primitive types"""
+        type_mapping = {int: "integer", float: "number", str: "string", bool: "boolean"}
+        return {"type": type_mapping.get(annotation, "object")}
+
+    @staticmethod
+    def process_list(annotation: type) -> Dict[str, Any]:
+        """Process list types"""
+        schema = {"type": "array"}
+
+        args = get_args(annotation)
+        if args:
+            item_type = args[0]
+            schema["items"] = SchemaProcessor._process_field("item", item_type)
+        else:
+            schema["items"] = {}
+        return schema
+
+    @staticmethod
+    def process_dict(annotation: type) -> Dict[str, Any]:
+        """Process dict types"""
+        schema = {"type": "object"}
+
+        args = get_args(annotation)
+        if args:
+            key_type, value_type = args
+            if key_type == str:  # noqa: E721
+                schema["additionalProperties"] = SchemaProcessor._process_field("value", value_type)
+        return schema
+
+    @classmethod
+    def _process_field(cls, name: str, field: Any) -> Dict[str, Any]:
+        """Process a single field"""
+        if isinstance(field, FieldInfo):
+            annotation = field.annotation
+        else:
+            annotation = field
+
+        # Process Union types
+        origin = get_origin(annotation)
+        if origin is Union:
+            return cls.process_union(get_args(annotation))
+
+        # Process Enum types
+        if isinstance(annotation, type) and issubclass(annotation, Enum):
+            return cls.process_enum(annotation)
+
+        # Process primitive types
+        if annotation in {int, float, str, bool}:
+            return cls.process_primitive(annotation)
+
+        # Process list types
+        if annotation == list or origin is list:  # noqa: E721
+            return cls.process_list(annotation)
+
+        # Process dict types
+        if annotation == dict or origin is dict:  # noqa: E721
+            return cls.process_dict(annotation)
+
+        # Process Pydantic models
+        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
+            return pydantic_to_swagger(annotation)
+
+        # Fallback for complex types
+        return {"type": "object"}
+
+
+def _process_field(name: str, field: Any) -> Dict[str, Any]:
+    """
+    Process a field and return its schema representation
+
+    Args:
+        name: Field name
+        field: Field type or FieldInfo object
+
+    Returns:
+        Dictionary representing the JSON schema for the field
+    """
+    return SchemaProcessor._process_field(name, field)
+
+
+class Route:
+    def __init__(
+        self,
+        path: str,
+        endpoint: Callable[..., Any] | None = None,
+        *,
+        name: str | None = None,
+        tags: List[str] | None = None,
+    ) -> None:
+        self.path = path
+        self.endpoint = endpoint
+        self.tags = tags or ["Default"]
+        self.name = name
+
+        self.http_methods = {
+            "GET": HTTPMethod.GET,
+            "POST": HTTPMethod.POST,
+            "PUT": HTTPMethod.PUT,
+            "DELETE": HTTPMethod.DELETE,
+            "PATCH": HTTPMethod.PATCH,
+            "HEAD": HTTPMethod.HEAD,
+            "OPTIONS": HTTPMethod.OPTIONS,
+        }
+        self.functional_handlers = []
+
+    def _process_authorization(self, item: type, docs: Dict) -> None:
+        if isinstance(item, type) and issubclass(item, Authorization):
+            auth_obj = item()
+            docs["security"] = [{auth_obj.name: []}]
+
+    def _process_model_params(self, key: str, item: type, docs: Dict) -> None:
+        if not (isinstance(item, type) and issubclass(item, BaseModel)):
+            return
+
+        if key == "form_data":
+            docs["requestBody"] = {"content": {"application/json": {"schema": pydantic_to_swagger(item).get(item.__name__)}}}
+        elif key == "query_params":
+            docs["parameters"] = [{"name": param, "in": "query", "schema": _process_field(param, field)} for param, field in item.model_fields.items()]
+        elif key == "path_params":
+            path_params = [
+                {"name": param, "in": "path", "required": True, "schema": _process_field(param, field)} for param, field in item.model_fields.items()
+            ]
+            docs.setdefault("parameters", []).extend(path_params)
+
+    def _process_response(self, response_type: type, docs: Dict) -> None:
+        if isinstance(response_type, type) and issubclass(response_type, BaseModel):
+            docs["responses"] = {
+                "200": {
+                    "description": "Successful response",
+                    "content": {"application/json": {"schema": pydantic_to_swagger(response_type).get(response_type.__name__)}},
+                }
+            }
+
+    def swagger_generate(self, signature: inspect.Signature, summary: str = "Document API") -> str:
+        _inputs = signature.parameters.values()
+        _inputs_dict = {_input.name: _input.annotation for _input in _inputs}
+        _docs: Dict = {"summary": summary, "tags": self.tags, "responses": [], "name": self.name}
+
+        for key, item in _inputs_dict.items():
+            self._process_authorization(item, _docs)
+            self._process_model_params(key, item, _docs)
+
+        self._process_response(signature.return_annotation, _docs)
+        return yaml.dump(_docs)
+
+    def _combine_path(self, path1: str, path2: str) -> str:
+        if path1.endswith("/") and path2.startswith("/"):
+            return path1 + path2[1:]
+        if not path1.endswith("/") and not path2.startswith("/"):
+            return path1 + "/" + path2
+        return path1 + path2
+
+    def make_internal_route(self, path, handler, method) -> InternalRoute:
+        is_async = asyncio.iscoroutinefunction(handler)
+        func_info = FunctionInfo(handler=handler, is_async=is_async)
+        return InternalRoute(path=path, function=func_info, method=method)
+
+    def __call__(self, app, *args: Any, **kwds: Any) -> Any:
+        router = Router(self.path)
+
+        # Validate handlers
+        if not self.endpoint and not self.functional_handlers:
+            raise ValueError(f"No handler found for route: {self.path}")
+
+        # Handle functional routes
+        for route in self.functional_handlers:
+            router.add_route(route=route)
+        if not self.endpoint:
+            return router
+
+        # Handle class-based routes
+        for name, func in self.endpoint.__dict__.items():
+            if name.upper() in self.http_methods:
+                sig = inspect.signature(func)
+                doc = self.swagger_generate(sig, func.__doc__)
+                endpoint_obj = self.endpoint()
+                route = self.make_internal_route(path="/", handler=endpoint_obj.dispatch, method=name.upper())
+                route.doc = doc
+                router.add_route(route=route)
+                del endpoint_obj  # free up memory
+        return router
+
+    def add_route(
+        self,
+        path: str,
+        method: str,
+    ) -> Callable:
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            async def functional_wrapper(request: Request, inject: Dict[str, Any]) -> Any:
+                return await dispatch(func, request, inject)
+
+            sig = inspect.signature(func)
+            route = self.make_internal_route(path=path, handler=functional_wrapper, method=method.upper())
+            route.doc = self.swagger_generate(sig, func.__doc__)
+
+            self.functional_handlers.append(route)
+
+        return decorator
+
+    def get(self, path: str) -> Callable:
+        return self.add_route(path, "GET")
+
+    def post(self, path: str) -> Callable:
+        return self.add_route(path, "POST")
+
+    def put(self, path: str) -> Callable:
+        return self.add_route(path, "PUT")
+
+    def delete(self, path: str) -> Callable:
+        return self.add_route(path, "DELETE")
+
+    def patch(self, path: str) -> Callable:
+        return self.add_route(path, "PATCH")
+
+    def head(self, path: str) -> Callable:
+        return self.add_route(path, "HEAD")
+
+    def options(self, path: str) -> Callable:
+        return self.add_route(path, "OPTIONS")

hypern/scheduler.py

@@ -0,0 +1,5 @@
+from .hypern import Scheduler
+
+__all__ = [
+    "Scheduler",
+]

hypern/worker.py

@@ -0,0 +1,274 @@
+import asyncio
+import logging
+import os
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial, wraps
+from typing import Callable, Dict, List
+
+from celery import Celery
+from celery.result import AsyncResult
+from celery.signals import (
+    after_setup_logger,
+    after_setup_task_logger,
+    task_failure,
+    task_postrun,
+    task_prerun,
+    worker_ready,
+    worker_shutdown,
+)
+from kombu import Exchange, Queue
+
+
+class Worker(Celery):
+    def __init__(
+        self,
+        main: str = None,
+        broker_url: str = None,
+        result_backend: str = "rpc://",
+        queues: Dict[str, Dict] = None,
+        task_routes: Dict[str, str] = None,
+        imports: List[str] = None,
+        **kwargs,
+    ):
+        super().__init__(main, **kwargs)
+
+        self._executor = ThreadPoolExecutor()
+        self._task_timings = {}
+
+        self.default_exchange = Exchange("default", type="direct")
+        self.priority_exchange = Exchange("priority", type="direct")
+
+        default_queues = {
+            "default": {"exchange": self.default_exchange, "routing_key": "default"},
+            "high_priority": {"exchange": self.priority_exchange, "routing_key": "high"},
+            "low_priority": {"exchange": self.priority_exchange, "routing_key": "low"},
+        }
+        if queues:
+            default_queues.update(queues)
+
+        self._queues = {
+            name: Queue(
+                name,
+                exchange=config.get("exchange", self.default_exchange),
+                routing_key=config.get("routing_key", name),
+                queue_arguments=config.get("arguments", {}),
+            )
+            for name, config in default_queues.items()
+        }
+
+        self.conf.update(
+            broker_url=broker_url,
+            result_backend=result_backend,
+            # Worker Pool Configuration
+            worker_pool="solo",
+            worker_pool_restarts=True,
+            broker_connection_retry_on_startup=True,
+            # Worker Configuration
+            worker_prefetch_multiplier=1,
+            worker_max_tasks_per_child=1000,
+            worker_concurrency=os.cpu_count(),
+            # Task Settings
+            task_acks_late=True,
+            task_reject_on_worker_lost=True,
+            task_time_limit=3600,
+            task_soft_time_limit=3000,
+            task_default_retry_delay=300,
+            task_max_retries=3,
+            # Memory Management
+            worker_max_memory_per_child=200000,  # 200MB
+            # Task Routing
+            task_routes=task_routes,
+            task_queues=list(self._queues.values()),
+            # Performance Settings
+            task_compression="gzip",
+            result_compression="gzip",
+            task_serializer="json",
+            result_serializer="json",
+            accept_content=["json"],
+            imports=imports,
+            task_default_exchange=self.default_exchange.name,
+            task_default_routing_key="default",
+        )
+
+        self._setup_signals()
+
+    def _setup_signals(self):
+        @worker_ready.connect
+        def on_worker_ready(sender, **kwargs):
+            self.logger.info(f"Worker {sender.hostname} is ready")
+
+        @worker_shutdown.connect
+        def on_worker_shutdown(sender, **kwargs):
+            self.logger.info(f"Worker {sender.hostname} is shutting down")
+            self._executor.shutdown(wait=True)
+
+        @task_prerun.connect
+        def task_prerun_handler(task_id, task, *args, **kwargs):
+            self._task_timings[task_id] = {"start": time.time()}
+            self.logger.info(f"Task {task.name}[{task_id}] started")
+
+        @task_postrun.connect
+        def task_postrun_handler(task_id, task, *args, retval=None, **kwargs):
+            if task_id in self._task_timings:
+                start_time = self._task_timings[task_id]["start"]
+                duration = time.time() - start_time
+                self.logger.info(f"Task {task.name}[{task_id}] completed in {duration:.2f}s")
+                del self._task_timings[task_id]
+
+        @task_failure.connect
+        def task_failure_handler(task_id, exc, task, *args, **kwargs):
+            self.logger.error(f"Task {task.name}[{task_id}] failed: {exc}\n{traceback.format_exc()}")
+
+        @after_setup_logger.connect
+        def setup_celery_logger(logger, *args, **kwargs):
+            existing_logger = logging.getLogger("hypern")
+            logger.handlers = existing_logger.handlers
+            logger.filters = existing_logger.filters
+            logger.level = existing_logger.level
+
+        @after_setup_task_logger.connect
+        def setup_task_logger(logger, *args, **kwargs):
+            existing_logger = logging.getLogger("hypern")
+            logger.handlers = existing_logger.handlers
+            logger.filters = existing_logger.filters
+            logger.level = existing_logger.level
+
+    def add_task_routes(self, routes: Dict[str, str]) -> None:
+        """
+        Example:
+            app.add_task_routes({
+                'tasks.email.*': 'email_queue',
+                'tasks.payment.process': 'payment_queue',
+                'tasks.high_priority.*': 'high_priority'
+            })
+        """
+        for task_pattern, queue in routes.items():
+            self.add_task_route(task_pattern, queue)
+
+    def add_task_route(self, task_pattern: str, queue: str) -> None:
+        """
+        Add a task route to the Celery app
+
+        Example:
+            app.add_task_route('tasks.email.send', 'email_queue')
+            app.add_task_route('tasks.payment.*', 'payment_queue')
+        """
+        if queue not in self._queues:
+            raise ValueError(f"Queue '{queue}' does not exist. Create it first using create_queue()")
+
+        self._task_route_mapping[task_pattern] = queue
+
+        # Update Celery task routes
+        routes = self.conf.task_routes or {}
+        routes[task_pattern] = {"queue": queue}
+        self.conf.task_routes = routes
+
+        self.logger.info(f"Added route: {task_pattern} -> {queue}")
+
+    def task(self, *args, **opts):
+        """
+        Decorator modified to support sync and async functions
+        """
+        base_task = Celery.task.__get__(self)
+
+        def decorator(func):
+            is_async = asyncio.iscoroutinefunction(func)
+
+            if is_async:
+
+                @wraps(func)
+                async def async_wrapper(*fargs, **fkwargs):
+                    return await func(*fargs, **fkwargs)
+
+                @base_task(*args, **opts)
+                def wrapped(*fargs, **fkwargs):
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        return loop.run_until_complete(async_wrapper(*fargs, **fkwargs))
+                    finally:
+                        loop.close()
+
+                return wrapped
+            else:
+                return base_task(*args, **opts)(func)
+
+        return decorator
+
+    async def async_send_task(self, task_name: str, *args, **kwargs) -> AsyncResult:
+        """
+        Version of send_task() that is async
+        """
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self._executor, partial(self.send_task, task_name, args=args, kwargs=kwargs))
+
+    async def async_result(self, task_id: str) -> Dict:
+        """
+        Get the result of a task asynchronously
+        """
+        async_result = self.AsyncResult(task_id)
+        loop = asyncio.get_event_loop()
+
+        result = await loop.run_in_executor(
+            self._executor,
+            lambda: {
+                "task_id": task_id,
+                "status": async_result.status,
+                "result": async_result.result,
+                "traceback": async_result.traceback,
+                "date_done": async_result.date_done,
+            },
+        )
+        return result
+
+    def get_queue_length(self, queue_name: str) -> int:
+        """
+        Get the number of messages in a queue
+        """
+        with self.connection_or_acquire() as conn:
+            channel = conn.channel()
+            queue = Queue(queue_name, channel=channel)
+            return queue.queue_declare(passive=True).message_count
+
+    async def chain_tasks(self, tasks: list) -> AsyncResult:
+        """
+        Function to chain multiple tasks together
+        """
+        chain = tasks[0]
+        for task in tasks[1:]:
+            chain = chain | task
+        return await self.adelay_task(chain)
+
+    def register_task_middleware(self, middleware: Callable):
+        """
+        Register a middleware function to be called before each task
+        """
+
+        def task_middleware(task):
+            @wraps(task)
+            def _wrapped(*args, **kwargs):
+                return middleware(task, *args, **kwargs)
+
+            return _wrapped
+
+        self.task = task_middleware(self.task)
+
+    def monitor_task(self, task_id: str) -> dict:
+        """
+        Get monitoring data for a task
+        """
+        result = self.AsyncResult(task_id)
+        timing_info = self._task_timings.get(task_id, {})
+
+        monitoring_data = {
+            "task_id": task_id,
+            "status": result.status,
+            "start_time": timing_info.get("start"),
+            "duration": time.time() - timing_info["start"] if timing_info.get("start") else None,
+            "result": result.result if result.ready() else None,
+            "traceback": result.traceback,
+        }
+
+        return monitoring_data

hypern/ws/__init__.py

@@ -0,0 +1,4 @@
+from hypern.hypern import WebSocketSession
+from .route import WebsocketRoute
+
+__all__ = ["WebsocketRoute", "WebSocketSession"]

hypern/ws/channel.py

@@ -0,0 +1,80 @@
+from dataclasses import dataclass, field
+from typing import Any, Awaitable, Callable, Dict, Set
+
+from hypern.hypern import WebSocketSession
+
+
+@dataclass
+class Channel:
+    name: str
+    subscribers: Set[WebSocketSession] = field(default_factory=set)
+    handlers: Dict[str, Callable[[WebSocketSession, Any], Awaitable[None]]] = field(default_factory=dict)
+
+    def publish(self, event: str, data: Any, publisher: WebSocketSession = None):
+        """Publish an event to all subscribers except the publisher"""
+        for subscriber in self.subscribers:
+            if subscriber != publisher:
+                subscriber.send({"channel": self.name, "event": event, "data": data})
+
+    def handle_event(self, event: str, session: WebSocketSession, data: Any):
+        """Handle an event on this channel"""
+        if event in self.handlers:
+            self.handlers[event](session, data)
+
+    def add_subscriber(self, subscriber: WebSocketSession):
+        """Add a subscriber to the channel"""
+        self.subscribers.add(subscriber)
+
+    def remove_subscriber(self, subscriber: WebSocketSession):
+        """Remove a subscriber from the channel"""
+        self.subscribers.discard(subscriber)
+
+    def on(self, event: str):
+        """Decorator for registering event handlers"""
+
+        def decorator(handler: Callable[[WebSocketSession, Any], Awaitable[None]]):
+            self.handlers[event] = handler
+            return handler
+
+        return decorator
+
+
+class ChannelManager:
+    def __init__(self):
+        self.channels: Dict[str, Channel] = {}
+        self.client_channels: Dict[WebSocketSession, Set[str]] = {}
+
+    def create_channel(self, channel_name: str) -> Channel:
+        """Create a new channel if it doesn't exist"""
+        if channel_name not in self.channels:
+            self.channels[channel_name] = Channel(channel_name)
+        return self.channels[channel_name]
+
+    def get_channel(self, channel_name: str) -> Channel:
+        """Get a channel by name"""
+        return self.channels.get(channel_name)
+
+    def subscribe(self, client: WebSocketSession, channel_name: str):
+        """Subscribe a client to a channel"""
+        channel = self.create_channel(channel_name)
+        channel.add_subscriber(client)
+
+        if client not in self.client_channels:
+            self.client_channels[client] = set()
+        self.client_channels[client].add(channel_name)
+
+    def unsubscribe(self, client: WebSocketSession, channel_name: str):
+        """Unsubscribe a client from a channel"""
+        channel = self.get_channel(channel_name)
+        if channel:
+            channel.remove_subscriber(client)
+            if client in self.client_channels:
+                self.client_channels[client].discard(channel_name)
+
+    def unsubscribe_all(self, client: WebSocketSession):
+        """Unsubscribe a client from all channels"""
+        if client in self.client_channels:
+            channels = self.client_channels[client].copy()
+            for channel_name in channels:
+                self.unsubscribe(client, channel_name)
+            del self.client_channels[client]