async-easy-model 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

async_easy_model/__init__.py

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

async_easy_model/model.py

@@ -411,6 +411,13 @@ class EasyModel(SQLModel):
                         # Process relationships first
                         processed_item = await cls._process_relationships_for_insert(session, item)
                         
+                        # Extract special _related_* fields for post-processing
+                        related_fields = {}
+                        for key in list(processed_item.keys()):
+                            if key.startswith("_related_"):
+                                rel_name = key[9:]  # Remove "_related_" prefix
+                                related_fields[rel_name] = processed_item.pop(key)
+                        
                         # Check if a record with unique constraints already exists
                         unique_fields = cls._get_unique_fields()
                         existing_obj = None
@@ -433,12 +440,33 @@ class EasyModel(SQLModel):
                             for key, value in processed_item.items():
                                 if key != 'id':  # Don't update ID
                                     setattr(existing_obj, key, value)
-                            objects.append(existing_obj)
+                            obj = existing_obj
                         else:
                             # Create new object
                             obj = cls(**processed_item)
                             session.add(obj)
-                            objects.append(obj)
+                            
+                        # Flush to get the ID for this object
+                        await session.flush()
+                        
+                        # Now handle any one-to-many relationships
+                        for rel_name, related_objects in related_fields.items():
+                            # Check if the relationship attribute exists in the class (not the instance)
+                            if hasattr(cls, rel_name):
+                                # Get the relationship attribute from the class
+                                rel_attr = getattr(cls, rel_name)
+                                
+                                # Check if it's a SQLAlchemy relationship
+                                if hasattr(rel_attr, 'property') and hasattr(rel_attr.property, 'back_populates'):
+                                    back_attr = rel_attr.property.back_populates
+                                    
+                                    # For each related object, set the back reference to this object
+                                    for related_obj in related_objects:
+                                        setattr(related_obj, back_attr, obj)
+                                        # Make sure the related object is in the session
+                                        session.add(related_obj)
+                        
+                        objects.append(obj)
                     except Exception as e:
                         logging.error(f"Error inserting record: {e}")
                         await session.rollback()
@@ -465,6 +493,13 @@ class EasyModel(SQLModel):
                     # Process relationships first
                     processed_data = await cls._process_relationships_for_insert(session, data)
                     
+                    # Extract special _related_* fields for post-processing
+                    related_fields = {}
+                    for key in list(processed_data.keys()):
+                        if key.startswith("_related_"):
+                            rel_name = key[9:]  # Remove "_related_" prefix
+                            related_fields[rel_name] = processed_data.pop(key)
+                    
                     # Check if a record with unique constraints already exists
                     unique_fields = cls._get_unique_fields()
                     existing_obj = None
@@ -494,6 +529,24 @@ class EasyModel(SQLModel):
                         session.add(obj)
                     
                     await session.flush()  # Flush to get the ID
+                    
+                    # Now handle any one-to-many relationships
+                    for rel_name, related_objects in related_fields.items():
+                        # Check if the relationship attribute exists in the class (not the instance)
+                        if hasattr(cls, rel_name):
+                            # Get the relationship attribute from the class
+                            rel_attr = getattr(cls, rel_name)
+                            
+                            # Check if it's a SQLAlchemy relationship
+                            if hasattr(rel_attr, 'property') and hasattr(rel_attr.property, 'back_populates'):
+                                back_attr = rel_attr.property.back_populates
+                                
+                                # For each related object, set the back reference to this object
+                                for related_obj in related_objects:
+                                    setattr(related_obj, back_attr, obj)
+                                    # Make sure the related object is in the session
+                                    session.add(related_obj)
+                    
                     await session.commit()
                     
                     if include_relationships:
@@ -510,60 +563,6 @@ class EasyModel(SQLModel):
                     logging.error(f"Error inserting record: {e}")
                     await session.rollback()
                     raise
