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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: core-framework
-Version: 0.12.13
+Version: 0.12.15
 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.15}/core/__init__.py

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

{core_framework-0.12.13 → core_framework-0.12.15}/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}",
@@ -522,6 +561,10 @@ migration = Migration(
                 return None
             
             operations = self._diff_to_operations(diff)
+            
+            if not operations:
+                print("No changes detected.")
+                return None
         
         # Gera nome da migração
         number = self._get_next_migration_number()

{core_framework-0.12.13 → core_framework-0.12.15}/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"
@@ -128,12 +138,58 @@ class ColumnDef:
         
         return self.type
     
+    def _format_default_value(self, value: Any, dialect: str) -> str | None:
+        """
+        Formata um valor para uso em cláusula DEFAULT SQL.
+        
+        Args:
+            value: Valor a ser formatado
+            dialect: Nome do dialeto SQL
+            
+        Returns:
+            String SQL formatada com DEFAULT ou None
+        """
+        from datetime import datetime, date, time
+        
+        if value is None:
+            return None
+        
+        if isinstance(value, bool):
+            if dialect == "postgresql":
+                return f"DEFAULT {'TRUE' if value else 'FALSE'}"
+            return f"DEFAULT {1 if value else 0}"
+        
+        if isinstance(value, datetime):
+            # Format datetime as ISO string for SQL
+            return f"DEFAULT '{value.isoformat()}'"
+        
+        if isinstance(value, date):
+            return f"DEFAULT '{value.isoformat()}'"
+        
+        if isinstance(value, time):
+            return f"DEFAULT '{value.isoformat()}'"
+        
+        if isinstance(value, str):
+            # Escape single quotes in strings
+            escaped = value.replace("'", "''")
+            return f"DEFAULT '{escaped}'"
+        
+        if isinstance(value, (int, float)):
+            return f"DEFAULT {value}"
+        
+        if isinstance(value, (dict, list)):
+            # JSON values - serialize and quote
+            import json
+            json_str = json.dumps(value).replace("'", "''")
+            return f"DEFAULT '{json_str}'"
+        
+        # Fallback: convert to string
+        return f"DEFAULT '{str(value)}'"
+    
     def _get_default_sql(self, dialect: str) -> str | None:
         """
         Gera SQL para valor default considerando o dialeto.
         
-        Bug #2: Boolean defaults usando TRUE/FALSE para PostgreSQL
-        
         Args:
             dialect: Nome do dialeto
             
@@ -143,17 +199,19 @@ class ColumnDef:
         if self.default is None:
             return None
         
-        if isinstance(self.default, str):
-            return f"DEFAULT '{self.default}'"
+        # Callable defaults: execute and use the result
+        # This is the most robust approach - no need to detect function names
+        if callable(self.default):
+            try:
+                result = self.default()
+                # Format the result as SQL DEFAULT
+                return self._format_default_value(result, dialect)
+            except Exception:
+                # If callable fails (needs arguments, etc.), skip DEFAULT
+                return None
         
-        if isinstance(self.default, bool):
-            # PostgreSQL exige TRUE/FALSE em vez de 1/0
-            if dialect == "postgresql":
-                return f"DEFAULT {'TRUE' if self.default else 'FALSE'}"
-            else:
-                return f"DEFAULT {1 if self.default else 0}"
-        
-        return f"DEFAULT {self.default}"
+        # Non-callable values: format directly
+        return self._format_default_value(self.default, dialect)
     
     def to_sql(self, dialect: str = "sqlite") -> str:
         """Gera SQL para a coluna, adaptado ao dialeto do banco."""
@@ -446,6 +504,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.15}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "core-framework"
-version = "0.12.13"
+version = "0.12.15"
 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.15}/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: