hypern 0.3.6__cp310-cp310-win32.whl → 0.3.8__cp310-cp310-win32.whl

hypern/database/sql/migrate.py

@@ -0,0 +1,263 @@
+# import os
+# import sys
+# import inspect
+# import importlib
+# import hashlib
+# import argparse
+# from datetime import datetime
+# from typing import List, Type, Dict
+
+# from hypern.config import get_config
+# from .model import Model
+
+
+# class MigrationManager:
+#     """Manages database migrations and schema changes."""
+
+#     def __init__(self, migrations_dir: str = "migrations"):
+#         self.migrations_dir = migrations_dir
+#         self.config = get_config()
+#         self.ensure_migrations_dir()
+
+#     def ensure_migrations_dir(self):
+#         """Ensure migrations directory exists."""
+#         if not os.path.exists(self.migrations_dir):
+#             os.makedirs(self.migrations_dir)
+#             # Create __init__.py to make it a package
+#             with open(os.path.join(self.migrations_dir, "__init__.py"), "w") as f:
+#                 pass
+
+#     def collect_models(self) -> Dict[str, Type[Model]]:
+#         """Collect all model classes from the project."""
+#         models = {}
+#         # Scan all Python files in the project directory
+#         for root, _, files in os.walk("."):
+#             if "venv" in root or "migrations" in root:
+#                 continue
+#             for file in files:
+#                 if file.endswith(".py"):
+#                     module_path = os.path.join(root, file)
+#                     module_name = module_path.replace("/", ".").replace("\\", ".")[2:-3]
+#                     try:
+#                         module = importlib.import_module(module_name)
+#                         for name, obj in inspect.getmembers(module):
+#                             if inspect.isclass(obj) and issubclass(obj, Model) and obj != Model:
+#                                 models[obj.__name__] = obj
+#                     except (ImportError, AttributeError):
+#                         continue
+#         return models
+
+#     def generate_migration(self, name: str):
+#         """Generate a new migration file."""
+#         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+#         migration_id = f"{timestamp}_{name}"
+#         filename = f"{migration_id}.py"
+#         filepath = os.path.join(self.migrations_dir, filename)
+
+#         models = self.collect_models()
+
+#         # Generate migration content
+#         content = self._generate_migration_content(migration_id, models)
+
+#         with open(filepath, "w") as f:
+#             f.write(content)
+
+#         print(f"Created migration: {filename}")
+
+#     def _generate_migration_content(self, migration_id: str, models: Dict[str, Type[Model]]) -> str:
+#         """Generate the content for a migration file."""
+#         content = [
+#             "from typing import List",
+#             "from hypern.migrations import Migration\n",
+#         ]
+
+#         # Import all models
+#         for model_name in models.keys():
+#             content.append(f"from app.models import {model_name}")
+
+#         content.extend([
+#             "\n\nclass " + migration_id + "(Migration):",
+#             "    \"\"\"",
+#             "    Auto-generated migration.",
+#             "    \"\"\"",
+#             "",
+#             "    def up(self) -> List[str]:",
+#             "        return [",
+#         ])
+
+#         # Add CREATE TABLE statements
+#         for model in models.values():
+#             content.append(f"            '''{model.create_table_sql()}''',")
+
+#         content.extend([
+#             "        ]",
+#             "",
+#             "    def down(self) -> List[str]:",
+#             "        return [",
+#         ])
+
+#         # Add DROP TABLE statements in reverse order
+#         for model_name in reversed(list(models.keys())):
+#             content.append(f"            '''DROP TABLE IF EXISTS {model_name.lower()} CASCADE;''',")
+
+#         content.extend([
+#             "        ]",
+#             ""
+#         ])
+
+#         return "\n".join(content)
+
+#     def get_applied_migrations(self) -> List[str]:
+#         """Get list of applied migrations from database."""
+#         session = get_session_database()
+#         try:
+#             result = session.execute("""
+#                 SELECT migration_id FROM migrations
+#                 ORDER BY applied_at;
+#             """)
+#             return [row[0] for row in result]
+#         except Exception:
+#             # Migrations table doesn't exist yet
+#             return []
+
+#     def apply_migrations(self, target: str = None):
+#         """Apply pending migrations up to target (or all if target is None)."""
+#         # Create migrations table if it doesn't exist
+#         self._ensure_migrations_table()
+
+#         # Get applied and available migrations
+#         applied = set(self.get_applied_migrations())
+#         available = self._get_available_migrations()
+
+#         # Determine which migrations to apply
+#         to_apply = []
+#         for migration_id, module in available.items():
+#             if migration_id not in applied:
+#                 to_apply.append((migration_id, module))
+
+#             if target and migration_id == target:
+#                 break
+
+#         # Apply migrations
+#         session = get_session_database()
+#         for migration_id, module in to_apply:
+#             print(f"Applying migration: {migration_id}")
+
+#             migration = module()
+#             for sql in migration.up():
+#                 session.execute(sql)
+
+#             # Record migration
+#             session.execute(
+#                 "INSERT INTO migrations (migration_id, applied_at) VALUES (%s, NOW())",
+#                 (migration_id,)
+#             )
+#             session.commit()
+
+#     def rollback_migrations(self, target: str = None):
+#         """Rollback migrations up to target (or last one if target is None)."""
+#         applied = self.get_applied_migrations()
+#         available = self._get_available_migrations()
+
+#         # Determine which migrations to rollback
+#         to_rollback = []
+#         rollback_all = target == "zero"
+
+#         for migration_id in reversed(applied):
+#             to_rollback.append((migration_id, available[migration_id]))
+
+#             if not rollback_all and (target == migration_id or target is None):
+#                 break
+
+#         # Rollback migrations
+#         session = get_session_database()
+#         for migration_id, module in to_rollback:
+#             print(f"Rolling back migration: {migration_id}")
+
+#             migration = module()
+#             for sql in migration.down():
+#                 session.execute(sql)
+
+#             # Remove migration record
+#             session.execute(
+#                 "DELETE FROM migrations WHERE migration_id = %s",
+#                 (migration_id,)
+#             )
+#             session.commit()
+
+#     def _ensure_migrations_table(self):
+#         """Ensure migrations table exists."""
+#         session = get_session_database()
+#         session.execute("""
+#             CREATE TABLE IF NOT EXISTS migrations (
+#                 migration_id VARCHAR(255) PRIMARY KEY,
+#                 applied_at TIMESTAMP NOT NULL
+#             );
+#         """)
+#         session.commit()
+
+#     def _get_available_migrations(self) -> Dict[str, Type['Migration']]:
+#         """Get available migrations from migrations directory."""
+#         migrations = {}
+
+#         for filename in sorted(os.listdir(self.migrations_dir)):
+#             if filename.endswith(".py") and not filename.startswith("__"):
+#                 migration_id = filename[:-3]
+#                 module_name = f"{self.migrations_dir}.{migration_id}"
+#                 module = importlib.import_module(module_name)
+
+#                 for name, obj in inspect.getmembers(module):
+#                     if (inspect.isclass(obj) and
+#                         name == migration_id and
+#                         hasattr(obj, 'up') and
+#                         hasattr(obj, 'down')):
+#                         migrations[migration_id] = obj
+
+#         return migrations
+
+
+# class Migration:
+#     """Base class for database migrations."""
+
+#     def up(self) -> List[str]:
+#         """Return list of SQL statements to apply migration."""
+#         raise NotImplementedError
+
+#     def down(self) -> List[str]:
+#         """Return list of SQL statements to rollback migration."""
+#         raise NotImplementedError
+
+
+# def main():
+#     parser = argparse.ArgumentParser(description="Database migration tool")
+
+#     subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+#     # makemigrations command
+#     make_parser = subparsers.add_parser("makemigrations", help="Generate new migration")
+#     make_parser.add_argument("name", help="Migration name")
+
+#     # migrate command
+#     migrate_parser = subparsers.add_parser("migrate", help="Apply migrations")
+#     migrate_parser.add_argument("--target", help="Target migration (default: latest)")
+
+#     # rollback command
+#     rollback_parser = subparsers.add_parser("rollback", help="Rollback migrations")
+#     rollback_parser.add_argument("--target", help="Target migration (default: last applied)")
+
+#     args = parser.parse_args()
+
+#     manager = MigrationManager()
+
+#     if args.command == "makemigrations":
+#         manager.generate_migration(args.name)
+#     elif args.command == "migrate":
+#         manager.apply_migrations(args.target)
+#     elif args.command == "rollback":
+#         manager.rollback_migrations(args.target)
+#     else:
+#         parser.print_help()
+
+
+# if __name__ == "__main__":
+#     main()