-    
-    @classmethod
-    async def insert_with_related(
-        cls: Type[T], 
-        data: Dict[str, Any],
-        related_data: Dict[str, List[Dict[str, Any]]] = None
-    ) -> T:
-        """
-        Create a model instance with related objects in a single transaction.
-        
-        Args:
-            data: Dictionary of field values for the main model
-            related_data: Dictionary mapping relationship names to lists of data dictionaries
-                          for creating related objects
-                          
-        Returns:
-            The created model instance with relationships loaded
-        """
-        if related_data is None:
-            related_data = {}
-            
-        async with cls.get_session() as session:
-            # Create the main object
-            obj = cls(**data)
-            session.add(obj)
-            await session.flush()  # Flush to get the ID
-            
-            # Create related objects
-            for rel_name, items_data in related_data.items():
-                if not hasattr(cls, rel_name):
-                    continue
-                    
-                rel_attr = getattr(cls, rel_name)
-                if not hasattr(rel_attr, "property"):
-                    continue
-                    
-                # Get the related model class and the back reference attribute
-                related_model = rel_attr.property.mapper.class_
-                back_populates = getattr(rel_attr.property, "back_populates", None)
-                
-                # Create each related object
-                for item_data in items_data:
-                    # Set the back reference if it exists
-                    if back_populates:
-                        item_data[back_populates] = obj
-                        
-                    related_obj = related_model(**item_data)
-                    session.add(related_obj)
-            
-            await session.commit()
-            
-            # Refresh with relationships
-            await session.refresh(obj, attribute_names=list(related_data.keys()))
-            return obj
 
     @classmethod
     def _get_unique_fields(cls) -> List[str]:
@@ -591,6 +590,15 @@ class EasyModel(SQLModel):
             "quantity": 2
         })
         
+        It also handles lists of related objects for one-to-many relationships:
+        publisher = await Publisher.insert({
+            "name": "Example Publisher",
+            "authors": [
+                {"name": "Author 1", "email": "author1@example.com"},
+                {"name": "Author 2", "email": "author2@example.com"}
+            ]
+        })
+        
         For each nested object:
         1. Find the target model class
         2. Check if an object with the same unique fields already exists
@@ -620,8 +628,8 @@ class EasyModel(SQLModel):
         
         # Handle nested relationship objects
         for key, value in data.items():
-            # Skip if the value is not a dictionary
-            if not isinstance(value, dict):
+            # Skip if None
+            if value is None:
                 continue
                 
             # Check if this is a relationship field (either by name or derived from foreign key)
@@ -675,105 +683,164 @@ class EasyModel(SQLModel):
                     logging.warning(f"Could not find related model for {key} in {cls.__name__}")
                     continue
                 
-                # Look for unique fields in the related model to use for searching
-                unique_fields = []
-                for field_name, field_info in related_model.__fields__.items():
-                    if (hasattr(field_info, "field_info") and 
-                        field_info.field_info.extra.get('unique', False)):
-                        unique_fields.append(field_name)
-                
-                # Create a search dictionary using unique fields
-                search_dict = {}
-                for field in unique_fields:
-                    if field in value and value[field] is not None:
-                        search_dict[field] = value[field]
-                
-                # If no unique fields found but ID is provided, use it
-                if not search_dict and 'id' in value and value['id']:
-                    search_dict = {'id': value['id']}
-                
-                # Special case for products without uniqueness constraints
-                if not search_dict and related_model.__tablename__ == 'products' and 'name' in value:
-                    search_dict = {'name': value['name']}
-                
-                # Try to find an existing record
-                related_obj = None
-                if search_dict:
-                    logging.info(f"Searching for existing {related_model.__name__} with {search_dict}")
+                # Check if the value is a list (one-to-many) or dict (one-to-one)
+                if isinstance(value, list):
+                    # Handle one-to-many relationship (list of dictionaries)
+                    related_objects = []
                     
