GeneralManager 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

general_manager/interface/baseInterface.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
     from general_manager.manager.input import Input
     from general_manager.manager.generalManager import GeneralManager
     from general_manager.manager.meta import GeneralManagerMeta
-    from general_manager.manager.groupManager import GroupedManager, GroupBucket
+    from general_manager.manager.groupManager import GroupManager, GroupBucket
 
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
@@ -70,9 +70,17 @@ class InterfaceBase(ABC):
         *args: Any,
         **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
+        """
+        Parses and validates input arguments into a structured identification dictionary.
+        
+        Converts positional and keyword arguments into a dictionary keyed by input field names, handling normalization of argument names and checking for unexpected or missing arguments. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for unexpected or missing arguments and a `ValueError` if circular dependencies among input fields are detected.
+        
+        Returns:
+            A dictionary mapping input field names to their validated and cast values.
+        """
         identification = {}
         kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)
-        # Prüfe auf fehlende oder unerwartete Argumente
+        # Check for extra arguments
         extra_args = set(kwargs.keys()) - set(self.input_fields.keys())
         if extra_args:
             for extra_arg in extra_args:
@@ -85,7 +93,7 @@ class InterfaceBase(ABC):
         if missing_args:
             raise TypeError(f"Missing required arguments: {', '.join(missing_args)}")
 
-        # Verarbeite Felder unter Berücksichtigung von Abhängigkeiten
+        # process input fields with dependencies
         processed = set()
         while len(processed) < len(self.input_fields):
             progress_made = False
@@ -100,7 +108,7 @@ class InterfaceBase(ABC):
                     processed.add(name)
                     progress_made = True
             if not progress_made:
-                # Zirkuläre Abhängigkeit erkannt
+                # detect circular dependencies
                 unresolved = set(self.input_fields.keys()) - processed
                 raise ValueError(
                     f"Circular dependency detected among inputs: {', '.join(unresolved)}"
@@ -123,13 +131,18 @@ class InterfaceBase(ABC):
     def _process_input(
         self, name: str, value: Any, identification: dict[str, Any]
     ) -> None:
+        """
+        Validates the type and allowed values of an input field.
+        
+        Checks that the provided value matches the expected type for the input field and, in debug mode, verifies that the value is among the allowed possible values if specified. Raises a TypeError for invalid types or possible value definitions, and a ValueError if the value is not permitted.
+        """
         input_field = self.input_fields[name]
         if not isinstance(value, input_field.type):
             raise TypeError(
                 f"Invalid type for {name}: {type(value)}, expected: {input_field.type}"
             )
         if settings.DEBUG:
-            # Prüfe mögliche Werte
+            # `possible_values` can be a callable or an iterable
             possible_values = input_field.possible_values
             if possible_values is not None:
                 if callable(possible_values):
@@ -239,7 +252,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     @abstractmethod
     def __iter__(
         self,
-    ) -> Generator[GeneralManagerType | GroupedManager[GeneralManagerType]]:
+    ) -> Generator[GeneralManagerType | GroupManager[GeneralManagerType]]:
         raise NotImplementedError
 
     @abstractmethod
@@ -251,11 +264,11 @@ class Bucket(ABC, Generic[GeneralManagerType]):
         raise NotImplementedError
 
     @abstractmethod
-    def first(self) -> GeneralManagerType | GroupedManager[GeneralManagerType] | None:
+    def first(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
         raise NotImplementedError
 
     @abstractmethod
-    def last(self) -> GeneralManagerType | GroupedManager[GeneralManagerType] | None:
+    def last(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
         raise NotImplementedError
 
     @abstractmethod
@@ -269,7 +282,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
     @abstractmethod
     def get(
         self, **kwargs: Any
-    ) -> GeneralManagerType | GroupedManager[GeneralManagerType]:
+    ) -> GeneralManagerType | GroupManager[GeneralManagerType]:
         raise NotImplementedError
 
     @abstractmethod
@@ -277,7 +290,7 @@ class Bucket(ABC, Generic[GeneralManagerType]):
         self, item: int | slice
     ) -> (
         GeneralManagerType
-        | GroupedManager[GeneralManagerType]
+        | GroupManager[GeneralManagerType]
         | Bucket[GeneralManagerType]
     ):
         raise NotImplementedError