hypern/database/sql/model.py

@@ -5,7 +5,7 @@ from hypern.config import context_store
 from hypern.exceptions import OutOfScopeApplicationException
 from hypern.hypern import get_session_database
 
-from .field import Field, ForeignKey
+from .field import Field, ForeignKeyField
 from .query import QuerySet
 
 
@@ -77,7 +77,7 @@ class Model(metaclass=MetaModel):
             fields_sql.append(cls._get_field_sql(name, field))
             if field.index:
                 indexes_sql.append(cls._get_index_sql(name))
-            if isinstance(field, ForeignKey):
+            if isinstance(field, ForeignKeyField):
                 foreign_keys.append(cls._get_foreign_key_sql(name, field))
 
         fields_sql.extend(foreign_keys)
@@ -109,7 +109,8 @@ class Model(metaclass=MetaModel):
 
     @classmethod
     def _get_foreign_key_sql(cls, name, field) -> str:
-        return f"FOREIGN KEY ({name}) REFERENCES {field.to_model}({field.related_field}) ON DELETE {field.on_delete} ON UPDATE {field.on_update}"
+        target_table = field.to_model.__name__.lower() if not isinstance(field.to_model, str) else field.to_model.lower()
+        return f"FOREIGN KEY ({name}) REFERENCES {target_table}({field.related_field}) ON DELETE {field.on_delete} ON UPDATE {field.on_update}"
 
     def save(self):
         query_object = QuerySet(self)