-                    try:
-                        # Create a more appropriate search query based on unique fields
-                        existing_stmt = select(related_model)
-                        for field, field_value in search_dict.items():
-                            existing_stmt = existing_stmt.where(getattr(related_model, field) == field_value)
-                        
-                        existing_result = await session.execute(existing_stmt)
-                        related_obj = existing_result.scalars().first()
-                        
-                        if related_obj:
-                            logging.info(f"Found existing {related_model.__name__} with ID: {related_obj.id}")
-                    except Exception as e:
-                        logging.error(f"Error finding existing record: {e}")
-                
-                if related_obj:
-                    # Update the existing record with any non-unique field values
-                    for attr, attr_val in value.items():
-                        # Skip ID field
-                        if attr == 'id':
+                    for item in value:
+                        if not isinstance(item, dict):
+                            logging.warning(f"Skipping non-dict item in list for {key}")
                             continue
                             
-                        # Skip unique fields with different values to avoid constraint violations
-                        if attr in unique_fields and getattr(related_obj, attr) != attr_val:
-                            continue
-                            
-                        # Update non-unique fields
-                        current_val = getattr(related_obj, attr, None)
-                        if current_val != attr_val:
-                            setattr(related_obj, attr, attr_val)
+                        related_obj = await cls._process_single_relationship_item(
+                            session, related_model, item
+                        )
+                        if related_obj:
+                            related_objects.append(related_obj)
                     
-                    # Add the updated object to the session
-                    session.add(related_obj)
-                    logging.info(f"Reusing existing {related_model.__name__} with ID: {related_obj.id}")
-                else:
-                    # Create a new record
-                    logging.info(f"Creating new {related_model.__name__} for {key}")
-                    related_obj = related_model(**value)
-                    session.add(related_obj)
+                    # For one-to-many, we need to keep a list of related objects to be attached later
+                    # We'll store them in a special field that will be removed before creating the model
+                    result[f"_related_{key}"] = related_objects
+                    
+                    # Remove the original field from the result
+                    if key in result:
+                        del result[key]
                 
-                # Ensure the object has an ID by flushing
-                try:
-                    await session.flush()
-                except Exception as e:
-                    logging.error(f"Error flushing session for {related_model.__name__}: {e}")
+                elif isinstance(value, dict):
+                    # Handle one-to-one relationship (single dictionary)
+                    related_obj = await cls._process_single_relationship_item(
+                        session, related_model, value
+                    )
                     
-                    # If there was a uniqueness error, try again to find the existing record
-                    if "UNIQUE constraint failed" in str(e):
-                        logging.info(f"UNIQUE constraint failed, trying to find existing record again")
-                        
-                        # Try to find by any field provided in the search_dict
-                        existing_stmt = select(related_model)
-                        for field, field_value in search_dict.items():
-                            existing_stmt = existing_stmt.where(getattr(related_model, field) == field_value)
-                        
-                        # Execute the search query
-                        existing_result = await session.execute(existing_stmt)
-                        related_obj = existing_result.scalars().first()
+                    if related_obj:
+                        # Update the result with the foreign key ID
+                        foreign_key_name = f"{key}_id"
+                        result[foreign_key_name] = related_obj.id
                         
-                        if not related_obj:
-                            # We couldn't find an existing record, re-raise the exception
-                            raise
-                        
-                        logging.info(f"Found existing {related_model.__name__} with ID: {related_obj.id} after constraint error")
+                        # Remove the relationship dictionary from the result
+                        if key in result:
+                            del result[key]
+        
+        return result
+    
+    @classmethod
+    async def _process_single_relationship_item(cls, session: AsyncSession, related_model: Type, item_data: Dict[str, Any]) -> Optional[Any]:
+        """
+        Process a single relationship item (dictionary).
+        
+        This helper method is used by _process_relationships_for_insert to handle
+        both singular relationship objects and items within lists of relationships.
+        
+        Args:
+            session: The database session to use
+            related_model: The related model class
+            item_data: Dictionary with field values for the related object
+            
+        Returns:
+            The created or found related object, or None if processing failed
+        """
+        # Look for unique fields in the related model to use for searching
+        unique_fields = []
+        for field_name, field_info in related_model.__fields__.items():
+            if (hasattr(field_info, "field_info") and 
+                field_info.field_info.extra.get('unique', False)):
+                unique_fields.append(field_name)
+        
+        # Create a search dictionary using unique fields
+        search_dict = {}
+        for field in unique_fields:
+            if field in item_data and item_data[field] is not None:
+                search_dict[field] = item_data[field]
+        
+        # If no unique fields found but ID is provided, use it
+        if not search_dict and 'id' in item_data and item_data['id']:
+            search_dict = {'id': item_data['id']}
+        
+        # Special case for products without uniqueness constraints
+        if not search_dict and related_model.__tablename__ == 'products' and 'name' in item_data:
+            search_dict = {'name': item_data['name']}
+        
+        # Try to find an existing record
+        related_obj = None
+        if search_dict:
+            logging.info(f"Searching for existing {related_model.__name__} with {search_dict}")
+            
+            try:
+                # Create a more appropriate search query based on unique fields
+                existing_stmt = select(related_model)
+                for field, field_value in search_dict.items():
+                    existing_stmt = existing_stmt.where(getattr(related_model, field) == field_value)
                 
