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

hypern/application.py

@@ -437,6 +437,9 @@ class Hypern:
             self.args.workers = self.thread_config.workers
             self.args.max_blocking_threads = self.thread_config.max_blocking_threads
 
+        if self.args.http2:
+            server.enable_http2()
+
         run_processes(
             server=server,
             host=self.args.host,

hypern/args_parser.py

@@ -55,6 +55,12 @@ class ArgsConfig:
             help="It sets the number of workers and max-blocking-threads automatically.",
         )
 
+        parser.add_argument(
+            "--http2",
+            action="store_true",
+            help="Enable HTTP/2 support.",
+        )
+
         args, _ = parser.parse_known_args()
 
         self.host = args.host or "127.0.0.1"
@@ -64,3 +70,4 @@ class ArgsConfig:
         self.workers = args.workers or 1
         self.reload = args.reload or False
         self.auto_workers = args.auto_workers
+        self.http2 = args.http2 or False

hypern/database/sqlalchemy/__init__.py

@@ -0,0 +1,4 @@
+from .repository import Model, PostgresRepository
+from .config import SqlalchemyConfig
+
+__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

hypern/database/{addons/sqlalchemy/__init__.py → sqlalchemy/config.py}

@@ -7,8 +7,6 @@ from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_scoped_sessi
 from sqlalchemy.orm import Session, sessionmaker
 from sqlalchemy.sql.expression import Delete, Insert, Update
 
-from .repository import Model, PostgresRepository
-
 
 class SqlalchemyConfig:
     def __init__(self, default_engine: AsyncEngine | None = None, reader_engine: AsyncEngine | None = None, writer_engine: AsyncEngine | None = None):
@@ -66,6 +64,3 @@ class SqlalchemyConfig:
 
     def init_app(self, app):
         app.inject("get_session", self.get_session)
-
-
-__all__ = ["Model", "PostgresRepository", "SqlalchemyConfig"]

hypern/database/{sql → sqlx}/query.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from typing import Any, Dict, List, Tuple, Union
-from hypern.database.sql.field import ForeignKeyField
+from hypern.database.sqlx.field import ForeignKeyField
 
 
 class JoinType(Enum):

hypern/hypern.pyi

@@ -188,6 +188,7 @@ class Server:
     def set_shutdown_handler(self, on_shutdown: FunctionInfo) -> None: ...
     def set_database_config(self, config: DatabaseConfig) -> None: ...
     def set_dependencies(self, dependencies: Dict[str, Any]) -> None: ...
+    def enable_http2(self) -> None: ...
 
 class Route:
     path: str

{hypern-0.3.8.dist-info → hypern-0.3.10.dist-info}/METADATA

@@ -1,31 +1,24 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.8
+Version: 0.3.10
 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: 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
-Requires-Dist: jsonschema ==4.23.0
 Requires-Dist: psutil ==6.1.0
 Requires-Dist: msgpack ==1.1.0
 Requires-Dist: redis ==5.2.1
+Requires-Dist: pydantic ==2.10.4
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>

{hypern-0.3.8.dist-info → hypern-0.3.10.dist-info}/RECORD

@@ -1,8 +1,8 @@
-hypern-0.3.8.dist-info/METADATA,sha256=0bMLw-pA0VeoGBbQxXr4cqCO8dS6esga5NjluEeV5MY,4356
-hypern-0.3.8.dist-info/WHEEL,sha256=19xj5Waw2omQTyAh5Pnrm7rXeZkfzX1OuBYghlKYN-I,92
-hypern-0.3.8.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
-hypern/application.py,sha256=07QGDd3w7tQRL8njfbNVinG6l8W7O0V-rN_SkO5O3B4,18002
-hypern/args_parser.py,sha256=BjGCooHdZjOpyN-AGL9PCKCKdzROVThE3dzQgC97rng,2035
+hypern-0.3.10.dist-info/METADATA,sha256=qForGiEDhs-zr3H_hrC_I7E5xDe4Otsl1yFLGAFeZJ0,4113
+hypern-0.3.10.dist-info/WHEEL,sha256=19xj5Waw2omQTyAh5Pnrm7rXeZkfzX1OuBYghlKYN-I,92
+hypern-0.3.10.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern/application.py,sha256=EVa3bjUjgEmM7jDpGTVcFlBa7kk2m69QMlpdsp8AWpU,18068
+hypern/args_parser.py,sha256=1v41RZT-35iY80I5OugjeFPXPr28HUvniQwu-29y1vw,2222
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
 hypern/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/background.py,sha256=xy38nQZSJsYFRXr3-uFJeNW9E1GiXXOC7lSe5pC0eyE,124
