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

general_manager/manager/meta.py

@@ -3,15 +3,19 @@
 from __future__ import annotations
 
 from django.conf import settings
-from typing import Any, Type, TYPE_CHECKING, ClassVar, TypeVar, Iterable, cast
-from general_manager.interface.baseInterface import InterfaceBase
+from typing import TYPE_CHECKING, Any, ClassVar, Iterable, Type, TypeVar, cast
+
+from general_manager.interface.base_interface import InterfaceBase
+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
 
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
 
+logger = get_logger("manager.meta")
+
 
 class InvalidInterfaceTypeError(TypeError):
     """Raised when a GeneralManager is configured with an incompatible Interface class."""
@@ -78,7 +82,7 @@ class GeneralManagerMeta(type):
         """
         Create a GeneralManager subclass, integrate any declared Interface hooks, and register the class for pending initialization and GraphQL processing.
 
-        If the class body defines an `Interface`, validates it is a subclass of `InterfaceBase`, invokes the interface's `handleInterface()` pre-creation hook to allow modification of the class namespace, creates the class, then invokes the post-creation hook and registers the class for attribute initialization and global tracking. If `Interface` is not defined, creates the class directly. If `settings.AUTOCREATE_GRAPHQL` is true, registers the created class for GraphQL interface processing.
+        If the class body defines an `Interface`, validates it is a subclass of `InterfaceBase`, invokes the interface's `handle_interface()` pre-creation hook to allow modification of the class namespace, creates the class, then invokes the post-creation hook and registers the class for attribute initialization and global tracking. If `Interface` is not defined, creates the class directly. If `settings.AUTOCREATE_GRAPHQL` is true, registers the created class for GraphQL interface processing.
 
         Parameters:
             mcs (type): The metaclass creating the class.
@@ -89,8 +93,16 @@ class GeneralManagerMeta(type):
         Returns:
             type: The newly created subclass, possibly modified by Interface hooks.
         """