-                # Update the result with the foreign key ID
-                foreign_key_name = f"{key}_id"
-                result[foreign_key_name] = related_obj.id
+                existing_result = await session.execute(existing_stmt)
+                related_obj = existing_result.scalars().first()
                 
-                # Remove the relationship dictionary from the result
-                if key in result:
-                    del result[key]
+                if related_obj:
+                    logging.info(f"Found existing {related_model.__name__} with ID: {related_obj.id}")
+            except Exception as e:
+                logging.error(f"Error finding existing record: {e}")
         
-        return result
+        if related_obj:
+            # Update the existing record with any non-unique field values
+            for attr, attr_val in item_data.items():
+                # Skip ID field
+                if attr == 'id':
+                    continue
+                    
+                # Skip unique fields with different values to avoid constraint violations
+                if attr in unique_fields and getattr(related_obj, attr) != attr_val:
+                    continue
+                    
+                # Update non-unique fields
+                current_val = getattr(related_obj, attr, None)
+                if current_val != attr_val:
+                    setattr(related_obj, attr, attr_val)
+            
+            # Add the updated object to the session
+            session.add(related_obj)
+            logging.info(f"Reusing existing {related_model.__name__} with ID: {related_obj.id}")
+        else:
+            # Create a new record
+            logging.info(f"Creating new {related_model.__name__}")
+            
+            # Process nested relationships in this item first
+            if hasattr(related_model, '_process_relationships_for_insert'):
+                # This is a recursive call to process nested relationships
+                processed_item_data = await related_model._process_relationships_for_insert(
+                    session, item_data
+                )
+            else:
+                processed_item_data = item_data
+            
+            related_obj = related_model(**processed_item_data)
+            session.add(related_obj)
+        
+        # Ensure the object has an ID by flushing
+        try:
+            await session.flush()
+        except Exception as e:
+            logging.error(f"Error flushing session for {related_model.__name__}: {e}")
+            
+            # If there was a uniqueness error, try again to find the existing record
+            if "UNIQUE constraint failed" in str(e):
+                logging.info(f"UNIQUE constraint failed, trying to find existing record again")
+                
+                # Try to find by any field provided in the search_dict
+                existing_stmt = select(related_model)
+                for field, field_value in search_dict.items():
+                    existing_stmt = existing_stmt.where(getattr(related_model, field) == field_value)
+                
+                # Execute the search query
+                existing_result = await session.execute(existing_stmt)
+                related_obj = existing_result.scalars().first()
+                
+                if not related_obj:
+                    # We couldn't find an existing record, re-raise the exception
+                    raise
+                
+                logging.info(f"Found existing {related_model.__name__} with ID: {related_obj.id} after constraint error")
+        
+        return related_obj
 
     @classmethod
     async def update(cls: Type[T], data: Dict[str, Any], criteria: Dict[str, Any], include_relationships: bool = True) -> Optional[T]:
@@ -997,7 +1064,7 @@ class EasyModel(SQLModel):
         Retrieve record(s) by matching attribute values.
         
         Args:
