hypern 0.1.0__cp310-cp310-manylinux_2_34_x86_64.whl

hypern/__init__.py

@@ -0,0 +1,4 @@
+from .application import Hypern
+from robyn import Response, Request, jsonify
+
+__all__ = ["Hypern", "Response", "Request", "jsonify"]

hypern/application.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+from typing import Any, List, TypeVar
+from typing_extensions import Annotated, Doc
+from robyn import Robyn
+import orjson
+
+from hypern.openapi import SwaggerUI, SchemaGenerator
+from hypern.routing import Route
+from hypern.response import JSONResponse
+from hypern.logging import reset_logger
+from hypern.datastructures import Contact, License, Info
+from hypern.scheduler import Scheduler
+
+reset_logger()
+
+AppType = TypeVar("AppType", bound="Hypern")
+
+
+class Hypern(Robyn):
+    def __init__(
+        self: AppType,
+        routes: Annotated[
+            List[Route] | None,
+            Doc(
+                """
+                A list of routes to serve incoming HTTP and WebSocket requests.
+                You can define routes using the `Route` class from `Hypern.routing`.
+                **Example**
+                ---
+                ```python
+                class DefaultRoute(HTTPEndpoint):
+                    async def get(self, global_dependencies):
+                        return PlainTextResponse("/hello")
+                Route("/test", DefaultRoute)
+
+                # Or you can define routes using the decorator
+                route = Route("/test)
+                @route.get("/route")
+                def def_get():
+                    return PlainTextResponse("Hello")
+                ```
+                """
+            ),
+        ] = None,
+        title: Annotated[
+            str,
+            Doc(
+                """
+                The title of the API.
+
+                It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+                Read more in the
+                """
+            ),
+        ] = "HyperN",
+        summary: Annotated[
+            str | None,
+            Doc(
+                """"
+                A short summary of the API.
+
+                It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+                """
+            ),
+        ] = None,
+        description: Annotated[
+            str,
+            Doc(
+                """
+                A description of the API. Supports Markdown (using
+                [CommonMark syntax](https://commonmark.org/)).
+
+                It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+                """
+            ),
+        ] = "",
+        version: Annotated[
+            str,
+            Doc(
+                """
+                The version of the API.
+
+                **Note** This is the version of your application, not the version of
+                the OpenAPI specification nor the version of Application being used.
+
+                It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+                """
+            ),
+        ] = "0.0.1",
+        contact: Annotated[
+            Contact | None,
+            Doc(
+                """
+                A dictionary with the contact information for the exposed API.
+
+                It can contain several fields.
+
+                * `name`: (`str`) The name of the contact person/organization.
+                * `url`: (`str`) A URL pointing to the contact information. MUST be in
+                    the format of a URL.
+                * `email`: (`str`) The email address of the contact person/organization.
+                    MUST be in the format of an email address.            
+                """
+            ),
+        ] = None,
+        openapi_url: Annotated[
+            str | None,
+            Doc(
+                """
+                The URL where the OpenAPI schema will be served from.
+
+                If you set it to `None`, no OpenAPI schema will be served publicly, and
+                the default automatic endpoints `/docs` and `/redoc` will also be
+                disabled.
+            """
+            ),
+        ] = "/openapi.json",
+        docs_url: Annotated[
+            str | None,
+            Doc(
+                """
+                The path to the automatic interactive API documentation.
+                It is handled in the browser by Swagger UI.
+
+                The default URL is `/docs`. You can disable it by setting it to `None`.
+
+                If `openapi_url` is set to `None`, this will be automatically disabled.
+            """
+            ),
+        ] = "/docs",
+        license_info: Annotated[
+            License | None,
+            Doc(
+                """
+                A dictionary with the license information for the exposed API.
+
+                It can contain several fields.
+
+                * `name`: (`str`) **REQUIRED** (if a `license_info` is set). The
+                    license name used for the API.
+                * `identifier`: (`str`) An [SPDX](https://spdx.dev/) license expression
+                    for the API. The `identifier` field is mutually exclusive of the `url`
+                    field. Available since OpenAPI 3.1.0
+                * `url`: (`str`) A URL to the license used for the API. This MUST be
+                    the format of a URL.
+
+                It will be added to the generated OpenAPI (e.g. visible at `/docs`).
+
+                **Example**
+
+                ```python
+                app = HyperN(
+                    license_info={
+                        "name": "Apache 2.0",
+                        "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
+                    }
+                )
+                ```
+                """
+            ),
+        ] = None,
+        scheduler: Annotated[
+            Scheduler | None,
+            Doc(
+                """
+                A scheduler to run background tasks.
+                """
+            ),
+        ] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(__file__, *args, **kwargs)
+        self.scheduler = scheduler
+
+        for route in routes:
+            self.router.routes.extend(route(self).get_routes())
+
+        if openapi_url and docs_url:
+            self.add_openapi(
+                info=Info(
+                    title=title,
+                    summary=summary,
+                    description=description,
+                    version=version,
+                    contact=contact,
+                    license=license_info,
+                ),
+                openapi_url=openapi_url,
+                docs_url=docs_url,
+            )
+
+    def add_openapi(
+        self,
+        info: Info,
+        openapi_url: str,
+        docs_url: str,
+    ):
+        @self.get(openapi_url)
+        def schema():
+            schemas = SchemaGenerator(
+                {
+                    "openapi": "3.0.0",
+                    "info": info.model_dump(),
+                    "components": {"securitySchemes": {}},
+                }
+            )
+            return JSONResponse(content=orjson.dumps(schemas.get_schema(self)))
+
+        @self.get(docs_url)
+        def template_render():
+            swagger = SwaggerUI(
+                title="Swagger",
+                openapi_url=openapi_url,
+            )
+            template = swagger.render_template()
+            return template
+
+    def add_middleware(self, middleware):
+        setattr(middleware, "app", self)
+        before_request = getattr(middleware, "before_request", None)
+        after_request = getattr(middleware, "after_request", None)
+        endpoint = getattr(middleware, "endpoint", None)
+        if before_request:
+            self.before_request(endpoint=endpoint)(before_request)
+        if after_request:
+            self.after_request(endpoint=endpoint)(after_request)
+        return self
+
+    def start(self, host: str = "127.0.0.1", port: int = 8080, _check_port: bool = True):
+        if self.scheduler:
+            self.scheduler.start()
+        return super().start(host, port, _check_port)

hypern/auth/authorization.py

@@ -0,0 +1,2 @@
+class Authorization:
+    pass

hypern/background.py

@@ -0,0 +1,4 @@
+from .hypern import BackgroundTask
+from .hypern import BackgroundTasks
+
+__all__ = ["BackgroundTask", "BackgroundTasks"]

hypern/caching/base/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+from .backend import BaseBackend
+from .key_maker import BaseKeyMaker
+
+__all__ = [
+    "BaseKeyMaker",
+    "BaseBackend",
+]

hypern/caching/base/backend.py

@@ -0,0 +1,3 @@
+from hypern.hypern import BaseBackend
+
+__all__ = ["BaseBackend"]

hypern/caching/base/key_maker.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+from abc import ABC, abstractmethod
+from typing import Callable
+
+
+class BaseKeyMaker(ABC):
+    @abstractmethod
+    async def make(self, function: Callable, prefix: str, identify_key: str) -> str: ...

hypern/caching/cache_manager.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+from functools import wraps
+from typing import Callable, Dict, Type
+
+from .base import BaseBackend, BaseKeyMaker
+from .cache_tag import CacheTag
+import orjson
+
+
+class CacheManager:
+    def __init__(self):
+        self.backend = None
+        self.key_maker = None
+
+    def init(self, backend: BaseBackend, key_maker: BaseKeyMaker) -> None:
+        self.backend = backend
+        self.key_maker = key_maker
+
+    def cached(self, tag: CacheTag, ttl: int = 60, identify: Dict = {}) -> Type[Callable]:
+        def _cached(function):
+            @wraps(function)
+            async def __cached(*args, **kwargs):
+                if not self.backend or not self.key_maker:
+                    raise ValueError("Backend or KeyMaker not initialized")
+
+                _identify_key = []
+                for key, values in identify.items():
+                    _obj = kwargs.get(key, None)
+                    if not _obj:
+                        raise ValueError(f"Caching: Identify key {key} not found in kwargs")
+                    for attr in values:
+                        _identify_key.append(f"{attr}={getattr(_obj, attr)}")
+                _identify_key = ":".join(_identify_key)
+
+                key = await self.key_maker.make(function=function, prefix=tag.value, identify_key=_identify_key)
+
+                cached_response = self.backend.get(key=key)
+                if cached_response:
+                    return orjson.loads(cached_response)
+
+                response = await function(*args, **kwargs)
+                self.backend.set(response=orjson.dumps(response).decode("utf-8"), key=key, ttl=ttl)
+                return response
+
+            return __cached
+
+        return _cached  # type: ignore
+
+    async def remove_by_tag(self, tag: CacheTag) -> None:
+        await self.backend.delete_startswith(value=tag.value)
+
+    async def remove_by_prefix(self, prefix: str) -> None:
+        await self.backend.delete_startswith(value=prefix)
+
+
+Cache = CacheManager()

hypern/caching/cache_tag.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+from enum import Enum
+
+
+class CacheTag(Enum):
+    GET_HEALTH_CHECK = "get_health_check"
+    GET_USER_INFO = "get_user_info"
+    GET_CATEGORIES = "get_categories"
+    GET_HISTORY = "get_chat_history"
+    GET_QUESTION = "get_question"

hypern/caching/custom_key_maker.py

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+from typing import Callable
+import inspect
+
+from hypern.caching.base import BaseKeyMaker
+
+
+class CustomKeyMaker(BaseKeyMaker):
+    async def make(self, function: Callable, prefix: str, identify_key: str = "") -> str:
+        path = f"{prefix}:{inspect.getmodule(function).__name__}.{function.__name__}:{identify_key}"  # type: ignore
+        return str(path)

hypern/caching/redis_backend.py

@@ -0,0 +1,3 @@
+from hypern.hypern import RedisBackend
+
+__all__ = ["RedisBackend"]

hypern/config.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import os
+import typing
+import warnings
+from pathlib import Path
+
+"""
+
+refer: https://github.com/encode/starlette/blob/master/starlette/config.py
+# Config will be read from environment variables and/or ".env" files.
+config = Config(".env")
+
+DEBUG = config('DEBUG', cast=bool, default=False)
+DATABASE_URL = config('DATABASE_URL')
+ALLOWED_HOSTS = config('ALLOWED_HOSTS', cast=CommaSeparatedStrings)
+"""
+
+
+class undefined:
+    pass
+
+
+class EnvironError(Exception):
+    pass
+
+
+class Environ(typing.MutableMapping[str, str]):
+    def __init__(self, environ: typing.MutableMapping[str, str] = os.environ):
+        self._environ = environ
+        self._has_been_read: set[str] = set()
+
+    def __getitem__(self, key: str) -> str:
+        self._has_been_read.add(key)
+        return self._environ.__getitem__(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        if key in self._has_been_read:
+            raise EnvironError(f"Attempting to set environ['{key}'], but the value has already been read.")
+        self._environ.__setitem__(key, value)
+
+    def __delitem__(self, key: str) -> None:
+        if key in self._has_been_read:
+            raise EnvironError(f"Attempting to delete environ['{key}'], but the value has already been read.")
+        self._environ.__delitem__(key)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return iter(self._environ)
+
+    def __len__(self) -> int:
+        return len(self._environ)
+
+
+environ = Environ()
+
+T = typing.TypeVar("T")
+
+
+class Config:
+    def __init__(
+        self,
+        env_file: str | Path | None = None,
+        environ: typing.Mapping[str, str] = environ,
+        env_prefix: str = "",
+    ) -> None:
+        self.environ = environ
+        self.env_prefix = env_prefix
+        self.file_values: dict[str, str] = {}
+        if env_file is not None:
+            if not os.path.isfile(env_file):
+                warnings.warn(f"Config file '{env_file}' not found.")
+            else:
+                self.file_values = self._read_file(env_file)
+
+    @typing.overload
+    def __call__(self, key: str, *, default: None) -> str | None: ...
+
+    @typing.overload
+    def __call__(self, key: str, cast: type[T], default: T = ...) -> T: ...
+
+    @typing.overload
+    def __call__(self, key: str, cast: type[str] = ..., default: str = ...) -> str: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        key: str,
+        cast: typing.Callable[[typing.Any], T] = ...,
+        default: typing.Any = ...,
+    ) -> T: ...
+
+    @typing.overload
+    def __call__(self, key: str, cast: type[str] = ..., default: T = ...) -> T | str: ...
+
+    def __call__(
+        self,
+        key: str,
+        cast: typing.Callable[[typing.Any], typing.Any] | None = None,
+        default: typing.Any = undefined,
+    ) -> typing.Any:
+        return self.get(key, cast, default)
+
+    def get(
+        self,
+        key: str,
+        cast: typing.Callable[[typing.Any], typing.Any] | None = None,
+        default: typing.Any = undefined,
+    ) -> typing.Any:
+        key = self.env_prefix + key
+        if key in self.environ:
+            value = self.environ[key]
+            return self._perform_cast(key, value, cast)
+        if key in self.file_values:
+            value = self.file_values[key]
+            return self._perform_cast(key, value, cast)
+        if default is not undefined:
+            return self._perform_cast(key, default, cast)
+        raise KeyError(f"Config '{key}' is missing, and has no default.")
+
+    def _read_file(self, file_name: str | Path) -> dict[str, str]:
+        file_values: dict[str, str] = {}
+        with open(file_name) as input_file:
+            for line in input_file.readlines():
+                line = line.strip()
+                if "=" in line and not line.startswith("#"):
+                    key, value = line.split("=", 1)
+                    key = key.strip()
+                    value = value.strip().strip("\"'")
+                    file_values[key] = value
+        return file_values
+
+    def _perform_cast(
+        self,
+        key: str,
+        value: typing.Any,
+        cast: typing.Callable[[typing.Any], typing.Any] | None = None,
+    ) -> typing.Any:
+        if cast is None or value is None:
+            return value
+        elif cast is bool and isinstance(value, str):
+            mapping = {"true": True, "1": True, "false": False, "0": False}
+            value = value.lower()
+            if value not in mapping:
+                raise ValueError(f"Config '{key}' has value '{value}'. Not a valid bool.")
+            return mapping[value]
+        try:
+            return cast(value)
+        except (TypeError, ValueError):
+            raise ValueError(f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}.")

hypern/datastructures.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from pydantic import BaseModel, AnyUrl, EmailStr
+
+
+class BaseModelWithConfig(BaseModel):
+    model_config = {"extra": "allow"}
+
+
+class Contact(BaseModelWithConfig):
+    name: Optional[str] = None
+    url: Optional[AnyUrl] = None
+    email: Optional[EmailStr] = None
+
+
+class License(BaseModelWithConfig):
+    name: str
+    identifier: Optional[str] = None
+    url: Optional[AnyUrl] = None
+
+
+class Info(BaseModelWithConfig):
+    title: str
+    summary: Optional[str] = None
+    description: Optional[str] = None
+    contact: Optional[Contact] = None
+    license: Optional[License] = None
+    version: str

hypern/db/nosql/__init__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+from typing import List, TypedDict
+
+from uuid import uuid4
+from mongoengine import connect
+
+
+class TypedDictModel(TypedDict):
+    host: str
+    alias: str
+
+
+class NoSqlConfig:
+    def __init__(self, dbs_config: List[TypedDictModel]):
+        self.dbs_config = dbs_config
+
+    def _connect_db(self, db_config: TypedDictModel):
+        _alias = db_config.get("alias", str(uuid4()))
+        connect(host=db_config["host"], alias=_alias)
+
+    def init_app(self, app):
+        self.app = app  # noqa
+        # connect
+        for db_config in self.dbs_config:
+            self._connect_db(db_config)

hypern/db/nosql/addons/__init__.py

@@ -0,0 +1,4 @@
+from .encrypted import EncryptedField
+from .password import PasswordField
+
+__all__ = ["EncryptedField", "PasswordField"]

hypern/db/nosql/addons/color.py

@@ -0,0 +1,16 @@
+from mongoengine import BaseField
+import re
+
+
+class ColorField(BaseField):
+    def validate(self, value):
+        color_regex = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"
+        if not re.match(color_regex, value):
+            self.error("Invalid color format. Use hexadecimal color codes (e.g., #FF0000)")
+        return True
+
+    def to_mongo(self, value):
+        return value
+
+    def to_python(self, value):
+        return value

hypern/db/nosql/addons/daterange.py

@@ -0,0 +1,30 @@
+from mongoengine import BaseField
+from datetime import datetime
+
+
+class DateRangeField(BaseField):
+    def __init__(self, **kwargs):
+        super(DateRangeField, self).__init__(**kwargs)
+
+    def validate(self, value):
+        if not isinstance(value, dict) or "start" not in value or "end" not in value:
+            self.error('DateRangeField must be a dictionary with "start" and "end" keys')
+        # Use get to safely access keys
+        start = value.get("start")
+        end = value.get("end")
+        # Check if both "start" and "end" are present
+        if start is None or end is None:
+            self.error('DateRangeField must contain both "start" and "end" keys')
+
+        # Check if "start" and "end" are datetime objects
+        if not isinstance(value["start"], datetime) or not isinstance(value["end"], datetime):
+            self.error('DateRangeField "start" and "end" must be datetime objects')
+        if value["start"] > value["end"]:
+            self.error('DateRangeField "start" must be earlier than "end"')
+        return True
+
+    def to_mongo(self, value):
+        return value
+
+    def to_python(self, value):
+        return value

hypern/db/nosql/addons/encrypted.py

@@ -0,0 +1,53 @@
+import os
+from typing import Any, Optional
+from mongoengine.base import BaseField
+
+from cryptography.hazmat.primitives import padding
+
+from hypern.security import EDEngine, AESEngine
+
+
+class EncryptedField(BaseField):
+    """
+    A custom MongoEngine field that encrypts data using AES-256-CBC.
+
+    The field automatically handles encryption when saving to MongoDB and
+    decryption when retrieving data.
+
+    Attributes:
+        engine: Encryption engine to use. If not provided, will use AES-256-CBC
+    """
+
+    def __init__(self, engine: Optional[EDEngine] = None, **kwargs):
+        if not engine:
+            key = os.urandom(32)
+            iv = os.urandom(16)
+            padding_class = padding.PKCS7
+            self.engine = AESEngine(secret_key=key, iv=iv, padding_class=padding_class)
+        else:
+            self.engine = engine  # type: ignore
+        super(EncryptedField, self).__init__(**kwargs)
+
+    def to_mongo(self, value: Any) -> Optional[str]:
+        """Convert a Python object to a MongoDB-compatible format."""
+        if value is None:
+            return None
+        return self.engine.encrypt(value)
+
+    def to_python(self, value: Optional[str]) -> Optional[str]:
+        """Convert a MongoDB-compatible format to a Python object."""
+        if value is None:
+            return None
+        if isinstance(value, bytes):
+            return self.engine.decrypt(value)
+        return value
+
+    def prepare_query_value(self, op, value: Any) -> Optional[str]:
+        """Prepare a value used in a query."""
+        if value is None:
+            return None
+
+        if op in ("set", "upsert"):
+            return self.to_mongo(value)
+
+        return value