GeneralManager 0.19.1__py3-none-any.whl → 0.20.0__py3-none-any.whl

general_manager/bucket/{databaseBucket.py → database_bucket.py}

@@ -6,15 +6,12 @@ from typing import TYPE_CHECKING, Any, Generator, Type, TypeVar
 from django.core.exceptions import FieldError
 from django.db import models
 
-from general_manager.bucket.baseBucket import Bucket
-from general_manager.interface.baseInterface import GeneralManagerType
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.utils.filterParser import create_filter_function
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.utils.filter_parser import create_filter_function
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
-
-if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import DatabaseInterface
+GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
 
 
 class DatabaseBucketTypeMismatchError(TypeError):
@@ -189,7 +186,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             {},
         )
 
-    def __mergeFilterDefinitions(
+    def __merge_filter_definitions(
         self, basis: dict[str, list[Any]], **kwargs: Any
     ) -> dict[str, list[Any]]:
         """
@@ -211,7 +208,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             kwarg_filter[key].append(value)
         return kwarg_filter
 
-    def __parseFilterDeifintions(
+    def __parse_filter_definitions(
         self,
         **kwargs: Any,
     ) -> tuple[dict[str, Any], dict[str, Any], list[tuple[str, Any, str]]]:
@@ -233,7 +230,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         annotations: dict[str, Any] = {}
         orm_kwargs: dict[str, Any] = {}
         python_filters: list[tuple[str, Any, str]] = []
-        properties = self._manager_class.Interface.getGraphQLProperties()
+        properties = self._manager_class.Interface.get_graph_ql_properties()
 
         for k, v in kwargs.items():
             root = k.split("__")[0]
@@ -251,7 +248,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
         return annotations, orm_kwargs, python_filters
 
-    def __parsePythonFilters(
+    def __parse_python_filters(
         self, query_set: models.QuerySet, python_filters: list[tuple[str, Any, str]]
     ) -> list[int]:
         """
@@ -293,7 +290,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             InvalidQueryAnnotationTypeError: If a query-annotation callback returns a non-QuerySet.
             QuerysetFilteringError: If the ORM rejects the filter arguments or filtering fails.
         """
-        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+        annotations, orm_kwargs, python_filters = self.__parse_filter_definitions(
             **kwargs
         )
         qs = self._data
@@ -313,10 +310,10 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
             raise QuerysetFilteringError(error) from error
 
         if python_filters:
-            ids = self.__parsePythonFilters(qs, python_filters)
+            ids = self.__parse_python_filters(qs, python_filters)
             qs = qs.filter(pk__in=ids)
 
-        merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
+        merged_filter = self.__merge_filter_definitions(self.filters, **kwargs)
         return self.__class__(qs, self._manager_class, merged_filter, self.excludes)
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
@@ -334,7 +331,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         Raises:
             InvalidQueryAnnotationTypeError: If an annotation callable is applied and does not return a Django QuerySet.
         """
-        annotations, orm_kwargs, python_filters = self.__parseFilterDeifintions(
+        annotations, orm_kwargs, python_filters = self.__parse_filter_definitions(
             **kwargs
         )
         qs = self._data
@@ -351,10 +348,10 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         qs = qs.exclude(**orm_kwargs)
 
         if python_filters:
-            ids = self.__parsePythonFilters(qs, python_filters)
+            ids = self.__parse_python_filters(qs, python_filters)
             qs = qs.exclude(pk__in=ids)
 
-        merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
+        merged_exclude = self.__merge_filter_definitions(self.excludes, **kwargs)
         return self.__class__(qs, self._manager_class, self.filters, merged_exclude)
 
     def first(self) -> GeneralManagerType | None:
@@ -467,7 +464,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         Returns:
             bool: True when the primary key exists in the queryset.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         if isinstance(item, GeneralManager):
             return item.identification.get("id", None) in self._data.values_list(
@@ -499,7 +496,7 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         """
         if isinstance(key, str):
             key = (key,)
-        properties = self._manager_class.Interface.getGraphQLProperties()
+        properties = self._manager_class.Interface.get_graph_ql_properties()
         annotations: dict[str, Any] = {}
         python_keys: list[str] = []
         qs = self._data

general_manager/bucket/{groupBucket.py → group_bucket.py}

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 from typing import Any, Generator, Type
-from general_manager.manager.groupManager import GroupManager
-from general_manager.bucket.baseBucket import Bucket, GeneralManagerType
+from general_manager.manager.group_manager import GroupManager
+from general_manager.bucket.base_bucket import Bucket, GeneralManagerType
 
 
 class InvalidGroupByKeyTypeError(TypeError):
@@ -132,10 +132,10 @@ class GroupBucket(Bucket[GeneralManagerType]):
             ValueError: If a group-by key is not a valid manager attribute.
         """
         super().__init__(manager_class)
-        self.__checkGroupByArguments(group_by_keys)
+        self.__check_group_by_arguments(group_by_keys)
         self._group_by_keys = group_by_keys
-        self._data: list[GroupManager[GeneralManagerType]] = self.__buildGroupedManager(
-            data
+        self._data: list[GroupManager[GeneralManagerType]] = (
+            self.__build_grouped_manager(data)
         )
         self._basis_data: Bucket[GeneralManagerType] = data
 
@@ -157,7 +157,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
             and self._group_by_keys == other._group_by_keys
         )
 
-    def __checkGroupByArguments(self, group_by_keys: tuple[str, ...]) -> None:
+    def __check_group_by_arguments(self, group_by_keys: tuple[str, ...]) -> None:
         """
         Validate that each provided group-by key is a string and is exposed by the manager interface.
 
@@ -171,12 +171,12 @@ class GroupBucket(Bucket[GeneralManagerType]):
         if not all(isinstance(arg, str) for arg in group_by_keys):
             raise InvalidGroupByKeyTypeError()
         if not all(
-            arg in self._manager_class.Interface.getAttributes()
+            arg in self._manager_class.Interface.get_attributes()
             for arg in group_by_keys
         ):
             raise UnknownGroupByKeyError(self._manager_class.__name__)
 
-    def __buildGroupedManager(
+    def __build_grouped_manager(
         self,
         data: Bucket[GeneralManagerType],
     ) -> list[GroupManager[GeneralManagerType]]:

general_manager/cache/{cacheDecorator.py → cache_decorator.py}

@@ -1,12 +1,15 @@
 """Helpers for caching GeneralManager computations with dependency tracking."""
 
-from typing import Any, Callable, Optional, Protocol, Set, TypeVar, cast
 from functools import wraps
+from typing import Any, Callable, Optional, Protocol, Set, TypeVar, cast
+
 from django.core.cache import cache as django_cache
-from general_manager.cache.cacheTracker import DependencyTracker
-from general_manager.cache.dependencyIndex import record_dependencies, Dependency
-from general_manager.cache.modelDependencyCollector import ModelDependencyCollector
-from general_manager.utils.makeCacheKey import make_cache_key
+
+from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.dependency_index import Dependency, record_dependencies
+from general_manager.cache.model_dependency_collector import ModelDependencyCollector
+from general_manager.logging import get_logger
+from general_manager.utils.make_cache_key import make_cache_key
 
 
 class CacheBackend(Protocol):
@@ -42,6 +45,7 @@ RecordFn = Callable[[str, Set[Dependency]], None]
 FuncT = TypeVar("FuncT", bound=Callable[..., object])
 
 _SENTINEL = object()
+logger = get_logger("cache.decorator")
 
 
 def cached(
@@ -74,11 +78,19 @@ def cached(
                 if cached_deps:
                     for class_name, operation, identifier in cached_deps:
                         DependencyTracker.track(class_name, operation, identifier)
+                logger.debug(
+                    "cache hit",
+                    context={
+                        "function": func.__qualname__,
+                        "key": key,
+                        "dependency_count": len(cached_deps) if cached_deps else 0,
+                    },
+                )
                 return cached_result
 
             with DependencyTracker() as dependencies:
                 result = func(*args, **kwargs)
-                ModelDependencyCollector.addArgs(dependencies, args, kwargs)
+                ModelDependencyCollector.add_args(dependencies, args, kwargs)
 
                 cache_backend.set(key, result, timeout)
                 cache_backend.set(deps_key, dependencies, timeout)
@@ -86,6 +98,15 @@ def cached(
                 if dependencies and timeout is None:
                     record_fn(key, dependencies)
 
+            logger.debug(
+                "cache miss recorded",
+                context={
+                    "function": func.__qualname__,
+                    "key": key,
+                    "dependency_count": len(dependencies),
+                    "timeout": timeout,
+                },
+            )
             return result
 
         # fix for python 3.14:

general_manager/cache/{cacheTracker.py → cache_tracker.py}

@@ -3,7 +3,7 @@
 import threading
 from types import TracebackType
 
-from general_manager.cache.dependencyIndex import (
+from general_manager.cache.dependency_index import (
     Dependency,
     filter_type,
     general_manager_name,

general_manager/cache/{dependencyIndex.py → dependency_index.py}

@@ -1,19 +1,21 @@
 """Dependency index management for cached GeneralManager query results."""
 
 from __future__ import annotations
-import time
+
 import ast
 import re
-import logging
+import time
 from datetime import date, datetime
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Tuple, Type, cast
 
 from django.core.cache import cache
-from general_manager.cache.signals import post_data_change, pre_data_change
 from django.dispatch import receiver
-from typing import Literal, Any, Iterable, TYPE_CHECKING, Type, Tuple, cast
+
+from general_manager.cache.signals import post_data_change, pre_data_change
+from general_manager.logging import get_logger
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
 
 type general_manager_name = str  # e.g. "Project", "Derivative", "User"
 type attribute = str  # e.g. "field", "name", "id"
@@ -31,7 +33,7 @@ type dependency_index = dict[
 type filter_type = Literal["filter", "exclude", "identification"]
 type Dependency = Tuple[general_manager_name, filter_type, str]
 
-logger = logging.getLogger(__name__)
+logger = get_logger("cache.dependency_index")
 
 
 class DependencyLockTimeoutError(TimeoutError):
@@ -616,7 +618,14 @@ def generic_cache_invalidation(
                         )
                         if should_invalidate:
                             logger.info(
-                                f"Invalidate cache key {ck} for filter {lookup} with value {val_key}"
+                                "invalidating cache key",
+                                context={
+                                    "manager": manager_name,
+                                    "key": ck,
+                                    "lookup": lookup,
+                                    "action": action,
+                                    "value": val_key,
+                                },
                             )
                             invalidate_cache_key(ck)
                             remove_cache_key_from_index(ck)
@@ -634,7 +643,14 @@ def generic_cache_invalidation(
                         )
                         if should_invalidate:
                             logger.info(
-                                f"Invalidate cache key {ck} for exclude {lookup} with value {val_key}"
+                                "invalidating cache key",
+                                context={
+                                    "manager": manager_name,
+                                    "key": ck,
+                                    "lookup": lookup,
+                                    "action": action,
+                                    "value": val_key,
+                                },
                             )
                             invalidate_cache_key(ck)
                             remove_cache_key_from_index(ck)

general_manager/cache/{modelDependencyCollector.py → model_dependency_collector.py}

@@ -1,9 +1,9 @@
 """Helpers that derive cache dependency metadata from GeneralManager objects."""
 
 from typing import Generator
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.bucket.baseBucket import Bucket
-from general_manager.cache.dependencyIndex import (
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.cache.dependency_index import (
     general_manager_name,
     Dependency,
     filter_type,
@@ -43,7 +43,7 @@ class ModelDependencyCollector:
                 yield from ModelDependencyCollector.collect(item)
 
     @staticmethod
-    def addArgs(dependencies: set[Dependency], args: tuple, kwargs: dict) -> None:
+    def add_args(dependencies: set[Dependency], args: tuple, kwargs: dict) -> None:
         """
         Enrich the dependency set with values discovered in positional and keyword arguments.
 

general_manager/cache/signals.py

@@ -13,7 +13,7 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
-def dataChange(func: Callable[P, R]) -> Callable[P, R]:
+def data_change(func: Callable[P, R]) -> Callable[P, R]:
     """
     Wrap a data-modifying function with pre- and post-change signal dispatching.
 

general_manager/factory/{autoFactory.py → auto_factory.py}

@@ -4,11 +4,14 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal
 from django.db import models
 from factory.django import DjangoModelFactory
-from general_manager.factory.factories import getFieldValue, getManyToManyFieldValue
+from general_manager.factory.factories import (
+    get_field_value,
+    get_many_to_many_field_value,
+)
 from django.contrib.contenttypes.fields import GenericForeignKey
 
 if TYPE_CHECKING:
-    from general_manager.interface.databaseInterface import (
+    from general_manager.interface.database_interface import (
         DBBasedInterface,
     )
 
@@ -82,7 +85,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             is_model = False
         if not is_model:
             raise InvalidAutoFactoryModelError
-        field_name_list, to_ignore_list = cls.interface.handleCustomFields(model)
+        field_name_list, to_ignore_list = cls.interface.handle_custom_fields(model)
 
         fields = [
             field
@@ -107,20 +110,20 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
                 continue  # Skip fields that are already set
             if isinstance(field, models.AutoField) or field.auto_created:
                 continue  # Skip auto fields
-            params[field.name] = getFieldValue(field)
+            params[field.name] = get_field_value(field)
 
         obj: list[models.Model] | models.Model = super()._generate(strategy, params)
         if isinstance(obj, list):
             for item in obj:
                 if not isinstance(item, models.Model):
                     raise InvalidGeneratedObjectError()
-                cls._handleManyToManyFieldsAfterCreation(item, params)
+                cls._handle_many_to_many_fields_after_creation(item, params)
         else:
-            cls._handleManyToManyFieldsAfterCreation(obj, params)
+            cls._handle_many_to_many_fields_after_creation(obj, params)
         return obj
 
     @classmethod
-    def _handleManyToManyFieldsAfterCreation(
+    def _handle_many_to_many_fields_after_creation(
         cls, obj: models.Model, attrs: dict[str, Any]
     ) -> None:
         """
@@ -134,7 +137,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             if field.name in attrs:
                 m2m_values = attrs[field.name]
             else:
-                m2m_values = getManyToManyFieldValue(field)
+                m2m_values = get_many_to_many_field_value(field)
             if m2m_values:
                 getattr(obj, field.name).set(m2m_values)
 
@@ -172,8 +175,10 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(use_creation_method=True, params=kwargs)
-        return cls._modelCreation(model_class, **kwargs)
+            return cls.__create_with_generate_func(
+                use_creation_method=True, params=kwargs
+            )
+        return cls._model_creation(model_class, **kwargs)
 
     @classmethod
     def _build(
@@ -192,13 +197,13 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
-            return cls.__createWithGenerateFunc(
+            return cls.__create_with_generate_func(
                 use_creation_method=False, params=kwargs
             )
-        return cls._modelBuilding(model_class, **kwargs)
+        return cls._model_building(model_class, **kwargs)
 
     @classmethod
-    def _modelCreation(
+    def _model_creation(
         cls, model_class: Type[models.Model], **kwargs: Any
     ) -> models.Model:
         """
@@ -219,7 +224,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return obj
 
     @classmethod
-    def _modelBuilding(
+    def _model_building(
         cls, model_class: Type[models.Model], **kwargs: Any
     ) -> models.Model:
         """Construct an unsaved model instance with the provided field values."""
@@ -229,7 +234,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return obj
 
     @classmethod
-    def __createWithGenerateFunc(
+    def __create_with_generate_func(
         cls, use_creation_method: bool, params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
@@ -251,13 +256,13 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         records = cls._adjustmentMethod(**params)
         if isinstance(records, dict):
             if use_creation_method:
-                return cls._modelCreation(model_cls, **records)
-            return cls._modelBuilding(model_cls, **records)
+                return cls._model_creation(model_cls, **records)
+            return cls._model_building(model_cls, **records)
 
         created_objects: list[models.Model] = []
         for record in records:
             if use_creation_method:
-                created_objects.append(cls._modelCreation(model_cls, **record))
+                created_objects.append(cls._model_creation(model_cls, **record))
             else:
-                created_objects.append(cls._modelBuilding(model_cls, **record))
+                created_objects.append(cls._model_building(model_cls, **record))
         return created_objects

general_manager/factory/factories.py

@@ -1,21 +1,18 @@
 """Helpers for generating realistic factory values for Django models."""
 
 from __future__ import annotations
-from typing import TYPE_CHECKING, Any, cast
+from typing import Any, cast
 
 from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex  # type: ignore[import-untyped]
 from django.core.validators import RegexValidator
 from django.db import models
-from datetime import date, datetime, time, timezone
+from datetime import date, datetime, time, timezone, timedelta
 from decimal import Decimal
 from random import SystemRandom
 from general_manager.measurement.measurement import Measurement
-from general_manager.measurement.measurementField import MeasurementField
-
-if TYPE_CHECKING:
-    from general_manager.factory.autoFactory import AutoFactory
+from general_manager.measurement.measurement_field import MeasurementField
 
 
 _RNG = SystemRandom()
@@ -65,7 +62,7 @@ class InvalidRelatedModelTypeError(TypeError):
         )
 
 
-def getFieldValue(
+def get_field_value(
     field: models.Field[Any, Any] | models.ForeignObjectRel,
 ) -> Any:
     """
@@ -158,7 +155,7 @@ def getFieldValue(
     elif isinstance(field, models.UUIDField):
         return cast(str, Faker("uuid4"))
     elif isinstance(field, models.DurationField):
-        return cast(time, Faker("time_delta"))
+        return cast(timedelta, Faker("time_delta"))
     elif isinstance(field, models.CharField):
         max_length = field.max_length or 100
         # Check for RegexValidator
@@ -173,7 +170,7 @@ def getFieldValue(
         else:
             return cast(str, Faker("text", max_nb_chars=max_length))
     elif isinstance(field, models.OneToOneField):
-        related_model = getRelatedModel(field)
+        related_model = get_related_model(field)
         if hasattr(related_model, "_general_manager_class"):
             related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
@@ -185,7 +182,7 @@ def getFieldValue(
             else:
                 raise MissingFactoryOrInstancesError(related_model)
     elif isinstance(field, models.ForeignKey):
-        related_model = getRelatedModel(field)
+        related_model = get_related_model(field)
         # Create or get an instance of the related model
         if hasattr(related_model, "_general_manager_class"):
             create_a_new_instance = _RNG.choice([True, True, False])
@@ -209,7 +206,7 @@ def getFieldValue(
         return None
 
 
-def getRelatedModel(
+def get_related_model(
     field: models.ForeignObjectRel | models.Field[Any, Any],
 ) -> type[models.Model]:
     """
@@ -239,7 +236,7 @@ def getRelatedModel(
     return cast(type[models.Model], related_model)
 
 
-def getManyToManyFieldValue(
+def get_many_to_many_field_value(
     field: models.ManyToManyField,
 ) -> list[models.Model]:
     """
@@ -257,7 +254,7 @@ def getManyToManyFieldValue(
         MissingFactoryOrInstancesError: If the related model provides neither a factory nor any existing instances.
     """
     related_factory = None
-    related_model = getRelatedModel(field)
+    related_model = get_related_model(field)
     related_instances = list(related_model.objects.all())
     if hasattr(related_model, "_general_manager_class"):
         related_factory = related_model._general_manager_class.Factory  # type: ignore