general_manager/interface/databaseInterface.py

@@ -8,7 +8,6 @@ from typing import (
     TYPE_CHECKING,
     Generator,
     TypeVar,
-    cast,
 )
 from django.db import models, transaction
 from django.contrib.auth import get_user_model
@@ -646,13 +645,14 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
         self, basis: dict[str, list[Any]], **kwargs: Any
     ) -> dict[str, list[Any]]:
         """
-        Combines existing filter definitions with additional keyword arguments.
+        Merges filter definitions by appending values from keyword arguments to the corresponding lists in the basis dictionary.
         
         Args:
-            basis: Dictionary mapping filter keys to lists of values. Additional keyword arguments are merged into this dictionary.
+            basis: A dictionary mapping filter keys to lists of values. Existing filter criteria.
+            **kwargs: Additional filter criteria to be merged, where each value is appended to the corresponding key's list.
         
         Returns:
-            A dictionary where each key maps to a list containing all values from both the original basis and the new keyword arguments.
+            A dictionary with keys mapping to lists containing all values from both the original basis and the new keyword arguments.
         """
         kwarg_filter: dict[str, list[Any]] = {}
         for key, value in basis.items():
@@ -665,9 +665,9 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def filter(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
-        Returns a new bucket with manager instances matching the specified filter criteria.
+        Returns a new bucket containing manager instances matching the given filter criteria.
         
-        Additional filter keyword arguments are merged with any existing filters to further restrict the queryset.
+        Additional filter keyword arguments are merged with existing filters to further restrict the queryset.
         """
         merged_filter = self.__mergeFilterDefinitions(self.filters, **kwargs)
         return self.__class__(
@@ -679,9 +679,9 @@ class DatabaseBucket(Bucket[GeneralManagerType]):
 
     def exclude(self, **kwargs: Any) -> DatabaseBucket[GeneralManagerType]:
         """
-        Returns a new DatabaseBucket excluding items that match the specified criteria.
+        Returns a new DatabaseBucket excluding items matching the given criteria.
         
-        Keyword arguments specify field lookups to exclude from the queryset. The resulting bucket contains only items that do not match these filters.
+        Keyword arguments define field lookups to exclude from the queryset. The returned bucket contains only items that do not match these filters.
         """
         merged_exclude = self.__mergeFilterDefinitions(self.excludes, **kwargs)
         return self.__class__(

general_manager/manager/groupManager.py

@@ -32,25 +32,37 @@ class GroupBucket(Bucket[GeneralManagerType]):
         self._data = self.__buildGroupedManager(data)
         self._basis_data = data
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._data == other._data
+            and self._manager_class == other._manager_class
+            and self._group_by_keys == other._group_by_keys
+        )
+
     def __checkGroupByArguments(self, group_by_keys: tuple[str, ...]) -> None:
         """
-        This method checks if the given arguments are valid for the groupBy method.
-        It raises a TypeError if the arguments are not valid.
+        Validates that all group-by keys are strings and valid attributes of the manager class.
+
+        Raises:
+            TypeError: If any group-by key is not a string.
+            ValueError: If any group-by key is not a valid attribute of the manager class.
         """
         if not all(isinstance(arg, str) for arg in group_by_keys):
             raise TypeError("groupBy() argument must be a string")
         if not all(
-            arg in self._manager_class.Interface.getAttributes().keys()
+            arg in self._manager_class.Interface.getAttributes()
             for arg in group_by_keys
         ):
-            raise TypeError(
+            raise ValueError(
                 f"groupBy() argument must be a valid attribute of {self._manager_class.__name__}"
             )
 
     def __buildGroupedManager(
         self,
         data: Bucket[GeneralManagerType],
-    ) -> list[GroupedManager[GeneralManagerType]]:
+    ) -> list[GroupManager[GeneralManagerType]]:
         """
         This method builds the grouped manager.
         It returns a GroupBucket with the grouped data.
@@ -63,11 +75,11 @@ class GroupBucket(Bucket[GeneralManagerType]):
             group_by_values.add(json.dumps(group_by_value))
 
         groups = []
-        for group_by_value in group_by_values:
+        for group_by_value in sorted(group_by_values):
             group_by_value = json.loads(group_by_value)
             grouped_manager_objects = data.filter(**group_by_value)
             groups.append(
-                GroupedManager(
+                GroupManager(
                     self._manager_class, group_by_value, grouped_manager_objects
                 )
             )
@@ -84,7 +96,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
             self._basis_data | other._basis_data,
         )
 
-    def __iter__(self) -> Generator[GroupedManager[GeneralManagerType]]:
+    def __iter__(self) -> Generator[GroupManager[GeneralManagerType]]:
         for grouped_manager in self._data:
             yield grouped_manager
 
@@ -104,13 +116,13 @@ class GroupBucket(Bucket[GeneralManagerType]):
             new_basis_data,
         )
 
