hypern 0.3.7__cp310-cp310-win32.whl → 0.3.8__cp310-cp310-win32.whl

hypern/__init__.py

@@ -1,4 +1,24 @@
+from hypern.logging import logger
+from hypern.routing import HTTPEndpoint, QueuedHTTPEndpoint, Route
+from hypern.ws import WebsocketRoute, WebSocketSession
+
 from .application import Hypern
 from .hypern import Request, Response
+from .response import FileResponse, HTMLResponse, JSONResponse, PlainTextResponse, RedirectResponse
 
-__all__ = ["Hypern", "Request", "Response"]
+__all__ = [
+    "Hypern",
+    "Request",
+    "Response",
+    "Route",
+    "HTTPEndpoint",
+    "QueuedHTTPEndpoint",
+    "WebsocketRoute",
+    "WebSocketSession",
+    "FileResponse",
+    "HTMLResponse",
+    "JSONResponse",
+    "PlainTextResponse",
+    "RedirectResponse",
+    "logger",
+]

hypern/application.py

@@ -83,6 +83,14 @@ class Hypern:
                 """
             ),
         ] = None,
+        dependencies: Annotated[
+            dict[str, Any] | None,
+            Doc(
+                """
+                A dictionary of global dependencies that can be accessed by all routes.
+                """
+            ),
+        ] = None,
         title: Annotated[
             str,
             Doc(
@@ -209,22 +217,6 @@ class Hypern:
                 """
             ),
         ] = None,
