hypern 0.3.5__cp312-cp312-win32.whl → 0.3.7__cp312-cp312-win32.whl

hypern/database/sql/__init__.py

@@ -1,11 +1,34 @@
 # from .context import SqlConfig, DatabaseType
-from .field import CharField, IntegerField
+from .field import (
+    CharField,
+    IntegerField,
+    TextField,
+    FloatField,
+    BooleanField,
+    ForeignKeyField,
+    DateTimeField,
+    Field,
+    JSONField,
+    ArrayField,
+    DecimalField,
+    DateField,
+)
 from .model import Model
 from .query import F, Q, QuerySet
 
 __all__ = [
     "CharField",
     "IntegerField",
+    "TextField",
+    "FloatField",
+    "BooleanField",
+    "ForeignKeyField",
+    "DateTimeField",
+    "Field",
+    "JSONField",
+    "ArrayField",
+    "DecimalField",
+    "DateField",
     "Model",
     "Q",
     "F",

hypern/database/sql/field.py

@@ -1,8 +1,7 @@
 import json
-import re
-from datetime import date, datetime, timezone
+from datetime import date, datetime
 from decimal import Decimal, InvalidOperation
-from typing import Any, Callable, List, Optional, Union
+from typing import Any, Optional, Union
 
 from hypern.exceptions import DBFieldValidationError
 
@@ -18,20 +17,9 @@ class Field:
         default: Any = None,
         unique: bool = False,
         index: bool = False,
-        validators: Optional[list[Callable]] = None,
+        validators: Optional[list] = None,
         auto_increment: bool = False,
     ):
-        """
-        Initialize a field with various constraints and validation options.
-
-        :param field_type: Type of the field
-        :param primary_key: Whether the field is a primary key
-        :param null: Whether the field can be null
-        :param default: Default value for the field
-        :param unique: Whether the field value must be unique
-        :param index: Whether to create an index for this field
-        :param validators: List of custom validator functions
-        """
         self.field_type = field_type
         self.primary_key = primary_key
         self.null = null
@@ -43,23 +31,20 @@ class Field:
         self.model = None
         self.auto_increment = auto_increment
 
-    def to_py_type(self, value: Any) -> Any:
-        """
-        Convert input value to the field's Python type.
-
-        :param value: Input value to convert
-        :return: Converted value
-        """
+    def validate(self, value: Any) -> None:
         if value is None:
-            return None
-        return value
+            if not self.null:
+                raise DBFieldValidationError(f"Field {self.name} cannot be null")
+            return
 
-    def to_sql_type(self) -> str:
-        """
-        Get the SQL type representation of the field.
+        for validator in self.validators:
+            try:
+                validator(value)
+            except Exception as e:
+                raise DBFieldValidationError(f"Validation failed for {self.name}: {str(e)}")
 
-        :return: SQL type string
-        """
+    def sql_type(self) -> str:
+        """Return SQL type definition for the field."""
         type_mapping = {
             "int": "INTEGER",
             "str": "VARCHAR(255)",
@@ -74,534 +59,188 @@ class Field:
         }
         return type_mapping.get(self.field_type, "VARCHAR(255)")
 
-    def validate(self, value: Any) -> None:
-        """
-        Validate the input value against field constraints.
-
-        :param value: Value to validate
-        :raises DBFieldValidationError: If validation fails
-        """
-        # Null check
-        if value is None:
-            if not self.null:
-                raise DBFieldValidationError(f"Field {self.name} cannot be null")
-            return
-
-        # Run custom validators
-        for validator in self.validators:
-            try:
-                validator(value)
-            except Exception as e:
-                raise DBFieldValidationError(f"Validation failed for {self.name}: {str(e)}")
-
 
 class CharField(Field):
-    """Character field with max length constraint."""
-
-    def __init__(self, max_length: int = 255, min_length: int = 0, regex: Optional[str] = None, **kwargs):
-        """
-        Initialize a character field.
-
-        :param max_length: Maximum allowed length
-        :param min_length: Minimum allowed length
-        :param regex: Optional regex pattern for validation
-        """
-        super().__init__("str", **kwargs)
+    def __init__(self, max_length: int = 255, **kwargs):
+        super().__init__(field_type="str", **kwargs)
         self.max_length = max_length
