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

general_manager/interface/{databaseInterface.py → database_interface.py}

@@ -8,7 +8,7 @@ from typing import (
 )
 from django.db import models, transaction
 from simple_history.utils import update_change_reason  # type: ignore
-from general_manager.interface.databaseBasedInterface import (
+from general_manager.interface.database_based_interface import (
     DBBasedInterface,
     GeneralManagerModel,
 )
@@ -69,7 +69,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
     @classmethod
     def create(
         cls, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
-    ) -> int:
+    ) -> dict[str, Any]:
         """
         Create a new model instance using the provided field values.
 
@@ -86,16 +86,16 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             ValidationError: If model validation fails during save.
         """
         model_cls = cast(type[GeneralManagerModel], cls._model)
-        cls._checkForInvalidKwargs(model_cls, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = cls._sortKwargs(model_cls, kwargs)
-        instance = cls.__setAttrForWrite(model_cls(), kwargs)
+        cls._check_for_invalid_kwargs(model_cls, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = cls._sort_kwargs(model_cls, kwargs)
+        instance = cls.__set_attr_for_write(model_cls(), kwargs)
         pk = cls._save_with_history(instance, creator_id, history_comment)
-        cls.__setManyToManyAttributes(instance, many_to_many_kwargs)
-        return pk
+        cls.__set_many_to_many_attributes(instance, many_to_many_kwargs)
+        return {"id": pk}
 
     def update(
         self, creator_id: int | None, history_comment: str | None = None, **kwargs: Any
-    ) -> int:
+    ) -> dict[str, Any]:
         """
         Update this instance with the provided field values.
 
@@ -112,16 +112,16 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             ValidationError: If model validation fails during save.
         """
         model_cls = cast(type[GeneralManagerModel], self._model)
-        self._checkForInvalidKwargs(model_cls, kwargs=kwargs)
-        kwargs, many_to_many_kwargs = self._sortKwargs(model_cls, kwargs)
-        instance = self.__setAttrForWrite(model_cls.objects.get(pk=self.pk), kwargs)
+        self._check_for_invalid_kwargs(model_cls, kwargs=kwargs)
+        kwargs, many_to_many_kwargs = self._sort_kwargs(model_cls, kwargs)
+        instance = self.__set_attr_for_write(model_cls.objects.get(pk=self.pk), kwargs)
         pk = self._save_with_history(instance, creator_id, history_comment)
-        self.__setManyToManyAttributes(instance, many_to_many_kwargs)
-        return pk
+        self.__set_many_to_many_attributes(instance, many_to_many_kwargs)
+        return {"id": pk}
 
     def deactivate(
         self, creator_id: int | None, history_comment: str | None = None
-    ) -> int:
+    ) -> dict[str, Any]:
         """
         Mark the current model instance as inactive and record the change.
 
@@ -139,10 +139,10 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             history_comment = f"{history_comment} (deactivated)"
         else:
             history_comment = "Deactivated"
-        return self._save_with_history(instance, creator_id, history_comment)
+        return {"id": self._save_with_history(instance, creator_id, history_comment)}
 
     @staticmethod
-    def __setManyToManyAttributes(
+    def __set_many_to_many_attributes(
         instance: GeneralManagerModel, many_to_many_kwargs: dict[str, list[Any]]
     ) -> GeneralManagerModel:
         """
@@ -155,7 +155,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         Returns:
             GeneralManagerModel: Updated instance.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         for key, value in many_to_many_kwargs.items():
             if value is None or value is NOT_PROVIDED:
@@ -173,7 +173,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return instance
 
     @staticmethod
