GeneralManager 0.19.0__py3-none-any.whl → 0.19.2__py3-none-any.whl

general_manager/public_api_registry.py

@@ -14,24 +14,24 @@ LazyExportMap = Mapping[str, str | tuple[str, str]]
 
 GENERAL_MANAGER_EXPORTS: LazyExportMap = {
     "GraphQL": ("general_manager.api.graphql", "GraphQL"),
-    "graphQlProperty": ("general_manager.api.property", "graphQlProperty"),
-    "graphQlMutation": ("general_manager.api.mutation", "graphQlMutation"),
-    "GeneralManager": ("general_manager.manager.generalManager", "GeneralManager"),
+    "graph_ql_property": ("general_manager.api.property", "graph_ql_property"),
+    "graph_ql_mutation": ("general_manager.api.mutation", "graph_ql_mutation"),
+    "GeneralManager": ("general_manager.manager.general_manager", "GeneralManager"),
     "Input": ("general_manager.manager.input", "Input"),
     "CalculationInterface": (
-        "general_manager.interface.calculationInterface",
+        "general_manager.interface.calculation_interface",
         "CalculationInterface",
     ),
     "DatabaseInterface": (
-        "general_manager.interface.databaseInterface",
+        "general_manager.interface.database_interface",
         "DatabaseInterface",
     ),
     "ReadOnlyInterface": (
-        "general_manager.interface.readOnlyInterface",
+        "general_manager.interface.read_only_interface",
         "ReadOnlyInterface",
     ),
     "ManagerBasedPermission": (
-        "general_manager.permission.managerBasedPermission",
+        "general_manager.permission.manager_based_permission",
         "ManagerBasedPermission",
     ),
     "Rule": ("general_manager.rule.rule", "Rule"),
@@ -42,36 +42,45 @@ API_EXPORTS: LazyExportMap = {
     "GraphQL": ("general_manager.api.graphql", "GraphQL"),
     "MeasurementType": ("general_manager.api.graphql", "MeasurementType"),
     "MeasurementScalar": ("general_manager.api.graphql", "MeasurementScalar"),
-    "graphQlProperty": ("general_manager.api.property", "graphQlProperty"),
-    "graphQlMutation": ("general_manager.api.mutation", "graphQlMutation"),
+    "graph_ql_property": ("general_manager.api.property", "graph_ql_property"),
+    "graph_ql_mutation": ("general_manager.api.mutation", "graph_ql_mutation"),
 }
 
 
 FACTORY_EXPORTS: LazyExportMap = {
-    "AutoFactory": ("general_manager.factory.autoFactory", "AutoFactory"),
-    "LazyMeasurement": ("general_manager.factory.factoryMethods", "LazyMeasurement"),
-    "LazyDeltaDate": ("general_manager.factory.factoryMethods", "LazyDeltaDate"),
-    "LazyProjectName": ("general_manager.factory.factoryMethods", "LazyProjectName"),
-    "LazyDateToday": ("general_manager.factory.factoryMethods", "LazyDateToday"),
-    "LazyDateBetween": ("general_manager.factory.factoryMethods", "LazyDateBetween"),
-    "LazyDateTimeBetween": (
-        "general_manager.factory.factoryMethods",
-        "LazyDateTimeBetween",
-    ),
-    "LazyInteger": ("general_manager.factory.factoryMethods", "LazyInteger"),
-    "LazyDecimal": ("general_manager.factory.factoryMethods", "LazyDecimal"),
-    "LazyChoice": ("general_manager.factory.factoryMethods", "LazyChoice"),
-    "LazySequence": ("general_manager.factory.factoryMethods", "LazySequence"),
-    "LazyBoolean": ("general_manager.factory.factoryMethods", "LazyBoolean"),
-    "LazyUUID": ("general_manager.factory.factoryMethods", "LazyUUID"),
-    "LazyFakerName": ("general_manager.factory.factoryMethods", "LazyFakerName"),
-    "LazyFakerEmail": ("general_manager.factory.factoryMethods", "LazyFakerEmail"),
-    "LazyFakerSentence": (
-        "general_manager.factory.factoryMethods",
-        "LazyFakerSentence",
-    ),
-    "LazyFakerAddress": ("general_manager.factory.factoryMethods", "LazyFakerAddress"),
-    "LazyFakerUrl": ("general_manager.factory.factoryMethods", "LazyFakerUrl"),
+    "AutoFactory": ("general_manager.factory.auto_factory", "AutoFactory"),
+    "lazy_measurement": ("general_manager.factory.factory_methods", "lazy_measurement"),
+    "lazy_delta_date": ("general_manager.factory.factory_methods", "lazy_delta_date"),
+    "lazy_project_name": (
+        "general_manager.factory.factory_methods",
+        "lazy_project_name",
+    ),
+    "lazy_date_today": ("general_manager.factory.factory_methods", "lazy_date_today"),
+    "lazy_date_between": (
+        "general_manager.factory.factory_methods",
+        "lazy_date_between",
+    ),
+    "lazy_date_time_between": (
+        "general_manager.factory.factory_methods",
+        "lazy_date_time_between",
+    ),
+    "lazy_integer": ("general_manager.factory.factory_methods", "lazy_integer"),
+    "lazy_decimal": ("general_manager.factory.factory_methods", "lazy_decimal"),
+    "lazy_choice": ("general_manager.factory.factory_methods", "lazy_choice"),
+    "lazy_sequence": ("general_manager.factory.factory_methods", "lazy_sequence"),
+    "lazy_boolean": ("general_manager.factory.factory_methods", "lazy_boolean"),
+    "lazy_uuid": ("general_manager.factory.factory_methods", "lazy_uuid"),
+    "lazy_faker_name": ("general_manager.factory.factory_methods", "lazy_faker_name"),
+    "lazy_faker_email": ("general_manager.factory.factory_methods", "lazy_faker_email"),
+    "lazy_faker_sentence": (
+        "general_manager.factory.factory_methods",
+        "lazy_faker_sentence",
+    ),
+    "lazy_faker_address": (
+        "general_manager.factory.factory_methods",
+        "lazy_faker_address",
+    ),
+    "lazy_faker_url": ("general_manager.factory.factory_methods", "lazy_faker_url"),
 }
 
 
@@ -80,88 +89,88 @@ MEASUREMENT_EXPORTS: LazyExportMap = {
     "ureg": ("general_manager.measurement.measurement", "ureg"),
     "currency_units": ("general_manager.measurement.measurement", "currency_units"),
     "MeasurementField": (
-        "general_manager.measurement.measurementField",
+        "general_manager.measurement.measurement_field",
         "MeasurementField",
     ),
 }
 
 
 UTILS_EXPORTS: LazyExportMap = {
-    "noneToZero": ("general_manager.utils.noneToZero", "noneToZero"),
-    "args_to_kwargs": ("general_manager.utils.argsToKwargs", "args_to_kwargs"),
-    "make_cache_key": ("general_manager.utils.makeCacheKey", "make_cache_key"),
-    "parse_filters": ("general_manager.utils.filterParser", "parse_filters"),
+    "none_to_zero": ("general_manager.utils.none_to_zero", "none_to_zero"),
+    "args_to_kwargs": ("general_manager.utils.args_to_kwargs", "args_to_kwargs"),
+    "make_cache_key": ("general_manager.utils.make_cache_key", "make_cache_key"),
+    "parse_filters": ("general_manager.utils.filter_parser", "parse_filters"),
     "create_filter_function": (
-        "general_manager.utils.filterParser",
+        "general_manager.utils.filter_parser",
         "create_filter_function",
     ),
-    "snake_to_pascal": ("general_manager.utils.formatString", "snake_to_pascal"),
-    "snake_to_camel": ("general_manager.utils.formatString", "snake_to_camel"),
-    "pascal_to_snake": ("general_manager.utils.formatString", "pascal_to_snake"),
-    "camel_to_snake": ("general_manager.utils.formatString", "camel_to_snake"),
-    "CustomJSONEncoder": ("general_manager.utils.jsonEncoder", "CustomJSONEncoder"),
-    "PathMap": ("general_manager.utils.pathMapping", "PathMap"),
+    "snake_to_pascal": ("general_manager.utils.format_string", "snake_to_pascal"),
+    "snake_to_camel": ("general_manager.utils.format_string", "snake_to_camel"),
+    "pascal_to_snake": ("general_manager.utils.format_string", "pascal_to_snake"),
+    "camel_to_snake": ("general_manager.utils.format_string", "camel_to_snake"),
+    "CustomJSONEncoder": ("general_manager.utils.json_encoder", "CustomJSONEncoder"),
+    "PathMap": ("general_manager.utils.path_mapping", "PathMap"),
 }
 
 
 PERMISSION_EXPORTS: LazyExportMap = {
-    "BasePermission": ("general_manager.permission.basePermission", "BasePermission"),
+    "BasePermission": ("general_manager.permission.base_permission", "BasePermission"),
     "ManagerBasedPermission": (
-        "general_manager.permission.managerBasedPermission",
+        "general_manager.permission.manager_based_permission",
         "ManagerBasedPermission",
     ),
     "MutationPermission": (
-        "general_manager.permission.mutationPermission",
+        "general_manager.permission.mutation_permission",
         "MutationPermission",
     ),
 }
 
 
 INTERFACE_EXPORTS: LazyExportMap = {
-    "InterfaceBase": "general_manager.interface.baseInterface",
-    "DBBasedInterface": "general_manager.interface.databaseBasedInterface",
-    "DatabaseInterface": "general_manager.interface.databaseInterface",
-    "ReadOnlyInterface": "general_manager.interface.readOnlyInterface",
-    "CalculationInterface": "general_manager.interface.calculationInterface",
+    "InterfaceBase": "general_manager.interface.base_interface",
+    "DBBasedInterface": "general_manager.interface.database_based_interface",
+    "DatabaseInterface": "general_manager.interface.database_interface",
+    "ReadOnlyInterface": "general_manager.interface.read_only_interface",
+    "CalculationInterface": "general_manager.interface.calculation_interface",
 }
 
 
 CACHE_EXPORTS: LazyExportMap = {
-    "cached": ("general_manager.cache.cacheDecorator", "cached"),
-    "CacheBackend": ("general_manager.cache.cacheDecorator", "CacheBackend"),
-    "DependencyTracker": ("general_manager.cache.cacheTracker", "DependencyTracker"),
+    "cached": ("general_manager.cache.cache_decorator", "cached"),
+    "CacheBackend": ("general_manager.cache.cache_decorator", "CacheBackend"),
+    "DependencyTracker": ("general_manager.cache.cache_tracker", "DependencyTracker"),
     "record_dependencies": (
-        "general_manager.cache.dependencyIndex",
+        "general_manager.cache.dependency_index",
         "record_dependencies",
     ),
     "remove_cache_key_from_index": (
-        "general_manager.cache.dependencyIndex",
+        "general_manager.cache.dependency_index",
         "remove_cache_key_from_index",
     ),
     "invalidate_cache_key": (
-        "general_manager.cache.dependencyIndex",
+        "general_manager.cache.dependency_index",
         "invalidate_cache_key",
     ),
 }
 
 
 BUCKET_EXPORTS: LazyExportMap = {
-    "Bucket": ("general_manager.bucket.baseBucket", "Bucket"),
-    "DatabaseBucket": ("general_manager.bucket.databaseBucket", "DatabaseBucket"),
+    "Bucket": ("general_manager.bucket.base_bucket", "Bucket"),
+    "DatabaseBucket": ("general_manager.bucket.database_bucket", "DatabaseBucket"),
     "CalculationBucket": (
-        "general_manager.bucket.calculationBucket",
+        "general_manager.bucket.calculation_bucket",
         "CalculationBucket",
     ),
-    "GroupBucket": ("general_manager.bucket.groupBucket", "GroupBucket"),
+    "GroupBucket": ("general_manager.bucket.group_bucket", "GroupBucket"),
 }
 
 
 MANAGER_EXPORTS: LazyExportMap = {
-    "GeneralManager": ("general_manager.manager.generalManager", "GeneralManager"),
+    "GeneralManager": ("general_manager.manager.general_manager", "GeneralManager"),
     "GeneralManagerMeta": ("general_manager.manager.meta", "GeneralManagerMeta"),
     "Input": ("general_manager.manager.input", "Input"),
-    "GroupManager": ("general_manager.manager.groupManager", "GroupManager"),
-    "graphQlProperty": ("general_manager.api.property", "graphQlProperty"),
+    "GroupManager": ("general_manager.manager.group_manager", "GroupManager"),
+    "graph_ql_property": ("general_manager.api.property", "graph_ql_property"),
 }
 
 

general_manager/rule/handler.py

@@ -213,7 +213,7 @@ class LenHandler(FunctionHandler):
         var_name = rule._get_node_name(arg_node)
         var_value = var_values.get(var_name)
 
-        # --- Hier der Typ-Guard für right_value ---
+        # --- Type guard for right_value ---
         raw = rule._eval_node(right_node)
         if not isinstance(raw, (int, float)):
             raise InvalidLenThresholdError()
@@ -230,7 +230,7 @@ class LenHandler(FunctionHandler):
         else:
             threshold = right_value
 
-        # Fehlermeldung formulieren
+        # Formulate the error message
         if op_symbol in (">", ">="):
             msg = f"[{var_name}] ({var_value}) is too short (min length {threshold})!"
         elif op_symbol in ("<", "<="):

general_manager/rule/rule.py

@@ -18,7 +18,7 @@ from general_manager.rule.handler import (
     MinHandler,
     SumHandler,
 )
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
 
@@ -137,7 +137,7 @@ class Rule(Generic[GeneralManagerType]):
         return self._func
 
     @property
-    def customErrorMessage(self) -> Optional[str]:
+    def custom_error_message(self) -> Optional[str]:
         return self._custom_error_message
 
     @property
@@ -145,15 +145,15 @@ class Rule(Generic[GeneralManagerType]):
         return self._variables
 
     @property
-    def lastEvaluationResult(self) -> Optional[bool]:
+    def last_evaluation_result(self) -> Optional[bool]:
         return self._last_result
 
     @property
-    def lastEvaluationInput(self) -> Optional[GeneralManagerType]:
+    def last_evaluation_input(self) -> Optional[GeneralManagerType]:
         return self._last_input
 
     @property
-    def ignoreIfNone(self) -> bool:
+    def ignore_if_none(self) -> bool:
         return self._ignore_if_none
 
     def evaluate(self, x: GeneralManagerType) -> Optional[bool]:
@@ -181,7 +181,7 @@ class Rule(Generic[GeneralManagerType]):
         self._last_result = self._func(x)
         return self._last_result
 
-    def validateCustomErrorMessage(self) -> None:
+    def validate_custom_error_message(self) -> None:
         """
         Validate that a provided custom error message template includes placeholders for every variable referenced by the rule.
 
@@ -196,7 +196,7 @@ class Rule(Generic[GeneralManagerType]):
         if missing:
             raise MissingErrorTemplateVariableError(missing)
 
-    def getErrorMessage(self) -> Optional[Dict[str, str]]:
+    def get_error_message(self) -> Optional[Dict[str, str]]:
         """
         Constructs error messages for the last failed evaluation and returns them keyed by variable name.
 
@@ -212,7 +212,7 @@ class Rule(Generic[GeneralManagerType]):
             raise ErrorMessageGenerationError()
 
         # Validate and substitute template placeholders
-        self.validateCustomErrorMessage()
+        self.validate_custom_error_message()
         vals = self._extract_variable_values(self._last_input)
 
         if self._custom_error_message:
@@ -250,7 +250,7 @@ class Rule(Generic[GeneralManagerType]):
                 self.vars: set[str] = set()
                 self.params = params
 
-            def visit_Attribute(self, node: ast.Attribute) -> None:
+            def visit_attribute(self, node: ast.Attribute) -> None:
                 """
                 Record dotted attribute accesses that originate from allowed parameter names.
 
@@ -268,6 +268,8 @@ class Rule(Generic[GeneralManagerType]):
                     self.vars.add(".".join(reversed(parts)))
                 self.generic_visit(node)
 
+            visit_Attribute = visit_attribute
+
         visitor = VarVisitor(param_names)
         visitor.visit(self._tree)
         return sorted(visitor.vars)
@@ -301,10 +303,12 @@ class Rule(Generic[GeneralManagerType]):
             def __init__(self) -> None:
                 self.comps: list[ast.Compare] = []
 
-            def visit_Compare(self, node: ast.Compare) -> None:
+            def visit_compare(self, node: ast.Compare) -> None:
                 self.comps.append(node)
                 self.generic_visit(node)
 
+            visit_Compare = visit_compare
+
         visitor = CompVisitor()
         visitor.visit(self._tree)
         return visitor.comps
@@ -313,11 +317,13 @@ class Rule(Generic[GeneralManagerType]):
         class LogicVisitor(ast.NodeVisitor):
             found: bool = False
 
-            def visit_BoolOp(self, node: ast.BoolOp) -> None:
+            def visit_bool_op(self, node: ast.BoolOp) -> None:
                 if isinstance(node.op, (ast.And, ast.Or)):
                     self.found = True
                 self.generic_visit(node)
 
+            visit_BoolOp = visit_bool_op
+
         visitor = LogicVisitor()
         visitor.visit(self._tree)
         return visitor.found

general_manager/utils/{filterParser.py → filter_parser.py}

@@ -36,7 +36,7 @@ def parse_filters(
     Raises:
         UnknownInputFieldError: If a filter references a field name not present in `possible_values`.
     """
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
 
     filters: dict[str, dict[str, Any]] = {}
     for kwarg, value in filter_kwargs.items():
@@ -49,7 +49,7 @@ def parse_filters(
         lookup = "__".join(parts[1:]) if len(parts) > 1 else ""
 
         if issubclass(input_field.type, GeneralManager):
-            # Sammle die Filter-Keyword-Argumente für das InputField
+            # Collect filter keyword arguments for the input field
             if lookup == "":
                 lookup = "id"
                 if not isinstance(value, GeneralManager):
@@ -59,7 +59,7 @@ def parse_filters(
                 lookup
             ] = value
         else:
-            # Erstelle Filterfunktionen für Nicht-Bucket-Typen
+            # Build filter functions for non-bucket types
             if isinstance(value, (list, tuple)) and not isinstance(
                 value, input_field.type
             ):

general_manager/utils/{jsonEncoder.py → json_encoder.py}

@@ -2,7 +2,7 @@
 
 from datetime import datetime, date, time
 import json
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 
 
 class CustomJSONEncoder(json.JSONEncoder):

general_manager/utils/{makeCacheKey.py → make_cache_key.py}

@@ -5,7 +5,7 @@ import json
 from hashlib import sha256
 from typing import Callable, Mapping
 
-from general_manager.utils.jsonEncoder import CustomJSONEncoder
+from general_manager.utils.json_encoder import CustomJSONEncoder
 
 
 def make_cache_key(

general_manager/utils/{noneToZero.py → none_to_zero.py}

@@ -6,7 +6,7 @@ from general_manager.measurement import Measurement
 NUMBERVALUE = TypeVar("NUMBERVALUE", int, float, Measurement)
 
 
-def noneToZero(
+def none_to_zero(
     value: Optional[NUMBERVALUE],
 ) -> NUMBERVALUE | Literal[0]:
     """

general_manager/utils/{pathMapping.py → path_mapping.py}

@@ -5,8 +5,8 @@ from typing import TYPE_CHECKING, Any, ClassVar, cast, get_args
 from general_manager.manager.meta import GeneralManagerMeta
 from general_manager.api.property import GraphQLProperty
 
-from general_manager.bucket.baseBucket import Bucket
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.manager.general_manager import GeneralManager
 
 
 type PathStart = str
@@ -20,9 +20,9 @@ class MissingStartInstanceError(ValueError):
         """
         Create the MissingStartInstanceError with its default message.
 
-        This initializer constructs the exception with the message: "Cannot call goTo on a PathMap without a start instance."
+        This initializer constructs the exception with the message: "Cannot call go_to on a PathMap without a start instance."
         """
-        super().__init__("Cannot call goTo on a PathMap without a start instance.")
+        super().__init__("Cannot call go_to on a PathMap without a start instance.")
 
 
 class PathMap:
@@ -40,11 +40,11 @@ class PathMap:
         """
         if not hasattr(cls, "instance"):
             cls.instance = super().__new__(cls)
-            cls.createPathMapping()
+            cls.create_path_mapping()
         return cls.instance
 
     @classmethod
-    def createPathMapping(cls) -> None:
+    def create_path_mapping(cls) -> None:
         """
         Populate the path mapping with tracers for every distinct pair of managed classes.
 
@@ -110,7 +110,7 @@ class PathMap:
             return None
         return tracer
 
-    def goTo(
+    def go_to(
         self, path_destination: PathDestination | type[GeneralManager] | str
     ) -> GeneralManager | Bucket | None:
         """
@@ -133,9 +133,9 @@ class PathMap:
             return None
         if self.start_instance is None:
             raise MissingStartInstanceError()
-        return tracer.traversePath(self.start_instance)
+        return tracer.traverse_path(self.start_instance)
 
-    def getAllConnected(self) -> set[str]:
+    def get_all_connected(self) -> set[str]:
         """
         Return the set of destination class names that are reachable from the configured start.
 
@@ -173,9 +173,9 @@ class PathTracer:
         if self.start_class == self.destination_class:
             self.path: list[str] | None = []
         else:
-            self.path = self.createPath(start_class, [])
+            self.path = self.create_path(start_class, [])
 
-    def createPath(
+    def create_path(
         self, current_manager: type[GeneralManager], path: list[str]
     ) -> list[str] | None:
         """
@@ -190,7 +190,7 @@ class PathTracer:
         """
         current_connections = {
             attr_name: attr_value["type"]
-            for attr_name, attr_value in current_manager.Interface.getAttributeTypes().items()
+            for attr_name, attr_value in current_manager.Interface.get_attribute_types().items()
         }
         for attr_name, attr_value in current_manager.__dict__.items():
             if not isinstance(attr_value, GraphQLProperty):
@@ -211,13 +211,13 @@ class PathTracer:
                 continue
             if attr_type == self.destination_class:
                 return [*path, attr]
-            result = self.createPath(attr_type, [*path, attr])
+            result = self.create_path(attr_type, [*path, attr])
             if result:
                 return result
 
         return None
 
-    def traversePath(
+    def traverse_path(
         self, start_instance: GeneralManager | Bucket
     ) -> GeneralManager | Bucket | None:
         """

general_manager/utils/testing.py

@@ -15,8 +15,8 @@ from unittest.mock import ANY
 
 from general_manager.api.graphql import GraphQL
 from general_manager.apps import GeneralmanagerConfig
-from general_manager.cache.cacheDecorator import _SENTINEL
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.cache.cache_decorator import _SENTINEL
+from general_manager.manager.general_manager import GeneralManager
 from general_manager.manager.meta import GeneralManagerMeta
 
 _original_get_app: Callable[[str], AppConfig | None] = (
@@ -24,7 +24,7 @@ _original_get_app: Callable[[str], AppConfig | None] = (
 )
 
 
-def createFallbackGetApp(fallback_app: str) -> Callable[[str], AppConfig | None]:
+def create_fallback_get_app(fallback_app: str) -> Callable[[str], AppConfig | None]:
     """
     Create an app-config lookup that falls back to a specific Django app.
 
@@ -32,7 +32,7 @@ def createFallbackGetApp(fallback_app: str) -> Callable[[str], AppConfig | None]
         fallback_app (str): App label used when the default lookup cannot resolve the object.
 
     Returns:
-        Callable[[str], Any]: Function returning either the resolved configuration or the fallback app configuration when available.
+        Callable[[str], AppConfig | None]: Function returning either the resolved configuration or the fallback app configuration when available.
     """
 
     def _fallback_get_app(object_name: str) -> AppConfig | None:
@@ -120,7 +120,7 @@ class GMTestCaseMeta(type):
             GraphQL._schema = None
 
             if fallback_app is not None:
-                handler = createFallbackGetApp(fallback_app)
+                handler = create_fallback_get_app(fallback_app)
                 global_apps.get_containing_app_config = cast(  # type: ignore[assignment]
                     Callable[[str], AppConfig | None], handler
                 )
@@ -154,11 +154,11 @@ class GMTestCaseMeta(type):
                         if history_model:
                             editor.create_model(history_model.model)  # type: ignore[attr-defined]
             # 4) GM & GraphQL initialization
-            GeneralmanagerConfig.initializeGeneralManagerClasses(
+            GeneralmanagerConfig.initialize_general_manager_classes(
                 cls.general_manager_classes, cls.general_manager_classes
             )
-            GeneralmanagerConfig.handleReadOnlyInterface(cls.read_only_classes)
-            GeneralmanagerConfig.handleGraphQL(cls.general_manager_classes)
+            GeneralmanagerConfig.handle_read_only_interface(cls.read_only_classes)
+            GeneralmanagerConfig.handle_graph_ql(cls.general_manager_classes)
             # 5) GraphQLTransactionTestCase.setUpClass
             base_setup.__func__(cls)
 
@@ -245,7 +245,7 @@ class GeneralManagerTransactionTestCase(
         """
         super().setUp()
         caches._connections.default = LoggingCache("test-cache", {})  # type: ignore[attr-defined]
-        self.__resetCacheCounter()
+        self.__reset_cache_counter()
 
     @classmethod
     def tearDownClass(cls) -> None:
@@ -311,7 +311,7 @@ class GeneralManagerTransactionTestCase(
         super().tearDownClass()
 
     #
-    def assertCacheMiss(self) -> None:
+    def assert_cache_miss(self) -> None:
         """
         Assert that a cache retrieval missed and was followed by a write.
 
@@ -328,9 +328,9 @@ class GeneralManagerTransactionTestCase(
             "Cache.get should have been called and found nothing",
         )
         self.assertIn(("set", ANY), ops, "Cache.set should have stored the value")
-        self.__resetCacheCounter()
+        self.__reset_cache_counter()
 
-    def assertCacheHit(self) -> None:
+    def assert_cache_hit(self) -> None:
         """
         Assert that a cache lookup succeeded without triggering a write.
 
@@ -352,9 +352,9 @@ class GeneralManagerTransactionTestCase(
             ops,
             "Cache.set should not have stored anything",
         )
-        self.__resetCacheCounter()
+        self.__reset_cache_counter()
 
-    def __resetCacheCounter(self) -> None:
+    def __reset_cache_counter(self) -> None:
         """
         Clear the log of cache operations recorded by the LoggingCache instance.
 

{generalmanager-0.19.0.dist-info → generalmanager-0.19.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.19.0
+Version: 0.19.2
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License