-        self.min_length = min_length
-        self.regex = regex
-
-    def to_py_type(self, value: Any) -> Optional[str]:
-        """Convert input to string."""
-        if value is None:
-            return None
-        return str(value)
-
-    def to_sql_type(self) -> str:
-        """Get SQL type with defined max length."""
-        return f"VARCHAR({self.max_length})"
 
     def validate(self, value: Any) -> None:
-        """
-        Validate character field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
+        if value is not None:
+            if not isinstance(value, str):
+                raise DBFieldValidationError(f"Field {self.name} must be a string")
+            if len(value) > self.max_length:
+                raise DBFieldValidationError(f"Field {self.name} cannot exceed {self.max_length} characters")
 
-        if value is None:
-            return
-
-        # Convert to string for validation
-        str_value = str(value)
+    def sql_type(self) -> str:
+        return f"VARCHAR({self.max_length})"
 
-        # Length validation
-        if len(str_value) > self.max_length:
-            raise DBFieldValidationError(f"Value exceeds max length of {self.max_length}")
 
-        if len(str_value) < self.min_length:
-            raise DBFieldValidationError(f"Value is shorter than min length of {self.min_length}")
+class TextField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="text", **kwargs)
 
-        # Regex validation
-        if self.regex and not re.match(self.regex, str_value):
-            raise DBFieldValidationError(f"Value does not match required pattern: {self.regex}")
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, str):
+            raise DBFieldValidationError(f"Field {self.name} must be a string")
 
 
 class IntegerField(Field):
-    """Integer field with range constraints."""
-
-    def __init__(self, min_value: Optional[int] = None, max_value: Optional[int] = None, **kwargs):
-        """
-        Initialize an integer field.
-
-        :param min_value: Minimum allowed value
-        :param max_value: Maximum allowed value
-        """
-        super().__init__("int", **kwargs)
-        self.min_value = min_value
-        self.max_value = max_value
-
-    def to_py_type(self, value: Any) -> Optional[int]:
-        """Convert input to integer."""
-        if value is None:
-            return None
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            raise DBFieldValidationError(f"Cannot convert {value} to integer")
+    def __init__(self, **kwargs):
+        super().__init__(field_type="int", **kwargs)
 
     def validate(self, value: Any) -> None:
-        """
-        Validate integer field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
+        if value is not None:
+            try:
+                int(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be an integer")
 
-        if value is None:
-            return
-
-        int_value = self.to_py_type(value)
-
-        # Range validation
-        if self.min_value is not None and int_value < self.min_value:
-            raise DBFieldValidationError(f"Value must be >= {self.min_value}")
-
-        if self.max_value is not None and int_value > self.max_value:
-            raise DBFieldValidationError(f"Value must be <= {self.max_value}")
-
-
-class DecimalField(Field):
-    """Decimal field with precision and scale constraints."""
-
-    def __init__(
-        self,
-        max_digits: int = 10,
-        decimal_places: int = 2,
-        min_value: Optional[Union[int, float, Decimal]] = None,
-        max_value: Optional[Union[int, float, Decimal]] = None,
-        **kwargs,
-    ):
-        """
-        Initialize a decimal field.
-
-        :param max_digits: Total number of digits
-        :param decimal_places: Number of decimal places
-        :param min_value: Minimum allowed value
-        :param max_value: Maximum allowed value
-        """
-        super().__init__("decimal", **kwargs)
-        self.max_digits = max_digits
-        self.decimal_places = decimal_places
-        self.min_value = min_value
-        self.max_value = max_value
-
-    def to_py_type(self, value: Any) -> Optional[Decimal]:
-        """Convert input to Decimal."""
-        if value is None:
-            return None
-        try:
-            decimal_value = Decimal(str(value))
 
-            # Check precision
-            parts = str(decimal_value).split(".")
-            total_digits = len(parts[0].lstrip("-")) + (len(parts[1]) if len(parts) > 1 else 0)
-            decimal_digits = len(parts[1]) if len(parts) > 1 else 0
+class FloatField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="float", **kwargs)
 