@@ -13,29 +13,14 @@ hypern/caching/__init__.py,sha256=ODO7zMm4iFG8wcvrhKmukryG5wOTW0DnzFvNMfF57Cc,35
 hypern/cli/commands.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/config.py,sha256=Jij9eGg5NgC8Un5Lw5i7ghuEMAfkVctdcoE4RaN5LTE,8157
-hypern/database/addons/sqlalchemy/fields/color.py,sha256=Jj8q4lkT0ukKyjVyZjBx7fokGrX7AIJpKOGzwsBpfnU,480
-hypern/database/addons/sqlalchemy/fields/daterange.py,sha256=qEfQN9c4jQdzeXNYKgQ4VIJ3Qc0HXHWRouzNF1se-RA,853
-hypern/database/addons/sqlalchemy/fields/datetime.py,sha256=Bp2jMja2lb_b2WnzRnfbjXXTHBgBTyph1ECsItIwvvg,643
-hypern/database/addons/sqlalchemy/fields/encrypted.py,sha256=pXsg4ImPpK-VkLDruKrv2gUtdp2kajQX7xDbRDxa-SI,1930
-hypern/database/addons/sqlalchemy/fields/password.py,sha256=9pypORygWaINj3oiAOBRIOGgpuA0lcjPq4rh1pqJxq0,5789
-hypern/database/addons/sqlalchemy/fields/ts_vector.py,sha256=bQyXYvQ1bAfFpYcS-sFwM7fU6L1lg9_7nGDRGp0CoUo,1361
-hypern/database/addons/sqlalchemy/fields/unicode.py,sha256=rbqyHlsPUqRDWIjYQSRFF3zkHncnwxo0sdlzqUlcrUw,411
-hypern/database/addons/sqlalchemy/fields/__init__.py,sha256=mLN_AvwgpSAbrWZvVHZuO7ff0gk1T_JbVwd5wug5nlw,359
-hypern/database/addons/sqlalchemy/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
-hypern/database/addons/sqlalchemy/__init__.py,sha256=FuY78ubEwtifdQTVHhCrscYaAarlp2urgYBc_R77yt0,2766
-hypern/database/addons/__init__.py,sha256=mdW0P0xvnK8htUk02ujvIaeHXl6w53JjrTS4ioNi1Bw,63
-hypern/database/nosql/addons/color.py,sha256=bAGRuARCAYwZ1nO4jK0lzGYKmavTDtS34BxvrsetF74,446
-hypern/database/nosql/addons/daterange.py,sha256=hGUSoVFqatNY-TB5wjZTq62iZpHpdsyRJIsHxsj1uDs,1192
-hypern/database/nosql/addons/encrypted.py,sha256=B0M-uDqvZHVmIZcFdwcuC2MGsv0pGJFQ1lrOg8klR9U,1741
-hypern/database/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZj9WT14n7dKE,5035
-hypern/database/nosql/addons/unicode.py,sha256=LaDpLfdoTcJuASPE-8fqOVD05H_uOx8gOdnyDn5Iu0c,268
-hypern/database/nosql/addons/__init__.py,sha256=WEtPM8sPHilvga7zxwqvINeTkF0hdcfgPcAnHc4MASE,125
-hypern/database/nosql/__init__.py,sha256=MH9YvlbRlbBCrQVNOdfTaK-hINwJxbJLmxwY9Mei7I8,644
-hypern/database/sql/field.py,sha256=gV9u_BvMIoxoDT3_J7sL5XJNa5XFsAO9w324ThwHbNs,9121
-hypern/database/sql/migrate.py,sha256=BTtAs3-iMyMDzIWl6B3rM9sj7XGggLDRjD0h_WgGPtc,9742
-hypern/database/sql/model.py,sha256=C8_rJA1Adw1yPWthjmAGh26hjTBuwwlEdtH45ADxvL0,4044
-hypern/database/sql/query.py,sha256=En19t27zt6iUDQbFgO_wLEWPQCkPeBuH3s37fzlhMVc,33345
-hypern/database/sql/__init__.py,sha256=dbSAz2nP0DPKK4Bb_jJdObSaSYQfgZ8D4U1TJdc4e7c,645
+hypern/database/sqlalchemy/config.py,sha256=3BKY8YoHKEvwdDulp1que6pqmyyzX3CgfrQHtDHZWeE,2646
+hypern/database/sqlalchemy/repository.py,sha256=ue6vWOTrnEPyDevlyh3v-7PU6GSfrZHYKrbXVuoS8UA,9516
+hypern/database/sqlalchemy/__init__.py,sha256=xOMrzdPyJBzwaZifxYg2XD3TSorCOBJOIKYbnbESTuo,154
+hypern/database/sqlx/field.py,sha256=gV9u_BvMIoxoDT3_J7sL5XJNa5XFsAO9w324ThwHbNs,9121
+hypern/database/sqlx/migrate.py,sha256=BTtAs3-iMyMDzIWl6B3rM9sj7XGggLDRjD0h_WgGPtc,9742
+hypern/database/sqlx/model.py,sha256=C8_rJA1Adw1yPWthjmAGh26hjTBuwwlEdtH45ADxvL0,4044
+hypern/database/sqlx/query.py,sha256=db4gKmw_Lvud2xUe97Kec886vLVMRkjoqFasSHxZMiA,33346
+hypern/database/sqlx/__init__.py,sha256=dbSAz2nP0DPKK4Bb_jJdObSaSYQfgZ8D4U1TJdc4e7c,645
 hypern/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/datastructures.py,sha256=Pxr9KsZZTFfp0KC1-A4v5AkQfmrUyvVwxKuToQUOLoE,882
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
@@ -50,7 +35,7 @@ hypern/gateway/gateway.py,sha256=26K2qvJUR-0JnN4IlhwvSSt7EYcpYrBVDuzZ1ivQQ34,147
 hypern/gateway/proxy.py,sha256=w1wcTplDnVrfjn7hb0M0yBVth5TGl88irF-MUYHysQQ,2463
 hypern/gateway/service.py,sha256=PkRaM08olqM_j_4wRjEJCR8X8ZysAF2WOcfhWjaX2eo,1701
 hypern/gateway/__init__.py,sha256=TpFWtqnJerW1-jCWq5fjypJcw9Y6ytyrkvkzby1Eg0E,235
