async-easy-model 0.2.9__py3-none-any.whl → 0.3.1__py3-none-any.whl

async_easy_model/__init__.py

@@ -12,7 +12,7 @@ from typing import Optional, Any
 from .model import EasyModel, init_db, db_config
 from sqlmodel import Field, Relationship as SQLModelRelationship
 
-__version__ = "0.2.9"
+__version__ = "0.3.1"
 __all__ = ["EasyModel", "init_db", "db_config", "Field", "Relationship", "Relation", "enable_auto_relationships", "disable_auto_relationships", "process_auto_relationships", "MigrationManager", "check_and_migrate_models", "ModelVisualizer"]
 
 # Create a more user-friendly Relationship function

async_easy_model/auto_relationships.py

@@ -119,10 +119,10 @@ def get_foreign_keys_from_model(model_cls: Type[SQLModel]) -> Dict[str, str]:
     
     foreign_keys = {}
     
-    # First method: Check SQLModel's __fields__ dictionary
-    if hasattr(model_cls, "__fields__"):
-        logger.info(f"Using __fields__ to find foreign keys in {model_cls.__name__}")
-        for field_name, field_info in model_cls.__fields__.items():
+    # First method: Check SQLModel's model_fields dictionary (Pydantic V2)
+    if hasattr(model_cls, "model_fields"):
+        logger.info(f"Using model_fields to find foreign keys in {model_cls.__name__}")
+        for field_name, field_info in model_cls.model_fields.items():
             # Check if the field has a foreign_key attribute
             if hasattr(field_info, "foreign_key") and field_info.foreign_key:
                 foreign_key = field_info.foreign_key
@@ -156,7 +156,7 @@ def get_foreign_keys_from_model(model_cls: Type[SQLModel]) -> Dict[str, str]:
     # Second method: Try to infer foreign keys from field names
     if not foreign_keys:
         logger.info(f"No foreign keys found in model {model_cls.__name__} metadata, trying to detect from field names")
-        for field_name in getattr(model_cls, "__fields__", {}):
+        for field_name in getattr(model_cls, "model_fields", {}):
             if field_name.endswith("_id"):
                 # Infer the referenced model from the field name
                 model_name = field_name[:-3]  # Remove _id suffix
@@ -593,7 +593,7 @@ def is_junction_table(model_cls: Type[SQLModel]) -> bool:
     
     # Check if all non-standard fields are foreign keys
     standard_fields = {'id', 'created_at', 'updated_at'}
-    model_fields = set(getattr(model_cls, '__fields__', {}).keys())
+    model_fields = set(getattr(model_cls, 'model_fields', {}).keys())
     non_standard_fields = model_fields - standard_fields
     foreign_key_fields = set(foreign_keys.keys())
     

async_easy_model/migrations.py

@@ -64,10 +64,26 @@ async def _create_table_without_indexes(table, connection):
     """
     # Create a copy of the table without indexes
     metadata = MetaData()
+    # Manually create columns instead of using deprecated copy() method
+    new_columns = []
+    for col in table.columns:
+        new_col = Column(
+            col.name,
+            col.type,
+            nullable=col.nullable,
+            default=col.default,
+            server_default=col.server_default,
+            primary_key=col.primary_key,
+            unique=col.unique,
+            autoincrement=col.autoincrement,
+            comment=col.comment
+        )
+        new_columns.append(new_col)
+    
     new_table = Table(
         table.name,
         metadata,
-        *[c.copy() for c in table.columns],
+        *new_columns,
         schema=table.schema
     )
     

async_easy_model/model.py

@@ -14,6 +14,9 @@ import re
 
 T = TypeVar("T", bound="EasyModel")
 
+# Global database configuration instance (forward declaration)
+db_config = None
+
 class DatabaseConfig:
     _engine = None
     _session_maker = None
@@ -107,13 +110,74 @@ class DatabaseConfig:
 # Global database configuration instance.
 db_config = DatabaseConfig()
 
+def _normalize_datetime_for_db(value: Any) -> Any:
+    """
+    Normalize datetime values for database compatibility.
+    
+    For PostgreSQL with TIMESTAMP WITHOUT TIME ZONE columns, converts timezone-aware
+    datetimes to timezone-naive UTC datetimes. For other databases, returns the value unchanged.
+    
+    Args:
+        value: The value to potentially normalize
+        
+    Returns:
+        The normalized value
+    """
+    global db_config
+    
+    # Only process datetime objects
+    if not isinstance(value, datetime):
+        return value
+    
+    # Only normalize for PostgreSQL
+    if db_config and db_config.db_type == "postgresql":
+        # If the datetime is timezone-aware, convert to UTC and make naive
+        if value.tzinfo is not None:
+            return value.astimezone(tz.utc).replace(tzinfo=None)
+    
+    return value
+
+def _normalize_data_for_db(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normalize all datetime values in a data dictionary for database compatibility.
+    
+    Args:
+        data: Dictionary containing field values
+        
+    Returns:
+        Dictionary with normalized datetime values
+    """
+    normalized_data = {}
+    for key, value in data.items():
+        normalized_data[key] = _normalize_datetime_for_db(value)
+    return normalized_data
+
+def _get_normalized_datetime() -> datetime:
+    """
+    Get a datetime that's appropriate for the current database backend.
+    
+    Returns:
+        For PostgreSQL: timezone-naive UTC datetime
+        For SQLite: timezone-aware UTC datetime (for backward compatibility)
+    """
+    global db_config
+    
+    utc_now = datetime.now(tz.utc)
+    
+    # For PostgreSQL, return timezone-naive datetime
+    if db_config and db_config.db_type == "postgresql":
+        return utc_now.replace(tzinfo=None)
+    
+    # For SQLite and others, return timezone-aware datetime (backward compatibility)
+    return utc_now
+
 class EasyModel(SQLModel):
     """
     Base model class providing common async database operations.
     """
     id: Optional[int] = Field(default=None, primary_key=True)
