GeneralManager 0.0.0__py3-none-any.whl

general_manager/rule/rule.py

@@ -0,0 +1,313 @@
+# generalManager/src/rule/rule.py
+
+from __future__ import annotations
+import ast
+import inspect
+import re
+import textwrap
+from typing import (
+    Callable,
+    ClassVar,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    TypeVar,
+    cast,
+)
+
+from django.conf import settings
+from django.utils.module_loading import import_string
+
+from general_manager.rule.handler import (
+    BaseRuleHandler,
+    LenHandler,
+    IntersectionCheckHandler,
+)
+from general_manager.manager.generalManager import GeneralManager
+
+GeneralManagerType = TypeVar("GeneralManagerType", bound=GeneralManager)
+
+
+class Rule(Generic[GeneralManagerType]):
+    """
+    Rule kapselt eine boolsche Bedingungsfunktion und erzeugt bei Fehlschlag
+    automatisierte oder benutzerdefinierte Fehlermeldungen auf Basis des AST.
+    """
+
+    _func: Callable[[GeneralManagerType], bool]
+    _custom_error_message: Optional[str]
+    _ignore_if_none: bool
+    _last_result: Optional[bool]
+    _last_input: Optional[GeneralManagerType]
+    _tree: ast.AST
+    _variables: List[str]
+    _handlers: Dict[str, BaseRuleHandler]
+
+    def __init__(
+        self,
+        func: Callable[[GeneralManagerType], bool],
+        custom_error_message: Optional[str] = None,
+        ignore_if_none: bool = True,
+    ) -> None:
+        self._func = func
+        self._custom_error_message = custom_error_message
+        self._ignore_if_none = ignore_if_none
+        self._last_result = None
+        self._last_input = None
+
+        # 1) Quelltext holen, Decorators abschneiden, Dedent
+        src = inspect.getsource(func)
+        lines = src.splitlines()
+        if lines and lines[0].strip().startswith("@"):
+            idx = next(i for i, L in enumerate(lines) if not L.strip().startswith("@"))
+            src = "\n".join(lines[idx:])
+        src = textwrap.dedent(src)
+
+        # 2) AST parsen & Elternverweise setzen
+        self._tree = ast.parse(src)
+        for parent in ast.walk(self._tree):
+            for child in ast.iter_child_nodes(parent):
+                setattr(child, "parent", parent)
+
+        # 3) Variablen extrahieren
+        self._variables = self._extract_variables()
+
+        # 4) Handler registrieren
+        self._handlers = {}  # type: Dict[str, BaseRuleHandler]
+        for cls in (LenHandler, IntersectionCheckHandler):
+            inst = cls()
+            self._handlers[inst.function_name] = inst
+        for path in getattr(settings, "RULE_HANDLERS", []):
+            handler_cls = import_string(path)
+            inst = handler_cls()
+            self._handlers[inst.function_name] = inst
+
+    @property
+    def func(self) -> Callable[[GeneralManagerType], bool]:
+        return self._func
+
+    @property
+    def customErrorMessage(self) -> Optional[str]:
+        return self._custom_error_message
+
+    @property
+    def variables(self) -> List[str]:
+        return self._variables
+
+    @property
+    def lastEvaluationResult(self) -> Optional[bool]:
+        return self._last_result
+
+    @property
+    def lastEvaluationInput(self) -> Optional[GeneralManagerType]:
+        return self._last_input
+
+    @property
+    def ignoreIfNone(self) -> bool:
+        return self._ignore_if_none
+
+    def evaluate(self, x: GeneralManagerType) -> Optional[bool]:
+        """
+        Führt die Regel aus. Gibt False bei Fehlschlag, True bei Erfolg
+        und None, falls ignore_if_none aktiv ist und eine Variable None war.
+        """
+        self._last_input = x
+        vals = self._extract_variable_values(x)
+        if self._ignore_if_none and any(v is None for v in vals.values()):
+            self._last_result = None
+            return None
+
+        self._last_result = self._func(x)
+        return self._last_result
+
+    def validateCustomErrorMessage(self) -> None:
+        """
+        Stellt sicher, dass in der custom_error_message alle Variablen
+        aus self._variables verwendet werden.
+        """
+        if not self._custom_error_message:
+            return
+
+        vars_in_msg = set(re.findall(r"{([^}]+)}", self._custom_error_message))
+        missing = [v for v in self._variables if v not in vars_in_msg]
+        if missing:
+            raise ValueError(
+                f"The custom error message does not contain all used variables: {missing}"
+            )
+
+    def getErrorMessage(self) -> Optional[Dict[str, str]]:
+        """
+        Liefert ein Dict variable→message, oder None, wenn kein Fehler.
+        """
+        if self._last_result or self._last_result is None:
+            return None
+        if self._last_input is None:
+            raise ValueError("No input provided for error message generation")
+
+        # Validierung und Ersetzen der Template-Platzhalter
+        self.validateCustomErrorMessage()
+        vals = self._extract_variable_values(self._last_input)
+
+        if self._custom_error_message:
+            formatted = re.sub(
+                r"{([^}]+)}",
+                lambda m: str(vals.get(m.group(1), m.group(0))),
+                self._custom_error_message,
+            )
+            return {v: formatted for v in self._variables}
+
+        errors = self._generate_error_messages(vals)
+        return errors or None
+
+    def _extract_variables(self) -> List[str]:
+        class VarVisitor(ast.NodeVisitor):
+            vars: set[str] = set()
+
+            def visit_Attribute(self, node: ast.Attribute) -> None:
+                parts: list[str] = []
+                curr: ast.AST = node
+                while isinstance(curr, ast.Attribute):
+                    parts.append(curr.attr)
+                    curr = curr.value
+                if isinstance(curr, ast.Name) and curr.id == "x":
+                    self.vars.add(".".join(reversed(parts)))
+                self.generic_visit(node)
+
+        visitor = VarVisitor()
+        visitor.visit(self._tree)
+        return sorted(visitor.vars)
+
+    def _extract_variable_values(
+        self, x: GeneralManagerType
+    ) -> Dict[str, Optional[object]]:
+        out: Dict[str, Optional[object]] = {}
+        for var in self._variables:
+            obj: object = x  # type: ignore
+            for part in var.split("."):
+                obj = getattr(obj, part)
+                if obj is None:
+                    break
+            out[var] = obj
+        return out
+
+    def _extract_comparisons(self) -> list[ast.Compare]:
+        class CompVisitor(ast.NodeVisitor):
+            comps: list[ast.Compare] = []
+
+            def visit_Compare(self, node: ast.Compare) -> None:
+                self.comps.append(node)
+                self.generic_visit(node)
+
+        visitor = CompVisitor()
+        visitor.visit(self._tree)
+        return visitor.comps
+
+    def _contains_logical_ops(self) -> bool:
+        class LogicVisitor(ast.NodeVisitor):
+            found: bool = False
+
+            def visit_BoolOp(self, node: ast.BoolOp) -> None:
+                if isinstance(node.op, (ast.And, ast.Or)):
+                    self.found = True
+                self.generic_visit(node)
+
+        visitor = LogicVisitor()
+        visitor.visit(self._tree)
+        return visitor.found
+
+    def _generate_error_messages(
+        self, var_values: Dict[str, Optional[object]]
+    ) -> Dict[str, str]:
+        errors: Dict[str, str] = {}
+        comparisons = self._extract_comparisons()
+        logical = self._contains_logical_ops()
+
+        if comparisons:
+            for cmp in comparisons:
+                left, rights, ops = cmp.left, cmp.comparators, cmp.ops
+                for right, op in zip(rights, ops):
+                    # Spezial-Handler?
+                    if isinstance(left, ast.Call):
+                        fn = self._get_node_name(left.func)
+                        handler = self._handlers.get(fn)
+                        if handler:
+                            errors.update(
+                                handler.handle(cmp, left, right, op, var_values, self)
+                            )
+                            continue
+
+                    # Standard-Fehler
+                    lnm = self._get_node_name(left)
+                    rnm = self._get_node_name(right)
+                    lval = self._eval_node(left)
+                    rval = self._eval_node(right)
+                    ldisp = f"[{lnm}] ({lval})" if lnm in var_values else str(lval)
+                    rdisp = f"[{rnm}] ({rval})" if rnm in var_values else str(rval)
+                    sym = self._get_op_symbol(op)
+                    msg = f"{ldisp} must be {sym} {rdisp}!"
+                    if lnm in var_values:
+                        errors[lnm] = msg
+                    if rnm in var_values and rnm != lnm:
+                        errors[rnm] = msg
+
+            if logical and not self._last_result:
+                combo = ", ".join(f"[{v}]" for v in self._variables)
+                msg = f"{combo} combination is not valid"
+                for v in self._variables:
+                    errors[v] = msg
+
+            return errors
+
+        # kein Vergleich → pauschale Meldung
+        combo = ", ".join(f"[{v}]" for v in self._variables)
+        return {v: f"{combo} combination is not valid" for v in self._variables}
+
+    def _get_op_symbol(self, op: Optional[ast.cmpop]) -> str:
+        return {
+            ast.Lt: "<",
+            ast.LtE: "<=",
+            ast.Gt: ">",
+            ast.GtE: ">=",
+            ast.Eq: "==",
+            ast.NotEq: "!=",
+            ast.Is: "is",
+            ast.IsNot: "is not",
+            ast.In: "in",
+            ast.NotIn: "not in",
+        }.get(type(op), "?")
+
+    def _get_node_name(self, node: ast.AST) -> str:
+        if isinstance(node, ast.Attribute):
+            parts: list[str] = []
+            curr: ast.AST = node
+            while isinstance(curr, ast.Attribute):
+                parts.insert(0, curr.attr)
+                curr = curr.value
+            return ".".join(parts)
+        if isinstance(node, ast.Name):
+            return node.id
+        if isinstance(node, ast.Constant):
+            return ""
+        if isinstance(node, ast.Call):
+            fn = self._get_node_name(node.func)
+            args = ", ".join(self._get_node_name(a) for a in node.args)
+            return f"{fn}({args})"
+        try:
+            # ast.unparse gibt einen str zurück
+            return ast.unparse(node)
+        except Exception:
+            return ""
+
+    def _eval_node(self, node: ast.expr) -> Optional[object]:
+        """
+        Evaluiert einen AST-Ausdruck im Kontext von `x`.
+        """
+        if not isinstance(node, ast.expr):
+            return None
+        try:
+            expr = ast.Expression(body=node)
+            code = compile(expr, "<ast>", "eval")
+            return eval(code, {"x": self._last_input}, {})
+        except Exception:
+            return None

