devaci 0.1.0__py3-none-any.whl

devaci/__init__.py

@@ -0,0 +1,20 @@
+"""devaci - Generate and push Cisco ACI configuration via the Cobra SDK."""
+
+from devaci.cobra import CobraBuilder
+from devaci.deploy import DeployClass
+from devaci.exceptions import CobraError, DataError, DeployError, DevaciError, JinjaError
+from devaci.jinja import JinjaRenderer
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "CobraBuilder",
+    "DeployClass",
+    "JinjaRenderer",
+    "DevaciError",
+    "CobraError",
+    "JinjaError",
+    "DataError",
+    "DeployError",
+    "__version__",
+]

devaci/cobra/__init__.py

@@ -0,0 +1,93 @@
+"""Cobra model builder for devaci."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, cast
+
+import cobra.mit.request
+import cobra.model.pol
+
+from devaci.cobra.registry import REGISTRY
+from devaci.console import logger
+from devaci.results import CobraResult
+
+
+class CobraBuilder:
+    """Build an ACI configuration (:class:`ConfigRequest`) from a rendered dict.
+
+    The dict's top-level keys map to registered handlers (see
+    :mod:`devaci.cobra.builders`). Each handler receives the builder and the
+    list of objects and is responsible for adding Mo instances to
+    :attr:`config`.
+    """
+
+    def __init__(self) -> None:
+        self._root = ""
+        self._uni = cobra.model.pol.Uni(self._root)
+        self.config = cobra.mit.request.ConfigRequest()
+        self.result: CobraResult | None = None
+
+    @property
+    def root(self) -> str:
+        """Return the ACI root (policy universe DN)."""
+        return self._root
+
+    @property
+    def uni(self) -> cobra.model.pol.Uni:
+        """Return the root ``pol.Uni`` managed object."""
+        return self._uni
+
+    @property
+    def xml(self) -> str | None:
+        """Return the rendered XML payload."""
+        return cast(str | None, self.config.xmldata)
+
+    @property
+    def json(self) -> Any:
+        """Return the rendered JSON payload as a dict."""
+        return json.loads(self.config.data)
+
+    def render(self, output: dict[str, Any]) -> CobraResult:
+        """Render ``output`` through the registered handlers.
+
+        Keys with empty values are skipped; unknown keys and handler errors
+        are logged and reported via the returned :class:`CobraResult`.
+        """
+        logs: list[str] = []
+        success = True
+
+        for key, value in output.items():
+            if value in (None, [], {}, ""):
+                continue
+
+            handler = REGISTRY.get(key)
+            if handler is None:
+                success = False
+                msg = f"[Cobra] -> [ConfigError]: Class {key} does not exist."
+                logger.warning(msg)
+                logs.append(msg)
+                continue
+
+            try:
+                handler(self, value)
+                msg = f"[Cobra]: Class {key} was rendered successfully."
+                logger.info(msg)
+                logs.append(msg)
+            except Exception as exc:
+                success = False
+                msg = f"[Cobra] -> [{type(exc).__name__}]: Class {key} failed: {exc}"
+                logger.error(msg)
+                logs.append(msg)
+
+        if not self.config.configMos:
+            success = False
+            msg = "[Cobra] -> [ConfigError]: No object was found in configuration."
+            logger.warning(msg)
+            logs.append(msg)
+
+        self.result = CobraResult(success=success, log=logs, config=self.config)
+        return self.result
+
+
+from devaci.cobra import builders  # noqa: E402, F401

devaci/cobra/base.py

@@ -0,0 +1,28 @@
+"""Shared helpers for Cobra object builders."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping
+from math import isnan
+from typing import Any
+
+
+def not_nan_str(value: Mapping[str, Any], keys: Iterable[str]) -> bool:
+    """Return True when none of the given keys hold an invalid value.
+
+    A value is considered invalid when it is ``None``, an empty/whitespace
+    string, the string ``nan`` (case-insensitive), or a float NaN. Missing
+    keys are ignored.
+    """
+
+    def is_invalid(v: Any) -> bool:
+        if v is None:
+            return True
+        if isinstance(v, str):
+            v = v.strip()
+            return not v or v.lower() == "nan"
+        if isinstance(v, float):
+            return isnan(v)
+        return False
+
+    return not any(is_invalid(value[k]) for k in keys if k in value)