winipedia-utils 0.1.0__py3-none-any.whl

winipedia_utils/django/command.py

@@ -0,0 +1,334 @@
+"""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 ABCImplementationLoggingMixin
+
+logger = logging.getLogger(__name__)
+
+
+class ABCBaseCommand(ABCImplementationLoggingMixin, 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

@@ -0,0 +1,304 @@
+"""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.contrib.contenttypes.fields import GenericForeignKey
+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
+from winipedia_utils.text.string import split_on_uppercase
+
+if TYPE_CHECKING:
+    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
+        # the rest does inherit
+        verbose_name = "Base Model"
+        verbose_name_plural = "Base Models"
+
+    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
+
+    @classmethod
+    def make_verbose_name(cls) -> str:
+        """Make a verbose name for the model."""
+        # split by upper case letters
+        return " ".join(split_on_uppercase(cls.__name__)).title()
+
+    @classmethod
+    def make_verbose_name_plural(cls) -> str:
+        """Make a verbose name plural for the model."""
+        return cls.make_verbose_name() + "s"

winipedia_utils/git/__init__.py

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