-hypern/hypern.pyi,sha256=Urc3uHhPupsN-RRYluyWiw8B_xYWzE91Og3Zft40NgU,9010
+hypern/hypern.pyi,sha256=C_RAN4E9m4FFGGTd3k6JVi59ORl_knLQtIHM1wqDlBg,9051
 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
@@ -77,7 +62,6 @@ hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
 hypern/routing/route.py,sha256=kan47-UeL-OPwcpp0rEhmBaaum6hN7FUj13Y8pZDEYA,10256
 hypern/routing/__init__.py,sha256=U4xW5fDRsn03z4cVLT4dJHHGGU6SVxyv2DL86LXodeE,162
 hypern/scheduler.py,sha256=-k3tW2AGCnHYSthKXk-FOs_SCtWp3yIxQzwzUJMJsbo,67
-hypern/security.py,sha256=3E86Yp_eOSVa1emUvBrDgoF0Sn6eNX0CfLnt87w5CPI,1773
 hypern/worker.py,sha256=ksJW8jWQg3HbIYnIZ5qdAmO-yh5hLpwvTT3dKkHR4Eo,9761
 hypern/ws/channel.py,sha256=0ns2qmeoFJOpGLXS_hqldhywDQm_DxHwj6KloQx4Q3I,3183
 hypern/ws/heartbeat.py,sha256=sWMXzQm6cbDHHA2NHc-gFjv7G_E56XtxswHQ93_BueM,2861
@@ -85,5 +69,5 @@ hypern/ws/room.py,sha256=0_L6Nun0n007F0rfNY8yX5x_A8EuXuI67JqpMkJ4RNI,2598
 hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
 hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
 hypern/__init__.py,sha256=p3AtJQbsPs1RYEiN1thxH-k5UP8FfLeiJSoP0Vt3MDg,639
