async-easy-model 0.2.1__py3-none-any.whl → 0.2.2__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.2"
 __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

@@ -511,6 +511,60 @@ class EasyModel(SQLModel):
                     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]:
         """
@@ -861,60 +915,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.

async_easy_model-0.2.2.dist-info/METADATA

@@ -0,0 +1,332 @@
+Metadata-Version: 2.2
+Name: async-easy-model
+Version: 0.2.2
+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 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
+})
+```
+
+### 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}, include_relationships=True)
+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})
+await post.load_related(["user", "comments"])
+
+# Insert with related objects in a single transaction
+new_post = await Post.insert_with_related({
+    "title": "My Post",
+    "content": "Content here",
+    "user": {"username": "john_doe"}
+})
+
+# 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/main/DOCS.md) file.
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

async_easy_model-0.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+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,,

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,,