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

general_manager/permission/{permissionDataManager.py → permission_data_manager.py}

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Callable, Optional, TypeVar, Generic, cast
 from django.contrib.auth.models import AbstractUser
 
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 
 
 class InvalidPermissionDataError(TypeError):
@@ -42,7 +42,7 @@ class PermissionDataManager(Generic[GeneralManagerData]):
         Raises:
             InvalidPermissionDataError: If `permission_data` is neither a dict nor an instance of GeneralManager.
         """
-        self.getData: Callable[[str], object]
+        self.get_data: Callable[[str], object]
         self._permission_data = permission_data
         self._manager: type[GeneralManagerData] | None
         if isinstance(permission_data, GeneralManager):
@@ -51,7 +51,7 @@ class PermissionDataManager(Generic[GeneralManagerData]):
             def manager_getter(name: str) -> object:
                 return getattr(gm_instance, name)
 
-            self.getData = manager_getter
+            self.get_data = manager_getter
             self._manager = cast(type[GeneralManagerData], permission_data.__class__)
         elif isinstance(permission_data, dict):
             data_mapping = permission_data
@@ -59,13 +59,13 @@ class PermissionDataManager(Generic[GeneralManagerData]):
             def dict_getter(name: str) -> object:
                 return data_mapping.get(name)
 
-            self.getData = dict_getter
+            self.get_data = dict_getter
             self._manager = manager
         else:
             raise InvalidPermissionDataError()
 
     @classmethod
-    def forUpdate(
+    def for_update(
         cls,
         base_data: GeneralManagerData,
         update_data: dict[str, object],
@@ -95,4 +95,4 @@ class PermissionDataManager(Generic[GeneralManagerData]):
 
     def __getattr__(self, name: str) -> object:
         """Proxy attribute access to the wrapped permission data."""
-        return self.getData(name)
+        return self.get_data(name)

general_manager/permission/utils.py

@@ -1,12 +1,12 @@
 """Utility helpers for evaluating permission expressions."""
 
-from general_manager.permission.permissionChecks import (
+from general_manager.permission.permission_checks import (
     permission_functions,
 )
-from general_manager.permission.permissionDataManager import PermissionDataManager
+from general_manager.permission.permission_data_manager import PermissionDataManager
 from django.contrib.auth.models import AbstractUser, AnonymousUser
 
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 from general_manager.manager.meta import GeneralManagerMeta
 
 
@@ -23,7 +23,7 @@ class PermissionNotFoundError(ValueError):
         super().__init__(f"Permission {permission} not found.")
 
 
-def validatePermissionString(
+def validate_permission_string(
     permission: str,
     data: PermissionDataManager | GeneralManager | GeneralManagerMeta,
     request_user: AbstractUser | AnonymousUser,
@@ -43,7 +43,7 @@ def validatePermissionString(
         PermissionNotFoundError: If a referenced permission function is not registered.
     """
 
-    def _validateSinglePermission(
+    def _validate_single_permission(
         permission: str,
     ) -> bool:
         """
@@ -68,7 +68,7 @@ def validatePermissionString(
 
     return all(
         [
-            _validateSinglePermission(sub_permission)
+            _validate_single_permission(sub_permission)
             for sub_permission in permission.split("&")
         ]
     )

general_manager/public_api_registry.py

@@ -14,24 +14,25 @@ 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"),
+    "get_logger": ("general_manager.logging", "get_logger"),
     "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 +43,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 +90,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,11 +18,13 @@ from general_manager.rule.handler import (
     MinHandler,
     SumHandler,
 )
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.logging import get_logger
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
 
 NOTEXISTENT = object()
+logger = get_logger("rule.engine")
 
 
 class NonexistentAttributeError(AttributeError):
@@ -131,13 +133,20 @@ class Rule(Generic[GeneralManagerType]):
             handler_cls: type[BaseRuleHandler] = import_string(path)
             inst = handler_cls()
             self._handlers[inst.function_name] = inst
+        logger.debug(
+            "initialised rule",
+            context={
+                "rule": self._func.__qualname__,
+                "variables": self._variables,
+            },
+        )
 
     @property
     def func(self) -> Callable[[GeneralManagerType], bool]:
         return self._func
 
     @property
-    def customErrorMessage(self) -> Optional[str]:
+    def custom_error_message(self) -> Optional[str]:
         return self._custom_error_message
 
     @property
@@ -145,15 +154,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]:
@@ -173,15 +182,50 @@ class Rule(Generic[GeneralManagerType]):
         if self._primary_param is not None:
             self._last_args[self._primary_param] = x
 
+        logger.debug(
+            "evaluating rule",
+            context={
+                "rule": self._func.__qualname__,
+                "manager": type(x).__name__,
+            },
+        )
+
         vals = self._extract_variable_values(x)
         if self._ignore_if_none and any(v is None for v in vals.values()):
             self._last_result = None
+            logger.debug(
+                "skipped rule evaluation due to missing values",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": type(x).__name__,
+                    "null_variables": [
+                        name for name, value in vals.items() if value is None
+                    ],
+                },
+            )
             return None
 
         self._last_result = self._func(x)
+        if self._last_result:
+            logger.debug(
+                "rule evaluation passed",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": type(x).__name__,
+                },
+            )
+        else:
+            logger.info(
+                "rule evaluation failed",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": type(x).__name__,
+                    "variables": self._variables,
+                },
+            )
         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 +240,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,8 +256,16 @@ 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)
+        manager_class = type(self._last_input).__name__
+        logger.debug(
+            "generating rule error messages",
+            context={
+                "rule": self._func.__qualname__,
+                "manager": manager_class,
+            },
+        )
 
         if self._custom_error_message:
             formatted = re.sub(
@@ -221,9 +273,34 @@ class Rule(Generic[GeneralManagerType]):
                 lambda m: str(vals.get(m.group(1), m.group(0))),
                 self._custom_error_message,
             )
+            logger.info(
+                "rule produced custom error message",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": manager_class,
+                    "variables": self._variables,
+                },
+            )
             return {v: formatted for v in self._variables}
 
         errors = self._generate_error_messages(vals)
+        if errors:
+            logger.info(
+                "rule produced error messages",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": manager_class,
+                    "variables": list(errors.keys()),
+                },
+            )
+        else:
+            logger.debug(
+                "rule generated no error messages",
+                context={
+                    "rule": self._func.__qualname__,
+                    "manager": manager_class,
+                },
+            )
         return errors or None
 
     def _extract_variables(self) -> List[str]:
@@ -250,7 +327,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 +345,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 +380,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 +394,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
@@ -349,6 +432,14 @@ class Rule(Generic[GeneralManagerType]):
                         fn = self._get_node_name(left.func)
                         handler = self._handlers.get(fn)
                         if handler:
+                            logger.debug(
+                                "rule handler invoked",
+                                context={
+                                    "rule": self._func.__qualname__,
+                                    "handler": handler.__class__.__name__,
+                                    "function": fn,
+                                },
+                            )
                             errors.update(
                                 handler.handle(cmp, left, right, op, var_values, self)
                             )

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]:
     """