pyavd 6.2.0.dev2__py3-none-any.whl → 6.2.0.dev3__py3-none-any.whl

pyavd/__init__.py

@@ -18,7 +18,7 @@ PYAVD_PRERELEASE = ""  # Set this to aN or bN for alpha and beta releases of pya
 __author__ = "Arista Networks"
 __copyright__ = "Copyright 2023-2026 Arista Networks"
 __license__ = "Apache 2.0"
-__version__ = "6.2.0.dev2"
+__version__ = "6.2.0.dev3"
 
 __all__ = [
     "get_avd_facts",

pyavd/_cv/schema/__init__.py

@@ -105,6 +105,7 @@ class CvDeploy(AvdModel):
             "system_mac_address": {"type": str},
             "cv_tags": {"type": EosCliConfigGen.Metadata.CvTags},
             "cv_pathfinder": {"type": EosCliConfigGen.Metadata.CvPathfinder},
+            "cv_use_static_config_manifest": {"type": bool},
         }
         _allow_other_keys: ClassVar[bool] = True
         is_deployed: bool | None
@@ -119,6 +120,18 @@ class CvDeploy(AvdModel):
         cv_tags: EosCliConfigGen.Metadata.CvTags
         cv_pathfinder: EosCliConfigGen.Metadata.CvPathfinder
         """Metadata used for CV Pathfinder visualization on CloudVision."""
+        cv_use_static_config_manifest: bool | None
+        """
+        PREVIEW: This option is marked as "preview", meaning the data models or generated configuration can
+        change at any time.
+
+        The device configuration is expected to be deployed via the
+        `static_config_manifest` / `cv_static_config_manifest` hierarchy instead of the
+        flat "AVD
+        Configurations" layout in the Static Configlet Studio.
+        The device will still be verified and
+        onboarded in the Inventory & Topology Studio.
+        """
 
         if TYPE_CHECKING:
 
@@ -130,6 +143,7 @@ class CvDeploy(AvdModel):
                 system_mac_address: str | None | UndefinedType = Undefined,
                 cv_tags: EosCliConfigGen.Metadata.CvTags | UndefinedType = Undefined,
                 cv_pathfinder: EosCliConfigGen.Metadata.CvPathfinder | UndefinedType = Undefined,
+                cv_use_static_config_manifest: bool | None | UndefinedType = Undefined,
             ) -> None:
                 """
                 Metadata.
@@ -145,6 +159,16 @@ class CvDeploy(AvdModel):
                     system_mac_address: system_mac_address
                     cv_tags: cv_tags
                     cv_pathfinder: Metadata used for CV Pathfinder visualization on CloudVision.
+                    cv_use_static_config_manifest:
+                       PREVIEW: This option is marked as "preview", meaning the data models or generated configuration can
+                       change at any time.
+
+                       The device configuration is expected to be deployed via the
+                       `static_config_manifest` / `cv_static_config_manifest` hierarchy instead of the
+                       flat "AVD
+                       Configurations" layout in the Static Configlet Studio.
+                       The device will still be verified and
+                       onboarded in the Inventory & Topology Studio.
 
                 """
 
@@ -155,6 +179,7 @@ class CvDeploy(AvdModel):
         "cv_device_tags": {"type": CvDeviceTags},
         "cv_interface_tags": {"type": CvInterfaceTags},
         "cv_pathfinder_metadata": {"type": EosCliConfigGen.Metadata.CvPathfinder},
+        "cv_use_static_config_manifest": {"type": bool},
         "metadata": {"type": Metadata},
     }
     _allow_other_keys: ClassVar[bool] = True
@@ -208,6 +233,18 @@ class CvDeploy(AvdModel):
     """
     cv_pathfinder_metadata: EosCliConfigGen.Metadata.CvPathfinder
     """Metadata used for CV Pathfinder visualization on CloudVision."""
+    cv_use_static_config_manifest: bool | None
+    """
+    PREVIEW: This option is marked as "preview", meaning the data models or generated configuration can
+    change at any time.
+
+    The device configuration is expected to be deployed via the
+    `static_config_manifest` / `cv_static_config_manifest` hierarchy instead of the
+    flat "AVD
+    Configurations" layout in the Static Configlet Studio.
+    The device will still be verified and
+    onboarded in the Inventory & Topology Studio.
+    """
     metadata: Metadata
     """
     Metadata from the `eos_designs` role, loaded automatically from structured configs.
@@ -230,6 +267,7 @@ class CvDeploy(AvdModel):
             cv_device_tags: CvDeviceTags | UndefinedType = Undefined,
             cv_interface_tags: CvInterfaceTags | UndefinedType = Undefined,
             cv_pathfinder_metadata: EosCliConfigGen.Metadata.CvPathfinder | UndefinedType = Undefined,
