hypern 0.3.0__cp310-cp310-win_amd64.whl

hypern/routing/parser.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+from __future__ import annotations
+
+import inspect
+import typing
+
+import orjson
+from pydantic import BaseModel, ValidationError
+from pydash import get
+
+from hypern.auth.authorization import Authorization
+from hypern.exceptions import BadRequest
+from hypern.exceptions import ValidationError as HypernValidationError
+from hypern.hypern import Request
+
+
+class ParamParser:
+    def __init__(self, request: Request):
+        self.request = request
+
+    def parse_data_by_name(self, param_name: str) -> dict:
+        param_name = param_name.lower()
+        data_parsers = {
+            "query_params": self._parse_query_params,
+            "path_params": self._parse_path_params,
+            "form_data": self._parse_form_data,
+        }
+
+        parser = data_parsers.get(param_name)
+        if not parser:
+            raise BadRequest(msg="Backend Error: Invalid parameter type, must be query_params, path_params or form_data.")
+        return parser()
+
+    def _parse_query_params(self) -> dict:
+        query_params = self.request.query_params.to_dict()
+        return {k: v[0] for k, v in query_params.items()}
+
+    def _parse_path_params(self) -> dict:
+        return lambda: dict(self.request.path_params.items())
+
+    def _parse_form_data(self) -> dict:
+        return self.request.json()
+
+
+class InputHandler:
+    def __init__(self, request):
+        self.request = request
+        self.param_parser = ParamParser(request)
+
+    async def parse_pydantic_model(self, param_name: str, model_class: typing.Type[BaseModel]) -> BaseModel:
+        try:
+            data = self.param_parser.parse_data_by_name(param_name)
+            return model_class(**data)
+        except ValidationError as e:
+            invalid_fields = orjson.loads(e.json())
+            raise HypernValidationError(
+                msg=orjson.dumps(
+                    [
+                        {
+                            "field": get(item, "loc")[0],
+                            "msg": get(item, "msg"),
+                        }
+                        for item in invalid_fields
+                    ]
+                ).decode("utf-8"),
+            )
+
+    async def handle_special_params(self, param_name: str) -> typing.Any:
+        special_params = {
+            "request": lambda: self.request,
+        }
+        return special_params.get(param_name, lambda: None)()
+
+    async def get_input_handler(self, signature: inspect.Signature, inject: typing.Dict[str, typing.Any]) -> typing.Dict[str, typing.Any]:
+        """
+        Parse the request data and return the kwargs for the handler
+        """
+        kwargs = {}
+
+        for param in signature.parameters.values():
+            name = param.name
+            ptype = param.annotation
+
+            # Handle Pydantic models
+            if isinstance(ptype, type) and issubclass(ptype, BaseModel):
+                kwargs[name] = await self.parse_pydantic_model(name, ptype)
+                continue
+
+            # Handle Authorization
+            if isinstance(ptype, type) and issubclass(ptype, Authorization):
+                kwargs[name] = await ptype().validate(self.request)
+                continue
+
+            # Handle special parameters
+            special_value = await self.handle_special_params(name)
+            if special_value is not None:
+                kwargs[name] = special_value
+            if name in inject:
+                kwargs[name] = inject[name]
+        return kwargs

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": 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 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/ws.py

@@ -0,0 +1,16 @@
+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"]

hypern-0.3.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: hypern
+Version: 0.3.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
+Requires-Dist: watchdog ==6.0.0
+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.3.0.dist-info/RECORD

@@ -0,0 +1,69 @@
+hypern-0.3.0.dist-info/METADATA,sha256=aG7HYARcYTZed6140LAyzlcSeZ189_4OOZIT0bqiOxE,3754
+hypern-0.3.0.dist-info/WHEEL,sha256=-9HWWVS-XCPZ6Ee3x-BEBZ1KoBrW-blQli_6xr491bE,96
+hypern-0.3.0.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=D8tye5rpOJzHGQHUelaDpjUL3B9xO40B7xAL9wC3Uno,14328
+hypern/args_parser.py,sha256=Crxzr8_uhiIk_AWJvuwJTEfRqEBqU_GfTbg6chg_YiY,1790
+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=b5Zjr9ipm43rI8eSUV4WYmKpIJWUsv6O2TrpvvbeTlE,7700
+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
+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=8hzUxu_mxra2QiDjAghgZtvwN6Dx07irPUiL12dbVhY,8152
+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=YW7Dg33Hla9D33x3Mf8xsjaTprHaovkLPK-4XnQKiGU,4045
+hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/reload.py,sha256=d28xP7MWiO2vL6RAAlIqSh8q7_ugsRBN66Mlbz3UWEI,2293
+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=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
+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/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
+hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
+hypern/hypern.cp310-win_amd64.pyd,sha256=eTZS9C_KGtOgKFir2Fb3OSe_32Pt-9cxB66Qvly2EWg,6267392
+hypern-0.3.0.dist-info/RECORD,,

hypern-0.3.0.dist-info/WHEEL

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