generalmanager-0.0.0.dist-info/METADATA

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: GeneralManager
+Version: 0.0.0
+Summary: Kurzbeschreibung deines Pakets
+Author-email: Tim Kleindick <tkleindick@yahoo.de>
+License: Non-Commercial MIT License
+        
+        Copyright (c) 2025 Tim Kleindick
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the “Software”), to deal
+        in the Software **solely for non-commercial purposes**, including without
+        limitation the rights to use, copy, modify, merge, publish, distribute,
+        sublicense, and/or sell copies of the Software **for non-commercial use only**,
+        and to permit persons to whom the Software is furnished to do so, subject to
+        the following conditions:
+        
+        1. Non-Commercial Use Only  
+           The Software may **not** be used for commercial purposes. “Commercial” means
+           any activity intended for or directed toward commercial advantage or
+           monetary compensation.
+        
+        2. Copyright Notice & License Text  
+           The above copyright notice and this permission notice shall be included in
+           all copies or substantial portions of the Software.
+        
+        3. Disclaimer of Warranty  
+           THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+           IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+           FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT SHALL
+           THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+           LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+           OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+           SOFTWARE.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asgiref>=3.8.1
+Requires-Dist: Django>=5.2
+Requires-Dist: django-simple-history>=3.8.0
+Requires-Dist: exrex>=0.12.0
+Requires-Dist: factory_boy>=3.3.3
+Requires-Dist: Faker>=37.1.0
+Requires-Dist: flexcache>=0.3
+Requires-Dist: flexparser>=0.4
+Requires-Dist: gitdb>=4.0.12
+Requires-Dist: GitPython>=3.1.41
+Requires-Dist: graphene>=3.4.3
+Requires-Dist: graphene-django>=3.2.3
+Requires-Dist: graphql-core>=3.2.6
+Requires-Dist: graphql-relay>=3.2.0
+Requires-Dist: numpy>=2.2.5
+Requires-Dist: Pint>=0.24.4
+Requires-Dist: platformdirs>=4.3.7
+Requires-Dist: promise>=2.3
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: setuptools>=75.6.0
+Requires-Dist: six>=1.17.0
+Requires-Dist: smmap>=5.0.2
+Requires-Dist: sqlparse>=0.5.3
+Requires-Dist: text-unidecode>=1.3
+Requires-Dist: typing_extensions>=4.13.2
+Requires-Dist: tzdata>=2025.2
+Dynamic: license-file
+
+# GeneralManager
+
+## Überblick
+
+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.
+
+## Hauptfunktionen
+
+### 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.
+
+### 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.
+
+### 3. **GraphQL-Integration**
+- Automatische Generierung von GraphQL-Schnittstellen für alle Modelle.
+- Unterstützung für benutzerdefinierte Abfragen und Mutationen.
+
+### 4. **Berechtigungssystem**
+- **ManagerBasedPermission**: Ein flexibles Berechtigungssystem, das auf Benutzerrollen und Attributen basiert.
+- Unterstützung für CRUD-Berechtigungen auf Attributebene.
+
+### 5. **Interfaces**
+- **CalculationInterface**: Ermöglicht die Implementierung von Berechnungslogiken.
+- **DatabaseInterface**: Bietet eine standardisierte Schnittstelle für Datenbankoperationen.
+- **ReadOnlyInterface**: Für schreibgeschützte Datenzugriffe.
+
+### 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.
+
+## Anwendung
+
+### Installation
+
+Installieren Sie das Modul über `pip`:
+
+```bash
+pip install GeneralManager
+```
+
+### Beispielcode
+
+Hier ist ein Beispiel, wie Sie einen GeneralManager erstellen und Testdaten (in diesem Fall 10 Projekte) generieren können:
+
+```python
+from general_manager import GeneralManager
+from general_manager.interface.database import DatabaseInterface
+from general_manager.measurement import MeasurementField, Measurement
+from general_manager.permission import ManagerBasedPermission
+
+class Project(GeneralManager):
+    name: str
+    start_date: Optional[date]
+    end_date: Optional[date]
+    total_capex: Optional[Measurement]
+    derivative_list: DatabaseBucket[Derivative]
+
+    class Interface(DatabaseInterface):
+        name = CharField(max_length=50)
+        number = CharField(max_length=7, validators=[RegexValidator(r"^AP\d{4,5}$")])
+        description = TextField(null=True, blank=True)
+        start_date = DateField(null=True, blank=True)
+        end_date = DateField(null=True, blank=True)
+        total_capex = MeasurementField(base_unit="EUR", null=True, blank=True)
+
+        class Meta:
+            constraints = [
+                constraints.UniqueConstraint(
+                    fields=["name", "number"], name="unique_booking"
+                )
+            ]
+
+            rules = [
+                Rule["Project"](
+                    lambda x: cast(date, x.start_date) < cast(date, x.end_date)
+                ),
+                Rule["Project"](lambda x: cast(Measurement, x.total_capex) >= "0 EUR"),
+            ]
+
+        class Factory:
+            name = LazyProjectName()
+            end_date = LazyDeltaDate(365 * 6, "start_date")
+            total_capex = LazyMeasurement(75_000, 1_000_000, "EUR")
+
+    class Permission(ManagerBasedPermission):
+        __read__ = ["ends_with:name:X-771", "public"]
+        __create__ = ["admin", "isMatchingKeyAccount"]
+        __update__ = ["admin", "isMatchingKeyAccount", "isProjectTeamMember"]
+        __delete__ = ["admin", "isMatchingKeyAccount", "isProjectTeamMember"]
+
+        total_capex = {"update": ["isSalesResponsible", "isProjectManager"]}
+
+Project.Factory.createBatch(10)
+```
+
+### 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.
+
+Beispiel für eine GraphQL-Abfrage:
+
+```graphql
+query {
+  projectList {
+    name
+    startDate
+    endDate
+    totalCapex {
+      value
+      unit
+    }
+  }
+}
+```
+
+## Vorteile
+
+- **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.
+
+## Anforderungen
+
+- Python >= 3.12
+- Django >= 5.2
+- Zusätzliche Abhängigkeiten (siehe `requirements.txt`):
+  - `graphene`
+  - `numpy`
+  - `Pint`
+  - `factory_boy`
+  - uvm.
+
+## Lizenz
+
+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).