hypern/database/sql/query.py

@@ -1,6 +1,6 @@
 from enum import Enum
 from typing import Any, Dict, List, Tuple, Union
-from hypern.database.sql.field import ForeignKey
+from hypern.database.sql.field import ForeignKeyField
 
 
 class JoinType(Enum):
@@ -553,7 +553,7 @@ class QuerySet:
         """
         qs = self.clone()
         for field in fields:
-            if field in qs.model._fields and isinstance(qs.model._fields[field], ForeignKey):
+            if field in qs.model._fields and isinstance(qs.model._fields[field], ForeignKeyField):
                 qs._selected_related.add(field)
         return qs
 

hypern/datastructures.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from enum import Enum
-from pydantic import BaseModel, AnyUrl, EmailStr
+from pydantic import BaseModel, AnyUrl
 
 
 class BaseModelWithConfig(BaseModel):
@@ -10,7 +10,7 @@ class BaseModelWithConfig(BaseModel):
 class Contact(BaseModelWithConfig):
     name: Optional[str] = None
     url: Optional[AnyUrl] = None
-    email: Optional[EmailStr] = None
+    email: Optional[str] = None
 
 
 class License(BaseModelWithConfig):

hypern/hypern.pyi

@@ -7,7 +7,7 @@ from enum import Enum
 @dataclass
 class BaseSchemaGenerator:
     remove_converter: Callable[[str], str]
-    parse_docstring: Callable[[Callable[..., Any]], str]
+    parse_docstring: Callable[..., str]
 
 @dataclass
 class SwaggerUI:
@@ -181,21 +181,19 @@ class Server:
     def set_router(self, router: Router) -> None: ...
     def set_websocket_router(self, websocket_router: WebsocketRouter) -> None: ...
     def start(self, socket: SocketHeld, worker: int, max_blocking_threads: int) -> None: ...
-    def inject(self, key: str, value: Any) -> None: ...
-    def set_injected(self, injected: Dict[str, Any]) -> None: ...
     def set_before_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_after_hooks(self, hooks: List[FunctionInfo]) -> None: ...
     def set_response_headers(self, headers: Dict[str, str]) -> None: ...
     def set_startup_handler(self, on_startup: FunctionInfo) -> None: ...
     def set_shutdown_handler(self, on_shutdown: FunctionInfo) -> None: ...
-    def set_auto_compression(self, enabled: bool) -> None: ...
     def set_database_config(self, config: DatabaseConfig) -> None: ...
-    def set_mem_pool_capacity(self, min_capacity: int, max_capacity: int) -> None: ...
+    def set_dependencies(self, dependencies: Dict[str, Any]) -> None: ...
 
 class Route:
     path: str
     function: FunctionInfo
     method: str
+    doc: str | None = None
 
     def matches(self, path: str, method: str) -> str: ...
     def clone_route(self) -> Route: ...
@@ -277,7 +275,7 @@ class UploadedFile:
     path: str
     size: int
     content: bytes
-    filename: str
+    file_name: str
 
 @dataclass
 class BodyData:
@@ -330,8 +328,5 @@ class DatabaseTransaction:
     def bulk_change(self, query: str, params: List[List[Any]], batch_size: int) -> int | None: ...
     def commit(self) -> None: ...
     def rollback(self) -> None: ...
-    def __del__(self) -> None: ...
-    def __enter__(self) -> None: ...
-    def __exit__(self, _exc_type, _exc_value, _traceback) -> None: ...
 
 def get_session_database(context_id: str) -> DatabaseTransaction: ...

hypern/openapi/schemas.py

@@ -37,17 +37,15 @@ class SchemaGenerator(BaseSchemaGenerator):
     def get_schema(self, app) -> dict[str, typing.Any]:
         schema = dict(self.base_schema)
         schema.setdefault("paths", {})
-        endpoints_info = self.get_endpoints(app.router.routes)
-
-        for endpoint in endpoints_info:
-            parsed = self.parse_docstring(endpoint.func)
+        for route in app.router.routes:
+            parsed = self.parse_docstring(route.doc)
 
             if not parsed:
                 continue
 
-            if endpoint.path not in schema["paths"]:
-                schema["paths"][endpoint.path] = {}
+            if route.path not in schema["paths"]:
+                schema["paths"][route.path] = {}
 
-            schema["paths"][endpoint.path][endpoint.http_method] = orjson.loads(parsed)
+            schema["paths"][route.path][route.method.lower()] = orjson.loads(parsed)
 
         return schema

hypern/routing/route.py

@@ -224,8 +224,8 @@ class Route:
             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()))
+        for route in self.functional_handlers:
+            router.add_route(route=route)
         if not self.endpoint:
             return router
 
@@ -234,9 +234,10 @@ class Route:
             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()))
+                route = self.make_internal_route(path="/", handler=endpoint_obj.dispatch, method=name.upper())
+                route.doc = doc
+                router.add_route(route=route)
                 del endpoint_obj  # free up memory
         return router
 
@@ -250,15 +251,10 @@ class Route:
                 return await dispatch(func, request, inject)
 
             sig = inspect.signature(func)
-            functional_wrapper.__doc__ = self.swagger_generate(sig, func.__doc__)
+            route = self.make_internal_route(path=path, handler=functional_wrapper, method=method.upper())
+            route.doc = self.swagger_generate(sig, func.__doc__)
 
-            self.functional_handlers.append(
-                {
-                    "path": path,
-                    "method": method,
-                    "func": functional_wrapper,
-                }
-            )
+            self.functional_handlers.append(route)
 
         return decorator