catalystwan 0.31.0.dev0__tar.gz → 0.31.0.dev2__tar.gz

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: catalystwan
-Version: 0.31.0.dev0
+Version: 0.31.0.dev2
 Summary: Cisco Catalyst WAN SDK for Python
 Home-page: https://github.com/CiscoDevNet/catalystwan
 Author: kagorski

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/catalystwan/api/configuration_groups/parcel.py

@@ -21,10 +21,10 @@ class _ParcelBase(BaseModel):
         validation_alias="description",
         description="Set the parcel description",
     )
-    # data: Optional[Any] = None
+    data: Optional[Any] = None
     _parcel_data_key: str = PrivateAttr(default="data")
 
-    @model_serializer(mode="wrap", when_used="json")
+    @model_serializer(mode="wrap")
     def envelope_parcel_data(self, handler) -> Dict[str, Any]:
         model_dict = handler(self)
         model_dict[self._parcel_data_key] = {}
@@ -49,7 +49,7 @@ class OptionType(str, Enum):
 
 
 class ParcelAttribute(BaseModel):
-    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+    model_config = ConfigDict(extra="forbid")
     option_type: OptionType = Field(serialization_alias="optionType", validation_alias="optionType")
 
 

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/catalystwan/api/partition_manager_api.py

@@ -1,11 +1,17 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Dict, List, Optional, cast
+from typing import TYPE_CHECKING, List, Optional, cast
 
 from catalystwan.api.task_status_api import Task
-from catalystwan.api.versions_utils import DeviceVersions, RemovePartitionPayload, RepositoryAPI
+from catalystwan.api.versions_utils import DeviceVersions, RepositoryAPI
 from catalystwan.dataclasses import Device
+from catalystwan.endpoints.configuration_device_actions import (
+    PartitionActionPayload,
+    RemovePartitionActionPayload,
+    RemovePartitionDevice,
+)
+from catalystwan.exceptions import EmptyVersionPayloadError
 from catalystwan.typed_list import DataSequence
 from catalystwan.utils.upgrades_helper import get_install_specification, validate_personality_homogeneity
 
@@ -60,14 +66,20 @@ class PartitionManagerAPI:
         else:
             payload_devices = self.device_version.get_devices_current_version(devices)
 