-            criteria: Dictionary of field values to filter by (field=value)
+            criteria: Dictionary of search criteria
             all: If True, return all matching records, otherwise return only the first one
             first: If True, return only the first record (equivalent to all=False)
             include_relationships: If True, eagerly load all relationships
@@ -1110,6 +1177,37 @@ class EasyModel(SQLModel):
         new_record = await cls.insert(data)
         return new_record, True
 
+    @classmethod
+    async def insert_with_related(
+        cls: Type[T], 
+        data: Dict[str, Any],
+        related_data: Dict[str, List[Dict[str, Any]]] = None
+    ) -> T:
+        """
+        Create a model instance with related objects in a single transaction.
+        
+        Args:
+            data: Dictionary of field values for the main model
+            related_data: Dictionary mapping relationship names to lists of data dictionaries
+                          for creating related objects
+                          
+        Returns:
+            The created model instance with relationships loaded
+        """
+        if related_data is None:
+            related_data = {}
+            
+        # Create a copy of data for modification
+        insert_data = data.copy()
+        
+        # Add relationship fields to the data
+        for rel_name, items_data in related_data.items():
+            if items_data:
+                insert_data[rel_name] = items_data
+        
+        # Use the enhanced insert method to handle all relationships
+        return await cls.insert(insert_data, include_relationships=True)
+
 # Register an event listener to update 'updated_at' on instance modifications.
 @event.listens_for(Session, "before_flush")
 def _update_updated_at(session, flush_context, instances):