-        default_injectables: Annotated[
-            dict[str, Any] | None,
-            Doc(
-                """
-                A dictionary of default injectables to be passed to all routes.
-                """
-            ),
-        ] = None,
-        auto_compression: Annotated[
-            bool,
-            Doc(
-                """
-                Enable automatic compression of responses.
-                """
-            ),
-        ] = False,
         database_config: Annotated[
             DatabaseConfig | None,
             Doc(
@@ -239,15 +231,14 @@ class Hypern:
         super().__init__(*args, **kwargs)
         self.router = Router(path="/")
         self.websocket_router = WebsocketRouter(path="/")
+        self.dependencies = dependencies or {}
         self.scheduler = scheduler
-        self.injectables = default_injectables or {}
         self.middleware_before_request = []
         self.middleware_after_request = []
         self.response_headers = {}
         self.args = ArgsConfig()
         self.start_up_handler = None
         self.shutdown_handler = None
-        self.auto_compression = auto_compression
         self.database_config = database_config
         self.thread_config = ThreadConfigurator().get_config()
 
@@ -255,7 +246,8 @@ class Hypern:
             self.router.extend_route(route(app=self).routes)
 
         for websocket_route in websockets or []:
-            self.websocket_router.add_route(websocket_route)
+            for route in websocket_route.routes:
+                self.websocket_router.add_route(route)
 
         if openapi_url and docs_url:
             self.__add_openapi(
@@ -313,6 +305,20 @@ class Hypern:
         self.add_route(HTTPMethod.GET, openapi_url, schema)
         self.add_route(HTTPMethod.GET, docs_url, template_render)
 
+    def inject(self, key: str, value: Any):
+        """
+        Injects a key-value pair into the injectables dictionary.
+
+        Args:
+            key (str): The key to be added to the injectables dictionary.
+            value (Any): The value to be associated with the key.
+
+        Returns:
+            self: Returns the instance of the class to allow method chaining.
+        """
+        self.dependencies[key] = value
+        return self
+
     def add_response_header(self, key: str, value: str):
         """
         Adds a response header to the response headers dictionary.
@@ -366,20 +372,6 @@ class Hypern:
 
         return decorator
 
-    def inject(self, key: str, value: Any):
-        """
-        Injects a key-value pair into the injectables dictionary.
-
-        Args:
-            key (str): The key to be added to the injectables dictionary.
-            value (Any): The value to be associated with the key.
-
-        Returns:
-            self: Returns the instance of the class to allow method chaining.
-        """
-        self.injectables[key] = value
-        return self
-
     def add_middleware(self, middleware: Middleware):
         """
         Adds middleware to the application.
@@ -429,12 +421,10 @@ class Hypern:
         server = Server()
         server.set_router(router=self.router)
         server.set_websocket_router(websocket_router=self.websocket_router)
-        server.set_injected(injected=self.injectables)
+        server.set_dependencies(dependencies=self.dependencies)
         server.set_before_hooks(hooks=self.middleware_before_request)
         server.set_after_hooks(hooks=self.middleware_after_request)
         server.set_response_headers(headers=self.response_headers)
-        server.set_auto_compression(enabled=self.auto_compression)
-        server.set_mem_pool_capacity(min_capacity=self.args.min_capacity, max_capacity=self.args.max_capacity)
 
         if self.database_config:
             server.set_database_config(config=self.database_config)

hypern/args_parser.py

@@ -49,35 +49,12 @@ class ArgsConfig:
             action="store_true",
             help="It restarts the server based on file changes.",
         )
-
-        parser.add_argument(
-            "--auto-compression",
-            action="store_true",
-            help="It compresses the response automatically.",
-        )
-
         parser.add_argument(
             "--auto-workers",
             action="store_true",
             help="It sets the number of workers and max-blocking-threads automatically.",
         )
 
-        parser.add_argument(
-            "--min-capacity",
-            type=int,
-            default=1,
-            required=False,
-            help="Choose the minimum memory pool capacity. [Default: 1]",
-        )
-
-        parser.add_argument(
-            "--max-capacity",
-            type=int,
-            default=100,
-            required=False,
-            help="Choose the maximum memory pool capacity. [Default: 100]",
-        )
-
         args, _ = parser.parse_known_args()
 
         self.host = args.host or "127.0.0.1"
@@ -86,7 +63,4 @@ class ArgsConfig:
         self.processes = args.processes or 1
         self.workers = args.workers or 1
         self.reload = args.reload or False
-        self.auto_compression = args.auto_compression
         self.auto_workers = args.auto_workers
-        self.min_capacity = args.min_capacity
-        self.max_capacity = args.max_capacity

hypern/datastructures.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from enum import Enum
-from pydantic import BaseModel, AnyUrl, EmailStr
+from pydantic import BaseModel, AnyUrl
 
 
 class BaseModelWithConfig(BaseModel):
@@ -10,7 +10,7 @@ class BaseModelWithConfig(BaseModel):
 class Contact(BaseModelWithConfig):
     name: Optional[str] = None
     url: Optional[AnyUrl] = None
-    email: Optional[EmailStr] = None
+    email: Optional[str] = None
 
 
 class License(BaseModelWithConfig):

hypern/hypern.pyi

@@ -181,16 +181,13 @@ class Server:
     def set_router(self, router: Router) -> None: ...
     def set_websocket_router(self, websocket_router: WebsocketRouter) -> None: ...
     def start(self, socket: SocketHeld, worker: int, max_blocking_threads: int) -> None: ...
-    def inject(self, key: str, value: Any) -> None: ...
-    def set_injected(self, injected: Dict[str, Any]) -> None: ...
     def set_before_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_after_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_response_headers(self, headers: Dict[str, str]) -> None: ...
     def set_startup_handler(self, on_startup: FunctionInfo) -> None: ...
     def set_shutdown_handler(self, on_shutdown: FunctionInfo) -> None: ...
-    def set_auto_compression(self, enabled: bool) -> None: ...
     def set_database_config(self, config: DatabaseConfig) -> None: ...
-    def set_mem_pool_capacity(self, min_capacity: int, max_capacity: int) -> None: ...
+    def set_dependencies(self, dependencies: Dict[str, Any]) -> None: ...
 
 class Route:
     path: str
@@ -278,7 +275,7 @@ class UploadedFile:
     path: str
     size: int
     content: bytes
-    filename: str
+    file_name: str
 
 @dataclass
 class BodyData:

hypern/worker.py

@@ -1,30 +1,274 @@
-# -*- coding: utf-8 -*-
-from typing import Any
+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 asgiref.sync import async_to_sync
+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)
 
-class AsyncCelery(Celery):
-    def __new__(cls, *args, **kwargs) -> Any:
-        if not hasattr(cls, "instance") or not cls.instance:  # type: ignore
-            cls.instance = super().__new__(cls)
-        return cls.instance
+    def register_task_middleware(self, middleware: Callable):
+        """
+        Register a middleware function to be called before each task
+        """
 
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.patch_task()
+        def task_middleware(task):
+            @wraps(task)
+            def _wrapped(*args, **kwargs):
+                return middleware(task, *args, **kwargs)
 
-    def patch_task(self) -> None:
-        TaskBase = self.Task
+            return _wrapped
 
-        class ContextTask(TaskBase):  # type: ignore
-            abstract = True
+        self.task = task_middleware(self.task)
 
-            def _run(self, *args, **kwargs):
-                result = async_to_sync(TaskBase.__call__)(self, *args, **kwargs)
-                return result
+    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, {})
 