-    def first(self) -> GroupedManager[GeneralManagerType] | None:
+    def first(self) -> GroupManager[GeneralManagerType] | None:
         try:
             return next(iter(self))
         except StopIteration:
             return None
 
-    def last(self) -> GroupedManager[GeneralManagerType] | None:
+    def last(self) -> GroupManager[GeneralManagerType] | None:
         items = list(self)
         if items:
             return items[-1]
@@ -122,7 +134,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
     def all(self) -> Bucket[GeneralManagerType]:
         return self
 
-    def get(self, **kwargs: Any) -> GroupedManager[GeneralManagerType]:
+    def get(self, **kwargs: Any) -> GroupManager[GeneralManagerType]:
         first_value = self.filter(**kwargs).first()
         if first_value is None:
             raise ValueError(
@@ -132,7 +144,7 @@ class GroupBucket(Bucket[GeneralManagerType]):
 
     def __getitem__(
         self, item: int | slice
-    ) -> GroupedManager[GeneralManagerType] | GroupBucket[GeneralManagerType]:
+    ) -> GroupManager[GeneralManagerType] | GroupBucket[GeneralManagerType]:
         if isinstance(item, int):
             return self._data[item]
         elif isinstance(item, slice):
@@ -162,12 +174,14 @@ class GroupBucket(Bucket[GeneralManagerType]):
         if isinstance(key, str):
             key = (key,)
         if reverse:
-            sorted_data = self._data.sort(
-                key=lambda x: tuple([-getattr(x, k) for k in key])
+            sorted_data = sorted(
+                self._data,
+                key=lambda x: tuple(getattr(x, k) for k in key),
+                reverse=True,
             )
         else:
-            sorted_data = self._data.sort(
-                key=lambda x: tuple([getattr(x, k) for k in key])
+            sorted_data = sorted(
+                self._data, key=lambda x: tuple(getattr(x, k) for k in key)
             )
 
         new_bucket = GroupBucket(
@@ -182,11 +196,13 @@ class GroupBucket(Bucket[GeneralManagerType]):
         It returns a GroupBucket with the grouped data.
         """
         return GroupBucket(
-            self._manager_class, tuple([*self._group_by_keys, *group_by_keys]), self
+            self._manager_class,
+            tuple([*self._group_by_keys, *group_by_keys]),
+            self._basis_data,
         )
 
 
-class GroupedManager(Generic[GeneralManagerType]):
+class GroupManager(Generic[GeneralManagerType]):
     """
     This class is used to group the data of a GeneralManager.
     It is used to create a new GeneralManager with the grouped data.
@@ -212,11 +228,6 @@ class GroupedManager(Generic[GeneralManagerType]):
             and self._group_by_value == other._group_by_value
         )
 
-    def __hash__(self) -> int:
-        return hash(
-            (self._manager_class, frozenset(self._group_by_value.items()), self._data)
-        )
-
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self._manager_class}, {self._group_by_value}, {self._data})"
 
