hypern 0.2.0__cp312-none-win_amd64.whl

hypern/routing/route.py

@@ -0,0 +1,284 @@
+# -*- 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": response_type.model_json_schema()}},
+                }
+            }
+
+    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 h in self.functional_handlers:
+            router.add_route(route=self.make_internal_route(path=h["path"], handler=h["func"], method=h["method"].upper()))
+        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__)
+                self.endpoint.dispatch.__doc__ = doc
+                endpoint_obj = self.endpoint()
+                router.add_route(route=self.make_internal_route(path="/", handler=endpoint_obj.dispatch, method=name.upper()))
+                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)
+            functional_wrapper.__doc__ = self.swagger_generate(sig, func.__doc__)
+
+            self.functional_handlers.append(
+                {
+                    "path": path,
+                    "method": method,
+                    "func": functional_wrapper,
+                }
+            )
+
+        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/security.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.backends import default_backend
+from base64 import b64encode, b64decode
+
+import typing
+
+
+class EDEngine(ABC):
+    @abstractmethod
+    def encrypt(self, data: str) -> str:
+        raise NotImplementedError("Method not implemented")
+
+    @abstractmethod
+    def decrypt(self, data: str) -> str:
+        raise NotImplementedError("Method not implemented")
+
+
+class AESEngine(EDEngine):
+    def __init__(self, secret_key: bytes, iv: bytes, padding_class: typing.Type) -> None:
+        super().__init__()
+        self.secret_key = secret_key
+        self.iv = iv
+        self.padding = padding_class(128)
+
+    def encrypt(self, data: str) -> bytes:
+        bytes_data = data.encode("utf-8")
+        encryptor = Cipher(algorithms.AES(self.secret_key), modes.GCM(self.iv), backend=default_backend()).encryptor()
+        padder = self.padding.padder()
+        padded_data = padder.update(bytes_data) + padder.finalize()
+        enctyped_data = encryptor.update(padded_data) + encryptor.finalize()
+        tag = encryptor.tag
+        return b64encode(tag + enctyped_data)
+
+    def decrypt(self, data: bytes) -> str:
+        data = b64decode(data)
+        tag = data[:16]
+        encrypted_data = data[16:]
+        decryptor = Cipher(algorithms.AES(self.secret_key), modes.GCM(self.iv, tag), backend=default_backend()).decryptor()
+        unpadder = self.padding.unpadder()
+        decrypted_data = decryptor.update(encrypted_data) + decryptor.finalize()
+        unpadded_data = unpadder.update(decrypted_data) + unpadder.finalize()
+        return unpadded_data.decode("utf-8")

hypern/worker.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+from typing import Any
+from celery import Celery
+from asgiref.sync import async_to_sync
+
+
+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 __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.patch_task()
+
+    def patch_task(self) -> None:
+        TaskBase = self.Task
+
+        class ContextTask(TaskBase):  # type: ignore
+            abstract = True
+
+            def _run(self, *args, **kwargs):
+                result = async_to_sync(TaskBase.__call__)(self, *args, **kwargs)
+                return result
+
+            def __call__(self, *args, **kwargs):
+                return self._run(*args, **kwargs)
+
+        self.Task = ContextTask