-            def __call__(self, *args, **kwargs):
-                return self._run(*args, **kwargs)
+        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,
+        }
 
-        self.Task = ContextTask
+        return monitoring_data

{hypern-0.3.7.dist-info → hypern-0.3.8.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.7
+Version: 0.3.8
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: sqlalchemy[asyncio] ==2.0.31
-Requires-Dist: pydantic[email] ==2.8.2
 Requires-Dist: passlib ==1.7.4
 Requires-Dist: pyjwt ==2.8.0
 Requires-Dist: pydash ==8.0.3
@@ -38,7 +37,7 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
 Hypern: A Versatile Python and Rust Framework
 
-Hypern is a flexible, open-source framework built on the [Axum](https://github.com/tokio-rs/axum), designed to jumpstart your high-performance web development endeavors. By providing a pre-configured structure and essential components, Hypern empowers you to rapidly develop custom web applications that leverage the combined power of Python and Rust.
+Hypern is a flexible, open-source framework built on the [Rust](https://github.com/rust-lang/rust), designed to jumpstart your high-performance web development endeavors. By providing a pre-configured structure and essential components, Hypern empowers you to rapidly develop custom web applications that leverage the combined power of Python and Rust.
 
 With Hypern, you can seamlessly integrate asynchronous features and build scalable solutions for RESTful APIs and dynamic web applications. Its intuitive design and robust tooling allow developers to focus on creating high-quality code while maximizing performance. Embrace the synergy of Python and Rust to elevate your web development experience.
 
@@ -92,7 +91,7 @@ routing = [
 app = Hypern(routing)
 
 if __name__ == "__main__":
-    app.start(host='localhost', port=5005)
+    app.start()
 ```
 
 ```
@@ -100,6 +99,16 @@ $ python3 main.py
 ```
 You can open swagger UI at path `/docs` 
 
+## CLI
+
+    - host (str): The host address to bind to. Defaults to '127.0.0.1'.
+    - port (int): The port number to bind to. Defaults to 5000.
+    - processes (int): The number of processes to use. Defaults to 1.
+    - workers (int): The number of worker threads to use. Defaults to 1.
+    - max_blocking_threads (int): The maximum number of blocking threads. Defaults to 32.
+    - reload (bool): If True, the server will restart on file changes.
+    - auto_workers (bool): If True, sets the number of workers and max-blocking-threads automatically.
+
 
 ## 💡 Features
 
@@ -107,7 +116,7 @@ You can open swagger UI at path `/docs`
 - Rust-powered core with Python flexibility
 - Multi-process architecture for optimal CPU utilization
 - Async/await support for non-blocking operations
-- Built on top of production-ready Axum web framework
+- Built on top of production-ready Rust language
 
 ### 🛠 Development Experience
 - Type hints and IDE support
@@ -118,7 +127,7 @@ You can open swagger UI at path `/docs`
 ### 🔌 Integration & Extensions
 - Easy dependency injection
 - Middleware support (before/after request hooks)
-- WebSocket support (Comming soon)
+- WebSocket support
 - Background task scheduling
 - File upload handling
 

{hypern-0.3.7.dist-info → hypern-0.3.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
-hypern-0.3.7.dist-info/METADATA,sha256=Sxz9aJX0DPkYH0LaD6PqhN6FWpAd2nVrrm1Iu848bp8,3879
-hypern-0.3.7.dist-info/WHEEL,sha256=HVA0wOUnIw3WSu8DET4aOHFt1dH_siSsnV6db_YgIxE,92
-hypern-0.3.7.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
-hypern/application.py,sha256=DCYFtU8e8NhQtmfaXbUfOxR2_Y3fEn-pzce9OOs6S4U,18396
-hypern/args_parser.py,sha256=zTfLfBoKBvYWxdPjabTfZsCtYF3La3PT0TD8dfLMeM4,2815
+hypern-0.3.8.dist-info/METADATA,sha256=0bMLw-pA0VeoGBbQxXr4cqCO8dS6esga5NjluEeV5MY,4356
+hypern-0.3.8.dist-info/WHEEL,sha256=XP_v6cPyiD7wlS03U072x6RNAGBEEICE5-GLPV2ppFI,92
+hypern-0.3.8.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=07QGDd3w7tQRL8njfbNVinG6l8W7O0V-rN_SkO5O3B4,18002
+hypern/args_parser.py,sha256=BjGCooHdZjOpyN-AGL9PCKCKdzROVThE3dzQgC97rng,2035
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
@@ -37,7 +37,7 @@ hypern/database/sql/model.py,sha256=C8_rJA1Adw1yPWthjmAGh26hjTBuwwlEdtH45ADxvL0,
 hypern/database/sql/query.py,sha256=En19t27zt6iUDQbFgO_wLEWPQCkPeBuH3s37fzlhMVc,33345
 hypern/database/sql/__init__.py,sha256=dbSAz2nP0DPKK4Bb_jJdObSaSYQfgZ8D4U1TJdc4e7c,645
 hypern/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hypern/datastructures.py,sha256=zZGGSP07kPc9KJDf11hX5uYhAyRE-Ck5wezW5QtOVXw,897
+hypern/datastructures.py,sha256=Pxr9KsZZTFfp0KC1-A4v5AkQfmrUyvVwxKuToQUOLoE,882
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
 hypern/exceptions/base.py,sha256=5AgfyEea79JjKk5MeAIJ-wy44FG5XEU0Jn3KXKScPiI,2017
 hypern/exceptions/common.py,sha256=0E8wHRRTWjYOmtOCkTDvZ5NMwL6vRW6aiDD9X1eYA30,227
@@ -50,7 +50,7 @@ hypern/gateway/gateway.py,sha256=26K2qvJUR-0JnN4IlhwvSSt7EYcpYrBVDuzZ1ivQQ34,147
 hypern/gateway/proxy.py,sha256=w1wcTplDnVrfjn7hb0M0yBVth5TGl88irF-MUYHysQQ,2463
 hypern/gateway/service.py,sha256=PkRaM08olqM_j_4wRjEJCR8X8ZysAF2WOcfhWjaX2eo,1701
 hypern/gateway/__init__.py,sha256=TpFWtqnJerW1-jCWq5fjypJcw9Y6ytyrkvkzby1Eg0E,235
-hypern/hypern.pyi,sha256=f0kHWHI4creyAezdPlr-HOX87xqpCyYpu6cFGpbFCe4,9210
+hypern/hypern.pyi,sha256=Urc3uHhPupsN-RRYluyWiw8B_xYWzE91Og3Zft40NgU,9010
 hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/logging/logger.py,sha256=WACam_IJiCMXX0hGVKMGSxUQpY4DgAXy7M1dD3q-Z9s,3256
 hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
@@ -78,13 +78,12 @@ hypern/routing/route.py,sha256=kan47-UeL-OPwcpp0rEhmBaaum6hN7FUj13Y8pZDEYA,10256
 hypern/routing/__init__.py,sha256=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
 hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
 hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
-hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
+hypern/worker.py,sha256=ksJW8jWQg3HbIYnIZ5qdAmO-yh5hLpwvTT3dKkHR4Eo,9761
 hypern/ws/channel.py,sha256=0ns2qmeoFJOpGLXS_hqldhywDQm_DxHwj6KloQx4Q3I,3183
 hypern/ws/heartbeat.py,sha256=sWMXzQm6cbDHHA2NHc-gFjv7G_E56XtxswHQ93_BueM,2861
 hypern/ws/room.py,sha256=0_L6Nun0n007F0rfNY8yX5x_A8EuXuI67JqpMkJ4RNI,2598
 hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
 hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
-hypern/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
-hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp310-win32.pyd,sha256=wT6oVemqaafBCSwbuTmh-lBTrPH1Hqk89MCgPDFTogw,9790976
-hypern-0.3.7.dist-info/RECORD,,
+hypern/__init__.py,sha256=p3AtJQbsPs1RYEiN1thxH-k5UP8FfLeiJSoP0Vt3MDg,639
+hypern/hypern.cp310-win32.pyd,sha256=kqmyHdU5z2fDpxju2DwEyb_JEp7Wvz3o6e4XS_3QzvA,7576064
+hypern-0.3.8.dist-info/RECORD,,

{hypern-0.3.7.dist-info → hypern-0.3.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.7.8)
+Generator: maturin (1.8.1)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win32

hypern/ws.py

@@ -1,16 +0,0 @@
-from .hypern import WebsocketRoute as WebsocketRouteInternal, WebSocketSession
-
-
-class WebsocketRoute:
-    def __init__(self) -> None:
-        self.routes = []
-
-    def on(self, path):
-        def wrapper(func):
-            self.routes.append(WebsocketRouteInternal(path, func))
-            return func
-
-        return wrapper
-
-
-__all__ = ["WebsocketRoute", "WebSocketSession"]