-
-        def createNewGeneralManagerClass(
+        logger.debug(
+            "creating manager class",
+            context={
+                "class_name": name,
+                "module": attrs.get("__module__"),
+                "has_interface": "Interface" in attrs,
+            },
+        )
+
+        def create_new_general_manager_class(
             mcs: type["GeneralManagerMeta"],
             name: str,
             bases: tuple[type, ...],
@@ -103,23 +115,42 @@ class GeneralManagerMeta(type):
             interface = attrs.pop("Interface")
             if not issubclass(interface, InterfaceBase):
                 raise InvalidInterfaceTypeError(interface.__name__)
-            preCreation, postCreation = interface.handleInterface()
-            attrs, interface_cls, model = preCreation(name, attrs, interface)
-            new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
-            postCreation(new_class, interface_cls, model)
+            pre_creation, post_creation = interface.handle_interface()
+            attrs, interface_cls, model = pre_creation(name, attrs, interface)
+            new_class = create_new_general_manager_class(mcs, name, bases, attrs)
+            post_creation(new_class, interface_cls, model)
             mcs.pending_attribute_initialization.append(new_class)
             mcs.all_classes.append(new_class)
+            logger.debug(
+                "registered manager class with interface",
+                context={
+                    "class_name": new_class.__name__,
+                    "interface": interface_cls.__name__,
+                },
+            )
 
         else:
-            new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
+            new_class = create_new_general_manager_class(mcs, name, bases, attrs)
+            logger.debug(
+                "registered manager class without interface",
+                context={
+                    "class_name": new_class.__name__,
+                },
+            )
 
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
             mcs.pending_graphql_interfaces.append(new_class)
+            logger.debug(
+                "queued manager for graphql generation",
+                context={
+                    "class_name": new_class.__name__,
+                },
+            )
 
         return new_class
 
     @staticmethod
-    def createAtPropertiesForAttributes(
+    def create_at_properties_for_attributes(
         attributes: Iterable[str], new_class: Type[GeneralManager]
     ) -> None:
         """
@@ -132,14 +163,14 @@ class GeneralManagerMeta(type):
             new_class (Type[GeneralManager]): Class that will receive the generated descriptor attributes.
         """
 
-        def descriptorMethod(
+        def descriptor_method(
             attr_name: str,
             new_class: type,
         ) -> object:
             """
             Create a descriptor that provides attribute access backed by an instance's interface attributes.
 
-            When accessed on the class, the descriptor returns the field type by delegating to the class's `Interface.getFieldType` for the configured attribute name. When accessed on an instance, it returns the value stored in `instance._attributes[attr_name]`. If the stored value is callable, it is invoked with `instance._interface` and the resulting value is returned. If the attribute is not present on the instance, a `MissingAttributeError` is raised. If invoking a callable attribute raises an exception, that error is wrapped in `AttributeEvaluationError`.
+            When accessed on the class, the descriptor returns the field type by delegating to the class's `Interface.get_field_type` for the configured attribute name. When accessed on an instance, it returns the value stored in `instance._attributes[attr_name]`. If the stored value is callable, it is invoked with `instance._interface` and the resulting value is returned. If the attribute is not present on the instance, a `MissingAttributeError` is raised. If invoking a callable attribute raises an exception, that error is wrapped in `AttributeEvaluationError`.
 
             Parameters:
                 attr_name (str): The name of the attribute the descriptor resolves.
@@ -164,7 +195,7 @@ class GeneralManagerMeta(type):
                     """
                     Provide the class field type when accessed on the class, or resolve and return the stored attribute value for an instance.
 
-                    When accessed on a class, returns the field type from the class's Interface via Interface.getFieldType.
+                    When accessed on a class, returns the field type from the class's Interface via Interface.get_field_type.
                     When accessed on an instance, retrieves the value stored in instance._attributes for this descriptor's attribute name;
                     if the stored value is callable, it is invoked with instance._interface and the result is returned.
 
@@ -176,9 +207,16 @@ class GeneralManagerMeta(type):
                         AttributeEvaluationError: If calling a callable attribute raises an exception; the original exception is wrapped.
                     """
                     if instance is None:
-                        return self._class.Interface.getFieldType(self._attr_name)
+                        return self._class.Interface.get_field_type(self._attr_name)
                     attribute = instance._attributes.get(self._attr_name, _nonExistent)
                     if attribute is _nonExistent:
+                        logger.warning(
+                            "missing attribute on manager instance",
+                            context={
+                                "attribute": self._attr_name,
+                                "manager": instance.__class__.__name__,
+                            },
+                        )
                         raise MissingAttributeError(
                             self._attr_name, instance.__class__.__name__
                         )
@@ -186,10 +224,18 @@ class GeneralManagerMeta(type):
                         try:
                             attribute = attribute(instance._interface)
                         except Exception as e:
+                            logger.exception(
+                                "attribute evaluation failed",
+                                context={
+                                    "attribute": self._attr_name,
+                                    "manager": instance.__class__.__name__,
+                                    "error": type(e).__name__,
+                                },
+                            )
                             raise AttributeEvaluationError(self._attr_name, e) from e
                     return attribute
 
             return Descriptor(attr_name, cast(Type[Any], new_class))
 
         for attr_name in attributes:
-            setattr(new_class, attr_name, descriptorMethod(attr_name, new_class))
+            setattr(new_class, attr_name, descriptor_method(attr_name, new_class))

general_manager/measurement/measurement.py

@@ -194,7 +194,7 @@ class Measurement:
                 raise InvalidMeasurementInitializationError() from error
         if not isinstance(value, Decimal):
             value = Decimal(str(value))
-        self.__quantity = ureg.Quantity(self.formatDecimal(value), unit)
+        self.__quantity = ureg.Quantity(self.format_decimal(value), unit)
 
     def __getstate__(self) -> dict[str, str]:
         """
@@ -221,7 +221,7 @@ class Measurement:
         """
         value = Decimal(state["magnitude"])
         unit = state["unit"]
-        self.__quantity = ureg.Quantity(self.formatDecimal(value), unit)
+        self.__quantity = ureg.Quantity(self.format_decimal(value), unit)
 
     @property
     def quantity(self) -> PlainQuantity:
@@ -282,7 +282,7 @@ class Measurement:
         return cls(value, unit)
 
     @staticmethod
-    def formatDecimal(value: Decimal) -> Decimal:
+    def format_decimal(value: Decimal) -> Decimal:
         """
         Normalise decimals so integers have no fractional component.
 

general_manager/permission/{basePermission.py → base_permission.py}

@@ -1,23 +1,25 @@
 """Base permission contract used by GeneralManager instances."""
 
 from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Literal, TypeAlias, cast
-from general_manager.permission.permissionChecks import permission_functions
 
-from django.contrib.auth.models import AnonymousUser, AbstractBaseUser, AbstractUser
-from general_manager.permission.permissionDataManager import PermissionDataManager
+from django.contrib.auth.models import AbstractBaseUser, AbstractUser, AnonymousUser
+
+from general_manager.logging import get_logger
+from general_manager.permission.permission_checks import permission_functions
+from general_manager.permission.permission_data_manager import PermissionDataManager
 from general_manager.permission.utils import (
-    validatePermissionString,
     PermissionNotFoundError,
+    validate_permission_string,
 )
-import logging
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
     from general_manager.manager.meta import GeneralManagerMeta
 
-logger = logging.getLogger(__name__)
+logger = get_logger("permission.base")
 
 UserLike: TypeAlias = AbstractBaseUser | AnonymousUser
 
@@ -63,7 +65,7 @@ class BasePermission(ABC):
         return self._request_user
 
     @classmethod
-    def checkCreatePermission(
+    def check_create_permission(
         cls,
         data: dict[str, Any],
         manager: type[GeneralManager],
@@ -82,22 +84,29 @@ class BasePermission(ABC):
         Raises:
             PermissionCheckError: If one or more attributes in `data` are denied for the resolved `request_user`.
         """
-        request_user = cls.getUserWithId(request_user)
+        request_user = cls.get_user_with_id(request_user)
         errors = []
         permission_data = PermissionDataManager(permission_data=data, manager=manager)
         Permission = cls(permission_data, request_user)
+        user_identifier = getattr(request_user, "id", None)
         for key in data.keys():
-            is_allowed = Permission.checkPermission("create", key)
+            is_allowed = Permission.check_permission("create", key)
             if not is_allowed:
-                logger.debug(
-                    f"Permission denied for {key} with value {data[key]} for user {request_user}"
+                logger.info(
+                    "permission denied",
+                    context={
+                        "manager": manager.__name__,
+                        "action": "create",
+                        "attribute": key,
+                        "user_id": user_identifier,
+                    },
                 )
                 errors.append(f"Create permission denied for attribute '{key}'")
         if errors:
             raise PermissionCheckError(request_user, errors)
 
     @classmethod
-    def checkUpdatePermission(
+    def check_update_permission(
         cls,
         data: dict[str, Any],
         old_manager_instance: GeneralManager,
@@ -109,30 +118,37 @@ class BasePermission(ABC):
         Parameters:
             data (dict[str, Any]): Mapping of attribute names to new values to be applied.
             old_manager_instance (GeneralManager): Existing manager instance whose current state is used to evaluate update permissions.
-            request_user (UserLike | Any): User instance or user id; non-user values will be resolved to a User or AnonymousUser via getUserWithId.
+            request_user (UserLike | Any): User instance or user id; non-user values will be resolved to a User or AnonymousUser via get_user_with_id.
 
         Raises:
             PermissionCheckError: Raised with a list of error messages when one or more fields are not permitted to be updated.
         """
-        request_user = cls.getUserWithId(request_user)
+        request_user = cls.get_user_with_id(request_user)
 
         errors = []
-        permission_data = PermissionDataManager.forUpdate(
+        permission_data = PermissionDataManager.for_update(
             base_data=old_manager_instance, update_data=data
         )
         Permission = cls(permission_data, request_user)
+        user_identifier = getattr(request_user, "id", None)
         for key in data.keys():
-            is_allowed = Permission.checkPermission("update", key)
+            is_allowed = Permission.check_permission("update", key)
             if not is_allowed:
-                logger.debug(
-                    f"Permission denied for {key} with value {data[key]} for user {request_user}"
+                logger.info(
+                    "permission denied",
+                    context={
+                        "manager": old_manager_instance.__class__.__name__,
+                        "action": "update",
+                        "attribute": key,
+                        "user_id": user_identifier,
+                    },
                 )
                 errors.append(f"Update permission denied for attribute '{key}'")
         if errors:
             raise PermissionCheckError(request_user, errors)
 
     @classmethod
-    def checkDeletePermission(
+    def check_delete_permission(
         cls,
         manager_instance: GeneralManager,
         request_user: UserLike | Any,
@@ -149,23 +165,30 @@ class BasePermission(ABC):
         Raises:
             PermissionCheckError: If one or more attributes are not permitted for deletion by request_user. The exception carries the user and the list of denial messages.
         """
-        request_user = cls.getUserWithId(request_user)
+        request_user = cls.get_user_with_id(request_user)
 
         errors = []
         permission_data = PermissionDataManager(manager_instance)
         Permission = cls(permission_data, request_user)
+        user_identifier = getattr(request_user, "id", None)
         for key in manager_instance.__dict__.keys():
-            is_allowed = Permission.checkPermission("delete", key)
+            is_allowed = Permission.check_permission("delete", key)
             if not is_allowed:
-                logger.debug(
-                    f"Permission denied for {key} with value {getattr(manager_instance, key)} for user {request_user}"
+                logger.info(
+                    "permission denied",
+                    context={
+                        "manager": manager_instance.__class__.__name__,
+                        "action": "delete",
+                        "attribute": key,
+                        "user_id": user_identifier,
+                    },
                 )
                 errors.append(f"Delete permission denied for attribute '{key}'")
         if errors:
             raise PermissionCheckError(request_user, errors)
 
     @staticmethod
-    def getUserWithId(
+    def get_user_with_id(
         user: Any | UserLike,
     ) -> UserLike:
         """
@@ -185,12 +208,12 @@ class BasePermission(ABC):
         if isinstance(user, (AbstractBaseUser, AnonymousUser)):
             return user
         try:
-            return User.objects.get(id=user)
-        except User.DoesNotExist:
+            return User.objects.get(pk=user)
+        except (User.DoesNotExist, ValueError, TypeError):
             return AnonymousUser()
 
     @abstractmethod
-    def checkPermission(
+    def check_permission(
         self,
         action: Literal["create", "read", "update", "delete"],
         attribute: str,
@@ -207,13 +230,13 @@ class BasePermission(ABC):
         """
         raise NotImplementedError
 
-    def getPermissionFilter(
+    def get_permission_filter(
         self,
     ) -> list[dict[Literal["filter", "exclude"], dict[str, str]]]:
         """Return the filter/exclude constraints associated with this permission."""
         raise NotImplementedError
 
-    def _getPermissionFilter(
+    def _get_permission_filter(
         self, permission: str
     ) -> dict[Literal["filter", "exclude"], dict[str, str]]:
         """
@@ -241,7 +264,7 @@ class BasePermission(ABC):
             return {"filter": {}, "exclude": {}}
         return permission_filter
 
-    def validatePermissionString(
+    def validate_permission_string(
         self,
         permission: str,
     ) -> bool:
@@ -254,7 +277,7 @@ class BasePermission(ABC):
         Returns:
             bool: True when every sub-permission evaluates to True for the current user.
         """
-        return validatePermissionString(
+        return validate_permission_string(
             permission,
             self.instance,
             cast(AbstractUser | AnonymousUser, self.request_user),

general_manager/permission/{managerBasedPermission.py → manager_based_permission.py}

@@ -2,13 +2,13 @@
 
 from __future__ import annotations
 from typing import TYPE_CHECKING, Literal, Optional, Dict
-from general_manager.permission.basePermission import BasePermission
+from general_manager.permission.base_permission import BasePermission
 
 if TYPE_CHECKING:
-    from general_manager.permission.permissionDataManager import (
+    from general_manager.permission.permission_data_manager import (
         PermissionDataManager,
     )
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
     from django.contrib.auth.models import AbstractUser
 
 type permission_type = Literal[
@@ -86,10 +86,10 @@ class ManagerBasedPermission(BasePermission):
             request_user (AbstractUser): User whose permissions are being checked.
         """
         super().__init__(instance, request_user)
-        self.__setPermissions()
+        self.__set_permissions()
 
-        self.__attribute_permissions = self.__getAttributePermissions()
-        self.__based_on_permission = self.__getBasedOnPermission()
+        self.__attribute_permissions = self.__get_attribute_permissions()
+        self.__based_on_permission = self.__get_based_on_permission()
         self.__overall_results: Dict[permission_type, Optional[bool]] = {
             "create": None,
             "read": None,
@@ -97,7 +97,7 @@ class ManagerBasedPermission(BasePermission):
             "delete": None,
         }
 
-    def __setPermissions(self, skip_based_on: bool = False) -> None:
+    def __set_permissions(self, skip_based_on: bool = False) -> None:
         """Populate CRUD permissions using class-level defaults and overrides."""
         default_read = ["public"]
         default_write = ["isAuthenticated"]
@@ -111,7 +111,7 @@ class ManagerBasedPermission(BasePermission):
         self.__update__ = getattr(self.__class__, "__update__", default_write)
         self.__delete__ = getattr(self.__class__, "__delete__", default_write)
 
-    def __getBasedOnPermission(self) -> Optional[BasePermission]:
+    def __get_based_on_permission(self) -> Optional[BasePermission]:
         """
         Resolve and return a BasePermission instance from the manager attribute named by the class-level `__based_on__` configuration.
 
@@ -124,7 +124,7 @@ class ManagerBasedPermission(BasePermission):
             InvalidBasedOnConfigurationError: If the configured `__based_on__` attribute does not exist on the target instance.
             InvalidBasedOnTypeError: If the configured attribute exists but does not resolve to a `GeneralManager` or subclass.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         __based_on__ = self.__based_on__
         if __based_on__ is None:
@@ -134,7 +134,7 @@ class ManagerBasedPermission(BasePermission):
         if basis_object is notExistent:
             raise InvalidBasedOnConfigurationError(__based_on__)
         if basis_object is None:
-            self.__setPermissions(skip_based_on=True)
+            self.__set_permissions(skip_based_on=True)
             return None
         if not isinstance(basis_object, GeneralManager) and not (
             isinstance(basis_object, type) and issubclass(basis_object, GeneralManager)
@@ -154,7 +154,7 @@ class ManagerBasedPermission(BasePermission):
             request_user=self.request_user,
         )
 
-    def __getAttributePermissions(
+    def __get_attribute_permissions(
         self,
     ) -> dict[str, dict[permission_type, list[str]]]:
         """Collect attribute-level permission overrides defined on the class."""
@@ -164,7 +164,7 @@ class ManagerBasedPermission(BasePermission):
                 attribute_permissions[attribute] = getattr(self, attribute)
         return attribute_permissions
 
-    def checkPermission(
+    def check_permission(
         self,
         action: permission_type,
         attribute: str,
@@ -184,7 +184,7 @@ class ManagerBasedPermission(BasePermission):
         """
         if (
             self.__based_on_permission
-            and not self.__based_on_permission.checkPermission(action, attribute)
+            and not self.__based_on_permission.check_permission(action, attribute)
         ):
             return False
 
@@ -210,15 +210,15 @@ class ManagerBasedPermission(BasePermission):
                 return last_result
             attribute_permission = True
         else:
-            attribute_permission = self.__checkSpecificPermission(
+            attribute_permission = self.__check_specific_permission(
                 self.__attribute_permissions[attribute][action]
             )
 
-        permission = self.__checkSpecificPermission(permissions)
+        permission = self.__check_specific_permission(permissions)
         self.__overall_results[action] = permission
         return permission and attribute_permission
 
-    def __checkSpecificPermission(
+    def __check_specific_permission(
         self,
         permissions: list[str],
     ) -> bool:
@@ -226,17 +226,17 @@ class ManagerBasedPermission(BasePermission):
         if not permissions:
             return True
         for permission in permissions:
-            if self.validatePermissionString(permission):
+            if self.validate_permission_string(permission):
                 return True
         return False
 
-    def getPermissionFilter(
+    def get_permission_filter(
         self,
     ) -> list[dict[Literal["filter", "exclude"], dict[str, str]]]:
         """
         Builds queryset filter and exclude mappings derived from this permission configuration.
 
-        If a based-on permission exists, its filters and excludes are included with each key prefixed by the name in __based_on__. Then appends filters produced from this class's read permissions via _getPermissionFilter.
+        If a based-on permission exists, its filters and excludes are included with each key prefixed by the name in __based_on__. Then appends filters produced from this class's read permissions via _get_permission_filter.
 
         Returns:
             list[dict[Literal["filter", "exclude"], dict[str, str]]]: A list of dictionaries each containing "filter" and "exclude" mappings where keys are queryset lookups and values are lookup values.
@@ -245,7 +245,7 @@ class ManagerBasedPermission(BasePermission):
         filters: list[dict[Literal["filter", "exclude"], dict[str, str]]] = []
 
         if self.__based_on_permission is not None:
-            base_permissions = self.__based_on_permission.getPermissionFilter()
+            base_permissions = self.__based_on_permission.get_permission_filter()
             for base_permission in base_permissions:
                 filter = base_permission.get("filter", {})
                 exclude = base_permission.get("exclude", {})
@@ -263,6 +263,6 @@ class ManagerBasedPermission(BasePermission):
                 )
 
         for permission in self.__read__:
-            filters.append(self._getPermissionFilter(permission))
+            filters.append(self._get_permission_filter(permission))
 
         return filters

general_manager/permission/{mutationPermission.py → mutation_permission.py}

@@ -3,13 +3,13 @@
 from __future__ import annotations
 from django.contrib.auth.models import AbstractUser, AnonymousUser
 from typing import Any
-from general_manager.permission.basePermission import (
+from general_manager.permission.base_permission import (
     BasePermission,
     PermissionCheckError,
 )
 
-from general_manager.permission.permissionDataManager import PermissionDataManager
-from general_manager.permission.utils import validatePermissionString
+from general_manager.permission.permission_data_manager import PermissionDataManager
+from general_manager.permission.utils import validate_permission_string
 
 
 class MutationPermission:
@@ -29,7 +29,7 @@ class MutationPermission:
         """
         self._data: PermissionDataManager = PermissionDataManager(data)
         self._request_user = request_user
-        self.__attribute_permissions = self.__getAttributePermissions()
+        self.__attribute_permissions = self.__get_attribute_permissions()
 
         self.__overall_result: bool | None = None
 
@@ -43,7 +43,7 @@ class MutationPermission:
         """Return the user whose permissions are being evaluated."""
         return self._request_user
 
-    def __getAttributePermissions(
+    def __get_attribute_permissions(
         self,
     ) -> dict[str, list[str]]:
         """Collect attribute-specific permission expressions declared on the class."""
@@ -71,17 +71,17 @@ class MutationPermission:
         """
         errors = []
         if not isinstance(request_user, (AbstractUser, AnonymousUser)):
-            request_user = BasePermission.getUserWithId(request_user)
+            request_user = BasePermission.get_user_with_id(request_user)
         Permission = cls(data, request_user)
         for key in data:
-            if not Permission.checkPermission(key):
+            if not Permission.check_permission(key):
                 errors.append(
                     f"Permission denied for {key} with value {data[key]} for user {request_user}"
                 )
         if errors:
             raise PermissionCheckError(request_user, errors)
 
-    def checkPermission(
+    def check_permission(
         self,
         attribute: str,
     ) -> bool:
@@ -105,20 +105,20 @@ class MutationPermission:
                 return last_result
             attribute_permission = True
         else:
-            attribute_permission = self.__checkSpecificPermission(
+            attribute_permission = self.__check_specific_permission(
                 self.__attribute_permissions[attribute]
             )
 
-        permission = self.__checkSpecificPermission(self.__mutate__)
+        permission = self.__check_specific_permission(self.__mutate__)
         self.__overall_result = permission
         return permission and attribute_permission
 
-    def __checkSpecificPermission(
+    def __check_specific_permission(
         self,
         permissions: list[str],
     ) -> bool:
         """Return True when any permission expression evaluates to True."""
         for permission in permissions:
-            if validatePermissionString(permission, self.data, self.request_user):
+            if validate_permission_string(permission, self.data, self.request_user):
                 return True
         return False

general_manager/permission/{permissionChecks.py → permission_checks.py}

@@ -4,10 +4,10 @@ from typing import Any, Callable, TYPE_CHECKING, TypedDict, Literal
 
 if TYPE_CHECKING:
     from django.contrib.auth.models import AbstractUser, AnonymousUser
-    from general_manager.permission.permissionDataManager import (
+    from general_manager.permission.permission_data_manager import (
         PermissionDataManager,
     )
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
     from general_manager.manager.meta import GeneralManagerMeta