hypern 0.1.0__cp310-cp310-manylinux_2_34_x86_64.whl

hypern/routing/router.py

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*-
+from typing import Callable, Any, Dict, List, Union, Type, get_origin, get_args
+from robyn.router import Router as RobynRouter
+from robyn import HttpMethod, Request
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+from enum import Enum
+
+import inspect
+import yaml  # type: ignore
+
+from hypern.auth.authorization import Authorization
+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]}
+
+    @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 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}
+        _response_type = signature.return_annotation
+
+        for key, item in _inputs_dict.items():
+            if isinstance(item, type) and issubclass(item, Authorization):
+                auth_obj = item()
+                _docs["security"] = [{auth_obj.name: []}]
+
+            if isinstance(item, type) and issubclass(item, BaseModel):
+                if key == "form_data":
+                    _docs["requestBody"] = {"content": {"application/json": {"schema": pydantic_to_swagger(item).get(item.__name__)}}}
+
+                if key == "query_params":
+                    _docs["parameters"] = [{"name": param, "in": "query", "schema": _process_field(param, field)} for param, field in item.model_fields.items()]
+
+                if 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)
+
+        if isinstance(_response_type, type) and issubclass(_response_type, BaseModel):
+            _docs["responses"] = {
+                "200": {
+                    "description": "Successful response",
+                    # type: ignore
+                    "content": {"application/json": {"schema": _response_type.model_json_schema()}},
+                }
+            }
+
+        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 __call__(self, app, *args: Any, **kwds: Any) -> Any:
+        router = RobynRouter()
+
+        # Validate handlers
+        if not self.endpoint and not self.functional_handlers:
+            raise ValueError(f"No handler found for route: {self.path}")
+
+        default_params = {"is_const": False, "injected_dependencies": app.dependencies.get_dependency_map(app), "exception_handler": app.exception_handler}
+
+        # Handle functional routes
+        for h in self.functional_handlers:
+            router.add_route(
+                route_type=self.http_methods[h["method"].upper()], endpoint=self._combine_path(self.path, h["path"]), handler=h["func"], **default_params
+            )
+
+        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_type=self.http_methods[name.upper()], endpoint=self.path, handler=endpoint_obj.dispatch, **default_params)
+                del endpoint_obj  # free up memory
+
+        return router
+
+    def route(
+        self,
+        path: str,
+        method: str,
+        *args: Any,
+        **kwds: Any,
+    ) -> Callable:
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            async def functional_wrapper(request: Request, global_dependencies, router_dependencies) -> Any:
+                return await dispatch(func, request, global_dependencies, router_dependencies)
+
+            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.route(path, "GET")
+
+    def post(self, path: str) -> Callable:
+        return self.route(path, "POST")
+
+    def put(self, path: str) -> Callable:
+        return self.route(path, "PUT")
+
+    def delete(self, path: str) -> Callable:
+        return self.route(path, "DELETE")
+
+    def patch(self, path: str) -> Callable:
+        return self.route(path, "PATCH")
+
+    def head(self, path: str) -> Callable:
+        return self.route(path, "HEAD")
+
+    def options(self, path: str) -> Callable:
+        return self.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.1.0.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.3
+Name: hypern
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: robyn ==0.58.0
+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
+License-File: LICENSE
+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 [Robyn](https://github.com/sparckles/Robyn/), 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 Robyn Rust package
+```
+maturin develop
+```
+
+## 🤔 Usage
+
+### 🏃 Run your code
+
+This using default CLI Robyn, you can see bellow. 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, global_dependencies):
+        return {"data": "Hello World"}
+
+routing = [
+    Route("/hello", MyEndpoint)
+]
+
+app = Hypern(routing)
+
+if __name__ == "__main__":
+    app.start(host='localhost', port=5005)
+```
+
+```
+$ python3 main.py
+```
+
+To see the usage
+
+```
+usage: main.py [-h] [--processes PROCESSES] [--workers WORKERS] [--dev] [--log-level LOG_LEVEL]
+
+options:
+  -h, --help                show this help message and exit
+  --processes PROCESSES     Choose the number of processes. [Default: 1]
+  --workers WORKERS         Choose the number of workers. [Default: 1]
+  --dev                     Development mode. It restarts the server based on file changes.
+  --log-level LOG_LEVEL     Set the log level name
+  --create                  Create a new project template.
+  --docs                    Open the Robyn documentation.
+  --open-browser            Open the browser on successful start.
+```
+
+Log level can be `DEBUG`, `INFO`, `WARNING`, or `ERROR`.
+
+You can open swagger UI at path `/docs` 
+
+
+## 💡 Features
+
+Comming Soon !
+
+
+## ✨ Special thanks
+
+Special thanks to the [PyO3](https://pyo3.rs/v0.13.2/) community and [Robyn](https://github.com/sparckles/Robyn) for their amazing libraries 💖
+

hypern-0.1.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+hypern-0.1.0.dist-info/METADATA,sha256=NidC7S9N8WeFH-YSl2_KK9bhXkkFQVLHYBTMWvpxKi4,3540
+hypern-0.1.0.dist-info/WHEEL,sha256=Eon-X1H-_QAARJHJrle01PrnTNoTi49kSjaP6kGdlhU,108
+hypern-0.1.0.dist-info/licenses/LICENSE,sha256=VdbaK2hSaaD-LUjtDIlEbeZVmvLGK7BEQvltP3mv-cY,1304
+hypern/middleware/cors.py,sha256=SfG-3vAS-4MPXqsIsegNwDx9mqC9lvgUc3RuYzN6HNg,1643
+hypern/middleware/base.py,sha256=zqUU85jkPNXOXC4JPXGwkJ7BwjafqI8dq3aajoCUQV0,345
+hypern/middleware/__init__.py,sha256=YpgxL7GQkzZM91VCNxHT2xmTa1R1b_BUS8n3tZ2b1Ys,268
+hypern/middleware/i18n.py,sha256=s82nQo6kKClZ0s3G3jsy87VRfwxpBDbASB_ErjRL3O0,15
+hypern/middleware/limit.py,sha256=3Kp1amDd3s27shHQPPgRMtYM5LFmSGccEWVzT9ajXI4,7962
+hypern/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/hypern.pyi,sha256=buOBdrrDel8PpkS6Fz0idBoOYuK8FYy2eo0nTlIyWL0,4191
+hypern/scheduler.py,sha256=nQoWIYMRmKd30g4XwdB072hWTNHvJlLd9S6rLlTFKS0,62
+hypern/application.py,sha256=KcINmggRIPmKUfbpRA7_dQ_8RG7qRA83VvyfrDmcXgc,7731
+hypern/openapi/swagger.py,sha256=E5fHYUfFa77zQsCyQGf_vnqJVpl4_KI5qsKFHdgJEdw,61
+hypern/openapi/__init__.py,sha256=oJ0HM9yAgSN00mBC_fRgV2irlGugrhvIpiveuDMv8PM,136
+hypern/openapi/schemas.py,sha256=d4AQUkDdw9AO4vUfUU0bckDh6KMCyGJYGW_u_PIOtew,2083
+hypern/background.py,sha256=fN38UlJG6wZf1gOGcvdY-INoD8zJKvGZZOdVYTMjDwg,120
+hypern/datastructures.py,sha256=MitMRsvoWz3_SJvtbkcaJ-FovaLrRhmkp5MqSMfZPjs,631
+hypern/response/__init__.py,sha256=9z99BDgASpG404GK8LGkOsXgac0wFwH_cQOTI5Ju-1U,223
+hypern/response/response.py,sha256=akOqPDOi4J0g9jxsoZ1Za2ErcSA9eZFy2Fg5Wn38sIU,4436
+hypern/logging/__init__.py,sha256=2K5q9ECE8HYVLnYbrzrzu6Bg2C5MiROD9KH835ujMUU,79
+hypern/logging/logger.py,sha256=1XVzlNoYEVDWQ20csClCkweEdKcNZWk-o63qfcVTLFI,3235
+hypern/db/sql/addons/unicode.py,sha256=gvsWvt0gTEwy62U4l6yDQjEXfc982QAaVay3YfxD3do,396
+hypern/db/sql/addons/datetime.py,sha256=vZEV0s8M6VlsV9DDcEsCFIwoEAi_vNGY5HGFGULc0H0,621
+hypern/db/sql/addons/color.py,sha256=1fHRVrqekip5u9nc7yv53niYnePmCdeYOr2gGVrXVzE,463
+hypern/db/sql/addons/daterange.py,sha256=MUgAFHBt-iqY0sTU4sJYzvVFANlD1WFokCabhuodFCg,829
+hypern/db/sql/addons/encrypted.py,sha256=hAzGaN_dXwlgYbC2_OsiHOxKh7PRX8gbM1_nnIF7M-w,1872
+hypern/db/sql/addons/ts_vector.py,sha256=xmh-iLLGG5uW4QL_cnONdQd5rEfYZpNXaX_rW2kBrZU,1315
+hypern/db/sql/addons/__init__.py,sha256=gZpp75nCNZHx9VDw5aNEmJzlpvVKv7Tulp40-Z7-ULM,345
+hypern/db/sql/addons/password.py,sha256=mPwD17_0Fk0l378wdNP_BGojbC9EGPoZE94nCPTNy80,5617
+hypern/db/sql/__init__.py,sha256=WnUiXBO2YV5f8q4gtu23opuu6vf4ZuMw-Inv2pqaE8Y,6314
+hypern/db/sql/repository.py,sha256=SeSHKfO2cdd65dKBB5tP9-ORPsjGHbPEDWH3GYhdERY,9225
+hypern/db/nosql/addons/unicode.py,sha256=vKyqfzrS9SKFo4eKlvu6klST0FrjM0wTx5N3ocvSSO8,258
+hypern/db/nosql/addons/color.py,sha256=8zUBFjR19J1zy_WaOCXlS14GjgdOaHAcuSb__zFp_II,430
+hypern/db/nosql/addons/daterange.py,sha256=YJBVfiX13Wx8DZociajWLBm20L_c0ZxTUbgCYMNk10Q,1162
+hypern/db/nosql/addons/encrypted.py,sha256=bbJozZfcsWvumqHYOrN1Y8XrwRZqaR-z__u11GEmIv4,1688
+hypern/db/nosql/addons/__init__.py,sha256=h6wJKPvCqyvivD52L7qsbFKnqqUnAdU1RQ30spnki98,121
+hypern/db/nosql/addons/password.py,sha256=kbqQRzT5uq9IQ4Z_eE69cVo1rHTiovhtG3I0l5AZmMk,4901
+hypern/db/nosql/__init__.py,sha256=LCVBhcJCQmFt5dCLiSf7C_TsjsEILeZe8JqiFEKuD2s,619
+hypern/db/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/i18n/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/routing/parser.py,sha256=tRGxlkLDAvavtf3sWNEbezkZki2yxtDlOuuR-6pmptU,3691
+hypern/routing/endpoint.py,sha256=bT8Dl0kaWIGOKzt-3J_gkBykZ2TDBefJq9dUt1yIGK8,1009
+hypern/routing/router.py,sha256=pf1oBvCjLP10kWwUv_EBz1D8X6HncJcm8FGu9OfG-l0,9776
+hypern/routing/dispatcher.py,sha256=o5H2qa_8iOui98gs1J9G6ZhJdHgB6kqvypa0iSZUho0,2329
+hypern/routing/__init__.py,sha256=inI2G6oZTnf8__0avz2f47M5_Cf-4oWN1sbyaARtcEg,98
+hypern/enum.py,sha256=-StRU0cWboP-y5fNuhB4Q7yMk8Zm_h1Eua9KzOtIyI8,347
+hypern/security.py,sha256=dOWdNHA8SoUhlbu6Z2MapOwT9tAhlsierrTBBiEV5-A,1729
+hypern/__init__.py,sha256=3fOyAFU6K9AusoP7UXeUGnHP3jPde5p6CZjtwJi3xHI,133
+hypern/caching/cache_tag.py,sha256=DpkhFeKvcPT0zJlIWq5ywkYM8zRWGJ_grYIVZmHj-Js,257
+hypern/caching/custom_key_maker.py,sha256=DxJv1RV--5IdFCCFYawVExwMQ097hZ5V6_nHDYIQIZI,383
+hypern/caching/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/caching/base/backend.py,sha256=RHOq9Y_FzTlYHKpTqAPxUYdJDOSYBXx-mxaDitYtP70,65
+hypern/caching/base/key_maker.py,sha256=FPW9L-N8NSPPgRngqMUCOdLurm1qmqe-KTe4UctoBp8,224
+hypern/caching/base/__init__.py,sha256=8S6QSax1FVGzfve_fYIzPmhrpvxXG8WYoc7M9v25b6Q,147
+hypern/caching/redis_backend.py,sha256=3FYzKCW0_OvoIMl-e9pARRGOUvRYGG7hGlaXEB18vnY,67
+hypern/caching/cache_manager.py,sha256=EBx89xNj38bYpQ9jf4MoQ3zNkfoCGYInxvvPtzsW5Xo,1997
+hypern/worker.py,sha256=kN93QGx4bst0inHRO_fsTzMmhDA0N3pdzaqNXwyu3N0,894
+hypern/config.py,sha256=v9KLL6snReAETKiVb8x3KOFrXpYd8-Io5tM7eruR85U,4781
+hypern/auth/authorization.py,sha256=b8N_MiBmSJBVR45SsOI2iMGmXYOlNKbsMsrMwXApxtk,30
+hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/exceptions.py,sha256=NJ19MXix0g9ueSkYA-ImghDiva7oAdmbtNEaiSCVLZo,2284
+hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hypern/hypern.cpython-310-x86_64-linux-gnu.so,sha256=44C4si9vfQfpf6rF4OtotP-8MvcMCt9AgAf7tzPliLQ,4911472
+hypern-0.1.0.dist-info/RECORD,,

hypern-0.1.0.dist-info/WHEEL

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

hypern-0.1.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.