+            cv_use_static_config_manifest: bool | None | UndefinedType = Undefined,
             metadata: Metadata | UndefinedType = Undefined,
         ) -> None:
             """
@@ -275,6 +313,16 @@ class CvDeploy(AvdModel):
                    Subclass of AvdList
                    with `CvInterfaceTagsItem` items.
                 cv_pathfinder_metadata: Metadata used for CV Pathfinder visualization on CloudVision.
+                cv_use_static_config_manifest:
+                   PREVIEW: This option is marked as "preview", meaning the data models or generated configuration can
+                   change at any time.
+
+                   The device configuration is expected to be deployed via the
+                   `static_config_manifest` / `cv_static_config_manifest` hierarchy instead of the
+                   flat "AVD
+                   Configurations" layout in the Static Configlet Studio.
+                   The device will still be verified and
+                   onboarded in the Inventory & Topology Studio.
                 metadata:
                    Metadata from the `eos_designs` role, loaded automatically from structured configs.
                    For standalone

pyavd/_cv/workflows/deploy_configs_to_cv.py

@@ -3,13 +3,14 @@
 # that can be found in the LICENSE file.
 from __future__ import annotations
 
+from asyncio import gather
 from logging import getLogger
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
 if TYPE_CHECKING:
     from pyavd._cv.client import CVClient
 
-    from .models import CVEosConfig, DeployToCvResult
+    from .models import CVDeviceDeployment, CVEosConfig, DeployToCvResult
 
 LOGGER = getLogger(__name__)
 
@@ -169,3 +170,88 @@ async def deploy_configlet_containers_to_cv(configs: list[CVEosConfig], workspac
             container_id=CONFIGLET_CONTAINER_ID,
             child_assignment_ids=list(update_device_container_ids.union(existing_device_containers_by_id)),
         )
+
+
+async def delete_configs_from_cv(device_deployments: list[CVDeviceDeployment], result: DeployToCvResult, cv_client: CVClient) -> None:
+    """
+    Delete leftovers device configurations from a previous `deploy_configs_to_cv` run.
+
+    For devices with `use_static_config_manifest=True`, the device configuration is expected to be deployed
+    via the static config manifest instead of the flat "AVD Configurations" layout. This function removes
+    the corresponding container (avd-<serial>) and configlet for these devices if they exist.
+
+    If all children are removed, the root container itself is deleted and unregistered from the Studio
+    """
+    workspace_id = result.workspace.id
+
+    # Build a stable list of target IDs from manifest-opted devices.
+    target_ids = [
+        f"{CONFIGLET_ID_PREFIX}{device_deployment.device.serial_number}"
+        for device_deployment in device_deployments
+        if device_deployment.use_static_config_manifest and device_deployment.device.serial_number
+    ]
+    if not target_ids:
+        return
+    target_ids_set = set(target_ids)
+
+    # Find what actually exists on CV for our targets and the root container.
+    existing_configlets, existing_containers = await gather(
+        cv_client.get_configlets(workspace_id=workspace_id, configlet_ids=target_ids),
+        cv_client.get_configlet_containers(workspace_id=workspace_id, container_ids=[*target_ids, CONFIGLET_CONTAINER_ID]),
+    )
+
+    configlets_by_id = {cast("str", configlet.key.configlet_id): configlet for configlet in existing_configlets}
+    containers_by_id = {cast("str", container.key.configlet_assignment_id): container for container in existing_containers}
+    root_cv_container = containers_by_id.pop(CONFIGLET_CONTAINER_ID, None)
+
+    # Delete leftover per-device containers and configlets in parallel.
+    delete_coroutines = [cv_client.delete_configlet_container(workspace_id=workspace_id, assignment_id=container_id) for container_id in containers_by_id]
+    if configlets_by_id:
+        delete_coroutines.append(cv_client.delete_configlets(workspace_id=workspace_id, configlet_ids=list(configlets_by_id)))
+
+    if delete_coroutines:
+        LOGGER.info(
+            "delete_configs_from_cv: Removing %s device containers and %s configlets.",
+            len(containers_by_id),
+            len(configlets_by_id),
+        )
+        await gather(*delete_coroutines)
+
+    result.removed_configs.extend(cast("str", configlet.display_name) for configlet in configlets_by_id.values())
+
+    # Reconcile the root "AVD Configurations" container if it exists.
+    if root_cv_container is None:
+        return
+
+    existing_child_ids = root_cv_container.child_assignment_ids.values
+    remaining_child_ids = [child_id for child_id in existing_child_ids if child_id not in target_ids_set]
+
+    if remaining_child_ids:
+        # Root still has non-target children. Update its child list only if we actually removed something.
+        if remaining_child_ids != list(existing_child_ids):
+            LOGGER.info("delete_configs_from_cv: Updating root container children (%s remaining).", len(remaining_child_ids))
+            await cv_client.set_configlet_container(
+                workspace_id=workspace_id,
+                container_id=CONFIGLET_CONTAINER_ID,
+                child_assignment_ids=remaining_child_ids,
+            )
+        return
+
+    # No remaining children, delete the root container and unregister from studio roots.
+    LOGGER.info("delete_configs_from_cv: All device containers removed. Cleaning up root container.")
+    await cv_client.delete_configlet_container(workspace_id=workspace_id, assignment_id=CONFIGLET_CONTAINER_ID)
+
+    root_containers: list = await cv_client.get_studio_inputs_with_path(
+        studio_id=STATIC_CONFIGLET_STUDIO_ID,
+        workspace_id=workspace_id,
+        input_path=["configletAssignmentRoots"],
+        default_value=[],
+    )
+    if CONFIGLET_CONTAINER_ID in root_containers:
+        root_containers.remove(CONFIGLET_CONTAINER_ID)
+        await cv_client.set_studio_inputs(
+            studio_id=STATIC_CONFIGLET_STUDIO_ID,
+            workspace_id=workspace_id,
+            input_path=["configletAssignmentRoots"],
+            inputs=root_containers,
+        )

pyavd/_cv/workflows/deploy_to_cv.py

@@ -10,7 +10,7 @@ from pyavd._cv.client import CVClient
 from pyavd._cv.client.exceptions import CVClientException
 
 from .create_workspace_on_cv import create_workspace_on_cv
-from .deploy_configs_to_cv import deploy_configs_to_cv
+from .deploy_configs_to_cv import delete_configs_from_cv, deploy_configs_to_cv
 from .deploy_cv_pathfinder_metadata_to_cv import deploy_cv_pathfinder_metadata_to_cv
 from .deploy_static_config_studio_manifest_to_cv import deploy_static_config_studio_manifest_to_cv
 from .deploy_studio_inputs_to_cv import deploy_studio_inputs_to_cv
@@ -20,15 +20,13 @@ from .finalize_workspace_on_cv import finalize_workspace_on_cv
 from .models import (
     CloudVision,
     CVChangeControl,
-    CVDeviceTag,
-    CVEosConfig,
-    CVInterfaceTag,
-    CVPathfinderMetadata,
+    CVDeviceDeployment,
     CVStudioInputs,
     CVTimeOuts,
     CVWorkspace,
     DeployToCvResult,
 )
+from .utils import extract_from_device_deployments
 from .verify_devices_on_cv import verify_devices_on_cv
 from .verify_inputs import verify_device_inputs
 
@@ -42,12 +40,9 @@ async def deploy_to_cv(
     cloudvision: CloudVision,
     workspace: CVWorkspace | None = None,
     change_control: CVChangeControl | None = None,
-    configs: list[CVEosConfig] | None = None,
+    device_deployments: list[CVDeviceDeployment] | None = None,
     static_config_manifest: AvdManifest | None = None,
-    device_tags: list[CVDeviceTag] | None = None,
-    interface_tags: list[CVInterfaceTag] | None = None,
     studio_inputs: list[CVStudioInputs] | None = None,
-    cv_pathfinder_metadata: list[CVPathfinderMetadata] | None = None,
     skip_missing_devices: bool = False,
     strict_system_mac_address: bool = False,
     strict_tags: bool = True,
@@ -56,7 +51,7 @@ async def deploy_to_cv(
     """
     Deploy various objects to CloudVision.
 
