async-easy-model 0.2.1__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.1.12"
+__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,7 +563,7 @@ class EasyModel(SQLModel):
                     logging.error(f"Error inserting record: {e}")
                     await session.rollback()
                     raise
-    
+
     @classmethod
     def _get_unique_fields(cls) -> List[str]:
         """
@@ -537,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
@@ -566,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)
@@ -621,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':
-                            continue
-                            
-                        # Skip unique fields with different values to avoid constraint violations
-                        if attr in unique_fields and getattr(related_obj, attr) != attr_val:
+                    for item in value:
+                        if not isinstance(item, dict):
+                            logging.warning(f"Skipping non-dict item in list for {key}")
                             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")
+                    if related_obj:
+                        # Update the result with the foreign key ID
+                        foreign_key_name = f"{key}_id"
+                        result[foreign_key_name] = related_obj.id
                         
-                        # 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")
+                        # 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]:
@@ -861,60 +982,6 @@ class EasyModel(SQLModel):
                 await session.rollback()
                 raise
 
-    @classmethod
-    async def create_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
-
     def to_dict(self, include_relationships: bool = True, max_depth: int = 4) -> Dict[str, Any]:
         """
         Convert the model instance to a dictionary.
@@ -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.3.dist-info/METADATA

@@ -0,0 +1,362 @@
+Metadata-Version: 2.2
+Name: async-easy-model
+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
+Author-email: pablo@puntorigen.com
+Keywords: orm,sqlmodel,database,async,postgresql,sqlite
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlmodel>=0.0.8
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: asyncpg>=0.25.0
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: greenlet>=3.1.1
+Requires-Dist: inflection>=0.5.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# async-easy-model
+
+A simplified SQLModel-based ORM for async database operations in Python. async-easy-model provides a clean, intuitive interface for common database operations while leveraging the power of SQLModel and SQLAlchemy.
+
+<p align="center">
+  <img src="https://img.shields.io/pypi/v/async-easy-model" alt="PyPI Version">
+  <img src="https://img.shields.io/pypi/pyversions/async-easy-model" alt="Python Versions">
+  <img src="https://img.shields.io/github/license/puntorigen/easy_model" alt="License">
+</p>
+
+## Features
+
+- 🚀 Easy-to-use async database operations with standardized methods
+- 🔄 Intuitive APIs with sensible defaults for rapid development
+- 📊 Dictionary-based CRUD operations (select, insert, update, delete)
+- 🔗 Enhanced relationship handling with eager loading and nested operations
+- 🔍 Powerful query methods with flexible ordering support
+- ⚙️ Automatic relationship detection and bidirectional setup
+- 📱 Support for both PostgreSQL and SQLite databases
+- 🛠️ 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
+- 🔄 Automatic schema migrations for evolving database models
+
+## Installation
+
+```bash
+pip install async-easy-model
+```
+
+## Basic Usage
+
+```python
+from async_easy_model import EasyModel, init_db, db_config, Field
+from typing import Optional
+from datetime import datetime
+
+# Configure your database
+db_config.configure_sqlite("database.db")
+
+# Define your model
+class User(EasyModel, table=True):
+    #no need to specify id, created_at or updated_at since EasyModel provides them by default
+    username: str = Field(unique=True)
+    email: str
+
+# Initialize your database
+async def setup():
+    await init_db()
+
+# Use it in your async code
+async def main():
+    await setup()
+    # Create a new user
+    user = await User.insert({
+        "username": "john_doe",
+        "email": "john@example.com"
+    })
+    
+    # Get user ID
+    print(f"New user id: {user.id}")
+```
+
+## CRUD Operations
+
+First, let's define some models that we'll use throughout the examples:
+
+```python
+from async_easy_model import EasyModel, Field
+from typing import Optional, List
+from datetime import datetime
+
+class User(EasyModel, table=True):
+    username: str = Field(unique=True)
+    email: str
+    is_active: bool = Field(default=True)
+    
+class Post(EasyModel, table=True):
+    title: str
+    content: str
+    user_id: Optional[int] = Field(default=None, foreign_key="user.id")
+    
+class Comment(EasyModel, table=True):
+    text: str
+    post_id: Optional[int] = Field(default=None, foreign_key="post.id")
+    user_id: Optional[int] = Field(default=None, foreign_key="user.id")
+    
+class Department(EasyModel, table=True):
+    name: str = Field(unique=True)
+    
+class Product(EasyModel, table=True):
+    name: str
+    price: float
+    sales: int = Field(default=0)
+    
+class Book(EasyModel, table=True):
+    title: str
+    author_id: Optional[int] = Field(default=None, foreign_key="author.id")
+    
+class Author(EasyModel, table=True):
+    name: str
+```
+
+### Create (Insert)
+
+```python
+# Insert a single record
+user = await User.insert({
+    "username": "john_doe",
+    "email": "john@example.com"
+})
+
+# Insert multiple records
+users = await User.insert([
+    {"username": "user1", "email": "user1@example.com"},
+    {"username": "user2", "email": "user2@example.com"}
+])
+
+# 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)
+
+```python
+# Select by ID
+user = await User.select({"id": 1})
+
+# Select with criteria
+users = await User.select({"is_active": True}, all=True)
+
+# Select first matching record
+first_user = await User.select({"is_active": True}, first=True)
+
+# Select all records
+all_users = await User.select({}, all=True)
+
+# Select with wildcard pattern matching
+gmail_users = await User.select({"email": "*@gmail.com"}, all=True)
+
+# Select with ordering
+recent_users = await User.select({}, order_by="-created_at", all=True)
+
+# Select with limit
+latest_posts = await Post.select({}, order_by="-created_at", limit=5)
+# Note: limit > 1 automatically sets all=True
+
+# Select with multiple ordering fields
+sorted_users = await User.select({}, order_by=["last_name", "first_name"], all=True)
+
+# Select with relationship ordering
+posts_by_author = await Post.select({}, order_by="user.username", all=True)
+```
+
+### Update
+
+```python
+# Update by ID
+user = await User.update({"is_active": False}, 1)
+
+# Update by criteria
+count = await User.update(
+    {"is_active": False},
+    {"last_login": None}  # Set all users without login to inactive
+)
+
+# Update with relationships
+await User.update(
+    {"department": {"name": "Sales"}},  # Update department relationship
+    {"username": "john_doe"}
+)
+```
+
+### Delete
+
+```python
+# Delete by ID
+success = await User.delete(1)
+
+# Delete by criteria
+deleted_count = await User.delete({"is_active": False})
+
+# Delete with compound criteria
+await Post.delete({"user": {"username": "john_doe"}, "is_published": False})
+```
+
+## Convenient Query Methods
+
+async-easy-model provides simplified methods for common query patterns:
+
+```python
+# Get all records with relationships loaded (default)
+users = await User.all()
+
+# Get all records ordered by a field (ascending)
+users = await User.all(order_by="username")
+
+# Get all records ordered by a field (descending)
+newest_users = await User.all(order_by="-created_at")
+
+# Get all records ordered by multiple fields
+sorted_users = await User.all(order_by=["last_name", "first_name"])
+
+# Get all records ordered by relationship fields
+books = await Book.all(order_by="author.name")
+
+# Get the first record 
+user = await User.first()
+
+# Get the most recently created user
+newest_user = await User.first(order_by="-created_at")
+
+# Get a limited number of records
+recent_users = await User.limit(10)
+
+# Get a limited number of records with ordering
+top_products = await Product.limit(5, order_by="-sales")
+```
+
+## Enhanced Relationship Handling
+
+Using the models defined earlier, here's how to work with relationships:
+
+```python
+# Load all relationships automatically
+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}, include_relationships=False)
+await post.load_related(["user", "comments"])
+
+# 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")
+
+# Convert to dictionary with nested relationships
+post_dict = post.to_dict(include_relationships=True, max_depth=2)
+```
+
+## Automatic Relationship Detection
+
+The package can automatically detect and set up bidirectional relationships between models:
+
+```python
+class User(EasyModel, table=True):
+    username: str
+
+class Post(EasyModel, table=True):
+    title: str
+    user_id: int = Field(foreign_key="user.id")
+
+# After init_db():
+# - post.user relationship is automatically available
+# - user.posts relationship is automatically available
+```
+
+## Database Configuration
+
+```python
+# SQLite Configuration
+db_config.configure_sqlite("database.db")
+db_config.configure_sqlite(":memory:")  # In-memory database
+
+# PostgreSQL Configuration
+db_config.configure_postgres(
+    user="your_user",
+    password="your_password",
+    host="localhost",
+    port="5432",
+    database="your_database"
+)
+
+# Custom Connection URL
+db_config.set_connection_url("postgresql+asyncpg://user:password@localhost:5432/database")
+```
+
+## 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/master/DOCS.md) file.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

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.1.dist-info/METADATA

@@ -1,343 +0,0 @@
-Metadata-Version: 2.2
-Name: async-easy-model
-Version: 0.2.1
-Summary: A simplified SQLModel-based ORM for async database operations
-Home-page: https://github.com/puntorigen/easy-model
-Author: Pablo Schaffner
-Author-email: pablo@puntorigen.com
-Keywords: orm,sqlmodel,database,async,postgresql,sqlite
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: sqlmodel>=0.0.8
-Requires-Dist: sqlalchemy>=2.0.0
-Requires-Dist: asyncpg>=0.25.0
-Requires-Dist: aiosqlite>=0.19.0
-Requires-Dist: greenlet>=3.1.1
-Requires-Dist: inflection>=0.5.1
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: keywords
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# EasyModel
-
-A simplified SQLModel-based ORM for async database operations in Python. EasyModel provides a clean and intuitive interface for common database operations while leveraging the power of SQLModel and SQLAlchemy.
-
-## Features
-
-- Easy-to-use async database operations with standardized methods
-- Intuitive APIs with sensible defaults (relationships loaded by default)
-- Dictionary-based CRUD operations (select, insert, update, delete)
-- Built on top of SQLModel and SQLAlchemy
-- Support for both PostgreSQL and SQLite databases
-- Type hints for better IDE support
-- Automatic `id`, `created_at` and `updated_at` fields provided by default
-- Enhanced relationship handling with eager loading and nested operations
-- Flexible ordering of query results with support for relationship fields
-- Automatic relationship detection
-- Automatic schema migrations for evolving database models
-
-## Installation
-
-```bash
-pip install async-easy-model
-```
-
-## Quick Start with Standardized API
-
-This section demonstrates the preferred usage of EasyModel with its standardized API methods.
-
-```python
-from async_easy_model import EasyModel, init_db, db_config, Field
-from typing import Optional
-from datetime import datetime
-
-# Configure your database
-db_config.configure_sqlite("database.db")
-
-# Define your model
-class User(EasyModel, table=True):
-    # id field is automatically created (primary key)
-    username: str = Field(unique=True)
-    email: str
-    is_active: bool = Field(default=True)
-    # created_at and updated_at fields are automatically included
-    
-class Post(EasyModel, table=True):
-    # id field is automatically created (primary key)
-    title: str
-    content: str
-    user_id: Optional[int] = Field(default=None, foreign_key="user.id")
-    # created_at and updated_at fields are automatically included
-
-# Initialize your database
-async def setup():
-    await init_db()
-
-# Use the standardized methods in your code
-async def main():
-    # Insert a new user
-    user = await User.insert({
-        "username": "john_doe",
-        "email": "john@example.com"
-    })
-    
-    # Insert with relationships
-    post = await Post.insert({
-        "title": "My First Post",
-        "content": "Hello world!",
-        "user": {"username": "john_doe"}  # Will find the user by username
-    })
-    
-    # Select with criteria
-    active_users = await User.select({"is_active": True}, all=True)
-    
-    # Select with wildcard search
-    gmail_users = await User.select({"email": "*@gmail.com"}, all=True)
-    
-    # Select with ordering and limit
-    recent_posts = await Post.select({}, order_by="-id", limit=5)
-    # Note: limit > 1 automatically sets all=True
-    
-    # Update by criteria
-    await User.update(
-        {"is_active": False},
-        {"last_login": None}  # Update users with no login
-    )
-    
-    # Delete with criteria
-    await Post.delete({"user": {"username": "john_doe"}})
-```
-
-## Standardized API Methods
-
-EasyModel provides a set of standardized methods that make it easy and intuitive to perform common database operations.
-
-### Select Method
-
-The `select()` method is a powerful and flexible way to query data:
-
-```python
-# Get active users
-active_users = await User.select({"is_active": True}, all=True)
-
-# Get single user by username (returns first match)
-user = await User.select({"username": "john_doe"})
-
-# Explicitly get first result
-first_admin = await User.select({"role": "admin"}, first=True)
-
-# With wildcard pattern matching
-gmail_users = await User.select({"email": "*@gmail.com"}, all=True)
-
-# With ordering and limit (automatically sets all=True)
-newest_users = await User.select({}, order_by="-created_at", limit=5)
-
-# With ordering by multiple fields
-sorted_users = await User.select({}, order_by=["last_name", "first_name"], all=True)
-
-# With ordering by nested relationship fields using dot notation
-books_by_author = await Book.select({}, order_by="author.name", all=True)
-posts_by_popularity = await Post.select({}, order_by=["-comments.count", "title"], all=True)
-```
-
-### Insert Method
-
-The `insert()` method supports both single and multiple records with relationship handling and returns the newly created records with assigned IDs and auto-generated fields (`created_at`, `updated_at`):
-
-```python
-# Insert single record
-user = await User.insert({
-    "username": "john_doe",
-    "email": "john@example.com"
-})
-print(user.id)  # Newly assigned ID is available
-print(user.created_at)  # Auto-generated timestamp is available
-
-# Insert with relationship
-comment = await Comment.insert({
-    "text": "Great post!",
-    "post": {"id": 1},  # Link by ID
-    "author": {"username": "jane_doe"}  # Link by attribute lookup
-})
-
-# Insert multiple records
-products = await Product.insert([
-    {"name": "Product 1", "price": 10.99},
-    {"name": "Product 2", "price": 24.99}
-])
-```
-
-### Update Method
-
-The `update()` method allows updates based on ID or criteria:
-
-```python
-# Update by ID
-user = await User.update({"email": "new@example.com"}, 1)
-
-# Update by criteria
-count = await User.update(
-    {"is_active": False},
-    {"last_login": None}  # Set all users without login to inactive
-)
-
-# Update with relationships
-await User.update(
-    {"department": {"name": "Sales"}},  # Update department relationship
-    {"username": "john_doe"}
-)
-```
-
-### Delete Method
-
-The `delete()` method provides a consistent way to delete records:
-
-```python
-# Delete by ID
-success = await User.delete(1)
-
-# Delete by criteria
-deleted_count = await User.delete({"is_active": False})
-
-# Delete with compound criteria
-await Post.delete({"author": {"username": "john_doe"}, "is_published": False})
-```
-
-## Convenience Query Methods
-
-EasyModel also provides convenient shorthand methods for common queries:
-
-```python
-# Get all records with relationships loaded (default)
-users = await User.all()
-
-# Get all records ordered by a field
-users = await User.all(order_by="username")
-
-# Get the first record
-user = await User.first()
-
-# Get the most recently created user
-newest_user = await User.first(order_by="-created_at")
-
-# Get limited records
-recent_users = await User.limit(10, order_by="-created_at")
-```
-
-## Automatic Relationship Detection
-
-EasyModel supports automatic relationship detection based on foreign key fields:
-
-```python
-from async_easy_model import enable_auto_relationships, EasyModel, init_db, Field
-from typing import Optional
-
-# Enable automatic relationship detection
-enable_auto_relationships()
-
-# Define models with foreign keys but without explicit relationships
-class Author(EasyModel, table=True):
-    # id field is automatically created (primary key)
-    name: str
-
-class Book(EasyModel, table=True):
-    title: str
-    author_id: Optional[int] = Field(default=None, foreign_key="author.id")
-    # No need to define Relationship attributes - they're detected automatically!
-
-# Use the automatically detected relationships
-async def main():
-    await init_db()
-    author = await Author.insert({"name": "Jane Author"})
-    
-    book = await Book.insert({
-        "title": "Auto-detected Relationships",
-        "author_id": author.id
-    })
-    
-    # Show the book with its author
-    print(f"Book: {book.title}, Author: {book.author.name}")
-```
-
-### Another Example
-```python
-# Using the standard insert with nested dictionaries (recommended)
-new_book = await Book.insert({
-    "title": "New Book",
-    "author": {"name": "Jane Author"}  # Will create or find the author
-})
-```
-
-## Automatic Schema Migrations
-
-EasyModel includes automatic database migration capabilities, similar to alembic:
-
-```python
-from async_easy_model import MigrationManager
-
-async def apply_migrations():
-    migration_manager = MigrationManager()
-    results = await migration_manager.migrate_models([User, Post])
-    
-    if results:
-        print("Migrations applied:")
-        for model_name, changes in results.items():
-            print(f"  {model_name}:")
-            for change in changes:
-                print(f"    - {change}")
-```
-
-## Legacy API Methods
-
-The following methods are still supported but the standardized methods above are recommended for new code:
-
-### Traditional CRUD Operations
-
-```python
-# Create a record (consider using insert() instead)
-user = User(username="john_doe", email="john@example.com")
-await user.save()
-
-# Get by ID (consider using select() instead)
-user = await User.get_by_id(1)
-
-# Get by attribute (consider using select() instead)
-users = await User.get_by_attribute(is_active=True, all=True)
-
-# Update by ID (consider using update() instead)
-updated_user = await User.update_by_id(1, {"email": "new_email@example.com"})
-
-# Update by attribute (consider using update() instead)
-await User.update_by_attribute(
-    {"is_active": False},  # Update data
-    is_active=True, role="guest"  # Filter criteria
-)
-
-# Delete by ID (consider using delete() instead)
-success = await User.delete_by_id(1)
-
-# Delete by attribute (consider using delete() instead)
-deleted_count = await User.delete_by_attribute(is_active=False)
-```
-
-## Complete Documentation
-
-For complete documentation, including advanced features, please see the [full documentation](DOCS.md).

async_easy_model-0.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-async_easy_model/__init__.py,sha256=JcNQU_W8DUFnGVoOkbwfLDz5akT6jjMNVYLzWy_HA6w,1643
-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=D8nXgiYGu1WdNGciVSESyH4hmYmEx2_Rs6pBQQpyEA8,52958
-async_easy_model/relationships.py,sha256=vR5BsJpGaDcecCcNlg9-ouZfxFXFQv5kOyiXhKp_T7A,3286
-async_easy_model-0.2.1.dist-info/LICENSE,sha256=uwDkl6oHbRltW7vYKNc4doJyhtwhyrSNFFlPpKATwLE,1072
-async_easy_model-0.2.1.dist-info/METADATA,sha256=RrlZpVzUvAO8RWPMH7g9w2DUKSyjsXqxfKsPzaOs6QM,10420
-async_easy_model-0.2.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-async_easy_model-0.2.1.dist-info/top_level.txt,sha256=e5_47sGmJnyxz2msfwU6C316EqmrSd9RGIYwZyWx68E,17
-async_easy_model-0.2.1.dist-info/RECORD,,