hypern-0.2.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.3
+Name: hypern
+Version: 0.2.0
+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
+Requires-Dist: sentry-sdk ==2.11.0
+Requires-Dist: pydantic-settings ==2.3.4
+Requires-Dist: celery ==5.4.0
+Requires-Dist: asgiref ==3.8.1
+Requires-Dist: psycopg ==3.2.3
+Requires-Dist: pyyaml ==6.0.2
+Requires-Dist: mongoengine ==0.29.1
+Requires-Dist: argon2-cffi ==23.1.0
+Requires-Dist: bcrypt ==4.2.0
+Requires-Dist: orjson ==3.10.11
+Requires-Dist: multiprocess ==0.70.17
+Requires-Dist: uvloop ==0.21.0 ; sys_platform != 'win32' and platform_python_implementation == 'CPython' and platform_machine != 'armv7l'
+Requires-Dist: cryptography ==43.0.3
+License-File: LICENSE
+Summary: A Fast Async Python backend with a Rust runtime.
+Author-email: Martin Dang <vannghiem848@gmail.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+
+# Hypern
+
+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.
+
+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.
+
+
+### 🏁 Get started
+
+### ⚙️ To Develop Locally
+
+- Setup a virtual environment:
+```
+python3 -m venv venv
+source venv/bin/activate
+```
+- Install required packages
+
+```
+pip install pre-commit poetry maturin
+```
+- Install development dependencies
+```
+poetry install --with dev --with test
+```
+- Install pre-commit git hooks
+```
+pre-commit install
+```
+- Build & install Rust package
+```
+maturin develop
+```
+
+## 🤔 Usage
+
+### 🏃 Run your code
+
+You will then have access to a server on the `localhost:5005`,
+```python
+# main.py
+from hypern import Hypern
+from hypern.routing import Route, HTTPEndpoint
+
+class MyEndpoint(HTTPEndpoint):
+    
+    async def get(self, request):
+        return {"data": "Hello World"}
+
+routing = [
+    Route("/hello", MyEndpoint)
+]
+
+app = Hypern(routing)
+
+if __name__ == "__main__":
+    app.start(host='localhost', port=5005)
+```
+
+```
+$ python3 main.py
+```
+You can open swagger UI at path `/docs` 
+
+
+## 💡 Features
+
+### ⚡ High Performance
+- 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
+
+### 🛠 Development Experience
+- Type hints and IDE support
+- Built-in Swagger/OpenAPI documentation
+- Hot reload during development
+- Comprehensive error handling and logging
+
+### 🔌 Integration & Extensions
+- Easy dependency injection
+- Middleware support (before/after request hooks)
+- WebSocket support (Comming soon)
+- Background task scheduling
+- File upload handling
+
+### 🔒 Security
+- Built-in authentication/authorization (Comming soon)
+- CORS configuration
+- Rate limiting
+- Request validation
+
+
+

hypern-0.2.0.dist-info/RECORD