@@ -277,12 +288,16 @@ class GroupedManager(Generic[GeneralManagerType]):
             for entry in total_data:
                 new_data.update(entry)
         elif issubclass(data_type, str):
-            new_data = " ".join(total_data)
+            temp_data = []
+            for entry in total_data:
+                if entry not in temp_data:
+                    temp_data.append(str(entry))
+            new_data = ", ".join(temp_data)
+        elif issubclass(data_type, bool):
+            new_data = any(total_data)
         elif issubclass(data_type, (int, float, Measurement)):
             new_data = sum(total_data)
         elif issubclass(data_type, (datetime, date, time)):
             new_data = max(total_data)
-        elif issubclass(data_type, bool):
-            new_data = any(total_data)
 
         return new_data

{generalmanager-0.5.0.dist-info → generalmanager-0.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.5.0
+Version: 0.5.2
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License-Expression: MIT
@@ -37,51 +37,51 @@ Dynamic: license-file
 
 # GeneralManager
 
-## Überblick
+## Overview
 
-Das GeneralManager-Modul ist ein leistungsstarkes und flexibles Framework, das speziell für die Verwaltung und Verarbeitung von Daten entwickelt wurde. Es bietet eine modulare Struktur, die es Entwicklern ermöglicht, komplexe Geschäftslogiken effizient zu implementieren und zu verwalten. Das Modul ist vollständig in Python geschrieben und nutzt Django als Backend-Framework.
+GeneralManager is a powerful and flexible framework designed for managing and processing data. It provides a modular structure that enables developers to implement complex business logic efficiently. The module is written entirely in Python and uses Django as the backend framework.
 
-## Hauptfunktionen
+## Key Features
 
-### 1. **Datenmanagement**
-- **Flexibilität**: Unterstützt die Verwaltung aller Arten von Daten, nicht nur Projekte und Derivate.
-- **Datenbank-Integration**: Nahtlose Integration mit dem Django ORM für Datenbankoperationen.
-- **Externe Schnittstellen**: Unterstützung für Schnittstellen zu anderen Programmen, wie z. B. Excel-Interfaces.
+### 1. **Data Management**
+- **Flexibility**: Supports managing all kinds of data, not just projects and derivatives.
+- **Database Integration**: Seamless integration with the Django ORM for database operations.
+- **External Interfaces**: Support for interfaces to other programs, such as Excel.
 
-### 2. **Datenmodellierung**
-- **Django-Modelle**: Die Datenstruktur basiert auf Django-Modellen, die durch benutzerdefinierte Felder wie `MeasurementField` erweitert werden.
-- **Regeln und Validierungen**: Definieren Sie Regeln für Datenvalidierungen, z. B. dass das Startdatum eines Projekts vor dem Enddatum liegen muss.
+### 2. **Data Modeling**
+- **Django Models**: The data structure is based on Django models, extended by custom fields like `MeasurementField`.
+- **Rules and Validations**: Define rules for data validation, e.g., ensuring that a project's start date is before its end date.
 
-### 3. **GraphQL-Integration**
-- Automatische Generierung von GraphQL-Schnittstellen für alle Modelle.
-- Unterstützung für benutzerdefinierte Abfragen und Mutationen.
+### 3. **GraphQL Integration**
+- Automatic generation of GraphQL interfaces for all models.
+- Support for custom queries and mutations.
 
-### 4. **Berechtigungssystem**
-- **ManagerBasedPermission**: Ein flexibles Berechtigungssystem, das auf Benutzerrollen und Attributen basiert.
-- Unterstützung für CRUD-Berechtigungen auf Attributebene.
+### 4. **Permission System**
+- **ManagerBasedPermission**: A flexible permission system based on user roles and attributes.
+- Attribute-level CRUD permissions.
 
 ### 5. **Interfaces**
-- **CalculationInterface**: Ermöglicht die Implementierung von Berechnungslogiken.
-- **DatabaseInterface**: Bietet eine standardisierte Schnittstelle für Datenbankoperationen.
-- **ReadOnlyInterface**: Für schreibgeschützte Datenzugriffe.
+- **CalculationInterface**: Allows the implementation of calculation logic.
+- **DatabaseInterface**: Provides a standardized interface for database operations.
+- **ReadOnlyInterface**: For read-only data access.
 
-### 6. **Datenverteilung und Berechnung**
-- **Volumenverteilung**: Automatische Berechnung und Verteilung von Volumen über mehrere Jahre.
-- **Kommerzielle Berechnungen**: Berechnung von Gesamtvolumen, Versandkosten und Einnahmen für Projekte.
+### 6. **Data Distribution and Calculations**
+- **Volume Distribution**: Automatically calculates and distributes volume over multiple years.
+- **Commercial Calculations**: Calculates total volume, shipping costs, and revenue for projects.
 
-## Anwendung
+## Usage
 
 ### Installation
 
-Installieren Sie das Modul über `pip`:
+Install the module via `pip`:
 
 ```bash
 pip install GeneralManager
 ```
 
-### Beispielcode
+### Example Code
 
-Hier ist ein Beispiel, wie Sie einen GeneralManager erstellen und Testdaten (in diesem Fall 10 Projekte) generieren können:
+The following example demonstrates how to create a GeneralManager and generate sample data (in this case 10 projects):
 
 ```python
 from general_manager import GeneralManager
@@ -134,11 +134,11 @@ class Project(GeneralManager):
 Project.Factory.createBatch(10)
 ```
 
-### GraphQL-Integration
+### GraphQL Integration
 
-Das Modul generiert automatisch GraphQL-Schnittstellen für alle Modelle. Sie können Abfragen und Mutationen über die GraphQL-URL ausführen, die in den Django-Einstellungen definiert ist.
+The module automatically generates GraphQL endpoints for all models. You can run queries and mutations through the GraphQL URL defined in your Django settings.
 
-Beispiel für eine GraphQL-Abfrage:
+Example of a GraphQL query:
 
 ```graphql
 query {
@@ -154,26 +154,26 @@ query {
 }
 ```
 
-## Vorteile
+## Benefits
 
-- **Modularität**: Einfach erweiterbar und anpassbar.
-- **Flexibilität**: Unterstützt komplexe Geschäftslogiken und Berechnungen.
-- **Integration**: Nahtlose Integration mit Django und GraphQL.
-- **Berechtigungen**: Fein abgestimmte Berechtigungen für Benutzer und Attribute.
-- **Datenvalidierung**: Automatische Validierung von Daten durch Regeln und Constraints.
-- **Caching**: Automatische Cache-Generierung mit @cached Decorator, um die Leistung zu verbessern.
+- **Modularity**: Easy to extend and adapt.
+- **Flexibility**: Supports complex business logic and calculations.
+- **Integration**: Seamless integration with Django and GraphQL.
+- **Permissions**: Fine-grained permissions for users and attributes.
+- **Data Validation**: Automatic validation of data through rules and constraints.
+- **Caching**: Automatic cache generation with the `@cached` decorator to improve performance.
 
-## Anforderungen
+## Requirements
 
 - Python >= 3.12
 - Django >= 5.2
-- Zusätzliche Abhängigkeiten (siehe `requirements.txt`):
+- Additional dependencies (see `requirements.txt`):
   - `graphene`
   - `numpy`
   - `Pint`
   - `factory_boy`
-  - uvm.
+  - and more.
 
-## Lizenz
+## License
 
-Dieses Projekt steht unter der **Non-Commercial MIT License**. Es darf nur für nicht-kommerzielle Zwecke verwendet werden. Weitere Details finden Sie in der [LICENSE](./LICENSE).
+This project is distributed under the **Non-Commercial MIT License**. It may only be used for non-commercial purposes. For further details see the [LICENSE](./LICENSE) file.

{generalmanager-0.5.0.dist-info → generalmanager-0.5.2.dist-info}/RECORD

@@ -20,12 +20,12 @@ general_manager/factory/autoFactory.py,sha256=WBhSuMVsxkPAPLhlZhYXwHVIqiomUveS7v
 general_manager/factory/factories.py,sha256=F6_nYFyJRYYc3LQApfoVFdctfLzsWUDHKafn6xjckB8,7224
 general_manager/factory/factoryMethods.py,sha256=9Bag891j0XHe3dUBAFi7gUKcKeUwcBZN3cDLBobyBiI,3225
 general_manager/interface/__init__.py,sha256=6x5adQLefTugvrJeyPcAxstyqgLAYeaJ1EPdAbac9pE,213
-general_manager/interface/baseInterface.py,sha256=mvSKUlA-0fazNnaIXGBwkiZxmX8DM_sOn-SaAIpaW8I,10273
+general_manager/interface/baseInterface.py,sha256=V8AzZ9CwswZAqc2aODmE_7DtqokOkOxzpXFVQ6qznMo,11271
 general_manager/interface/calculationInterface.py,sha256=GzSNXjU6Z7bFz60gHyMKkI5xNUDIPuniV8wbyVtQT50,14250
-general_manager/interface/databaseInterface.py,sha256=1hQcgOQkEhniv7Mrx2CbqPaes_qqH9zTqSnlriZQfGo,28314
+general_manager/interface/databaseInterface.py,sha256=khzqoOcKrBSaYnZAdPmm9cdseNx4YdPRqx5B-81KGf4,28431
 general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
 general_manager/manager/generalManager.py,sha256=L470Jevvh87doI5leUbTa9P6weIdekRZ6OTorqN-WpY,6091
-general_manager/manager/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zhmk7ktN8a-Y,10087
+general_manager/manager/groupManager.py,sha256=gT7cLq3d6PhsLfVGaIG5-fC7xnwN-4nT46N2WpnSesY,10588
 general_manager/manager/input.py,sha256=iKawV3P1QICz-0AQUF00OvH7LZYxussg3svpvCUl8hE,2977
 general_manager/manager/meta.py,sha256=Km4axFpDKI_Wx000dOok5jUwjJVqq5QJG9XhrWRw5mo,3624
 general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
@@ -40,8 +40,8 @@ general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzr
 general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
 general_manager/rule/handler.py,sha256=z8SFHTIZ0LbLh3fV56Mud0V4_OvWkqJjlHvFqau7Qfk,7334
 general_manager/rule/rule.py,sha256=3FVCKGL7BTVoStdgOTdWQwuoVRIxAIAilV4VOzouDpc,10759
-generalmanager-0.5.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
-generalmanager-0.5.0.dist-info/METADATA,sha256=x_8Yw5IpORQc7MOjzTp-J_vmcuptPWmTFL7zkGUEI7c,6528
-generalmanager-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-generalmanager-0.5.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
-generalmanager-0.5.0.dist-info/RECORD,,
+generalmanager-0.5.2.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.5.2.dist-info/METADATA,sha256=7fumKNtzVKr86HwflW_Sesa93yWWHXTJAyumR-TWDEU,6101
+generalmanager-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+generalmanager-0.5.2.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.5.2.dist-info/RECORD,,