-        url = "/dataservice/device/action/defaultpartition"
-        payload = {
-            "action": "defaultpartition",
-            "devices": [device.model_dump() for device in payload_devices],  # type: ignore
-            "deviceType": get_install_specification(devices.first()).device_type.value,
-        }
-        set_default = dict(self.session.post(url, json=payload).json())
-        return Task(self.session, set_default["id"])
+        for device in payload_devices:
+            if not device.version:
+                raise EmptyVersionPayloadError("PartitionDevice payload contains entry with empty version field.")
+
+        device_type = get_install_specification(devices.first()).device_type.value
+        partition_payload = PartitionActionPayload(
+            action="defaultpartition", devices=[dev for dev in payload_devices], device_type=device_type
+        )
+
+        partition_action = self.session.endpoints.configuration_device_actions.process_mark_default_partition(
+            payload=partition_payload
+        )
+
+        return Task(self.session, partition_action.id)
 
     def remove_partition(
         self, devices: DataSequence[Device], partition: Optional[str] = None, force: bool = False
@@ -90,33 +102,36 @@ class PartitionManagerAPI:
         else:
             payload_devices = self.device_version.get_devices_available_versions(devices)
 
-        remove_partition_payload = [
-            RemovePartitionPayload(
-                device_id=device.device_id, device_ip=device.device_id, version=device.version
-            )  # type: ignore
-            for device in payload_devices
-        ]
-
-        url = "/dataservice/device/action/removepartition"
-        payload = {
-            "action": "removepartition",
-            "devices": [device.model_dump() for device in remove_partition_payload],  # type: ignore
-            "deviceType": get_install_specification(devices.first()).device_type.value,
-        }
+        for device in payload_devices:
+            if not device.version:
+                raise EmptyVersionPayloadError("PartitionDevice payload contains entry with empty version field.")
+
+        device_type = get_install_specification(devices.first()).device_type.value
+        partition_payload = RemovePartitionActionPayload(
+            action="removepartition",
+            devices=[RemovePartitionDevice(**dev.model_dump()) for dev in payload_devices],
+            device_type=device_type,
+        )
+
         if force is False:
-            self._check_remove_partition_possibility(cast(list, payload["devices"]))
-        remove_action: Dict[str, str] = self.session.post(url, json=payload).json()
-        return Task(self.session, remove_action["id"])
+            self._check_remove_partition_possibility(cast(list, partition_payload.devices))
+
+        partition_action = self.session.endpoints.configuration_device_actions.process_remove_partition(
+            payload=partition_payload
+        )
+
+        return Task(self.session, partition_action.id)
 
-    def _check_remove_partition_possibility(self, payload_devices: List[dict]) -> None:
+    def _check_remove_partition_possibility(self, payload_devices: List[RemovePartitionDevice]) -> None:
         devices_versions_repository = self.repository.get_devices_versions_repository()
         invalid_devices = []
         for device in payload_devices:
-            if device["version"] in (
-                devices_versions_repository[device["deviceId"]].current_version,
-                devices_versions_repository[device["deviceId"]].default_version,
-            ):
-                invalid_devices.append((device["deviceId"]))
+            for version in device.version:
+                if version in (
+                    devices_versions_repository[device.device_id].current_version,
+                    devices_versions_repository[device.device_id].default_version,
+                ):
+                    invalid_devices.append((device.device_id))
         if invalid_devices:
             raise ValueError(
                 f"Current or default version of devices with ids {invalid_devices} \

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/catalystwan/api/policy_api.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Tuple, Type, overload
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Type, overload
 from uuid import UUID
 
 from catalystwan.api.task_status_api import Task
@@ -637,12 +637,6 @@ class PolicyListsAPI:
             return endpoints.get_lists_by_id(id=id)
         return endpoints.get_policy_lists()
 
-    def get_all(self) -> List[AnyPolicyList]:
-        infos: List[AnyPolicyList] = []
-        for list_type, _ in POLICY_LIST_ENDPOINTS_MAP.items():
-            infos.extend(self.get(list_type))
-        return infos
-
 
 class PolicyDefinitionsAPI:
     def __init__(self, session: ManagerSession):
@@ -786,12 +780,6 @@ class PolicyDefinitionsAPI:
             return endpoints.get_policy_definition(id=id)
         return endpoints.get_definitions()
 
-    def get_all(self) -> List[Tuple[type, PolicyDefinitionInfo]]:
-        all_items: List[Tuple[type, PolicyDefinitionInfo]] = []
-        for definition_type, _ in POLICY_DEFINITION_ENDPOINTS_MAP.items():
-            all_items.extend([(definition_type, info) for info in self.get(definition_type)])
-        return all_items
-
 
 class PolicyAPI:
     """This is exposing so called 'UX 1.0' API"""

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/catalystwan/api/software_action_api.py

@@ -1,12 +1,18 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import TYPE_CHECKING, List, Optional, cast
 
 from catalystwan.api.task_status_api import Task
 from catalystwan.api.versions_utils import DeviceVersions, RepositoryAPI
 from catalystwan.dataclasses import Device
-from catalystwan.exceptions import VersionDeclarationError  # type: ignore
+from catalystwan.endpoints.configuration_device_actions import (
+    InstallActionPayload,
+    InstallDevice,
+    InstallInput,
+    PartitionActionPayload,
+)
+from catalystwan.exceptions import EmptyVersionPayloadError, VersionDeclarationError  # type: ignore
 from catalystwan.typed_list import DataSequence
 from catalystwan.utils.personality import Personality
 from catalystwan.utils.upgrades_helper import get_install_specification, validate_personality_homogeneity
@@ -58,7 +64,7 @@ class SoftwareActionAPI:
         Args:
             devices (List[Device]): For those devices software will be activated
             version_to_activate (Optional[str]): version to be set as current version
-            image (Optional[str]): path to software image
+            image (Optional[str]): path to software image or its name from available files
 
             Notice: Have to pass one of those arguments (version_to_activate,
             image)
@@ -74,14 +80,21 @@ class SoftwareActionAPI:
         else:
             raise VersionDeclarationError("You can not provide software_image and image version at the same time!")
 
-        url = "/dataservice/device/action/changepartition"
-        payload = {
-            "action": "changepartition",
-            "devices": [device.model_dump() for device in self.device_versions.get_device_available(version, devices)],
-            "deviceType": get_install_specification(devices.first()).device_type.value,
-        }
-        activate = dict(self.session.post(url, json=payload).json())
-        return Task(self.session, activate["id"])
+        payload_devices = self.device_versions.get_device_available(version, devices)
+        for device in payload_devices:
+            if not device.version:
+                raise EmptyVersionPayloadError("PartitionDevice payload contains entry with empty version field.")
+
+        device_type = get_install_specification(devices.first()).device_type.value
+        partition_payload = PartitionActionPayload(
+            action="changepartition", devices=[dev for dev in payload_devices], device_type=device_type
+        )
+
+        partition_action = self.session.endpoints.configuration_device_actions.process_mark_change_partition(
+            payload=partition_payload
+        )
+
+        return Task(self.session, partition_action.id)
 
     def install(
         self,
@@ -99,7 +112,7 @@ class SoftwareActionAPI:
             devices (List[Device]): For those devices software will be activated
             reboot (bool): reboot device after action end
             sync (bool, optional): Synchronize settings. Defaults to True.
-            image (str): path to software image
+            image (str): path to software image or its name from available files
             image_version (str): version of software image
             downgrade_check (bool): perform a downgrade check when applicable
 
@@ -119,32 +132,38 @@ class SoftwareActionAPI:
             version = cast(str, image_version)
         else:
             raise VersionDeclarationError("You can not provide image and image version at the same time")
+
         install_specification = get_install_specification(devices.first())
+        install_devices = [
+            InstallDevice(**device.model_dump(by_alias=True))
+            for device in self.device_versions.get_device_list(devices)
+        ]
+        input = InstallInput(
+            v_edge_vpn=0,
+            v_smart_vpn=0,
+            family=install_specification.family.value,
+            version=version,
+            version_type=install_specification.version_type.value,
+            reboot=reboot,
+            sync=sync,
+        )
+        device_type = install_specification.device_type.value
+        install_payload = InstallActionPayload(
+            action="install", input=input, devices=install_devices, device_type=device_type
+        )
 
-        url = "/dataservice/device/action/install"
-        payload: Dict[str, Any] = {
-            "action": "install",
-            "input": {
-                "vEdgeVPN": 0,
-                "vSmartVPN": 0,
-                "family": install_specification.family.value,
-                "version": version,
-                "versionType": install_specification.version_type.value,
-                "reboot": reboot,
-                "sync": sync,
-            },
-            "devices": [
-                {"deviceId": device.device_id, "deviceIP": device.device_ip}
-                for device in self.device_versions.get_device_list(devices)
-            ],  # type: ignore
-            "deviceType": install_specification.device_type.value,
-        }
         if downgrade_check and devices.first().personality in (Personality.VMANAGE, Personality.EDGE):
-            self._downgrade_check(payload["devices"], payload["input"]["version"], install_specification.family.value)
-        upgrade = dict(self.session.post(url, json=payload).json())
-        return Task(self.session, upgrade["id"])
+            self._downgrade_check(
+                install_payload.devices, install_payload.input.version, install_specification.family.value
+            )
+
+        install_action = self.session.endpoints.configuration_device_actions.process_install_operation(
+            payload=install_payload
+        )
+
+        return Task(self.session, install_action.id)
 
-    def _downgrade_check(self, payload_devices: List[dict], version_to_upgrade: str, family: str) -> None:
+    def _downgrade_check(self, payload_devices: List[InstallDevice], version_to_upgrade: str, family: str) -> None:
         """
         Check if upgrade operation is not actually a downgrade opeartion.
         If so, in some cases action is being blocked.
@@ -159,19 +178,18 @@ class SoftwareActionAPI:
         incorrect_devices = []
         devices_versions_repo = self.repository.get_devices_versions_repository()
         for device in payload_devices:
-            device_id = device["deviceId"]
-            current_version = parse_vmanage_version(devices_versions_repo[device_id].current_version)
+            current_version = parse_vmanage_version(devices_versions_repo[device.device_id].current_version)
             upgrade_version = parse_vmanage_version(version_to_upgrade)
             # check if downgrade
             if current_version > upgrade_version:
                 logger.warning(
-                    f"Requested to downgrade device: {device_id} from {current_version} to {upgrade_version}"
+                    f"Requested to downgrade device: {device.device_id} from {current_version} to {upgrade_version}"
                 )
                 # allow vmanage downgrade only if major and minor version match, downgrade for other devices is allowed
                 if family == "vmanage":
                     if not current_version.release[:2] == upgrade_version.release[:2]:
                         logger.error(
-                            f"Blocking downgrade of device: {device_id} "
+                            f"Blocking downgrade of device: {device.device_id} "
                             f"from {current_version.release} to {upgrade_version.release}"
                         )
                         incorrect_devices.append(device)

{catalystwan-0.31.0.dev0 → catalystwan-0.31.0.dev2}/catalystwan/api/versions_utils.py

@@ -4,15 +4,14 @@ import logging
 from pathlib import PurePath
 from typing import TYPE_CHECKING, Dict, List, Union
 
-from clint.textui.progress import Bar as ProgressBar  # type: ignore
 from pydantic import BaseModel, ConfigDict, Field
-from pydantic.functional_validators import BeforeValidator
-from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor  # type: ignore
-from typing_extensions import Annotated
 
 from catalystwan.dataclasses import Device
+from catalystwan.endpoints.configuration.software_actions import SoftwareImageDetails
+from catalystwan.endpoints.configuration_device_actions import PartitionDevice
 from catalystwan.exceptions import ImageNotInRepositoryError
 from catalystwan.typed_list import DataSequence
+from catalystwan.utils.upgrades_helper import SoftwarePackageUploadPayload
 
 if TYPE_CHECKING:
     from catalystwan.session import ManagerSession
@@ -37,25 +36,6 @@ class DeviceSoftwareRepository(BaseModel):
     device_id: str = Field(default="", serialization_alias="uuid", validation_alias="uuid")
 
 
-class DeviceVersionPayload(BaseModel):
-    device_id: str = Field(serialization_alias="deviceId")
-    device_ip: str = Field(serialization_alias="deviceIP")
-    version: Union[str, List[str]] = Field(default="")
-
-
-def convert_to_list(element: Union[str, List[str]]) -> List[str]:
-    return [element] if isinstance(element, str) else element
-
-
-VersionList = Annotated[Union[str, List[str]], BeforeValidator(convert_to_list)]
-
-
-class RemovePartitionPayload(BaseModel):
-    device_id: str = Field(serialization_alias="deviceId")
-    device_ip: str = Field(serialization_alias="deviceIP")
-    version: VersionList
-
-
 class RepositoryAPI:
     """
     API methods to get information about images and devices software versions
@@ -75,16 +55,14 @@ class RepositoryAPI:
     ):
         self.session = session
 
-    def get_all_software_images(self) -> list:
+    def get_all_software_images(self) -> DataSequence[SoftwareImageDetails]:
         """
-        Get all info about all software images stored
-        in Vmanage repository
+        Get all info about all software images stored in Vmanage repository
 
         Returns:
             list: software images list
         """
-        url = "/dataservice/device/action/software/images?imageType=software"
-        software_images = list(self.session.get_data(url))
+        software_images = self.session.endpoints.configuration_software_actions.get_list_of_all_images()
         return software_images
 
     def get_devices_versions_repository(self) -> Dict[str, DeviceSoftwareRepository]:
@@ -97,13 +75,18 @@ class RepositoryAPI:
             information
         """
 
-        url = "/dataservice/system/device/controllers"
-        controllers_versions_info = self.session.get_data(url)
-        url = "/dataservice/system/device/vedges"
-        edges_versions_info = self.session.get_data(url)
+        controllers_versions_info = self.session.endpoints.configuration_device_actions.get_list_of_installed_devices(
+            device_type="controller"
+        )
+        edges_versions_info = self.session.endpoints.configuration_device_actions.get_list_of_installed_devices(
+            device_type="vedge"
+        )
+        vmanages_versions_info = self.session.endpoints.configuration_device_actions.get_list_of_installed_devices(
+            device_type="vmanage"
+        )
         devices_versions_repository = {}
-        for device in controllers_versions_info + edges_versions_info:
-            device_software_repository = DeviceSoftwareRepository(**device)
+        for device in controllers_versions_info + edges_versions_info + vmanages_versions_info:
+            device_software_repository = DeviceSoftwareRepository(**device.model_dump(by_alias=True))
             device_software_repository.installed_versions = [a for a in device_software_repository.available_versions]
             device_software_repository.installed_versions.append(device_software_repository.current_version)
             devices_versions_repository[device_software_repository.device_id] = device_software_repository
@@ -111,7 +94,7 @@ class RepositoryAPI:
 
     def get_image_version(self, software_image: str) -> Union[str, None]:
         """
-        Get proper software image version
+        Get proper software image version, based on name in available files
 
         Args:
             software_image (str): path to software image
@@ -122,25 +105,16 @@ class RepositoryAPI:
 
         image_name = PurePath(software_image).name
         software_images = self.get_all_software_images()
-        for img in software_images:
-            if image_name in img["availableFiles"]:
-                image_version = img["versionName"]
+        for image in software_images:
+            if image.available_files and image_name in image.available_files:
+                image_version = image.version_name
                 return image_version
         logger.error(f"Software image {image_name} is not in available images")
         return None
 
-    def _create_callback(self, encoder: MultipartEncoder):
-        bar = ProgressBar(expected_size=encoder._calculate_length(), filled_char="=")
-
-        def callback(monitor: MultipartEncoderMonitor):
-            bar.show(monitor.bytes_read)
-
-        return callback
-
-    def upload_image(self, image_path: str) -> int:
+    def upload_image(self, image_path: str) -> None:
         """
-        Upload software image 'tar.gz' to Vmanage
-        software repository
+        Upload software image ('tar.gz' or 'SPA.bin') to vManage software repository
 
         Args:
             image_path (str): path to software image
@@ -148,21 +122,16 @@ class RepositoryAPI:
         Returns:
             str: Response status code
         """
-        url = "/dataservice/device/action/software/package"
-        encoder = MultipartEncoder(
-            fields={"file": (PurePath(image_path).name, open(image_path, "rb"), "application/x-gzip")}
+        self.session.endpoints.configuration_device_software_update.upload_software_to_manager(
+            payload=SoftwarePackageUploadPayload(image_path=image_path)
         )
-        callback = self._create_callback(encoder)
-        monitor = MultipartEncoderMonitor(encoder, callback)
-        upload = self.session.post(url, data=monitor, headers={"content-type": monitor.content_type})
-        return upload.status_code
 
-    def delete_image(self, image_name: str) -> int:
+    def delete_image(self, image_name: str) -> None:
         """
         Delete image from vManage software repository
 
         Args:
-            image_name (str): image name
+            image_name (str): image name (in available files)
 
         Raises:
             ImageNotInRepositoryError: raise error if image not in repository
@@ -171,11 +140,12 @@ class RepositoryAPI:
             int: Reponse status code
         """
         for image in self.get_all_software_images():
-            if image_name in image["availableFiles"]:
-                version_id = image["versionId"]
-                url = f"/dataservice/device/action/software/{version_id}"
-                delete = self.session.delete(url)
-                return delete.status_code
+            if image.available_files and image_name in image.available_files:
+                version_id = image.version_id
+                self.session.endpoints.configuration_software_actions.delete_software_from_software_repository(
+                    version_id=version_id
+                )
+                return None
         raise ImageNotInRepositoryError(f"Image: {image_name} is not the vManage software repository")
 
 
@@ -189,7 +159,7 @@ class DeviceVersions:
 
     def _get_device_list_in(
         self, version_to_set_up: str, devices: DataSequence[Device], version_type: str
-    ) -> DataSequence[DeviceVersionPayload]:
+    ) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included requested version, if requested version
         is in specified version type
@@ -203,8 +173,8 @@ class DeviceVersions:
             list : list of devices
         """
         devices_payload = DataSequence(
-            DeviceVersionPayload,
-            [DeviceVersionPayload(device_id=device.uuid, device_ip=device.id) for device in devices],
+            PartitionDevice,
+            [PartitionDevice(device_id=device.uuid, device_ip=device.id) for device in devices],
         )
         all_dev_versions = self.repository.get_devices_versions_repository()
         for device in devices_payload:
@@ -223,7 +193,7 @@ class DeviceVersions:
 
     def get_device_list_in_installed(
         self, version_to_set_up: str, devices: DataSequence[Device]
-    ) -> DataSequence[DeviceVersionPayload]:
+    ) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included requested version, if requested version
         is in installed versions
@@ -239,7 +209,7 @@ class DeviceVersions:
 
     def get_device_available(
         self, version_to_set_up: str, devices: DataSequence[Device]
-    ) -> DataSequence[DeviceVersionPayload]:
+    ) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included requested, if requested version
         is in available versions
@@ -256,7 +226,7 @@ class DeviceVersions:
 
     def _get_devices_chosen_version(
         self, devices: DataSequence[Device], version_type: str
-    ) -> DataSequence[DeviceVersionPayload]:
+    ) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included software version key
         for every device in devices list
@@ -269,15 +239,15 @@ class DeviceVersions:
             list : list of devices
         """
         devices_payload = DataSequence(
-            DeviceVersionPayload,
-            [DeviceVersionPayload(device_id=device.uuid, device_ip=device.id) for device in devices],
+            PartitionDevice,
+            [PartitionDevice(device_id=device.uuid, device_ip=device.id) for device in devices],
         )
         all_dev_versions = self.repository.get_devices_versions_repository()
         for device in devices_payload:
             device.version = getattr(all_dev_versions[device.device_id], version_type)
         return devices_payload
 
-    def get_devices_current_version(self, devices: DataSequence[Device]) -> DataSequence[DeviceVersionPayload]:
+    def get_devices_current_version(self, devices: DataSequence[Device]) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included current software version key
         for every device in devices list
@@ -292,7 +262,7 @@ class DeviceVersions:
 
         return self._get_devices_chosen_version(devices, "current_version")
 
-    def get_devices_available_versions(self, devices: DataSequence[Device]) -> DataSequence[DeviceVersionPayload]:
+    def get_devices_available_versions(self, devices: DataSequence[Device]) -> DataSequence[PartitionDevice]:
         """
         Create devices payload list included available software versions key
         for every device in devices list
@@ -306,5 +276,5 @@ class DeviceVersions:
 
         return self._get_devices_chosen_version(devices, "available_versions")
 
-    def get_device_list(self, devices: DataSequence[Device]) -> List[DeviceVersionPayload]:
-        return [DeviceVersionPayload(device_id=device.uuid, device_ip=device.id) for device in devices]  # type: ignore
+    def get_device_list(self, devices: DataSequence[Device]) -> List[PartitionDevice]:
+        return [PartitionDevice(device_id=device.uuid, device_ip=device.id) for device in devices]  # type: ignore