core-framework 0.12.13__tar.gz → 0.12.14__tar.gz

{core_framework-0.12.13 → core_framework-0.12.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.13
+Version: 0.12.14
 Summary: Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema.
 Project-URL: Homepage, https://github.com/SorPuti/core-framework
 Project-URL: Documentation, https://github.com/SorPuti/core-framework#readme

{core_framework-0.12.13 → core_framework-0.12.14}/core/__init__.py

@@ -287,7 +287,7 @@ from core.exceptions import (
     MissingDependency,
 )
 
-__version__ = "0.12.13"
+__version__ = "0.12.14"
 __all__ = [
     # Models
     "Model",

{core_framework-0.12.13 → core_framework-0.12.14}/core/migrations/engine.py

@@ -52,6 +52,41 @@ if TYPE_CHECKING:
 MIGRATIONS_TABLE = "_core_migrations"
 
 
+def _detect_extra_imports(ops_code: str) -> list[str]:
+    """
+    Detect and return extra import statements needed for migration code.
+    
+    Analyzes the generated operation code to find references like:
+    - timezone.now -> from core.datetime import timezone
+    - AdvancedField.xxx -> from core.fields import AdvancedField
+    
+    Args:
+        ops_code: The generated operation code string
+    
+    Returns:
+        List of import statements to add to the migration file
+    """
+    imports = set()
+    
+    # Patterns for short-form callable references
+    # These match the output of _serialize_default()
+    patterns = [
+        # timezone.xxx -> from core.datetime import timezone
+        # Match timezone.now but not datetime.timezone.now
+        (r'(?<![.\w])timezone\.\w+', 'from core.datetime import timezone'),
+        # AdvancedField.xxx -> from core.fields import AdvancedField  
+        (r'(?<![.\w])AdvancedField\.\w+', 'from core.fields import AdvancedField'),
+        # datetime.xxx -> from datetime import datetime (for full module path)
+        (r'(?<![.\w])datetime\.\w+', 'from datetime import datetime'),
+    ]
+    
+    for pattern, import_stmt in patterns:
+        if re.search(pattern, ops_code):
+            imports.add(import_stmt)
+    
+    return sorted(imports)
+
+
 def _get_migrations_table_sql(dialect: str) -> str:
     """
     Returns dialect-specific SQL for creating migrations table.
@@ -442,6 +477,10 @@ class MigrationEngine:
         
         ops_str = ",\n".join(ops_code) if ops_code else "    # No operations"
         
+        # Detect and add extra imports needed for callable defaults
+        extra_imports = _detect_extra_imports(ops_str)
+        extra_imports_str = "\n".join(extra_imports) + "\n" if extra_imports else ""
+        
         return f'''"""
 Migration: {name}
 Generated at: {timezone.now().isoformat()}
@@ -467,7 +506,7 @@ from core.migrations.operations import (
     DropEnum,
     AlterEnum,
 )
-
+{extra_imports_str}
 
 migration = Migration(
     name="{name}",

{core_framework-0.12.13 → core_framework-0.12.14}/core/migrations/operations.py

@@ -26,7 +26,7 @@ def _serialize_default(value: Any) -> str:
     - None -> "None"
     - Strings -> repr()
     - Booleans -> "True"/"False"
-    - Callables -> "module.function" (importable reference)
+    - Callables -> short name (e.g., "timezone.now" not "core.datetime.timezone.now")
     - Other -> repr()
     
     Args:
@@ -41,11 +41,21 @@ def _serialize_default(value: Any) -> str:
     if callable(value):
         # Get module and function name for proper serialization
         module = getattr(value, "__module__", "")
-        name = getattr(value, "__qualname__", "") or getattr(value, "__name__", "")
-        
-        if module and name:
-            # Return importable reference
-            return f"{module}.{name}"
+        qualname = getattr(value, "__qualname__", "") or getattr(value, "__name__", "")
+        
+        if module and qualname:
+            # Use short form for known modules to avoid long paths
+            # e.g., "core.datetime.timezone.now" -> "timezone.now"
+            # The corresponding import will be added to the migration file
+            if module == "core.datetime" and qualname.startswith("timezone."):
+                return qualname  # Returns "timezone.now"
+            if module == "core.fields" and qualname.startswith("AdvancedField."):
+                return qualname  # Returns "AdvancedField.json_field..."
+            if module == "datetime":
+                return f"datetime.{qualname}"  # Returns "datetime.now"
+            
+            # For other modules, return full path
+            return f"{module}.{qualname}"
         
         # Fallback for lambdas or unnamed functions
         return "None"
@@ -139,10 +149,30 @@ class ColumnDef:
             
         Returns:
             String SQL para o default ou None
+            
+        Note:
+            Callable defaults (like timezone.now) cannot be used as SQL DEFAULT.
+            They are handled by the application layer when creating records.
+            For timestamp defaults, use server-side defaults like CURRENT_TIMESTAMP.
         """
         if self.default is None:
             return None
         
+        # Callable defaults cannot be used in SQL - they're Python functions
+        # The ORM handles these when creating records
+        if callable(self.default):
+            # For datetime-related callables, use SQL equivalent
+            func_name = getattr(self.default, "__name__", "") or getattr(self.default, "__qualname__", "")
+            if "now" in func_name.lower() or "utcnow" in func_name.lower():
+                if dialect == "postgresql":
+                    return "DEFAULT CURRENT_TIMESTAMP"
+                elif dialect == "sqlite":
+                    return "DEFAULT CURRENT_TIMESTAMP"
+                elif dialect == "mysql":
+                    return "DEFAULT CURRENT_TIMESTAMP"
+            # For other callables, skip DEFAULT (handled by ORM)
+            return None
+        
         if isinstance(self.default, str):
             return f"DEFAULT '{self.default}'"
         
@@ -446,6 +476,27 @@ class AlterColumn(Operation):
         if self.set_default:
             changes.append(f"default to {self.new_default}")
         return f"Alter column '{self.column_name}' in '{self.table_name}': {', '.join(changes)}"
+    
+    def to_code(self) -> str:
+        """Gera código Python para AlterColumn com serialização correta de callables."""
+        new_type_str = f"'{self.new_type}'" if self.new_type else "None"
+        old_type_str = f"'{self.old_type}'" if self.old_type else "None"
+        
+        # Serializa defaults corretamente (callables, None, strings, etc.)
+        new_default_str = _serialize_default(self.new_default)
+        old_default_str = _serialize_default(self.old_default)
+        
+        return f"""AlterColumn(
+        table_name='{self.table_name}',
+        column_name='{self.column_name}',
+        new_type={new_type_str},
+        new_nullable={self.new_nullable},
+        new_default={new_default_str},
+        set_default={self.set_default},
+        old_type={old_type_str},
+        old_nullable={self.old_nullable},
+        old_default={old_default_str},
+    )"""
 
 
 @dataclass

{core_framework-0.12.13 → core_framework-0.12.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "core-framework"
-version = "0.12.13"
+version = "0.12.14"
 description = "Core Framework - Django-inspired, FastAPI-powered. Alta performance, baixo acoplamento, produtividade extrema."
 requires-python = ">=3.10,<4.0"
 readme = "README.md"

{core_framework-0.12.13 → core_framework-0.12.14}/tests/test_issues_fixes.py

@@ -251,6 +251,31 @@ class TestIssue5MigrationSerialization:
         assert "0x" not in code
         # Should contain proper reference
         assert "CreateTable" in code
+    
+    def test_alter_column_to_code_with_callable(self):
+        """AlterColumn.to_code() should serialize callable defaults correctly."""
+        from core.migrations.operations import AlterColumn
+        from core.datetime import timezone
+        
+        op = AlterColumn(
+            table_name="users",
+            column_name="created_at",
+            new_type="DATETIME",
+            new_default=timezone.now,
+            set_default=True,
+            old_type="TIMESTAMP",
+            old_default=None,
+        )
+        
+        code = op.to_code()
+        
+        # Should NOT contain <function ... at 0x...>
+        assert "<function" not in code, f"Generated invalid code: {code}"
+        assert "0x" not in code, f"Generated memory address: {code}"
+        # Should be valid Python
+        assert "AlterColumn" in code
+        # Should have proper serialization
+        assert "core.datetime.timezone.now" in code or "timezone.now" in code
 
 
 class TestIssue6ResetDbCascade: