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

general_manager/manager/meta.py

@@ -4,10 +4,10 @@ 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 general_manager.interface.base_interface import InterfaceBase
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
 
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
@@ -78,7 +78,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.
@@ -90,7 +90,7 @@ class GeneralManagerMeta(type):
             type: The newly created subclass, possibly modified by Interface hooks.
         """
 
-        def createNewGeneralManagerClass(
+        def create_new_general_manager_class(
             mcs: type["GeneralManagerMeta"],
             name: str,
             bases: tuple[type, ...],
@@ -103,15 +103,15 @@ 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)
 
         else:
-            new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
+            new_class = create_new_general_manager_class(mcs, name, bases, attrs)
 
         if getattr(settings, "AUTOCREATE_GRAPHQL", False):
             mcs.pending_graphql_interfaces.append(new_class)
@@ -119,7 +119,7 @@ class GeneralManagerMeta(type):
         return new_class
 
     @staticmethod
-    def createAtPropertiesForAttributes(
+    def create_at_properties_for_attributes(
         attributes: Iterable[str], new_class: Type[GeneralManager]
     ) -> None:
         """
@@ -132,14 +132,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 +164,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,7 +176,7 @@ 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:
                         raise MissingAttributeError(
@@ -192,4 +192,4 @@ class GeneralManagerMeta(type):
             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}

@@ -3,18 +3,18 @@
 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 general_manager.permission.permission_checks import permission_functions
 
 from django.contrib.auth.models import AnonymousUser, AbstractBaseUser, AbstractUser
-from general_manager.permission.permissionDataManager import PermissionDataManager
+from general_manager.permission.permission_data_manager import PermissionDataManager
 from general_manager.permission.utils import (
-    validatePermissionString,
+    validate_permission_string,
     PermissionNotFoundError,
 )
 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__)
@@ -63,7 +63,7 @@ class BasePermission(ABC):
         return self._request_user
 
     @classmethod
-    def checkCreatePermission(
+    def check_create_permission(
         cls,
         data: dict[str, Any],
         manager: type[GeneralManager],
@@ -82,12 +82,12 @@ 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)
         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}"
@@ -97,7 +97,7 @@ class BasePermission(ABC):
             raise PermissionCheckError(request_user, errors)
 
     @classmethod
-    def checkUpdatePermission(
+    def check_update_permission(
         cls,
         data: dict[str, Any],
         old_manager_instance: GeneralManager,
@@ -109,20 +109,20 @@ 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)
         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}"
@@ -132,7 +132,7 @@ class BasePermission(ABC):
             raise PermissionCheckError(request_user, errors)
 
     @classmethod
-    def checkDeletePermission(
+    def check_delete_permission(
         cls,
         manager_instance: GeneralManager,
         request_user: UserLike | Any,
@@ -149,13 +149,13 @@ 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)
         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}"
@@ -165,7 +165,7 @@ class BasePermission(ABC):
             raise PermissionCheckError(request_user, errors)
 
     @staticmethod
-    def getUserWithId(
+    def get_user_with_id(
         user: Any | UserLike,
     ) -> UserLike:
         """
@@ -190,7 +190,7 @@ class BasePermission(ABC):
             return AnonymousUser()
 
     @abstractmethod
-    def checkPermission(
+    def check_permission(
         self,
         action: Literal["create", "read", "update", "delete"],
         attribute: str,
@@ -207,13 +207,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 +241,7 @@ class BasePermission(ABC):
             return {"filter": {}, "exclude": {}}
         return permission_filter
 
-    def validatePermissionString(
+    def validate_permission_string(
         self,
         permission: str,
     ) -> bool:
@@ -254,7 +254,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
 
 

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("&")
         ]
     )