-            if total_digits > self.max_digits or decimal_digits > self.decimal_places:
-                raise DBFieldValidationError(f"Decimal exceeds precision: {self.max_digits} digits, {self.decimal_places} decimal places")
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None:
+            try:
+                float(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be a float")
 
-            return decimal_value
-        except (TypeError, ValueError, InvalidOperation):
-            raise DBFieldValidationError(f"Cannot convert {value} to Decimal")
 
-    def to_sql_type(self) -> str:
-        """Get SQL type with defined precision."""
-        return f"DECIMAL({self.max_digits},{self.decimal_places})"
+class BooleanField(Field):
+    def __init__(self, **kwargs):
+        super().__init__(field_type="bool", **kwargs)
 
     def validate(self, value: Any) -> None:
-        """
-        Validate decimal field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
+        if value is not None and not isinstance(value, bool):
+            raise DBFieldValidationError(f"Field {self.name} must be a boolean")
 
-        if value is None:
-            return
 
-        decimal_value = self.to_py_type(value)
-
-        # Range validation
-        if self.min_value is not None and decimal_value < Decimal(str(self.min_value)):
-            raise DBFieldValidationError(f"Value must be >= {self.min_value}")
+class DateTimeField(Field):
+    def __init__(self, auto_now: bool = False, auto_now_add: bool = False, **kwargs):
+        super().__init__(field_type="datetime", **kwargs)
+        self.auto_now = auto_now
+        self.auto_now_add = auto_now_add
 
-        if self.max_value is not None and decimal_value > Decimal(str(self.max_value)):
-            raise DBFieldValidationError(f"Value must be <= {self.max_value}")
+    def validate(self, value: Any) -> None:
+        super().validate(value)
+        if value is not None and not isinstance(value, datetime):
+            raise DBFieldValidationError(f"Field {self.name} must be a datetime object")
 
 
 class DateField(Field):
-    """Date field with range constraints."""
-
-    def __init__(self, auto_now: bool = False, auto_now_add: bool = False, min_date: Optional[date] = None, max_date: Optional[date] = None, **kwargs):
-        """
-        Initialize a date field.
-
-        :param auto_now: Update to current date on every save
-        :param auto_now_add: Set to current date when first created
-        :param min_date: Minimum allowed date
-        :param max_date: Maximum allowed date
-        """
-        super().__init__("date", **kwargs)
+    def __init__(self, auto_now: bool = False, auto_now_add: bool = False, **kwargs):
+        super().__init__(field_type="date", **kwargs)
         self.auto_now = auto_now
         self.auto_now_add = auto_now_add
-        self.min_date = min_date
-        self.max_date = max_date
-
-    def to_py_type(self, value: Any) -> Optional[date]:
-        """Convert input to date."""
-        if value is None:
-            return None
-
-        if isinstance(value, date):
-            return value
-
-        try:
-            return date.fromisoformat(str(value))
-        except ValueError:
-            raise DBFieldValidationError(f"Cannot convert {value} to date")
 
     def validate(self, value: Any) -> None:
-        """
-        Validate date field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
-
-        if value is None:
-            return
-
-        date_value = self.to_py_type(value)
-
-        # Range validation
-        if self.min_date is not None and date_value < self.min_date:
-            raise DBFieldValidationError(f"Date must be >= {self.min_date}")
-
-        if self.max_date is not None and date_value > self.max_date:
-            raise DBFieldValidationError(f"Date must be <= {self.max_date}")
+        if value is not None and not isinstance(value, date):
+            raise DBFieldValidationError(f"Field {self.name} must be a date object")
 
 
 class JSONField(Field):
-    """JSON field with optional schema validation."""
-
-    def __init__(self, schema: Optional[dict] = None, **kwargs):
-        """
-        Initialize a JSON field.
-
-        :param schema: Optional JSON schema for validation
-        """
-        super().__init__("json", **kwargs)
-        self.schema = schema
-
-    def to_py_type(self, value: Any) -> Optional[dict]:
-        """Convert input to JSON."""
-        if value is None:
-            return None
-
-        if isinstance(value, str):
-            try:
-                return json.loads(value)
-            except json.JSONDecodeError:
-                raise DBFieldValidationError(f"Invalid JSON string: {value}")
-
-        if isinstance(value, dict):
-            return value
-
-        raise DBFieldValidationError(f"Cannot convert {value} to JSON")
+    def __init__(self, **kwargs):
+        super().__init__(field_type="json", **kwargs)
 
     def validate(self, value: Any) -> None:
-        """
-        Validate JSON field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
-
-        if value is None:
-            return
-
-        json_value = self.to_py_type(value)
-
-        # Schema validation
-        if self.schema:
-            from jsonschema import DBFieldValidationError as JsonSchemaError
-            from jsonschema import validate
-
+        if value is not None:
             try:
-                validate(instance=json_value, schema=self.schema)
-            except JsonSchemaError as e:
-                raise DBFieldValidationError(f"JSON schema validation failed: {str(e)}")
+                json.dumps(value)
+            except (TypeError, ValueError):
+                raise DBFieldValidationError(f"Field {self.name} must be JSON serializable")
 
 
 class ArrayField(Field):
-    """Array field with base field type validation."""
-
-    def __init__(self, base_field: Field, min_length: Optional[int] = None, max_length: Optional[int] = None, **kwargs):
-        """
-        Initialize an array field.
-
-        :param base_field: Field type for array elements
-        :param min_length: Minimum number of elements
-        :param max_length: Maximum number of elements
-        """
-        super().__init__("array", **kwargs)
+    def __init__(self, base_field: Field, **kwargs):
+        super().__init__(field_type="array", **kwargs)
         self.base_field = base_field
-        self.min_length = min_length
-        self.max_length = max_length
-
-    def to_py_type(self, value: Any) -> Optional[List[Any]]:
-        """
-        Convert input to a list with base field type conversion.
-
-        :param value: Input value to convert
-        :return: Converted list
-        """
-        if value is None:
-            return None
-
-        # Ensure input is a list
-        if not isinstance(value, list):
-            try:
-                value = list(value)
-            except TypeError:
-                raise DBFieldValidationError(f"Cannot convert {value} to list")
-
-        # Convert each element using base field's to_py_type
-        return [self.base_field.to_py_type(item) for item in value]
-
-    def to_sql_type(self) -> str:
-        """
-        Get SQL type representation of the array.
-
-        :return: SQL array type string
-        """
-        return f"{self.base_field.to_sql_type()}[]"
 
     def validate(self, value: Any) -> None:
-        """
-        Validate array field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
+        if value is not None:
+            if not isinstance(value, (list, tuple)):
+                raise DBFieldValidationError(f"Field {self.name} must be a list or tuple")
+            for item in value:
+                self.base_field.validate(item)
 
-        if value is None:
-            return
-
-        # Ensure we have a list
-        list_value = self.to_py_type(value)
-
-        # Length validation
-        if self.min_length is not None and len(list_value) < self.min_length:
-            raise DBFieldValidationError(f"Array must have at least {self.min_length} elements")
-
-        if self.max_length is not None and len(list_value) > self.max_length:
-            raise DBFieldValidationError(f"Array must have no more than {self.max_length} elements")
+    def sql_type(self) -> str:
+        return f"{self.base_field.sql_type()}[]"
 
-        # Validate each element using base field's validate method
-        for item in list_value:
-            self.base_field.validate(item)
 
-
-class ForeignKey(Field):
-    """Foreign key field representing a relationship to another model."""
-
-    def __init__(self, to_model: str, related_field: str, on_delete: str = "CASCADE", on_update: str = "CASCADE", **kwargs):
-        """
-        Initialize a foreign key field.
-
-        :param to_model: Name of the related model
-        :param on_delete: Action to take on related record deletion
-        :param on_update: Action to take on related record update
-        """
-        # Allow overriding primary key and null status if not specified
-        if "primary_key" not in kwargs:
-            kwargs["primary_key"] = False
-        if "null" not in kwargs:
-            kwargs["null"] = False
-
-        super().__init__("int", **kwargs)
-        self.to_model = to_model
-        self.on_delete = on_delete
-        self.on_update = on_update
-        self.related_field = related_field
-
-    def to_py_type(self, value: Any) -> Optional[int]:
-        """
-        Convert input to integer representing foreign key.
-
-        :param value: Value to convert
-        :return: Converted integer
-        """
-        if value is None:
-            return None
-
-        try:
-            return int(value)
-        except (TypeError, ValueError):
-            raise DBFieldValidationError(f"Cannot convert {value} to integer foreign key")
-
-    def to_sql_type(self) -> str:
-        """
-        Get SQL type for foreign key.
-
-        :return: SQL integer type string
-        """
-        return "INTEGER"
+class DecimalField(Field):
+    def __init__(self, max_digits: int = 10, decimal_places: int = 2, **kwargs):
+        super().__init__(field_type="decimal", **kwargs)
+        self.max_digits = max_digits
+        self.decimal_places = decimal_places
 
     def validate(self, value: Any) -> None:
-        """
-        Validate foreign key constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
+        if value is not None:
+            try:
+                decimal_value = Decimal(str(value))
+                decimal_tuple = decimal_value.as_tuple()
+                if len(decimal_tuple.digits) - (-decimal_tuple.exponent) > self.max_digits:
+                    raise DBFieldValidationError(f"Field {self.name} exceeds maximum digits {self.max_digits}")
+                if -decimal_tuple.exponent > self.decimal_places:
+                    raise DBFieldValidationError(f"Field {self.name} exceeds maximum decimal places {self.decimal_places}")
+            except InvalidOperation:
+                raise DBFieldValidationError(f"Field {self.name} must be a valid decimal number")
+
+    def sql_type(self) -> str:
+        return f"DECIMAL({self.max_digits},{self.decimal_places})"
 
 
-class DateTimeField(Field):
-    """DateTime field with advanced validation and auto-update capabilities."""
+class ForeignKeyField(Field):
+    """Field for foreign key relationships."""
 
     def __init__(
         self,
-        auto_now: bool = False,
-        auto_now_add: bool = False,
-        min_datetime: Optional[datetime] = None,
-        max_datetime: Optional[datetime] = None,
-        timezone_aware: bool = True,
+        to_model: Union[str, Any],
+        related_field: str = "id",
+        on_delete: str = "CASCADE",
+        on_update: str = "CASCADE",
+        related_name: Optional[str] = None,
         **kwargs,
     ):
-        """
-        Initialize a datetime field.
-
-        :param auto_now: Update to current datetime on every save
-        :param auto_now_add: Set to current datetime when first created
-        :param min_datetime: Minimum allowed datetime
-        :param max_datetime: Maximum allowed datetime
-        :param timezone_aware: Enforce timezone awareness
-        """
-        super().__init__("datetime", **kwargs)
-        self.auto_now = auto_now
-        self.auto_now_add = auto_now_add
-        self.min_datetime = min_datetime
-        self.max_datetime = max_datetime
-        self.timezone_aware = timezone_aware
-
-    def to_py_type(self, value: Any) -> Optional[datetime]:
-        """
-        Convert input to datetime with robust parsing.
-
-        :param value: Value to convert
-        :return: Converted datetime
-        """
-        if value is None:
-            return None
-
-        # If already a datetime, handle timezone
-        if isinstance(value, datetime):
-            return self._handle_timezone(value)
-
-        # String parsing with multiple formats
-        if isinstance(value, str):
-            try:
-                # ISO format parsing
-                parsed_datetime = datetime.fromisoformat(value)
-                return self._handle_timezone(parsed_datetime)
-            except ValueError:
-                # Additional parsing formats can be added
-                try:
-                    # Alternative parsing (e.g., common formats)
-                    parsed_datetime = datetime.strptime(value, "%Y-%m-%d %H:%M:%S")
-                    return self._handle_timezone(parsed_datetime)
-                except ValueError:
-                    raise DBFieldValidationError(f"Cannot parse datetime from: {value}")
-
-        # Attempt generic conversion
-        try:
-            converted_datetime = datetime.fromtimestamp(float(value))
-            return self._handle_timezone(converted_datetime)
-        except (TypeError, ValueError):
-            raise DBFieldValidationError(f"Cannot convert {value} to datetime")
-
-    def _handle_timezone(self, dt: datetime) -> datetime:
-        """
-        Handle timezone requirements.
-
-        :param dt: Input datetime
-        :return: Timezone-adjusted datetime
-        """
-        if self.timezone_aware:
-            # If no timezone, assume UTC
-            if dt.tzinfo is None:
-                dt = dt.replace(tzinfo=timezone.utc)
+        if isinstance(to_model, str):
+            field_type = "int"
         else:
-            # Remove timezone if not required
-            dt = dt.replace(tzinfo=None)
+            related_field_obj = getattr(to_model, related_field, None)
+            if related_field_obj is None:
+                raise ValueError(f"Field {related_field} not found in model {to_model.__name__}")
+            field_type = related_field_obj.field_type
 
-        return dt
+        super().__init__(field_type=field_type, **kwargs)
+        self.to_model = to_model
+        self.related_field = related_field
+        self.on_delete = on_delete.upper()
+        self.on_update = on_update.upper()
+        self.related_name = related_name
 
-    def to_sql_type(self) -> str:
-        """
-        Get SQL type for datetime.
+        valid_actions = {"CASCADE", "SET NULL", "RESTRICT", "NO ACTION"}
+        if self.on_delete not in valid_actions:
+            raise ValueError(f"Invalid on_delete action. Must be one of: {valid_actions}")
+        if self.on_update not in valid_actions:
+            raise ValueError(f"Invalid on_update action. Must be one of: {valid_actions}")
 
-        :return: SQL timestamp type string
-        """
-        return "TIMESTAMP"
+        if (self.on_delete == "SET NULL" or self.on_update == "SET NULL") and not kwargs.get("null", True):
+            raise ValueError("Field must be nullable to use SET NULL referential action")
 
     def validate(self, value: Any) -> None:
-        """
-        Validate datetime field constraints.
-
-        :param value: Value to validate
-        """
         super().validate(value)
-
-        if value is None:
-            return
-
-        datetime_value = self.to_py_type(value)
-
-        # Range validation
-        if self.min_datetime is not None:
-            min_dt = self._handle_timezone(self.min_datetime)
-            if datetime_value < min_dt:
-                raise DBFieldValidationError(f"Datetime must be >= {min_dt}")
-
-        if self.max_datetime is not None:
-            max_dt = self._handle_timezone(self.max_datetime)
-            if datetime_value > max_dt:
-                raise DBFieldValidationError(f"Datetime must be <= {max_dt}")
-
-        # Timezone awareness check
-        if self.timezone_aware and datetime_value.tzinfo is None:
-            raise DBFieldValidationError("Datetime must be timezone-aware")
+        if value is not None and not isinstance(self.to_model, str):
+            related_field_obj = getattr(self.to_model, self.related_field)
+            try:
+                related_field_obj.validate(value)
+            except DBFieldValidationError as e:
+                raise DBFieldValidationError(f"Foreign key {self.name} validation failed: {str(e)}")

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/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:
@@ -196,6 +196,7 @@ 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: ...
@@ -330,8 +331,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
 

{hypern-0.3.5.dist-info → hypern-0.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypern
-Version: 0.3.5
+Version: 0.3.7
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -26,6 +26,7 @@ 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
 License-File: LICENSE
 Summary: A Fast Async Python backend with a Rust runtime.
 Author-email: Martin Dang <vannghiem848@gmail.com>

{hypern-0.3.5.dist-info → hypern-0.3.7.dist-info}/RECORD

@@ -1,6 +1,6 @@
-hypern-0.3.5.dist-info/METADATA,sha256=Lhxf8FMnS1RvE17wHATRz6F1-v0S3IYcXrGmzWkm3Jg,3850
-hypern-0.3.5.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
-hypern-0.3.5.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
+hypern-0.3.7.dist-info/METADATA,sha256=Sxz9aJX0DPkYH0LaD6PqhN6FWpAd2nVrrm1Iu848bp8,3879
+hypern-0.3.7.dist-info/WHEEL,sha256=SK_cql1gpDHx6aBV-LOSvGbTt4TUC8AJJOzjOP2tdpI,92
+hypern-0.3.7.dist-info/licenses/LICENSE,sha256=qbYKAIJLS6jYg5hYncKE7OtWmqOtpVTvKNkwOa0Iwwg,1328
 hypern/application.py,sha256=DCYFtU8e8NhQtmfaXbUfOxR2_Y3fEn-pzce9OOs6S4U,18396
 hypern/args_parser.py,sha256=zTfLfBoKBvYWxdPjabTfZsCtYF3La3PT0TD8dfLMeM4,2815
 hypern/auth/authorization.py,sha256=-NprZsI0np889ZN1fp-MiVFrPoMNzUtatBJaCMtkllM,32
@@ -31,10 +31,11 @@ hypern/database/nosql/addons/password.py,sha256=jfZxvWFm6nV9EWpXq5Mj-jpqnl9QbokZ
 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=tSs8iaYjy-K6nplJJ-1X4OQddzW76cfBlx9xTrG_NbQ,20073
-hypern/database/sql/model.py,sha256=BLRmOlmfn6ibedR9Bv_rHErSruudJ24B9-nDbRHqWm4,3913
-hypern/database/sql/query.py,sha256=tQ7Wss2NAIqsAH0M-fT5m9DU_MsiBR0DcoyTbS_aatU,33335
-hypern/database/sql/__init__.py,sha256=lCOGNTHaXNSJbuLLIOe2IWWNmX0MFQFPNCl2yytD2Xs,261
+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/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hypern/datastructures.py,sha256=zZGGSP07kPc9KJDf11hX5uYhAyRE-Ck5wezW5QtOVXw,897
 hypern/enum.py,sha256=KcVziJj7vWvyie0r2rtxhrLzdtkZAsf0DY58oJ4tQl4,360
@@ -49,7 +50,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=yXaWGPt598gwPN-CT1ARDdwOSqryZCBFuDLQC8gRd1U,9345
+hypern/hypern.pyi,sha256=f0kHWHI4creyAezdPlr-HOX87xqpCyYpu6cFGpbFCe4,9210
 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
@@ -61,7 +62,7 @@ hypern/middleware/i18n.py,sha256=jHzVzjTx1nnjbraZtIVOprrnSaeKMxZB8RuSqRp2I4s,16
 hypern/middleware/limit.py,sha256=eAYARPjqxq8Ue0TCpnxlVRB5hv7hwBF0PxeD-bG6Sl0,8252
 hypern/middleware/security.py,sha256=fGBSF7n2iKBtDHE2QW4q_sQE4awYgaYxVUFKsDHkMXg,7675
 hypern/middleware/__init__.py,sha256=V-Gnv-Jf-14BVuA28z7PN7GBVQ9BBiBdab6-QnTPCfY,493
-hypern/openapi/schemas.py,sha256=YHfMlPUeP5DzDX5ao3YH8p_25Vvyaf616dh6XDCUZRc,1677
+hypern/openapi/schemas.py,sha256=hsqSPpwsOETQ5NoGiR9Ay0qEp6GxJ2xhh69rzwxx0CY,1598
 hypern/openapi/swagger.py,sha256=naqUY3rFAEYA1ZLIlmDsMYaol0yIm6TVebdkFa5cMTc,64
 hypern/openapi/__init__.py,sha256=4rEVD8pa0kdSpsy7ZkJ5JY0Z2XF0NGSKDMwYAd7YZpE,141
 hypern/processpool.py,sha256=qEsu9WXWc3_Cl0Frn1jGs7jUJho45zck5L5Ww81Vm70,3883
@@ -73,7 +74,7 @@ hypern/routing/dispatcher.py,sha256=NAVjILlEJjYrixJZ4CO4N1CKkuqbk4TGZOjnQNTTEu4,
 hypern/routing/endpoint.py,sha256=RKVhvqOEGL9IKBXQ3KJgPi9bgJj9gfWC5BdZc5U_atc,1026
 hypern/routing/parser.py,sha256=0tJVVNwHC3pWDsehwH6SwJv8_gEuDjltVXrNQWbHyrU,3426
 hypern/routing/queue.py,sha256=NtFBbogU22ddyyX-CuQMip1XFDPZdMCVMIeUCQ-CR6Y,7176
-hypern/routing/route.py,sha256=IUnWU5ra-0R9rrRDpxJiwiw7vaEefn-We2dZ4EocJGw,10403
+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
@@ -85,5 +86,5 @@ hypern/ws/route.py,sha256=fGQ2RC708MPOiiIHPUo8aZ-oK379TTAyQYm4htNA5jM,803
 hypern/ws/__init__.py,sha256=dhRoRY683_rfPfSPM5qUczfTuyYDeuLOCFxY4hIdKt8,131
 hypern/ws.py,sha256=F6SA2Z1KVnqTEX8ssvOXqCtudUS4eo30JsiIsvfbHnE,394
 hypern/__init__.py,sha256=9Ww_aUQ0vJls0tOq7Yw1_TVOCRsa5bHJ-RtnSeComwk,119
-hypern/hypern.cp312-win32.pyd,sha256=vNJOrF5I7_yOmuisz19FaH0C2M5CsHxv1SWLm-CzQOk,9797632
-hypern-0.3.5.dist-info/RECORD,,
+hypern/hypern.cp312-win32.pyd,sha256=CI_xA65mZqW-8yj7IeYzsjP9Xtp6gyF4LVGt6arbfnE,9805824
+hypern-0.3.7.dist-info/RECORD,,