-    def __setAttrForWrite(
+    def __set_attr_for_write(
         instance: GeneralManagerModel,
         kwargs: dict[str, Any],
     ) -> GeneralManagerModel:
@@ -193,7 +193,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
             InvalidFieldValueError: If setting an attribute raises a `ValueError`.
             InvalidFieldTypeError: If setting an attribute raises a `TypeError`.
         """
-        from general_manager.manager.generalManager import GeneralManager
+        from general_manager.manager.general_manager import GeneralManager
 
         for key, value in kwargs.items():
             if isinstance(value, GeneralManager):
@@ -210,7 +210,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
         return instance
 
     @staticmethod
-    def _checkForInvalidKwargs(
+    def _check_for_invalid_kwargs(
         model: Type[models.Model], kwargs: dict[str, Any]
     ) -> None:
         """
@@ -231,7 +231,7 @@ class DatabaseInterface(DBBasedInterface[GeneralManagerModel]):
                 raise UnknownFieldError(key, model.__name__)
 
     @staticmethod
-    def _sortKwargs(
+    def _sort_kwargs(
         model: Type[models.Model], kwargs: dict[Any, Any]
     ) -> tuple[dict[str, Any], dict[str, list[Any]]]:
         """

general_manager/interface/models.py

@@ -10,13 +10,13 @@ from django.core.exceptions import ValidationError
 
 
 if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.general_manager import GeneralManager
     from general_manager.rule.rule import Rule
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
 
-def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
+def get_full_clean_methode(model: Type[models.Model]) -> Callable[..., None]:
     """
     Return a custom `full_clean` method for a Django model that performs both standard validation and additional rule-based checks.
 
@@ -44,7 +44,7 @@ def getFullCleanMethode(model: Type[models.Model]) -> Callable[..., None]:
         rules: list[Rule] = getattr(self._meta, "rules", [])
         for rule in rules:
             if rule.evaluate(self) is False:
-                error_message = rule.getErrorMessage()
+                error_message = rule.get_error_message()
                 if error_message:
                     errors.update(error_message)
 

general_manager/interface/{readOnlyInterface.py → read_only_interface.py}

@@ -1,28 +1,29 @@
 """Read-only interface that mirrors JSON datasets into Django models."""
 
 from __future__ import annotations
+
 import json
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Type, cast
+
+from django.core.checks import Warning
+from django.db import connection, models, transaction
 
-from typing import Type, Any, Callable, TYPE_CHECKING, cast, ClassVar
-from django.db import models, transaction
-from general_manager.interface.databaseBasedInterface import (
+from general_manager.interface.database_based_interface import (
     DBBasedInterface,
     GeneralManagerBasisModel,
-    classPreCreationMethod,
+    attributes,
     classPostCreationMethod,
+    classPreCreationMethod,
     generalManagerClassName,
-    attributes,
     interfaceBaseClass,
 )
-from django.db import connection
-from django.core.checks import Warning
-import logging
+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
 
 
-logger = logging.getLogger(__name__)
+logger = get_logger("interface.read_only")
 
 
 class MissingReadOnlyDataError(ValueError):
@@ -86,7 +87,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
     _parent_class: ClassVar[Type["GeneralManager"]]
 
     @staticmethod
-    def getUniqueFields(model: Type[models.Model]) -> set[str]:
+    def get_unique_fields(model: Type[models.Model]) -> set[str]:
         """
         Determine which fields on the given Django model uniquely identify its instances.
 
@@ -117,7 +118,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return unique_fields
 
     @classmethod
-    def syncData(cls) -> None:
+    def sync_data(cls) -> None:
         """
         Synchronize the Django model with the parent manager's class-level `_data` JSON.
 
@@ -129,9 +130,13 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
             InvalidReadOnlyDataTypeError: If `_data` is neither a string nor a list.
             MissingUniqueFieldError: If the model exposes no unique fields to identify records.
         """
-        if cls.ensureSchemaIsUpToDate(cls._parent_class, cls._model):
+        if cls.ensure_schema_is_up_to_date(cls._parent_class, cls._model):
             logger.warning(
-                f"Schema for ReadOnlyInterface '{cls._parent_class.__name__}' is not up to date."
+                "readonly schema out of date",
+                context={
+                    "manager": cls._parent_class.__name__,
+                    "model": cls._model.__name__,
+                },
             )
             return
 
@@ -153,7 +158,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
 
         data_list = cast(list[dict[str, Any]], parsed_data)
 
-        unique_fields = cls.getUniqueFields(model)
+        unique_fields = cls.get_unique_fields(model)
         if not unique_fields:
             raise MissingUniqueFieldError(parent_class.__name__)
 
@@ -208,14 +213,18 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
 
         if changes["created"] or changes["updated"] or changes["deactivated"]:
             logger.info(
-                f"Data changes for ReadOnlyInterface '{parent_class.__name__}': "
-                f"Created: {len(changes['created'])}, "
-                f"Updated: {len(changes['updated'])}, "
-                f"Deactivated: {len(changes['deactivated'])}"
+                "readonly data synchronized",
+                context={
+                    "manager": parent_class.__name__,
+                    "model": model.__name__,
+                    "created": len(changes["created"]),
+                    "updated": len(changes["updated"]),
+                    "deactivated": len(changes["deactivated"]),
+                },
             )
 
     @staticmethod
-    def ensureSchemaIsUpToDate(
+    def ensure_schema_is_up_to_date(
         new_manager_class: Type[GeneralManager], model: Type[models.Model]
     ) -> list[Warning]:
         """
@@ -286,7 +295,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return []
 
     @staticmethod
-    def readOnlyPostCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+    def read_only_post_create(func: Callable[..., Any]) -> Callable[..., Any]:
         """
         Decorator for post-creation hooks that registers a new manager class as read-only.
 
@@ -311,7 +320,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return wrapper
 
     @staticmethod
-    def readOnlyPreCreate(func: Callable[..., Any]) -> Callable[..., Any]:
+    def read_only_pre_create(func: Callable[..., Any]) -> Callable[..., Any]:
         """
         Decorator for pre-creation hook functions that ensures the base model class is set to `GeneralManagerBasisModel`.
 
@@ -344,7 +353,7 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         return wrapper
 
     @classmethod
-    def handleInterface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
+    def handle_interface(cls) -> tuple[classPreCreationMethod, classPostCreationMethod]:
         """
         Return the pre- and post-creation hook methods for integrating the interface with a manager meta-class system.
 
@@ -355,6 +364,6 @@ class ReadOnlyInterface(DBBasedInterface[GeneralManagerBasisModel]):
         Returns:
             tuple: The pre-creation and post-creation hook methods for manager class lifecycle integration.
         """
-        return cls.readOnlyPreCreate(cls._preCreate), cls.readOnlyPostCreate(
-            cls._postCreate
+        return cls.read_only_pre_create(cls._pre_create), cls.read_only_post_create(
+            cls._post_create
         )

general_manager/logging.py

@@ -0,0 +1,133 @@
+"""
+Shared logging utilities for the GeneralManager package.
+
+The helpers defined here keep logger names consistent (``general_manager.*``),
+expose lightweight context support, and stay fully compatible with Django's
+``LOGGING`` settings.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Mapping, MutableMapping
+from typing import Any, cast
+
+BASE_LOGGER_NAME = "general_manager"
+COMPONENT_EXTRA_FIELD = "component"
+CONTEXT_EXTRA_FIELD = "context"
+
+
+class InvalidContextError(TypeError):
+    def __init__(self) -> None:
+        super().__init__("context must be a mapping when provided.")
+
+
+class InvalidExtraError(TypeError):
+    def __init__(self) -> None:
+        super().__init__("extra must be a mutable mapping.")
+
+
+class BlankComponentError(ValueError):
+    def __init__(self) -> None:
+        super().__init__("component cannot be blank or only dots.")
+
+
+__all__ = [
+    "BASE_LOGGER_NAME",
+    "COMPONENT_EXTRA_FIELD",
+    "CONTEXT_EXTRA_FIELD",
+    "GeneralManagerLoggerAdapter",
+    "build_logger_name",
+    "get_logger",
+]
+
+
+class GeneralManagerLoggerAdapter(logging.LoggerAdapter[Any]):
+    """
+    Attach structured metadata (component + context) to log records.
+
+    The adapter keeps ``extra`` mutable, merges ``context`` mappings, and can be
+    used anywhere ``logging.Logger`` is expected.
+    """
+
+    def log(self, level: int, msg: Any, *args: Any, **kwargs: Any) -> None:  # type: ignore[override]
+        context_mapping = self._pop_context(kwargs)
+        if context_mapping is not None:
+            kwargs["context"] = context_mapping
+        super().log(level, msg, *args, **kwargs)
+
+    @staticmethod
+    def _pop_context(
+        kwargs: MutableMapping[str, Any],
+    ) -> Mapping[str, Any] | None:
+        context = kwargs.pop("context", None)
+        if context is None:
+            return None
+        if not isinstance(context, Mapping):
+            raise InvalidContextError()
+        return context
+
+    def process(
+        self, msg: Any, kwargs: MutableMapping[str, Any]
+    ) -> tuple[Any, MutableMapping[str, Any]]:
+        context = self._pop_context(kwargs)
+
+        extra_obj = kwargs.setdefault("extra", {})
+        if not isinstance(extra_obj, MutableMapping):
+            raise InvalidExtraError()
+        extra = cast(MutableMapping[str, Any], extra_obj)
+
+        extra_metadata = cast(Mapping[str, Any], self.extra or {})
+        component = extra_metadata.get(COMPONENT_EXTRA_FIELD)
+        if component is not None:
+            extra.setdefault(COMPONENT_EXTRA_FIELD, component)
+
+        if context is not None:
+            current_context = cast(Mapping[str, Any], context)
+            existing_context = extra.get(CONTEXT_EXTRA_FIELD)
+            if existing_context is None:
+                merged_context: dict[str, Any] = dict(current_context)
+            elif isinstance(existing_context, Mapping):
+                merged_context = {**dict(existing_context), **current_context}
+            else:
+                raise InvalidContextError()
+
+            extra[CONTEXT_EXTRA_FIELD] = merged_context
+
+        return msg, kwargs
+
+
+def _normalize_component_name(component: str | None) -> str | None:
+    if component is None:
+        return None
+
+    normalized = component.strip().strip(".")
+    if not normalized:
+        raise BlankComponentError()
+
+    return normalized.replace(" ", "_")
+
+
+def build_logger_name(component: str | None = None) -> str:
+    """
+    Build a fully-qualified logger name within the ``general_manager`` namespace.
+    """
+
+    normalized_component = _normalize_component_name(component)
+    if not normalized_component:
+        return BASE_LOGGER_NAME
+
+    return ".".join([BASE_LOGGER_NAME, normalized_component])
+
+
+def get_logger(component: str | None = None) -> GeneralManagerLoggerAdapter:
+    """
+    Return a ``GeneralManagerLoggerAdapter`` scoped to the requested component.
+    """
+
+    normalized_component = _normalize_component_name(component)
+    logger_name = build_logger_name(normalized_component)
+    adapter_extra: dict[str, Any] = {}
+    if normalized_component:
+        adapter_extra[COMPONENT_EXTRA_FIELD] = normalized_component
+    return GeneralManagerLoggerAdapter(logging.getLogger(logger_name), adapter_extra)

general_manager/manager/{generalManager.py → general_manager.py}

@@ -1,11 +1,12 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Any, Iterator, Self, Type
-from general_manager.manager.meta import GeneralManagerMeta
 
 from general_manager.api.property import GraphQLProperty
-from general_manager.cache.cacheTracker import DependencyTracker
-from general_manager.cache.signals import dataChange
-from general_manager.bucket.baseBucket import Bucket
+from general_manager.bucket.base_bucket import Bucket
+from general_manager.cache.cache_tracker import DependencyTracker
+from general_manager.cache.signals import data_change
+from general_manager.logging import get_logger
+from general_manager.manager.meta import GeneralManagerMeta
 
 
 class UnsupportedUnionOperandError(TypeError):
@@ -22,8 +23,11 @@ class UnsupportedUnionOperandError(TypeError):
 
 
 if TYPE_CHECKING:
-    from general_manager.permission.basePermission import BasePermission
-    from general_manager.interface.baseInterface import InterfaceBase
+    from general_manager.permission.base_permission import BasePermission
+    from general_manager.interface.base_interface import InterfaceBase
+
+
+logger = get_logger("manager.general")
 
 
 class GeneralManager(metaclass=GeneralManagerMeta):
@@ -45,6 +49,13 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         DependencyTracker.track(
             self.__class__.__name__, "identification", f"{self.__id}"
         )
+        logger.debug(
+            "instantiated manager",
+            context={
+                "manager": self.__class__.__name__,
+                "identification": self.__id,
+            },
+        )
 
     def __str__(self) -> str:
         """Return a user-friendly representation showing the identification."""
@@ -117,7 +128,7 @@ class GeneralManager(metaclass=GeneralManagerMeta):
                 yield name, getattr(self, name)
 
     @classmethod
-    @dataChange
+    @data_change
     def create(
         cls,
         creator_id: int | None = None,
@@ -141,13 +152,23 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            cls.Permission.checkCreatePermission(kwargs, cls, creator_id)
+            cls.Permission.check_create_permission(kwargs, cls, creator_id)
         identification = cls.Interface.create(
             creator_id=creator_id, history_comment=history_comment, **kwargs
         )
-        return cls(identification)
+        logger.info(
+            "manager created",
+            context={
+                "manager": cls.__name__,
+                "creator_id": creator_id,
+                "ignore_permission": ignore_permission,
+                "fields": sorted(kwargs.keys()),
+                "identification": identification,
+            },
+        )
+        return cls(**identification)
 
-    @dataChange
+    @data_change
     def update(
         self,
         creator_id: int | None = None,
@@ -171,15 +192,25 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            self.Permission.checkUpdatePermission(kwargs, self, creator_id)
+            self.Permission.check_update_permission(kwargs, self, creator_id)
         self._interface.update(
             creator_id=creator_id,
             history_comment=history_comment,
             **kwargs,
         )
+        logger.info(
+            "manager updated",
+            context={
+                "manager": self.__class__.__name__,
+                "creator_id": creator_id,
+                "ignore_permission": ignore_permission,
+                "fields": sorted(kwargs.keys()),
+                "identification": self.identification,
+            },
+        )
         return self.__class__(**self.identification)
 
-    @dataChange
+    @data_change
     def deactivate(
         self,
         creator_id: int | None = None,
@@ -201,10 +232,19 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             PermissionError: Propagated if the permission check fails.
         """
         if not ignore_permission:
-            self.Permission.checkDeletePermission(self, creator_id)
+            self.Permission.check_delete_permission(self, creator_id)
         self._interface.deactivate(
             creator_id=creator_id, history_comment=history_comment
         )
+        logger.info(
+            "manager deactivated",
+            context={
+                "manager": self.__class__.__name__,
+                "creator_id": creator_id,
+                "ignore_permission": ignore_permission,
+                "identification": self.identification,
+            },
+        )
         return self.__class__(**self.identification)
 
     @classmethod
@@ -218,8 +258,14 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         Returns:
             Bucket[Self]: Bucket of matching manager instances.
         """
-        DependencyTracker.track(
-            cls.__name__, "filter", f"{cls.__parse_identification(kwargs)}"
+        identifier_map = cls.__parse_identification(kwargs) or kwargs
+        DependencyTracker.track(cls.__name__, "filter", repr(identifier_map))
+        logger.debug(
+            "manager filter",
+            context={
+                "manager": cls.__name__,
+                "filters": identifier_map,
+            },
         )
         return cls.Interface.filter(**kwargs)
 
@@ -234,14 +280,26 @@ class GeneralManager(metaclass=GeneralManagerMeta):
         Returns:
             Bucket[Self]: Bucket of manager instances that do not satisfy the lookups.
         """
-        DependencyTracker.track(
-            cls.__name__, "exclude", f"{cls.__parse_identification(kwargs)}"
+        identifier_map = cls.__parse_identification(kwargs) or kwargs
+        DependencyTracker.track(cls.__name__, "exclude", repr(identifier_map))
+        logger.debug(
+            "manager exclude",
+            context={
+                "manager": cls.__name__,
+                "filters": identifier_map,
+            },
         )
         return cls.Interface.exclude(**kwargs)
 
     @classmethod
     def all(cls) -> Bucket[Self]:
         """Return a bucket containing every managed object of this class."""
+        logger.debug(
+            "manager all",
+            context={
+                "manager": cls.__name__,
+            },
+        )
         return cls.Interface.filter()
 
     @staticmethod

general_manager/manager/{groupManager.py → group_manager.py}

@@ -5,8 +5,8 @@ from typing import Any, Generic, Iterator, Type, cast, get_args
 from datetime import datetime, date, time
 from general_manager.api.property import GraphQLProperty
 from general_manager.measurement import Measurement
-from general_manager.manager.generalManager import GeneralManager
-from general_manager.bucket.baseBucket import (
+from general_manager.manager.general_manager import GeneralManager
+from general_manager.bucket.base_bucket import (
     Bucket,
     GeneralManagerType,
 )
@@ -99,7 +99,7 @@ class GroupManager(Generic[GeneralManagerType]):
         Yields:
             tuple[str, Any]: Attribute name and aggregated value pairs.
         """
-        for attribute in self._manager_class.Interface.getAttributes().keys():
+        for attribute in self._manager_class.Interface.get_attributes().keys():
             yield attribute, getattr(self, attribute)
         for attribute, attr_value in self._manager_class.__dict__.items():
             if isinstance(attr_value, GraphQLProperty):
@@ -121,10 +121,10 @@ class GroupManager(Generic[GeneralManagerType]):
         if item in self._group_by_value:
             return self._group_by_value[item]
         if item not in self._grouped_data.keys():
-            self._grouped_data[item] = self.combineValue(item)
+            self._grouped_data[item] = self.combine_value(item)
         return self._grouped_data[item]
 
-    def combineValue(self, item: str) -> Any:
+    def combine_value(self, item: str) -> Any:
         """
         Aggregate the values of a named attribute across all records in the group.
 
@@ -140,7 +140,7 @@ class GroupManager(Generic[GeneralManagerType]):
         if item == "id":
             return None
 
-        attribute_types = self._manager_class.Interface.getAttributeTypes()
+        attribute_types = self._manager_class.Interface.get_attribute_types()
         attr_info = attribute_types.get(item)
         data_type = attr_info["type"] if attr_info else None
         if data_type is None and item in self._manager_class.__dict__:

general_manager/manager/input.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 from typing import Iterable, Optional, Callable, List, TypeVar, Generic, Any, Type, cast
 import inspect
 
-from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.general_manager import GeneralManager
 from datetime import date, datetime
 from general_manager.measurement import Measurement