winidjango 1.0.4__py3-none-any.whl

winidjango/src/db/fields.py

@@ -0,0 +1,101 @@
+"""Fields module.
+
+Utils for working with Django model fields.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from django.db.models import Field, Model
+
+if TYPE_CHECKING:
+    from django.contrib.contenttypes.fields import GenericForeignKey
+    from django.db.models.fields.related import ForeignObjectRel
+    from django.db.models.options import Options
+
+
+def get_field_names(
+    fields: "list[Field[Any, Any] | ForeignObjectRel | GenericForeignKey]",
+) -> list[str]:
+    """Get the names of all fields from a Django model including relationships.
+
+    Retrieves the names of all field objects from a Django model, including
+    regular fields, foreign key relationships, reverse foreign key relationships,
+    and generic foreign keys. This provides a comprehensive view of all model
+    attributes that can be used for introspection, validation, or bulk operations.
+
+    Args:
+        fields (list[Field | ForeignObjectRel | GenericForeignKey]):
+            The list of field objects to get names from.
+
+    Returns:
+        list[str]: A list containing the names of all fields.
+
+    Example:
+        >>> from django.contrib.auth.models import User
+        >>> fields = get_fields(User)
+        >>> field_names = get_field_names(fields)
+        >>> 'username' in field_names
+        True
+        >>> 'email' in field_names
+        True
+    """
+    return [field.name for field in fields]
+
+
+def get_model_meta(model: type[Model]) -> "Options[Model]":
+    """Get the Django model metadata options object.
+
+    Retrieves the _meta attribute from a Django model class, which contains
+    metadata about the model including field definitions, table name, and
+    other model configuration options. This is a convenience wrapper around
+    accessing the private _meta attribute directly.
+
+    Args:
+        model (type[Model]): The Django model class to get metadata from.
+
+    Returns:
+        Options[Model]: The model's metadata options object containing
+            field definitions, table information, and other model configuration.
+
+    Example:
+        >>> from django.contrib.auth.models import User
+        >>> meta = get_model_meta(User)
+        >>> meta.db_table
+        'auth_user'
+        >>> len(meta.get_fields())
+        11
+    """
+    return model._meta  # noqa: SLF001
+
+
+def get_fields[TModel: Model](
+    model: type[TModel],
+) -> "list[Field[Any, Any] | ForeignObjectRel | GenericForeignKey]":
+    """Get all fields from a Django model including relationships.
+
+    Retrieves all field objects from a Django model, including regular fields,
+    foreign key relationships, reverse foreign key relationships, and generic
+    foreign keys. This provides a comprehensive view of all model attributes
+    that can be used for introspection, validation, or bulk operations.
+
+    Args:
+        model (type[Model]): The Django model class to get fields from.
+
+    Returns:
+        list[Field | ForeignObjectRel | GenericForeignKey]: A list
+            containing all field objects associated with the model, including:
+            - Regular model fields (CharField, IntegerField, etc.)
+            - Foreign key fields (ForeignKey, OneToOneField, etc.)
+            - Reverse relationship fields (ForeignObjectRel)
+            - Generic foreign key fields (GenericForeignKey)
+
+    Example:
+        >>> from django.contrib.auth.models import User
+        >>> fields = get_fields(User)
+        >>> field_names = [f.name for f in fields if hasattr(f, 'name')]
+        >>> 'username' in field_names
+        True
+        >>> 'email' in field_names
+        True
+    """
+    return get_model_meta(model).get_fields()

winidjango/src/db/models.py

@@ -0,0 +1,145 @@
+"""Database utilities for Django.
+
+This module provides utility functions for working with Django models,
+including hashing, topological sorting, and database operations.
+These utilities help with efficient and safe database interactions.
+"""
+
+from datetime import datetime
+from graphlib import TopologicalSorter
+from typing import TYPE_CHECKING, Any, Self, cast
+
+from django.db.models import DateTimeField, Field, Model
+from django.db.models.fields.related import ForeignKey, ForeignObjectRel
+from django.forms.models import model_to_dict
+
+from winidjango.src.db.fields import get_field_names, get_fields
+
+if TYPE_CHECKING:
+    from django.contrib.contenttypes.fields import GenericForeignKey
+    from django.db.models.options import Options
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def topological_sort_models[TModel: Model](
+    models: list[type[TModel]],
+) -> list[type[TModel]]:
+    """Sort Django models in dependency order using topological sorting.
+
+    Analyzes foreign key relationships between Django models and returns them
+    in an order where dependencies come before dependents. This ensures that
+    when performing operations like bulk creation or deletion, models are
+    processed in the correct order to avoid foreign key constraint violations.
+
+    The function uses Python's graphlib.TopologicalSorter to perform the sorting
+    based on ForeignKey relationships between the provided models. Only
+    relationships between models in the input list are considered.
+
+    Args:
+        models (list[type[Model]]): A list of Django model classes to sort
+            based on their foreign key dependencies.
+
+    Returns:
+        list[type[Model]]: The input models sorted in dependency order, where
+            models that are referenced by foreign keys appear before models
+            that reference them. Self-referential relationships are ignored.
+
+    Raises:
+        graphlib.CycleError: If there are circular dependencies between models
+            that cannot be resolved.
+
+    Example:
+        >>> # Assuming Author model has no dependencies
+        >>> # and Book model has ForeignKey to Author
+        >>> models = [Book, Author]
+        >>> sorted_models = topological_sort_models(models)
+        >>> sorted_models
+        [<class 'Author'>, <class 'Book'>]
+
+    Note:
+        - Only considers ForeignKey relationships, not other field types
+        - Self-referential foreign keys are ignored to avoid self-loops
+        - Only relationships between models in the input list are considered
+    """
+    ts: TopologicalSorter[type[TModel]] = TopologicalSorter()
+
+    for model in models:
+        deps = {
+            cast("type[TModel]", field.related_model)
+            for field in get_fields(model)
+            if isinstance(field, ForeignKey)
+            and isinstance(field.related_model, type)
+            and field.related_model in models
+            and field.related_model is not model
+        }
+        ts.add(model, *deps)
+
+    return list(ts.static_order())
+
+
+def hash_model_instance(
+    instance: Model,
+    fields: "list[Field[Any, Any] | ForeignObjectRel | GenericForeignKey]",
+) -> int:
+    """Hash a model instance based on its field values.
+
+    Generates a hash for a Django model instance by considering the values
+    of its fields. This can be useful for comparing instances, especially
+    when dealing with related objects or complex data structures. The hash
+    is generated by recursively hashing related objects up to a specified
+    depth.
+    This is not very reliable, use with caution.
+    Only use if working with unsafed objects or bulks, as with safed
+
+    Args:
+        instance (Model): The Django model instance to hash
+        fields (list[str]): The fields to hash
+
+    Returns:
+        int: The hash value representing the instance's data
+
+    """
+    if instance.pk:
+        return hash(instance.pk)
+
+    field_names = get_field_names(fields)
+    model_dict = model_to_dict(instance, fields=field_names)
+    sorted_dict = dict(sorted(model_dict.items()))
+    values = (type(instance), tuple(sorted_dict.items()))
+    return hash(values)
+
+
+class BaseModel(Model):
+    """Base model for all models in the project.
+
+    Provides common fields and methods for all models.
+    """
+
+    created_at: DateTimeField[datetime, datetime] = DateTimeField(auto_now_add=True)
+    updated_at: DateTimeField[datetime, datetime] = DateTimeField(auto_now=True)
+
+    class Meta:
+        """Mark the model as abstract."""
+
+        # abstract does not inherit in children
+        abstract = True
+
+    def __str__(self) -> str:
+        """Base string representation of a model.
+
+        Returns:
+            str: The string representation of the model as all fields and their values.
+        """
+        return f"{self.__class__.__name__}({self.pk})"
+
+    def __repr__(self) -> str:
+        """Base representation of a model."""
+        return str(self)
+
+    @property
+    def meta(self) -> "Options[Self]":
+        """Get the meta options for the model."""
+        return self._meta

winidjango/src/db/sql.py

@@ -0,0 +1,63 @@
+"""Module for database operations with sql."""
+
+from typing import Any
+
+from django.db import connection
+
+
+def execute_sql(
+    sql: str, params: dict[str, Any] | None = None
+) -> tuple[list[str], list[Any]]:
+    """Execute raw SQL query and return column names with results.
+
+    Executes a raw SQL query using Django's database connection and returns
+    both the column names and the result rows. This provides a convenient
+    way to run custom SQL queries while maintaining Django's database
+    connection management and parameter binding for security.
+
+    The function automatically handles cursor management and ensures proper
+    cleanup of database resources. Parameters are safely bound to prevent
+    SQL injection attacks.
+
+    Args:
+        sql (str): The SQL query string to execute. Can contain parameter
+            placeholders that will be safely bound using the params argument.
+        params (dict[str, Any] | None, optional): Dictionary of parameters
+            to bind to the SQL query for safe parameter substitution.
+            Defaults to None if no parameters are needed.
+
+    Returns:
+        tuple[list[str], list[Any]]: A tuple containing:
+            - list[str]: Column names from the query result
+            - list[Any]: List of result rows, where each row is a tuple
+              of values corresponding to the column names
+        Empty list if no results are returned
+
+    Raises:
+        django.db.Error: If there's a database error during query execution
+        django.db.ProgrammingError: If the SQL syntax is invalid
+        django.db.IntegrityError: If the query violates database constraints
+
+    Example:
+        >>> sql = "SELECT id, username FROM auth_user WHERE is_active = %(active)s"
+        >>> params = {"active": True}
+        >>> columns, rows = execute_sql(sql, params)
+        >>> columns
+        ['id', 'username']
+        >>> rows[0]
+        (1, 'admin')
+
+    Note:
+        - Uses Django's default database connection
+        - Automatically manages cursor lifecycle
+        - Parameters are safely bound to prevent SQL injection
+        - Returns all results in memory - use with caution for large datasets
+    """
+    with connection.cursor() as cursor:
+        cursor.execute(sql=sql, params=params)
+        rows = cursor.fetchall()
+        column_names = (
+            [col[0] for col in cursor.description] if cursor.description else []
+        )
+
+    return column_names, rows

winidjango-1.0.4.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.4
+Name: winidjango
+Version: 1.0.4
+Summary: A utils package for django
+License-Expression: MIT
+License-File: LICENSE
+Author: Winipedia
+Author-email: win.steveker@gmx.de
+Requires-Python: >=3.12
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: django
+Requires-Dist: pyrig
+Requires-Dist: winiutils
+Description-Content-Type: text/markdown
+
+# winidjango
+
+(This project uses [pyrig](https://github.com/Winipedia/pyrig))
+
+## Overview
+
+**winidjango** is a production-ready Django utilities library that simplifies complex database operations and provides structured patterns for data management tasks. Built with type safety and performance in mind, it leverages modern Python features and integrates seamlessly with Django's ORM.
+
+## Features
+
+### Database Utilities (`winidjango.src.db`)
+
+High-performance database operations with automatic optimization, dependency management, and type safety.
+
+#### Bulk Operations (`bulk.py`)
+
+Efficiently process large datasets with automatic chunking, multithreading, and transaction management.
+
+**Core Functions:**
+
+**`bulk_create_in_steps(model, bulk, step=1000)`**
+- Creates thousands of model instances in configurable batches (default: 1000)
+- Uses multithreading for parallel processing across chunks
+- Returns list of created instances with populated PKs
+- Wrapped in atomic transactions for data integrity
+
+**`bulk_update_in_steps(model, bulk, update_fields, step=1000)`**
+- Updates large datasets efficiently in batches
+- Requires explicit `update_fields` list for safety
+- Returns total count of updated objects
+- Multithreaded processing for maximum performance
+
+**`bulk_delete_in_steps(model, bulk, step=1000)`**
+- Deletes in batches with cascade tracking
+- Returns tuple: `(total_count, {model_name: count})`
+- Tracks all cascade deletions across related models
+- Safe handling of foreign key constraints
+
+**`bulk_create_bulks_in_steps(bulk_by_class, step=1000)`**
+- **Automatic Dependency Resolution**: Creates multiple model types in correct order
+- Uses topological sorting to handle foreign key relationships
+- Accepts dict mapping model classes to instance lists
+- Returns dict with created instances (PKs populated)
+
+**Advanced Comparison & Simulation:**
+
+**`get_differences_between_bulks(bulk1, bulk2, fields)`**
+- Compares two bulks by hashing field values
+- Returns 4-tuple: `(in_1_not_2, in_2_not_1, in_both_from_1, in_both_from_2)`
+- Useful for sync operations and change detection
+- Preserves original object references
+
+**`simulate_bulk_deletion(model_class, entries)`**
+- **Preview deletions without executing** using Django's Collector
+- Returns dict mapping models to objects that would be deleted
+- Includes all cascade deletions
+- Perfect for "what-if" analysis before destructive operations
+
+**`multi_simulate_bulk_deletion(entries)`**
+- Simulates deletions across multiple model types
+- Aggregates cascade effects into single summary
+- Accepts dict of `{model_class: [instances]}`
+
+**Usage Examples:**
+
+```python
+from winidjango.src.db.bulk import (
+    bulk_create_in_steps,
+    bulk_create_bulks_in_steps,
+    get_differences_between_bulks,
+    simulate_bulk_deletion,
+)
+
+# Create 10,000 objects in batches of 1000
+authors = [Author(name=f"Author {i}") for i in range(10000)]
+created = bulk_create_in_steps(Author, authors, step=1000)
+# Uses multithreading: ~10x faster than individual saves
+
+# Create related models in dependency order
+books = [Book(title=f"Book {i}", author=author) for i, author in enumerate(created)]
+reviews = [Review(book=book, rating=5) for book in books]
+
+results = bulk_create_bulks_in_steps({
+    Author: authors,
+    Book: books,      # Created after Author (foreign key dependency)
+    Review: reviews,  # Created after Book (foreign key dependency)
+})
+# Automatically sorted: Author → Book → Review
+
+# Compare two datasets
+from winidjango.src.db.fields import get_fields
+fields = get_fields(Author)
+old_authors = Author.objects.all()
+new_authors = [Author(name=f"Updated {i}") for i in range(100)]
+
+to_delete, to_create, unchanged_old, unchanged_new = get_differences_between_bulks(
+    list(old_authors), new_authors, fields
+)
+
+# Preview deletion impact
+deletion_preview = simulate_bulk_deletion(Author, to_delete)
+# Returns: {Author: {<Author: 1>, <Author: 2>}, Book: {<Book: 1>, <Book: 2>}, ...}
+print(f"Would delete {len(deletion_preview[Author])} authors")
+print(f"Would cascade delete {len(deletion_preview[Book])} books")
+```
+
+**Key Features:**
+- **Multithreading**: Parallel processing of chunks for maximum speed
+- **Transaction Safety**: Atomic operations with nested transaction warnings
+- **Configurable Batch Size**: Default 1000, adjustable per operation
+- **Type-Safe**: Full generic type hints with overloads
+- **Memory Efficient**: Processes data in chunks, not all at once
+
+#### Model Utilities (`models.py`)
+
+**`topological_sort_models(models)`**
+- Sorts models by foreign key dependencies using Python's `graphlib.TopologicalSorter`
+- Ensures correct creation/deletion order
+- Ignores self-referential relationships
+- Raises `CycleError` for circular dependencies
+
+**`hash_model_instance(instance, fields)`**
+- Hashes model instances for comparison
+- PK-based for saved instances (fast)
+- Field-based for unsaved instances (content comparison)
+- Used internally by `get_differences_between_bulks()`
+
+**`BaseModel`** - Abstract base model with common fields:
+- `created_at` - Auto-populated on creation
+- `updated_at` - Auto-updated on save
+- `meta` property - Type-safe access to `_meta`
+- Custom `__str__()` and `__repr__()`
+
+```python
+from winidjango.src.db.models import BaseModel
+
+class MyModel(BaseModel):
+    name = models.CharField(max_length=100)
+
+    class Meta(BaseModel.Meta):
+        db_table = "my_model"
+
+# Automatically includes created_at and updated_at
+obj = MyModel.objects.create(name="test")
+print(obj.created_at)  # datetime
+print(obj)  # "MyModel(1)"
+```
+
+#### Field Utilities (`fields.py`)
+
+**`get_fields(model)`** - Get all fields including relationships
+**`get_field_names(fields)`** - Extract field names from field objects
+**`get_model_meta(model)`** - Type-safe access to model `_meta`
+
+```python
+from winidjango.src.db.fields import get_fields, get_field_names
+
+fields = get_fields(User)
+field_names = get_field_names(fields)
+# ['id', 'username', 'email', 'groups', 'user_permissions', ...]
+```
+
+#### SQL Utilities (`sql.py`)
+
+**`execute_sql(sql, params=None)`**
+- Execute raw SQL with safe parameter binding
+- Returns tuple: `(column_names, rows)`
+- Automatic cursor management
+- Protection against SQL injection
+
+```python
+from winidjango.src.db.sql import execute_sql
+
+columns, rows = execute_sql(
+    "SELECT id, username FROM auth_user WHERE is_active = %(active)s",
+    params={"active": True}
+)
+# columns: ['id', 'username']
+# rows: [(1, 'admin'), (2, 'user'), ...]
+```
+
+### Management Commands (`winidjango.src.commands`)
+
+A powerful framework for building Django management commands with built-in best practices, automatic logging, and standardized argument handling.
+
+#### `ABCBaseCommand` - Base Command Framework
+
+Abstract base class that provides a robust foundation for all Django management commands:
+
+**Key Features:**
+- **Template Method Pattern**: Enforces consistent command structure while allowing customization
+- **Automatic Logging**: All method calls are logged with performance tracking via `ABCLoggingMixin`
+- **Built-in Common Arguments**: Pre-configured standard options available to all commands:
+  - `--dry_run` - Preview changes without executing
+  - `--force` - Force execution of actions
+  - `--delete` - Enable deletion operations
+  - `--yes` - Auto-confirm all prompts
+  - `--timeout` - Set command timeout
+  - `--batch_size` - Configure batch processing size
+  - `--threads` - Control thread count for parallel processing
+  - `--processes` - Control process count for multiprocessing
+- **Type-Safe**: Full type hints with abstract method enforcement at compile-time
+- **Structured Execution Flow**: Separates common setup (`base_handle`) from command-specific logic (`handle_command`)
+
+**Usage Pattern:**
+```python
+from winidjango.src.commands.base.base import ABCBaseCommand
+from argparse import ArgumentParser
+
+class MyCommand(ABCBaseCommand):
+    def add_command_arguments(self, parser: ArgumentParser) -> None:
+        """Add command-specific arguments."""
+        parser.add_argument('--input-file', type=str, required=True)
+        parser.add_argument('--output-format', choices=['json', 'csv'])
+
+    def handle_command(self) -> None:
+        """Execute command logic."""
+        input_file = self.get_option('input_file')
+        dry_run = self.get_option('dry_run')  # Built-in argument
+        batch_size = self.get_option('batch_size')  # Built-in argument
+
+        if dry_run:
+            self.stdout.write('Dry run mode - no changes will be made')
+
+        # Your command logic here
+        self.process_data(input_file, batch_size)
+```
+
+#### `ImportDataBaseCommand` - Data Import Framework
+
+Specialized command for structured data import workflows with automatic cleaning and bulk creation:
+
+**Workflow Steps:**
+1. **Import** (`handle_import()`) - Fetch raw data from any source, returns Polars DataFrame
+2. **Clean** (`get_cleaning_df_cls()`) - Define data cleaning logic using `winiutils.CleaningDF`
+3. **Transform** (`get_bulks_by_model()`) - Convert cleaned DataFrame to Django model instances
+4. **Load** (`import_to_db()`) - Bulk create with automatic dependency resolution via topological sorting
+
+**Key Features:**
+- **Polars Integration**: High-performance data processing with Polars DataFrames
+- **Automatic Cleaning**: Leverages `winiutils.CleaningDF` for standardized data cleaning pipeline
+- **Dependency-Aware**: Uses `bulk_create_bulks_in_steps()` to handle foreign key relationships automatically
+- **Inherits All Base Features**: Gets all `ABCBaseCommand` functionality (logging, common args, etc.)
+
+**Usage Pattern:**
+```python
+from winidjango.src.commands.import_data import ImportDataBaseCommand
+from winiutils.src.data.dataframe.cleaning import CleaningDF
+import polars as pl
+
+class MyCleaningDF(CleaningDF):
+    """Define your data cleaning rules."""
+    NAME_COL = "name"
+    EMAIL_COL = "email"
+
+    @classmethod
+    def get_rename_map(cls) -> dict[str, str]:
+        return {"name": "user_name", "email": "user_email"}
+
+    @classmethod
+    def get_col_dtype_map(cls) -> dict[str, type[pl.DataType]]:
+        return {cls.NAME_COL: pl.Utf8, cls.EMAIL_COL: pl.Utf8}
+
+    # ... other cleaning methods
+
+class ImportUsersCommand(ImportDataBaseCommand):
+    def handle_import(self) -> pl.DataFrame:
+        """Fetch data from source."""
+        return pl.read_csv("users.csv")
+
+    def get_cleaning_df_cls(self) -> type[CleaningDF]:
+        """Return your cleaning class."""
+        return MyCleaningDF
+
+    def get_bulks_by_model(self, df: pl.DataFrame) -> dict[type[Model], Iterable[Model]]:
+        """Convert cleaned data to model instances."""
+        users = [User(name=row["name"], email=row["email"])
+                 for row in df.iter_rows(named=True)]
+        profiles = [Profile(user=user) for user in users]
+
+        # Automatically created in correct order (User before Profile)
+        return {User: users, Profile: profiles}
+```
+
+**Benefits:**
+- **Standardized Import Process**: Consistent pattern across all data import commands
+- **Separation of Concerns**: Import, cleaning, and transformation logic clearly separated
+- **Automatic Optimization**: Bulk operations with multithreading and dependency resolution
+- **Data Quality**: Built-in cleaning pipeline ensures data consistency
+- **Testable**: Each step can be tested independently
+

winidjango-1.0.4.dist-info/RECORD

@@ -0,0 +1,26 @@
+winidjango/__init__.py,sha256=1s_h2cuQCaChY4Jk0ZDzzvhCKgvuD59XfzmGH6tm6x4,552
+winidjango/dev/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/dev/artifacts/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/dev/artifacts/builder/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/dev/artifacts/builder/builder.py,sha256=DdbLRMGQQdPgtYu8DSOZrw8Ukz5EmStSq4etgShh6_I,96
+winidjango/dev/cli/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/dev/cli/subcommands.py,sha256=iurWZwJwEKAfGpfjkn1YOhnRbIruCB4ouE-8R_Lh3JY,228
+winidjango/dev/configs/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/dev/configs/configs.py,sha256=fbUjVQCECHsylMBkazUzs2YXpTGlDr4Nq6tPlgf035o,105
+winidjango/main.py,sha256=uZR5lqPpMeSla1EOltLoCnh5V6GYyRL8H_JTYJEqYuo,420
+winidjango/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+winidjango/src/__init__.py,sha256=4h5GWbLSKlFjaNIUbEAiX1wambPOxlE50TWTJnHGs3s,43
+winidjango/src/commands/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/src/commands/base/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/src/commands/base/base.py,sha256=I4fevCwaMgHeDVt9YSSstvvxs44kGD4V09OtAOPNRJE,12716
+winidjango/src/commands/import_data.py,sha256=-heq2183v-vgMoOTOwLmYZ3-tRg68H9Haia3sYa5270,2484
+winidjango/src/db/__init__.py,sha256=XHsbmjiaGom-KX-S3leCY9cJD3aP9p_0X6xYMcdkHBU,23
+winidjango/src/db/bulk.py,sha256=Rpw8pUK-swUMm2OrzR5XUzs4Gfx_OB0LvKQus13i9js,22468
+winidjango/src/db/fields.py,sha256=o_gJlb4D7FmNh9smL8qv0SbEeISjd4WXTu4fDQHNJC8,3616
+winidjango/src/db/models.py,sha256=dV6ZdayNFfUCHB6Gpsp_V4a1ZiciKzsQXZ83oW_gj-Q,5052
+winidjango/src/db/sql.py,sha256=MG9iTUTJCetCKGf75k-EyacUzbb-G4u_-NL9NTngFrk,2446
+winidjango-1.0.4.dist-info/METADATA,sha256=kysKXWS3NAh3hCp_YM-n_Pqs2PvqJ7zbSl36JXYfJmQ,11862
+winidjango-1.0.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+winidjango-1.0.4.dist-info/entry_points.txt,sha256=NZcqI0Rnuc57cW9gJtrGTGwbyeOjCkEnfXQcmGjOuIQ,53
+winidjango-1.0.4.dist-info/licenses/LICENSE,sha256=o316mE2gGzd__JT69p7S_zlOmKiHh8YjpImCCcWyTvM,1066
+winidjango-1.0.4.dist-info/RECORD,,

winidjango-1.0.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

winidjango-1.0.4.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+winidjango=pyrig.dev.cli.cli:main
+

winidjango-1.0.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Winipedia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.