hypern 0.3.6__cp312-cp312-win32.whl → 0.3.8__cp312-cp312-win32.whl

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.6.dist-info → hypern-0.3.8.dist-info}/METADATA

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.6
+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
@@ -26,6 +25,7 @@ Requires-Dist: watchdog ==6.0.0
 Requires-Dist: jsonschema ==4.23.0
 Requires-Dist: psutil ==6.1.0
 Requires-Dist: msgpack ==1.1.0
+Requires-Dist: redis ==5.2.1
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>
@@ -37,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.
 
@@ -91,7 +91,7 @@ routing = [
 app = Hypern(routing)
 
 if __name__ == "__main__":
-    app.start(host='localhost', port=5005)
+    app.start()
 ```
 
 ```
@@ -99,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
 
@@ -106,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
@@ -117,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.6.dist-info → hypern-0.3.8.dist-info}/RECORD

@@ -1,8 +1,8 @@
-hypern-0.3.6.dist-info/METADATA,sha256=NZSUrAbL7D7aleTF03qoRJiO2r8cQ7OQdwYlPu9hRoM,3850
-hypern-0.3.6.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
-hypern-0.3.6.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=19xj5Waw2omQTyAh5Pnrm7rXeZkfzX1OuBYghlKYN-I,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
@@ -31,12 +31,13 @@ hypern/database/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZ
 hypern/database/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
 hypern/database/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
 hypern/database/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
-hypern/database/sql/field.py,sha256=tSs8iaYjy-K6nplJJ-1X4OQddzW76cfBlx9xTrG_NbQ,20073
-hypern/database/sql/model.py,sha256=BLRmOlmfn6ibedR9Bv_rHErSruudJ24B9-nDbRHqWm4,3913
-hypern/database/sql/query.py,sha256=tQ7Wss2NAIqsAH0M-fT5m9DU_MsiBR0DcoyTbS_aatU,33335
-hypern/database/sql/__init__.py,sha256=lCOGNTHaXNSJbuLLIOe2IWWNmX0MFQFPNCl2yytD2Xs,261
+hypern/database/sql/field.py,sha256=gV9u_BvMIoxoDT3_J7sL5XJNa5XFsAO9w324ThwHbNs,9121
+hypern/database/sql/migrate.py,sha256=BTtAs3-iMyMDzIWl6B3rM9sj7XGggLDRjD0h_WgGPtc,9742
+hypern/database/sql/model.py,sha256=C8_rJA1Adw1yPWthjmAGh26hjTBuwwlEdtH45ADxvL0,4044
+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
@@ -49,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=yXaWGPt598gwPN-CT1ARDdwOSqryZCBFuDLQC8gRd1U,9345
+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
@@ -61,7 +62,7 @@ hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
 hypern/middleware/limit.py,sha256=eAYARPjqxq8Ue0TCpnxlVRB5hv7hwBF0PxeD-bG6Sl0,8252
 hypern/middleware/security.py,sha256=fGBSF7n2iKBtDHE2QW4q_sQE4awYgaYxVUFKsDHkMXg,7675
 hypern/middleware/__init__.py,sha256=V-Gnv-Jf-14BVuA28z7PN7GBVQ9BBiBdab6-QnTPCfY,493
-hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
+hypern/openapi/schemas.py,sha256=hsqSPpwsOETQ5NoGiR9Ay0qEp6GxJ2xhh69rzwxx0CY,1598
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
 hypern/processpool.py,sha256=qEsu9WXWc3_Cl0Frn1jGs7jUJho45zck5L5Ww81Vm70,3883
@@ -73,17 +74,16 @@ hypern/routing/dispatcher.py,sha256=NAVjILlEJjYrixJZ4CO4N1CKkuqbk4TGZOjnQNTTEu4,
 hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
 hypern/routing/parser.py,sha256=0tJVVNwHC3pWDsehwH6SwJv8_gEuDjltVXrNQWbHyrU,3426
 hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
-hypern/routing/route.py,sha256=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
+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.cp312-win32.pyd,sha256=UEZnqNJkk-53t73JL5FWC2oDcmxOUmLAT8rc1R0E4DI,9796096
-hypern-0.3.6.dist-info/RECORD,,
+hypern/__init__.py,sha256=p3AtJQbsPs1RYEiN1thxH-k5UP8FfLeiJSoP0Vt3MDg,639
+hypern/hypern.cp312-win32.pyd,sha256=rvh5yYWRidA1p4JK6cneYi7yjaJ8okvTNHUIpwn6c9k,7591936
+hypern-0.3.8.dist-info/RECORD,,

{hypern-0.3.6.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: cp312-cp312-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"]