-    For any device referred under `configs`, `device_tags` and `interface_tags` the device:
+    For any device referred under `device_deployments`:
     - The device must be present in the CloudVision Inventory and onboarded to the "Inventory & Topology Studio".
         - TODO: See if we can onboard ZTP devices and/or preprovision.
     - The hostname will we updated in the I&T Studio.
@@ -72,9 +67,8 @@ async def deploy_to_cv(
         change_control: CloudVision Change Control to create for the deployment. \
             It is not supported to reuse an existing Change Control, so the `id` field should not be set in the given CVChangeControl object. \
             The `id` and `state` properties will be inplace updated in the given CVChangeControl object.
-        configs: Configs to be deployed using the "Static Configlet Studio".
-        device_tags: Device Tags to be deployed and assigned.
-        interface_tags: Interface Tags to be deployed and assigned.
+        device_deployments: Per-device deployment objects containing configs, tags, and metadata to be deployed.
+        static_config_manifest: Static Configuration Studio manifest to deploy.
         studio_inputs: Studio Inputs to be deployed. \
             It is not supported to update overlapping input paths for the same studio in the same deployment.
         cv_pathfinder_metadata: Special metadata for CV Pathfinder solution. Metadata will be combined and deployed to the hidden metadata studio.
@@ -126,16 +120,24 @@ async def deploy_to_cv(
     """
     LOGGER.info("deploy_to_cv:")
     result = DeployToCvResult(workspace=workspace or CVWorkspace(), change_control=change_control)
-    if device_tags is None:
-        device_tags = []
-    if interface_tags is None:
-        interface_tags = []
-    if configs is None:
-        configs = []
+    if device_deployments is None:
+        device_deployments = []
     if studio_inputs is None:
         studio_inputs = []
-    if cv_pathfinder_metadata is None:
-        cv_pathfinder_metadata = []
+
+    # Extract sub-lists from device deployments.
+    # TODO: Refactor sub-workflows to accept list[CVDeviceDeployment] directly and extract what they need internally.
+    devices = [device_deployment.device for device_deployment in device_deployments]
+    configs, device_tags, interface_tags, cv_pathfinder_metadata = extract_from_device_deployments(device_deployments)
+
+    # Warn if devices are opted into the manifest but no manifest is provided.
+    if static_config_manifest is None and any(device_deployment.use_static_config_manifest for device_deployment in device_deployments):
+        manifest_device_count = sum(1 for device_deployment in device_deployments if device_deployment.use_static_config_manifest)
+        result.warnings.append(
+            f"{manifest_device_count} device(s) have 'cv_use_static_config_manifest' set to 'true' but no static config manifest was provided. "
+            "These devices will not have their configuration deployed to CloudVision."
+        )
+
     try:
         async with CVClient(
             servers=cloudvision.servers,
@@ -151,17 +153,6 @@ async def deploy_to_cv(
             # Create workspace
             await create_workspace_on_cv(workspace=result.workspace, cv_client=cv_client)
 
-            # Form deduplicated list of targeted CVDevices
-            devices = list(
-                {
-                    id(device): device
-                    for device in (
-                        [tag.device for tag in device_tags if tag.device is not None]
-                        + [tag.device for tag in interface_tags if tag.device is not None]
-                        + [config.device for config in configs if config.device is not None]
-                    )
-                }.values()
-            )
             # Check structured config of the targeted devices for overlapping `serial_number`s or `system_mac_address`es.
             verify_device_inputs(devices, result.warnings, strict_system_mac_address=strict_system_mac_address)
 
@@ -230,6 +221,13 @@ async def deploy_to_cv(
                     cv_client=cv_client,
                 )
 
+                # Delete any leftover device configs for devices managed by the static config manifest
+                await delete_configs_from_cv(
+                    device_deployments=device_deployments,
+                    result=result,
+                    cv_client=cv_client,
+                )
+
             except CVClientException as e:
                 result.errors.append(e)
                 result.failed = True

pyavd/_cv/workflows/models.py

@@ -270,6 +270,20 @@ class CVEosConfig:
     """By default "AVD_<hostname>"""
 
 
+@dataclass
+class CVDeviceDeployment:
+    """All deployment objects for a single device."""
+
+    device: CVDevice
+    use_static_config_manifest: bool = False
+    """When `True`, the device configuration is expected to be deployed via the static config manifest hierarchy
+    instead of the flat "AVD Configurations" layout."""
+    eos_config: CVEosConfig | None = None
+    device_tags: list[CVDeviceTag] = field(default_factory=list)
+    interface_tags: list[CVInterfaceTag] = field(default_factory=list)
+    cv_pathfinder_metadata: CVPathfinderMetadata | None = None
+
+
 @dataclass
 class CVTimeOuts:
     """Timeouts in seconds."""

pyavd/_cv/workflows/utils.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2023-2026 Arista Networks, Inc.
+# Use of this source code is governed by the Apache License 2.0
+# that can be found in the LICENSE file.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .models import CVDeviceDeployment, CVDeviceTag, CVEosConfig, CVInterfaceTag, CVPathfinderMetadata
+
+
+def extract_from_device_deployments(
+    device_deployments: list[CVDeviceDeployment],
+) -> tuple[list[CVEosConfig], list[CVDeviceTag], list[CVInterfaceTag], list[CVPathfinderMetadata]]:
+    """Extract configs, device tags, interface tags and pathfinder metadata from a list of CVDeviceDeployment objects."""
+    configs: list[CVEosConfig] = []
+    device_tags: list[CVDeviceTag] = []
+    interface_tags: list[CVInterfaceTag] = []
+    cv_pathfinder_metadata: list[CVPathfinderMetadata] = []
+    for device_deployment in device_deployments:
+        if device_deployment.eos_config is not None:
+            configs.append(device_deployment.eos_config)
+        device_tags.extend(device_deployment.device_tags)
+        interface_tags.extend(device_deployment.interface_tags)
+        if device_deployment.cv_pathfinder_metadata is not None:
+            cv_pathfinder_metadata.append(device_deployment.cv_pathfinder_metadata)
+    return configs, device_tags, interface_tags, cv_pathfinder_metadata