{async_easy_model-0.2.2.dist-info → async_easy_model-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: async-easy-model
-Version: 0.2.2
+Version: 0.2.3
 Summary: A simplified SQLModel-based ORM for async database operations
 Home-page: https://github.com/puntorigen/easy-model
 Author: Pablo Schaffner
@@ -154,12 +154,36 @@ users = await User.insert([
     {"username": "user2", "email": "user2@example.com"}
 ])
 
-# Insert with relationships using nested dictionaries
-post = await Post.insert({
-    "title": "My First Post",
-    "content": "Hello world!",
-    "user": {"username": "john_doe"}  # Will automatically link to existing user
+# Insert with nested relationships
+new_post = await Post.insert({
+    "title": "My Post",
+    "content": "Content here",
+    "user": {"username": "jane_doe"},  # Will automatically link to existing user
+    "comments": [  # Create multiple comments in a single transaction
+        {"text": "Great post!", "user": {"username": "reader1"}},
+        {"text": "Thanks for sharing", "user": {"username": "reader2"}}
+    ]
+})
+# Access nested data without requerying
+print(f"Post by {new_post.user.username} with {len(new_post.comments)} comments")
+
+# Insert with nested one-to-many relationships 
+publisher = await Publisher.insert({
+    "name": "Example Publisher",
+    "books": [  # List of nested objects
+        {
+            "title": "Python Mastery",
+            "genres": [
+                {"name": "Programming"},
+                {"name": "Education"}
+            ]
+        },
+        {"title": "Data Science Handbook"}
+    ]
 })
+# Access nested relationships immediately
+print(f"Publisher: {publisher.name} with {len(publisher.books)} books")
+print(f"First book genres: {[g.name for g in publisher.books[0].genres]}")
 ```
 
 ### Read (Retrieve)
@@ -265,22 +289,28 @@ Using the models defined earlier, here's how to work with relationships:
 
 ```python
 # Load all relationships automatically
-post = await Post.select({"id": 1}, include_relationships=True)
+post = await Post.select({"id": 1})
 print(post.user.username)  # Access related objects directly
 
 # Load specific relationships
 post = await Post.get_with_related(1, ["user", "comments"])
 
 # Load relationships after fetching
-post = await Post.select({"id": 1})
+post = await Post.select({"id": 1}, include_relationships=False)
 await post.load_related(["user", "comments"])
 
-# Insert with related objects in a single transaction
-new_post = await Post.insert_with_related({
+# Insert with nested relationships
+new_post = await Post.insert({
     "title": "My Post",
     "content": "Content here",
-    "user": {"username": "john_doe"}
+    "user": {"username": "jane_doe"},  # Will automatically link to existing user
+    "comments": [  # Create multiple comments in a single transaction
+        {"text": "Great post!", "user": {"username": "reader1"}},
+        {"text": "Thanks for sharing", "user": {"username": "reader2"}}
+    ]
 })
+# Access nested data without requerying
+print(f"Post by {new_post.user.username} with {len(new_post.comments)} comments")
 
 # Convert to dictionary with nested relationships
 post_dict = post.to_dict(include_relationships=True, max_depth=2)
@@ -325,7 +355,7 @@ db_config.set_connection_url("postgresql+asyncpg://user:password@localhost:5432/
 
 ## Documentation
 
-For more detailed documentation, please visit the [GitHub repository](https://github.com/puntorigen/easy_model) or refer to the [DOCS.md](https://github.com/puntorigen/easy_model/blob/main/DOCS.md) file.
+For more detailed documentation, please visit the [GitHub repository](https://github.com/puntorigen/easy-model) or refer to the [DOCS.md](https://github.com/puntorigen/easy-model/blob/master/DOCS.md) file.
 
 ## License
 

async_easy_model-0.2.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+async_easy_model/__init__.py,sha256=u1yerriPm93E_uXcK9r-y7wcMOV1F4t-KjKEooCaiIA,1642
+async_easy_model/auto_relationships.py,sha256=VetxcrOdKGGSImTiysRFR8PSOSlo50RqnVG95CLe8Jg,22433
+async_easy_model/migrations.py,sha256=rYDGCGlruSugAmPfdIF2-uhyG6UvC_2qbF3BXJ084qI,17803
+async_easy_model/model.py,sha256=G-0htjy78Nae5HdNE2dMGV8Z8s-rUNRTUANcKArxrDM,57852
+async_easy_model/relationships.py,sha256=vR5BsJpGaDcecCcNlg9-ouZfxFXFQv5kOyiXhKp_T7A,3286
+async_easy_model-0.2.3.dist-info/LICENSE,sha256=uwDkl6oHbRltW7vYKNc4doJyhtwhyrSNFFlPpKATwLE,1072
+async_easy_model-0.2.3.dist-info/METADATA,sha256=SZJy5Ozs7Jn-J3qVTiVB637IGza-5C6hdet_dPocM3I,10720
+async_easy_model-0.2.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+async_easy_model-0.2.3.dist-info/top_level.txt,sha256=e5_47sGmJnyxz2msfwU6C316EqmrSd9RGIYwZyWx68E,17
+async_easy_model-0.2.3.dist-info/RECORD,,

async_easy_model-0.2.2.dist-info/RECORD

@@ -1,10 +0,0 @@
-async_easy_model/__init__.py,sha256=A0U-LtrK9tjK-b94oDNJyc3XFmmnjQAHXP7Bs-FHx18,1642
-async_easy_model/auto_relationships.py,sha256=VetxcrOdKGGSImTiysRFR8PSOSlo50RqnVG95CLe8Jg,22433
-async_easy_model/migrations.py,sha256=rYDGCGlruSugAmPfdIF2-uhyG6UvC_2qbF3BXJ084qI,17803
-async_easy_model/model.py,sha256=TUTTLP47YWCdlsrsyf-7HmMAhPdlvTNZG416pA7UfCo,52958
-async_easy_model/relationships.py,sha256=vR5BsJpGaDcecCcNlg9-ouZfxFXFQv5kOyiXhKp_T7A,3286
-async_easy_model-0.2.2.dist-info/LICENSE,sha256=uwDkl6oHbRltW7vYKNc4doJyhtwhyrSNFFlPpKATwLE,1072
-async_easy_model-0.2.2.dist-info/METADATA,sha256=QcX4beoXLL0fbPJ8ZVMAL4Q5QlXGgJfb4jjSjPx3Yqw,9474
-async_easy_model-0.2.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-async_easy_model-0.2.2.dist-info/top_level.txt,sha256=e5_47sGmJnyxz2msfwU6C316EqmrSd9RGIYwZyWx68E,17
-async_easy_model-0.2.2.dist-info/RECORD,,