-hypern/hypern.cp312-win32.pyd,sha256=rvh5yYWRidA1p4JK6cneYi7yjaJ8okvTNHUIpwn6c9k,7591936
-hypern-0.3.8.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=vIv05Fu6jD72f8YzNQcW2C--drkzTBYvmy68E1Be3DI,8263680
+hypern-0.3.10.dist-info/RECORD,,

hypern/database/addons/__init__.py

@@ -1,5 +0,0 @@
-from . import sqlalchemy
-
-__all__ = [
-    "sqlalchemy",
-]

hypern/database/addons/sqlalchemy/fields/__init__.py

@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-from .ts_vector import TSVector
-from .datetime import DatetimeType
-from .password import PasswordType
-from .encrypted import StringEncryptType, LargeBinaryEncryptType, AESEngine
-
-__all__ = [
-    "TSVector",
-    "DatetimeType",
-    "PasswordType",
-    "StringEncryptType",
-    "LargeBinaryEncryptType",
-    "AESEngine",
-]

hypern/database/addons/sqlalchemy/fields/color.py

@@ -1,16 +0,0 @@
-import re
-
-from sqlalchemy.types import String, TypeDecorator
-
-
-class ColorField(TypeDecorator):
-    impl = String
-
-    def process_bind_param(self, value, dialect):
-        color_regex = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"
-        if not re.match(color_regex, value):
-            raise ValueError("Invalid color format. Use hexadecimal color codes (e.g., #FF0000)")
-        return value
-
-    def process_result_value(self, value, dialect):
-        return value

hypern/database/addons/sqlalchemy/fields/daterange.py

@@ -1,23 +0,0 @@
-from datetime import datetime
-
-from sqlalchemy.dialects.postgresql import DATERANGE
-from sqlalchemy.types import TypeDecorator
-
-
-class DateRangeField(TypeDecorator):
-    impl = DATERANGE
-
-    def process_bind_param(self, value, dialect):
-        if value is None:
-            return None
-        elif "start" in value and "end" in value:
-            return f"['{value['start']}', '{value['end']}']"
-        else:
-            raise ValueError('DateRangeField must be a dictionary with "start" and "end" keys')
-
-    def process_result_value(self, value, dialect):
-        if value is None:
-            return None
-        else:
-            start, end = value[1:-1].split(",")
-            return {"start": datetime.strptime(start.strip("'"), "%Y-%m-%d %H:%M:%S.%f"), "end": datetime.strptime(end.strip("'"), "%Y-%m-%d %H:%M:%S.%f")}

hypern/database/addons/sqlalchemy/fields/datetime.py

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-from sqlalchemy import types
-
-
-class DatetimeType(types.TypeDecorator):
-    impl = types.DateTime
-    cache_ok = True
-
-    def load_dialect_impl(self, dialect):
-        if dialect.name == "sqlite":
-            return dialect.type_descriptor(types.TEXT)
-        return dialect.type_descriptor(self.impl)
-
-    def process_bind_param(self, value, dialect):
-        if dialect.name == "sqlite":
-            return value.isoformat()
-        return value
-
-    def process_result_value(self, value, dialect):
-        if dialect.name != "sqlite":
-            return value.timestamp()
-        return value