generalmanager-0.0.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+general_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general_manager/apps.py,sha256=-AX9imxqht55Xr8q5abnoeKc48ubj-tzDq7WhUrcNUg,3313
+general_manager/api/graphql.py,sha256=Virzi9njCD6qVcOLxmD9mdQOgd6ap8JeuKWovBZ73HA,27514
+general_manager/api/mutation.py,sha256=uu5RVxc9wbb-Zrbtt4azegvyKymMqEsxk_CkerKCd9Q,5178
+general_manager/api/property.py,sha256=oc93p1P8dcIvrNorRuqD1EJVsd6eYttYhZuAS0s28gs,696
+general_manager/auxiliary/__init__.py,sha256=4IwKJzsNxGduF-Ej0u1BNHVaMhkql8PjHbVtx9DOTSY,76
+general_manager/auxiliary/argsToKwargs.py,sha256=kmp1xonpQp4X_y8ZJG6c5uOW7zQwo0HtPqsHWVzXRSM,921
+general_manager/auxiliary/filterParser.py,sha256=exmRGVwvdMPgN-65MLwAV2q6L23bI4gTWb6lWXO4ZuU,3108
+general_manager/auxiliary/noneToZero.py,sha256=UtIdye6wPdiIZqOnHxSdHnc0aKcH_sMjeCHPs7uLwKo,276
+general_manager/cache/cacheDecorator.py,sha256=RmUDyJfkouO2-R2KZZJF1n8RCB0FjVa2OoTeLQ0vUyg,2934
+general_manager/cache/cacheTracker.py,sha256=vUQCarqABIW_O02hbKeRo0thurmPD0TfrOlIUh7kneI,1045
+general_manager/cache/dependencyIndex.py,sha256=KUDroajKrWfJv0PO2EQVNTrYq7XxrpBT4MGKBgPwMwo,10676
+general_manager/cache/pathMapping.py,sha256=WtECIek9fI-2_nqIYI4Ux9Lan6g8P9TMO_AfthkznX8,5656
+general_manager/cache/signals.py,sha256=ZHeXKFMN7tj9t0J-vSqf_05_NhGqEF2sZtbZO3vaRqI,1234
+general_manager/factory/__init__.py,sha256=DLSQbpSBpujPtDSZcruPc43OLWzKCCtf20gbalCDYRU,91
+general_manager/factory/factories.py,sha256=31NyVw2Ju5ZDPJ6sax6_seyZesCU5UrviNbk-2PaKnA,11559
+general_manager/factory/lazy_methods.py,sha256=UJC50a4Gbe4T5IQPh7ucyQqpaS2x4zhQzznwpJvyVLo,1155
+general_manager/interface/__init__.py,sha256=6x5adQLefTugvrJeyPcAxstyqgLAYeaJ1EPdAbac9pE,213
+general_manager/interface/baseInterface.py,sha256=mvSKUlA-0fazNnaIXGBwkiZxmX8DM_sOn-SaAIpaW8I,10273
+general_manager/interface/calculationInterface.py,sha256=GzSNXjU6Z7bFz60gHyMKkI5xNUDIPuniV8wbyVtQT50,14250
+general_manager/interface/databaseInterface.py,sha256=2Xzb04J7c1Z4ZKlA-6-8AOXaWNvF6zUVNNzM6k0jzLQ,27337
+general_manager/manager/__init__.py,sha256=l3RYp62aEhj3Y975_XUTIzo35LUnkTJHkb_hgChnXXI,111
+general_manager/manager/generalManager.py,sha256=xt7tvwTaPGhh7Z8VhbdMJuScsl78B9QDVQoMWv4amuo,5158
+general_manager/manager/groupManager.py,sha256=O4FABqbm7KlZw6t36Ot3HU1FsBYN0h6Zhmk7ktN8a-Y,10087
+general_manager/manager/input.py,sha256=NTZis3QsF0N3SODZBeQrR2R-_iMbmdEBvoYNuVKWNtE,1737
+general_manager/manager/meta.py,sha256=5wHrCVnua5c38vpVZSCesrNvgydQDH8h6pxW6_QgCDg,3107
+general_manager/measurement/__init__.py,sha256=X97meFujBldE5v0WMF7SmKeGpC5R0JTczfLo_Lq1Xek,84
+general_manager/measurement/measurement.py,sha256=hTISANW7nAN2voakq9f-naJxa1MUcxWLDrcDW1Rdn3s,9340
+general_manager/measurement/measurementField.py,sha256=iq9Hqe6ZGX8CxXm4nIqTAWTRkQVptzpqE9ExX-jFyNs,5928
+general_manager/permission/__init__.py,sha256=5UlDERN60Vn8obGVkT-cOM8kHjzmoxgK5w5FgTCDhGE,59
+general_manager/permission/basePermission.py,sha256=PsJiX-UNeSh6xUlcUwuQNCLYvHZipWUJ0kAoMkdxXJc,6113
+general_manager/permission/fileBasedPermission.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+general_manager/permission/managerBasedPermission.py,sha256=VgZJVgkXWdaLk6K7c0kYxTbELnTYK6UY9mMuKH5u64w,5728
+general_manager/permission/permissionChecks.py,sha256=T-9khBqiwM4ASBdey9p07sC_xgzceIU9EAE0reukguM,1655
+general_manager/permission/permissionDataManager.py,sha256=Ji7fsnuaKTa6M8yzCGyzrIHyGa_ZvqJM7sXR97-uTrA,1937
+general_manager/rule/__init__.py,sha256=4Har5cfPD1fmOsilTDod-ZUz3Com-tkl58jz7yY4fD0,23
+general_manager/rule/handler.py,sha256=O3BZbTnUE9o3LTSWpoq6hgm3tKy1sEBjRcDrRaA54Gw,3936
+general_manager/rule/rule.py,sha256=tu3pNe_avs6ayI16KYeaQX85o2lXcPip_LN9CJEhr8Y,10708
+generalmanager-0.0.0.dist-info/licenses/LICENSE,sha256=YGFm0ieb4KpkMRRt2qnWue6uFh0cUMtobwEBkHwajhc,1450
+generalmanager-0.0.0.dist-info/METADATA,sha256=xCCtFrVLe_ta1Y9q5Ezw5SeJhZTQ7aVIq53ggT3L88s,8188
+generalmanager-0.0.0.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+generalmanager-0.0.0.dist-info/top_level.txt,sha256=sTDtExP9ga-YP3h3h42yivUY-A2Q23C2nw6LNKOho4I,16
+generalmanager-0.0.0.dist-info/RECORD,,

generalmanager-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.3.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

generalmanager-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+Non-Commercial MIT License
+
+Copyright (c) 2025 Tim Kleindick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software **solely for non-commercial purposes**, including without
+limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software **for non-commercial use only**,
+and to permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+1. Non-Commercial Use Only  
+   The Software may **not** be used for commercial purposes. “Commercial” means
+   any activity intended for or directed toward commercial advantage or
+   monetary compensation.
+
+2. Copyright Notice & License Text  
+   The above copyright notice and this permission notice shall be included in
+   all copies or substantial portions of the Software.
+
+3. Disclaimer of Warranty  
+   THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. IN NO EVENT SHALL
+   THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.

generalmanager-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+general_manager