-    created_at: Optional[datetime] = Field(default_factory=lambda: datetime.now(tz.utc))
-    updated_at: Optional[datetime] = Field(default_factory=lambda: datetime.now(tz.utc))
+    created_at: Optional[datetime] = Field(default_factory=_get_normalized_datetime)
+    updated_at: Optional[datetime] = Field(default_factory=_get_normalized_datetime)
 
     # Default table args with extend_existing=True to ensure all subclasses can redefine tables
     __table_args__ = {"extend_existing": True}
@@ -331,7 +395,7 @@ class EasyModel(SQLModel):
             List of field names that have unique constraints
         """
         unique_fields = []
-        for name, field in cls.__fields__.items():
+        for name, field in cls.model_fields.items():
             if name != 'id' and hasattr(field, "field_info") and field.field_info.extra.get('unique', False):
                 unique_fields.append(name)
         return unique_fields
@@ -437,6 +501,9 @@ class EasyModel(SQLModel):
             try:
                 processed_data = await cls._process_relationships_for_insert(session, data)
                 
+                # Normalize datetime values for database compatibility
+                processed_data = _normalize_data_for_db(processed_data)
+                
                 # Create the model instance
                 obj = cls(**processed_data)
                 session.add(obj)
@@ -609,7 +676,7 @@ class EasyModel(SQLModel):
         """
         # Look for unique fields in the related model to use for searching
         unique_fields = []
-        for name, field in related_model.__fields__.items():
+        for name, field in related_model.model_fields.items():
             if (hasattr(field, "field_info") and 
                 field.field_info.extra.get('unique', False)):
                 unique_fields.append(name)
@@ -755,7 +822,7 @@ class EasyModel(SQLModel):
                 # Check for unique constraints before updating
                 for field_name, new_value in data.items():
                     if field_name != 'id' and hasattr(cls, field_name):