hypern/database/addons/sqlalchemy/fields/encrypted.py

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import typing
-
-from cryptography.hazmat.primitives import padding
-from sqlalchemy.types import LargeBinary, String, TypeDecorator
-
-from hypern.security import AESEngine, EDEngine
-
-
-class StringEncryptType(TypeDecorator):
-    impl = String
-    cache_ok = True
-
-    def __init__(self, engine: typing.Optional[EDEngine] = None, *args, **kwargs) -> None:
-        super().__init__(*args, **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
-
-    def process_bind_param(self, value, dialect):
-        if value is None:
-            return value
-        if not isinstance(value, str):
-            raise ValueError("Value String Encrypt Type must be a string")
-        return self.engine.encrypt(value).decode(encoding="utf-8")
-
-    def process_result_value(self, value, dialect):
-        if value is None:
-            return value
-        return self.engine.decrypt(value)
-
-
-class LargeBinaryEncryptType(StringEncryptType):
-    impl = LargeBinary
-    cache_ok = True
-
-    def __init__(self, engine: typing.Optional[EDEngine] = None, *args, **kwargs) -> None:
-        super().__init__(engine=engine, *args, **kwargs)  # type: ignore
-
-    def process_bind_param(self, value, dialect):
-        if value is None:
-            return value
-        value = super().process_bind_param(value, dialect)
-        if isinstance(value, str):
-            return value.encode("utf-8")
-        return value
-
-    def process_result_value(self, value, dialect):
-        if isinstance(value, bytes):
-            value = value.decode("utf-8")
-            return super().process_result_value(value, dialect)
-        return value

hypern/database/addons/sqlalchemy/fields/password.py

@@ -1,171 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import weakref
-
-import passlib
-from passlib.context import LazyCryptContext
-from sqlalchemy import types
-from sqlalchemy.dialects import oracle, postgresql, sqlite
-from sqlalchemy.ext.mutable import Mutable
-
-
-class Password(Mutable):
-    @classmethod
-    def coerce(cls, key, value):
-        if isinstance(value, Password):
-            return value
-
-        if isinstance(value, (str, bytes)):
-            return cls(value, secret=True)
-
-        super().coerce(key, value)
-
-    def __init__(self, value, context=None, secret=False):
-        # Store the hash (if it is one).
-        self.hash = value if not secret else None
-
-        # Store the secret if we have one.
-        self.secret = value if secret else None
-
-        # The hash should be bytes.
-        if isinstance(self.hash, str):
-            self.hash = self.hash.encode("utf8")
-
-        # Save weakref of the password context (if we have one)
-        self.context = weakref.proxy(context) if context is not None else None
-
-    def __eq__(self, value):
-        if self.hash is None or value is None:
-            # Ensure that we don't continue comparison if one of us is None.
-            return self.hash is value
-
-        if isinstance(value, Password):
-            # Comparing 2 hashes isn't very useful; but this equality
-            # method breaks otherwise.
-            return value.hash == self.hash
-
-        if self.context is None:
-            # Compare 2 hashes again as we don't know how to validate.
-            return value == self
-
-        if isinstance(value, (str, bytes)):
-            valid, new = self.context.verify_and_update(value, self.hash)
-            if valid and new:
-                # New hash was calculated due to various reasons; stored one
-                # wasn't optimal, etc.
-                self.hash = new
-
-                # The hash should be bytes.
-                if isinstance(self.hash, str):
-                    self.hash = self.hash.encode("utf8")
-                    self.changed()
-
-            return valid
-
-        return False
-
-    def __ne__(self, value):
-        return self != value
-
-
-class PasswordType(types.TypeDecorator):
-    impl = types.String
-    cache_ok = True
-
-    def __init__(self, max_length=None, **kwargs):
-        # Fail if passlib is not found.
-        if passlib is None:
-            raise ImportError("'passlib' is required to use 'PasswordType'")
-
-        # Construct the passlib crypt context.
-        self.context = LazyCryptContext(**kwargs)
-        self._max_length = max_length
-
-    @property
-    def hashing_method(self):
-        return "hash" if hasattr(self.context, "hash") else "encrypt"
-
-    @property
-    def max_length(self):
-        """Get column length."""
-        if self._max_length is None:
-            self._max_length = self.calculate_max_length()
-
-        return self._max_length
-
-    def calculate_max_length(self):
-        # Calculate the largest possible encoded password.
-        # name + rounds + salt + hash + ($ * 4) of largest hash
-        max_lengths = [1024]
-        for name in self.context.schemes():
-            scheme = getattr(__import__("passlib.hash").hash, name)
-            length = 4 + len(scheme.name)
-            length += len(str(getattr(scheme, "max_rounds", "")))
-            length += getattr(scheme, "max_salt_size", 0) or 0
-            length += getattr(scheme, "encoded_checksum_size", scheme.checksum_size)
-            max_lengths.append(length)
-
-        # Return the maximum calculated max length.
-        return max(max_lengths)
-
-    def load_dialect_impl(self, dialect):
-        if dialect.name == "postgresql":
-            # Use a BYTEA type for postgresql.
-            impl = postgresql.BYTEA(self.max_length)
-        elif dialect.name == "oracle":
-            # Use a RAW type for oracle.
-            impl = oracle.RAW(self.max_length)
-        elif dialect.name == "sqlite":
-            # Use a BLOB type for sqlite
-            impl = sqlite.BLOB(self.max_length)
-        else:
-            # Use a VARBINARY for all other dialects.
-            impl = types.VARBINARY(self.max_length)
-        return dialect.type_descriptor(impl)
-
-    def process_bind_param(self, value, dialect):
-        if isinstance(value, Password):
-            # If were given a password secret; hash it.
-            if value.secret is not None:
-                return self._hash(value.secret).encode("utf8")
-
-            # Value has already been hashed.
-            return value.hash
-
-        if isinstance(value, str):
-            # Assume value has not been hashed.
-            return self._hash(value).encode("utf8")
-
-    def process_result_value(self, value, dialect):
-        if value is not None:
-            return Password(value, self.context)
-
-    def _hash(self, value):
-        return getattr(self.context, self.hashing_method)(value)
-
-    def _coerce(self, value):
-        if value is None:
-            return
-
-        if not isinstance(value, Password):
-            # Hash the password using the default scheme.
-            value = self._hash(value).encode("utf8")
-            return Password(value, context=self.context)
-
-        else:
-            # If were given a password object; ensure the context is right.
-            value.context = weakref.proxy(self.context)
-
-            # If were given a password secret; hash it.
-            if value.secret is not None:
-                value.hash = self._hash(value.secret).encode("utf8")
-                value.secret = None
-
-        return value
-
-    @property
-    def python_type(self):
-        return self.impl.type.python_type
-
-
-Password.associate_with(PasswordType)

hypern/database/addons/sqlalchemy/fields/ts_vector.py

@@ -1,46 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import sqlalchemy as sa
-from sqlalchemy.dialects.postgresql import TSVECTOR
-
-
-class TSVector(sa.types.TypeDecorator):
-    """
-    .. _TSVECTOR:
-    https://docs.sqlalchemy.org/en/latest/dialects/postgresql.html#full-text-search
-
-
-    class IndexModel(Model):
-        ....
-        search_vector = Column(
-            TSVector(),
-            Computed(
-                "to_tsvector('english', some_text|| ' ' ||some_text)",
-                persisted=True,
-            ),
-        )
-    session.query(IndexModel).filter(IndexModel.search_vector.match('foo'))
-
-    session.query(IndexModel).filter(
-        (IndexModel.name_vector | IndexModel.content_vector).match('foo')
-    )
-
-    """
-
-    impl = TSVECTOR
-    cache_ok = True
-
-    class comparator_factory(TSVECTOR.Comparator):
-        def match(self, other, **kwargs):
-            if "postgresql_regconfig" not in kwargs:
-                if "regconfig" in self.type.options:
-                    kwargs["postgresql_regconfig"] = self.type.options["regconfig"]
-            return TSVECTOR.Comparator.match(self, other, **kwargs)
-
-        def __or__(self, other):
-            return self.op("||")(other)
-
-    def __init__(self, *args, **kwargs):
-        self.columns = args
-        self.options = kwargs
-        super(TSVector, self).__init__()

hypern/database/addons/sqlalchemy/fields/unicode.py

@@ -1,15 +0,0 @@
-from sqlalchemy.types import TypeDecorator, Unicode
-
-
-class UnicodeField(TypeDecorator):
-    impl = Unicode
-
-    def process_bind_param(self, value, dialect):
-        try:
-            value.encode("utf-8")
-        except UnicodeEncodeError:
-            raise ValueError("Value must be valid Unicode")
-        return value
-
-    def process_result_value(self, value, dialect):
-        return value

hypern/database/nosql/__init__.py

@@ -1,25 +0,0 @@
-# -*- 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/database/nosql/addons/__init__.py

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

hypern/database/nosql/addons/color.py

@@ -1,16 +0,0 @@
-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/database/nosql/addons/daterange.py

@@ -1,30 +0,0 @@
-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/database/nosql/addons/encrypted.py

@@ -1,53 +0,0 @@
-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

hypern/database/nosql/addons/password.py

@@ -1,134 +0,0 @@
-from mongoengine.base import BaseField
-import weakref
-from passlib.context import CryptContext
-import re
-from typing import Optional, Any
-
-
-class PasswordField(BaseField):
-    """
-    A custom password field using passlib for hashing and weakref for reference management.
-    Supports multiple hashing schemes and automatic upgrade of hash algorithms.
-    """
-
-    # Class-level password context - shared across all instances
-    pwd_context = CryptContext(
-        # List of hashing schemes in order of preference
-        schemes=["argon2", "pbkdf2_sha256", "bcrypt_sha256"],
-        # Mark argon2 as default
-        default="argon2",
-        # Argon2 parameters
-        argon2__rounds=4,
-        argon2__memory_cost=65536,
-        argon2__parallelism=2,
-        # PBKDF2 parameters
-        pbkdf2_sha256__rounds=29000,
-    )
-
-    def __init__(
-        self,
-        min_length: int = 8,
-        require_number: bool = False,
-        require_special: bool = False,
-        require_uppercase: bool = False,
-        require_lowercase: bool = False,
-        **kwargs,
-    ):
-        """
-        Initialize the password field with validation rules.
-
-        Args:
-            min_length: Minimum password length
-            require_number: Require at least one number
-            require_special: Require at least one special character
-            require_uppercase: Require at least one uppercase letter
-            require_lowercase: Require at least one lowercase letter
-        """
-        self.min_length = min_length
-        self.require_number = require_number
-        self.require_special = require_special
-        self.require_uppercase = require_uppercase
-        self.require_lowercase = require_lowercase
-
-        # Use weakref to store references to parent documents
-        self.instances = weakref.WeakKeyDictionary()
-
-        kwargs["required"] = True
-        super(PasswordField, self).__init__(**kwargs)
-
-    def validate_password(self, password: str) -> tuple[bool, str]:
-        """Validate password strength."""
-
-        if len(password) < self.min_length:
-            return False, f"Password must be at least {self.min_length} characters long"
-
-        if self.require_number and not re.search(r"\d", password):
-            return False, "Password must contain at least one number"
-
-        if self.require_special and not re.search(r"[!@#$%^&*(),.?\":{}|<>]", password):
-            return False, "Password must contain at least one special character"
-
-        if self.require_uppercase and not re.search(r"[A-Z]", password):
-            return False, "Password must contain at least one uppercase letter"
-
-        if self.require_lowercase and not re.search(r"[a-z]", password):
-            return False, "Password must contain at least one lowercase letter"
-
-        return True, ""
-
-    def hash_password(self, password: str) -> str:
-        """Hash password using the configured passlib context."""
-        return self.pwd_context.hash(password)
-
-    def verify_password(self, password: str, hash: str) -> tuple[bool, Optional[str]]:
-        """
-        Verify password and return tuple of (is_valid, new_hash).
-        new_hash is provided if the hash needs to be upgraded.
-        """
-        try:
-            is_valid = self.pwd_context.verify(password, hash)
-            # Check if the hash needs to be upgraded
-            if is_valid and self.pwd_context.needs_update(hash):
-                return True, self.hash_password(password)
-            return is_valid, None
-        except Exception:
-            return False, None
-
-    def __get__(self, instance, owner):
-        """Custom getter using weakref."""
-        if instance is None:
-            return self
-        return self.instances.get(instance)
-
-    def __set__(self, instance, value):
-        """Custom setter using weakref."""
-        if value and isinstance(value, str):
-            # Validate and hash new password
-            is_valid, error = self.validate_password(value)
-            if not is_valid:
-                raise ValueError(error)
-            hashed = self.hash_password(value)
-            self.instances[instance] = hashed
-            instance._data[self.name] = hashed
-        else:
-            # If it's already hashed or None
-            self.instances[instance] = value
-            instance._data[self.name] = value
-
-    def to_mongo(self, value: str) -> Optional[str]:
-        """Convert to MongoDB-compatible value."""
-        if value is None:
-            return None
-        return self.hash_password(value)
-
-    def to_python(self, value: str) -> str:
-        """Convert from MongoDB to Python."""
-        return value
-
-    def prepare_query_value(self, op, value: Any) -> Optional[str]:
-        """Prepare value for database operations."""
-        if value is None:
-            return None
-        if op == "exact":
-            return self.hash_password(value)
-        return value

hypern/database/nosql/addons/unicode.py

@@ -1,10 +0,0 @@
-from mongoengine import StringField
-
-
-class UnicodeField(StringField):
-    def validate(self, value):
-        try:
-            value.encode("utf-8")
-        except UnicodeEncodeError:
-            self.error("Value must be valid Unicode")
-        return True

hypern/security.py

@@ -1,44 +0,0 @@
-# -*- 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")