@@ -0,0 +1,66 @@
+hypern-0.2.0.dist-info/METADATA,sha256=0dwMDftVhFSbT6b6f41rTkO-2VTmxvLyUNBgblWBXc0,3722
+hypern-0.2.0.dist-info/WHEEL,sha256=VGMDu5jnp_XpyXOq-L1-cbr3x9_PzCpsKi1udyLAeSI,95
+hypern-0.2.0.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=W_eltIwV2WcTaAQonxstMebGGgvMkIujowNvLYTX0nc,15183
+hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
+hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
+hypern/caching/base/backend.py,sha256=nHl5_nH95LSYWBS9RmOvOzsps_p19HcnQsb4h4W7cP8,68
+hypern/caching/base/key_maker.py,sha256=-W1r3ywfQ-K6saniiK3aTMaW3iy3aXai2pvQqM8f74I,232
+hypern/caching/base/__init__.py,sha256=M-B56YGTkSwCkKW_I6GcV1LSIFfxZ6KuXowB1_aJQpQ,155
+hypern/caching/cache_manager.py,sha256=TF6UosJ54950JgsrPVZUS3MH2R8zafAu5PTryNJ0sRs,2053
+hypern/caching/cache_tag.py,sha256=bZcjivMNETAzAHAIobuLN0S2wHgPgLLL8Gg4uso_qbk,267
+hypern/caching/custom_key_maker.py,sha256=88RIIJjpQYFnv857wOlCKgWWBbK_S23zNHsIrJz_4PY,394
+hypern/caching/redis_backend.py,sha256=IgQToCnHYGpKEErq2CNZkR5woo01z456Ef3C-XRPRV8,70
+hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/config.py,sha256=frZSdXBI8GaM0tkw1Rs-XydZ9-XjGLRPj6DL4d51-y4,4930
+hypern/datastructures.py,sha256=zZGGSP07kPc9KJDf11hX5uYhAyRE-Ck5wezW5QtOVXw,897
+hypern/db/nosql/addons/color.py,sha256=bAGRuARCAYwZ1nO4jK0lzGYKmavTDtS34BxvrsetF74,446
+hypern/db/nosql/addons/daterange.py,sha256=hGUSoVFqatNY-TB5wjZTq62iZpHpdsyRJIsHxsj1uDs,1192
+hypern/db/nosql/addons/encrypted.py,sha256=B0M-uDqvZHVmIZcFdwcuC2MGsv0pGJFQ1lrOg8klR9U,1741
+hypern/db/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZj9WT14n7dKE,5035
+hypern/db/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
+hypern/db/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
+hypern/db/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
+hypern/db/sql/addons/color.py,sha256=Jj8q4lkT0ukKyjVyZjBx7fokGrX7AIJpKOGzwsBpfnU,480
+hypern/db/sql/addons/daterange.py,sha256=qEfQN9c4jQdzeXNYKgQ4VIJ3Qc0HXHWRouzNF1se-RA,853
+hypern/db/sql/addons/datetime.py,sha256=Bp2jMja2lb_b2WnzRnfbjXXTHBgBTyph1ECsItIwvvg,643
+hypern/db/sql/addons/encrypted.py,sha256=pXsg4ImPpK-VkLDruKrv2gUtdp2kajQX7xDbRDxa-SI,1930
+hypern/db/sql/addons/password.py,sha256=9pypORygWaINj3oiAOBRIOGgpuA0lcjPq4rh1pqJxq0,5789
+hypern/db/sql/addons/ts_vector.py,sha256=bQyXYvQ1bAfFpYcS-sFwM7fU6L1lg9_7nGDRGp0CoUo,1361
+hypern/db/sql/addons/unicode.py,sha256=rbqyHlsPUqRDWIjYQSRFF3zkHncnwxo0sdlzqUlcrUw,411
+hypern/db/sql/addons/__init__.py,sha256=mLN_AvwgpSAbrWZvVHZuO7ff0gk1T_JbVwd5wug5nlw,359
+hypern/db/sql/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
+hypern/db/sql/__init__.py,sha256=1UoWQi2CIcUAbQj3FadR-8V0o_b286nI2wYvOsvtbFc,6478
+hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
+hypern/exceptions.py,sha256=nHTkF0YdNBMKfSiNtjRMHMNKoY3RMUm68YYluuW15us,2428
+hypern/hypern.pyi,sha256=PsoQ-UV3q_xJs0BsW3In8gVWJjmqrffCY4xTC0hSDfk,6915
+hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/logging/logger.py,sha256=ebLT-DX5OOt1UqP2OajFTm4I9tL6RSBN_GbJEKe4UI4,3256
+hypern/logging/__init__.py,sha256=6eVriyncsJ4J73fGYhoejv9MX7aGTkRezTpPxO4DX1I,52
+hypern/middleware/base.py,sha256=mJoz-i-7lqw1eDxZ8Bb0t8sz60lx5TE-OjZT4UR75e4,541
+hypern/middleware/cors.py,sha256=x90DnCOJSfp4ojm1krttn_EdtlqeDazyUzVg66NES4A,1681
+hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
+hypern/middleware/limit.py,sha256=S2abCkQb3yGEQlXZ8azGIlpzTmE8eS6gt-c546IC9_c,8148
+hypern/middleware/__init__.py,sha256=lXwR3fdmpVK4Z7QWaLsgf3Sazy5NPPFXIOxIEv1xDC8,273
+hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
+hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
+hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
+hypern/processpool.py,sha256=_vtC9mmEisfDWuSH9prvgaipbHdP5tszPWEwqsxQGo4,3031
+hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/response/response.py,sha256=-dnboAraPic8asf503PxwmDuxhNllUO5h97_DGmbER4,4582
+hypern/response/__init__.py,sha256=_w3u3TDNuYx5ejnnN1unqnTY8NlBgUATQi6wepEB_FQ,226
+hypern/routing/dispatcher.py,sha256=i2wLAAW1ZXgpi5K2heGXhTODnP1WdQzaR5WlUjs1o9c,2368
+hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
+hypern/routing/parser.py,sha256=R-4lcN9Ha1iMeAjlqDe8HwkjjMVG-c-ubQLZyWKXj6M,3554
+hypern/routing/route.py,sha256=tW6orvfWz9O1XDWD295IuovALa4rBd4zwTsRwWaMZJk,10374
+hypern/routing/__init__.py,sha256=7rw7EAxougCXtmkgJjrmLP3N5RXctIpI_3JmG9FcKVU,101
+hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
+hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
+hypern/worker.py,sha256=WQrhY_awR6zjMwY4Q7izXi4E4fFrDqt7jIblUW8Bzcg,924
+hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
+hypern/hypern.cp312-win_amd64.pyd,sha256=tW0O9hPiYkkNB-ev14wiefs0CIvcZHVnmUbkOEUywYo,6056960
+hypern-0.2.0.dist-info/RECORD,,

hypern-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.7.4)
+Root-Is-Purelib: false
+Tag: cp312-none-win_amd64

hypern-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+BSD 2-Clause License
+
+Copyright (c) 2024, Dang Van Nghiem
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.