-                        field = getattr(cls.__fields__.get(field_name), 'field_info', None)
+                        field = getattr(cls.model_fields.get(field_name), 'field_info', None)
                         if field and field.extra.get('unique', False):
                             # Check if the new value would conflict with an existing record
                             check_statement = select(cls).where(
@@ -769,9 +836,10 @@ class EasyModel(SQLModel):
                             if existing:
                                 raise ValueError(f"Cannot update {field_name} to '{new_value}': value already exists")
                 
-                # Apply the updates
+                # Apply the updates with datetime normalization
                 for key, value in data.items():
-                    setattr(record, key, value)
+                    normalized_value = _normalize_datetime_for_db(value)
+                    setattr(record, key, normalized_value)
                 
                 # Process many-to-many relationships if any
                 for rel_name, rel_data in many_to_many_data.items():
@@ -1383,7 +1451,7 @@ class EasyModel(SQLModel):
 def _update_updated_at(session, flush_context, instances):
     for instance in session.dirty:
         if isinstance(instance, EasyModel) and hasattr(instance, "updated_at"):
-            instance.updated_at = datetime.now(tz.utc)
+            instance.updated_at = _get_normalized_datetime()
 
 async def init_db(migrate: bool = True, model_classes: List[Type[SQLModel]] = None):
     """

async_easy_model/visualization.py

@@ -80,7 +80,7 @@ class ModelVisualizer:
         foreign_keys = {}
         
         try:
-            # Check model annotations and __fields__ for foreign keys
+            # Check model annotations and model_fields for foreign keys
             if hasattr(model_class, "__annotations__"):
                 for field_name, field_type in model_class.__annotations__.items():
                     if hasattr(model_class, field_name):
@@ -102,8 +102,8 @@ class ModelVisualizer:
                     pass
             
             # Try to infer foreign keys from field names ending with _id
-            if hasattr(model_class, "__fields__"):
-                for field_name in model_class.__fields__:
+            if hasattr(model_class, "model_fields"):
+                for field_name in model_class.model_fields:
                     if field_name.endswith("_id") and field_name not in foreign_keys:
                         related_name = field_name[:-3]  # Remove _id suffix
                         # Check if there's a model with this name

{async_easy_model-0.2.9.dist-info → async_easy_model-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: async-easy-model
-Version: 0.2.9
+Version: 0.3.1
 Summary: A simplified SQLModel-based ORM for async database operations
 Home-page: https://github.com/puntorigen/easy-model
 Author: Pablo Schaffner
@@ -59,6 +59,7 @@ A simplified SQLModel-based ORM for async database operations in Python. async-e
 - 🛠️ Built on top of SQLModel and SQLAlchemy for robust performance
 - 📝 Type hints for better IDE support
 - 🕒 Automatic `id`, `created_at` and `updated_at` fields provided by default
+- ⏰ **PostgreSQL DateTime Compatibility**: Automatic timezone-aware to timezone-naive datetime conversion for PostgreSQL TIMESTAMP WITHOUT TIME ZONE columns
 - 🔄 Automatic schema migrations for evolving database models
 - 📊 Visualization of database schema using Mermaid ER diagrams
 

async_easy_model-0.3.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+async_easy_model/__init__.py,sha256=jZ6t8zToAbMXdEbFcOh15WlOa9uHYrO4QmoqxuZImCI,1921
+async_easy_model/auto_relationships.py,sha256=ZYM3IdNBLJ5Q0jz9W9UuL379m0Y3ZVOCbngz0Xa2I_U,27782
+async_easy_model/migrations.py,sha256=o0q2LjzGE8abjjpWDpB7G6EJt-nZOQ_oM2lm56GvS0E,18289
+async_easy_model/model.py,sha256=FviTK-RQ0GMCQNiR8G1cACcrSY1jQMl7bPEg1mcD5WI,66514
+async_easy_model/relationships.py,sha256=vR5BsJpGaDcecCcNlg9-ouZfxFXFQv5kOyiXhKp_T7A,3286
+async_easy_model/visualization.py,sha256=rL3J_KhstR3UI-DxIvyjaDd60YueCnlfG_7E2Cf9i_E,29979
+async_easy_model-0.3.1.dist-info/licenses/LICENSE,sha256=uwDkl6oHbRltW7vYKNc4doJyhtwhyrSNFFlPpKATwLE,1072
+async_easy_model-0.3.1.dist-info/METADATA,sha256=YKgL1jBWsxPh7JrlKwhUOb0Jm-N-3kQaxtoO44Gtfus,13047
+async_easy_model-0.3.1.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+async_easy_model-0.3.1.dist-info/top_level.txt,sha256=e5_47sGmJnyxz2msfwU6C316EqmrSd9RGIYwZyWx68E,17
+async_easy_model-0.3.1.dist-info/RECORD,,

async_easy_model-0.2.9.dist-info/RECORD

@@ -1,11 +0,0 @@
-async_easy_model/__init__.py,sha256=eGTq3OypupyVvLe2Zyn3ZFBeuU4v8EXW-XQ047vUMoM,1921
-async_easy_model/auto_relationships.py,sha256=V2LAzNi7y-keFk4C_m-byVRM-k_7nL5HEy9Ig3nEdq8,27756
-async_easy_model/migrations.py,sha256=rYDGCGlruSugAmPfdIF2-uhyG6UvC_2qbF3BXJ084qI,17803
-async_easy_model/model.py,sha256=pBWRAVhazZuI_rBOnILPttiCF_ZEomWBJGDmfdFp8Nk,64243
-async_easy_model/relationships.py,sha256=vR5BsJpGaDcecCcNlg9-ouZfxFXFQv5kOyiXhKp_T7A,3286
-async_easy_model/visualization.py,sha256=RVCdc8j3uUQe-zy3jXju_yhA13qJ8KWVbQ5fQyjyqkA,29973
-async_easy_model-0.2.9.dist-info/licenses/LICENSE,sha256=uwDkl6oHbRltW7vYKNc4doJyhtwhyrSNFFlPpKATwLE,1072
-async_easy_model-0.2.9.dist-info/METADATA,sha256=iVRM1qe6DfdFUSa5FYYES-oXgkKScm7m2BVClhlH-k8,12888
-async_easy_model-0.2.9.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-async_easy_model-0.2.9.dist-info/top_level.txt,sha256=e5_47sGmJnyxz2msfwU6C316EqmrSd9RGIYwZyWx68E,17
-async_easy_model-0.2.9.dist-info/RECORD,,