winipedia-utils 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

winipedia_utils/django/command.py

@@ -1,334 +0,0 @@
-"""Command utilities for Django.
-
-This module provides utility functions for working with Django commands,
-including command execution and output handling. These utilities help with
-managing and automating Django command-line tasks.
-"""
-
-import logging
-from abc import abstractmethod
-from argparse import ArgumentParser
-from typing import Any, final
-
-from django.core.management import BaseCommand
-
-from winipedia_utils.oop.mixins.mixin import ABCLoggingMixin
-
-logger = logging.getLogger(__name__)
-
-
-class ABCBaseCommand(ABCLoggingMixin, BaseCommand):
-    """Abstract base class for Django management commands with logging and validation.
-
-    This class serves as a foundation for creating Django management commands that
-    require abstract method implementation enforcement and automatic logging.
-    It combines Django's BaseCommand with ABCImplementationLoggingMixin to provide
-    both command functionality and development-time validation.
-
-    The class implements a template method pattern where common argument handling
-    and execution flow are managed by final methods, while specific implementations
-    are defined through abstract methods that subclasses must implement.
-
-    Key Features:
-        - Automatic logging of method calls with performance tracking
-        - Compile-time validation that all abstract methods are implemented
-        - Structured argument handling with base and custom arguments
-        - Template method pattern for consistent command execution flow
-
-    Inheritance Order:
-        The order of inheritance is critical: ABCImplementationLoggingMixin must
-        come before BaseCommand because Django's BaseCommand doesn't call
-        super().__init__(), so the mixin's metaclass initialization must happen
-        first to ensure proper class construction.
-
-    Example:
-        >>> class MyCommand(ABCBaseCommand):
-        ...     def add_command_arguments(self, parser):
-        ...         parser.add_argument('--my-option', help='Custom option')
-        ...
-        ...     def handle_command(self, *args, **options):
-        ...         self.stdout.write('Executing my command')
-
-    Note:
-        - All methods are automatically logged with performance tracking
-        - Subclasses must implement add_command_arguments and handle_command
-        - The @final decorator prevents overriding of template methods
-    """
-
-    @final
-    def add_arguments(self, parser: ArgumentParser) -> None:
-        """Configure command-line arguments for the Django management command.
-
-        This method implements the template method pattern by first adding common
-        base arguments that are used across multiple commands, then delegating
-        to the abstract add_command_arguments method for command-specific arguments.
-
-        The @final decorator prevents subclasses from overriding this method,
-        ensuring consistent argument handling across all commands while still
-        allowing customization through the abstract method.
-
-        Args:
-            parser (ArgumentParser): Django's argument parser instance used to
-                define command-line options and arguments for the command.
-
-        Note:
-            - This method is final and cannot be overridden by subclasses
-            - Common arguments are added first via _add_arguments()
-            - Custom arguments are added via the abstract add_command_arguments()
-            - Subclasses must implement add_command_arguments() for specific needs
-        """
-        # add base args that are used in most commands
-        self._add_arguments(parser)
-
-        # add additional args that are specific to the command
-        self.add_command_arguments(parser)
-
-    @final
-    def _add_arguments(self, parser: ArgumentParser) -> None:
-        """Add common command-line arguments used across multiple commands.
-
-        This method defines base arguments that are commonly used across different
-        Django management commands. These arguments provide standard functionality
-        like dry-run mode, verbosity control, and batch processing options.
-
-        The method is final to ensure consistent base argument handling, while
-        command-specific arguments are handled through the abstract
-        add_command_arguments method.
-
-        Args:
-            parser (ArgumentParser): Django's argument parser instance to which
-                common arguments should be added.
-
-        Note:
-            - Provides standard arguments for dry-run, verbosity, and batch processing
-            - The @final decorator prevents subclasses from overriding this method
-            - Command-specific arguments should be added via add_command_arguments()
-        """
-        parser.add_argument(
-            "--dry-run",
-            action="store_true",
-            help="Show what would be done without actually executing the changes",
-        )
-
-        parser.add_argument(
-            "--size",
-            type=int,
-            default=None,
-            help="Size of smth in a command",
-        )
-
-        parser.add_argument(
-            "--force",
-            action="store_true",
-            help="Force an action in a command",
-        )
-
-        parser.add_argument(
-            "--delete",
-            action="store_true",
-            help="Deleting smth in a command",
-        )
-
-        parser.add_argument(
-            "--quiet",
-            action="store_true",
-            help="Suppress non-error output for cleaner automation",
-        )
-
-        parser.add_argument(
-            "--debug",
-            action="store_true",
-            help="Print debug output for detailed tracing",
-        )
-
-        parser.add_argument(
-            "--yes",
-            action="store_true",
-            help="Answer yes to all prompts",
-            default=False,
-        )
-
-        parser.add_argument(
-            "--config",
-            type=str,
-            help="A configuration setup like filepath or json string for a command",
-            default=None,
-        )
-
-        parser.add_argument(
-            "--timeout",
-            type=int,
-            help="Timeout for a command",
-            default=None,
-        )
-
-        parser.add_argument(
-            "--batch-size",
-            type=int,
-            default=None,
-            help="Number of items to process in each batch",
-        )
-
-        parser.add_argument(
-            "--no-input",
-            action="store_true",
-            help="Do not prompt for user input",
-        )
-
-        parser.add_argument(
-            "--threads",
-            type=int,
-            default=None,
-            help="Number of threads to use for processing",
-        )
-
-        parser.add_argument(
-            "--processes",
-            type=int,
-            default=None,
-            help="Number of processes to use for processing",
-        )
-
-    @abstractmethod
-    def add_command_arguments(self, parser: ArgumentParser) -> None:
-        """Add command-specific arguments to the argument parser.
-
-        This abstract method must be implemented by subclasses to define
-        command-specific command-line arguments. It is called after common
-        base arguments are added, allowing each command to customize its
-        argument interface while maintaining consistent base functionality.
-
-        Subclasses should use this method to add arguments specific to their
-        command's functionality, such as file paths, configuration options,
-        or operational flags.
-
-        Args:
-            parser (ArgumentParser): Django's argument parser instance to which
-                command-specific arguments should be added.
-
-        Example:
-            >>> def add_command_arguments(self, parser):
-            ...     parser.add_argument(
-            ...         '--input-file',
-            ...         type=str,
-            ...         required=True,
-            ...         help='Path to input file'
-            ...     )
-            ...     parser.add_argument(
-            ...         '--output-format',
-            ...         choices=['json', 'csv', 'xml'],
-            ...         default='json',
-            ...         help='Output format for results'
-            ...     )
-
-        Note:
-            - This method is abstract and must be implemented by subclasses
-            - Called after _add_arguments() adds common base arguments
-            - Should focus on command-specific functionality only
-        """
-
-    @final
-    def handle(self, *args: Any, **options: Any) -> None:
-        """Execute the Django management command using template method pattern.
-
-        This method implements the main execution flow for the command by first
-        calling common handling logic through _handle(), then delegating to
-        the command-specific implementation via handle_command().
-
-        The @final decorator ensures this execution pattern cannot be overridden,
-        maintaining consistent command execution flow while allowing customization
-        through the abstract handle_command method.
-
-        Args:
-            *args: Positional arguments passed from Django's command execution.
-            **options: Keyword arguments containing parsed command-line options
-                and their values as defined by add_arguments().
-
-        Note:
-            - This method is final and cannot be overridden by subclasses
-            - Common handling logic is executed first via _handle()
-            - Command-specific logic is executed via abstract handle_command()
-            - All method calls are automatically logged with performance tracking
-        """
-        self._handle(*args, **options)
-        self.handle_command(*args, **options)
-
-    @final
-    def _handle(self, *_args: Any, **options: Any) -> None:
-        """Execute common handling logic shared across all commands.
-
-        This method is intended to contain common processing logic that should
-        be executed before command-specific handling. Currently, it serves as
-        a placeholder for future common functionality such as logging setup,
-        validation, or shared initialization.
-
-        The method is final to ensure consistent common handling across all
-        commands, while command-specific logic is handled through the abstract
-        handle_command method.
-
-        Args:
-            *args: Positional arguments passed from Django's command execution.
-                Currently unused but reserved for future common processing.
-            **options: Keyword arguments containing parsed command-line options.
-                Currently unused but reserved for future common processing.
-
-        Note:
-            - Examples might include logging setup, database connection validation, etc.
-            - The @final decorator prevents subclasses from overriding this method
-            - Called before handle_command() in the template method pattern
-        """
-        # log each option for the command
-        for key, value in options.items():
-            logger.info(
-                "Command '%s' - runs with option: '%s' with value: '%s'",
-                self.__class__.__name__,
-                key,
-                value,
-            )
-
-    @abstractmethod
-    def handle_command(self, *args: Any, **options: Any) -> None:
-        """Execute command-specific logic and functionality.
-
-        This abstract method must be implemented by subclasses to define the
-        core functionality of the Django management command. It is called after
-        common handling logic is executed, allowing each command to implement
-        its specific business logic while benefiting from shared infrastructure.
-
-        This method should contain the main logic that the command is designed
-        to perform, such as data processing, database operations, file manipulation,
-        or any other command-specific tasks.
-
-        Args:
-            *args: Positional arguments passed from Django's command execution.
-                These are typically not used in Django management commands.
-            **options: Keyword arguments containing parsed command-line options
-                and their values as defined by add_command_arguments().
-
-        Example:
-            >>> def handle_command(self, *args, **options):
-            ...     input_file = options['input_file']
-            ...     dry_run = options['dry_run']  # Base argument
-            ...     batch_size = options['batch_size']  # Base argument
-            ...     quiet = options['quiet']  # Base argument
-            ...
-            ...     if dry_run:
-            ...         self.stdout.write('Dry run mode - no changes will be made')
-            ...
-            ...     if not quiet:
-            ...         msg = f'Processing {input_file} in batches of {batch_size}'
-            ...         self.stdout.write(msg)
-            ...
-            ...     # Perform command-specific operations
-            ...     self.process_file(input_file, batch_size, dry_run)
-            ...
-            ...     if not quiet:
-            ...         self.stdout.write('Command completed successfully')
-
-        Note:
-            - This method is abstract and must be implemented by subclasses
-            - Called after _handle() executes common logic
-            - Should contain the main functionality of the command
-            - All method calls are automatically logged with performance tracking
-            - Use self.stdout.write() for output instead of print()
-        """

winipedia_utils/django/database.py

@@ -1,289 +0,0 @@
-"""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
-
-from django.db import connection
-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 winipedia_utils.logging.logger import get_logger
-
-if TYPE_CHECKING:
-    from django.contrib.contenttypes.fields import GenericForeignKey
-    from django.db.models.options import Options
-
-logger = get_logger(__name__)
-
-
-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(
-    model: type[Model],
-) -> "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()
-
-
-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 topological_sort_models(models: list[type[Model]]) -> list[type[Model]]:
-    """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[Model]] = TopologicalSorter()
-
-    for model in models:
-        deps = {
-            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 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
-
-    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]
-
-    return column_names, rows
-
-
-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.
-        """
-        fields_values = ", ".join(
-            f"{field.name}={getattr(self, field.name)}"
-            for field in get_fields(self.__class__)
-        )
-        return f"{self.__class__.__name__}({fields_values})"
-
-    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

winipedia_utils/pyside/__init__.py

@@ -1 +0,0 @@
-"""__init__ module for winipedia_utils.pyside6."""

winipedia_utils/pyside/core/__init__.py

@@ -1 +0,0 @@
-"""__init__ module for winipedia_utils.pyside6.core."""