catalystwan 0.40.2.dev1__py3-none-any.whl → 2.0.0a1__py3-none-any.whl

catalystwan/utils/feature_template/find_template_values.py

@@ -1,111 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import Any, Dict, List, Optional, Union
-
-from catalystwan.api.templates.device_variable import DeviceVariable
-
-
-def find_template_values(
-    template_definition: dict,
-    templated_values: Optional[dict] = None,
-    target_key: str = "vipType",
-    target_key_value_to_ignore: str = "ignore",
-    target_key_for_template_value: str = "vipValue",
-    path: Optional[List[str]] = None,
-) -> Dict[str, Union[str, list, dict]]:
-    """Based on provided template definition generates a dictionary with template fields and values
-
-    Args:
-        template_definition: template definition provided as dict
-        templated_values: dictionary, empty at the beginning and filed out with names of fields as keys
-            and values of those fields as values
-        target_key: name of the key specifying if field is used in template, defaults to 'vipType'
-        target_key_value_to_ignore: value of the target key indicating
-            that field is not used in template, defaults to 'ignore'
-        target_key_for_template_value: name of the key specifying value of field used in template,
-            defaults to 'vipValue'
-        path: a list of keys indicating current path, defaults to None
-    Returns:
-        templated_values: dictionary containing template fields as key and values assigned to those fields as values
-    """
-    if path is None:
-        path = []
-    if templated_values is None:
-        templated_values = {}
-    # if value object is reached, try to extract the value
-    if target_key in template_definition:
-        if template_definition[target_key] == target_key_value_to_ignore:
-            return templated_values
-
-        value = template_definition[target_key]  # vipType
-        template_value = template_definition.get(target_key_for_template_value)
-
-        field_key = path[-1]
-        if value == "variableName":
-            # For example this is the current dictionary:
-            # field_key is "dns-addr"
-            # {
-            #     "vipType": "variableName",
-            #     "vipValue": "",
-            #     "vipObjectType": "object",
-            #     "vipVariableName": "vpn_dns_primary",
-            # }
-            # vipType is "variableName" so we need to return
-            # {"dns-addr": DeviceVariable(name="vpn_dns_primary")}
-            templated_values[field_key] = DeviceVariable(name=template_definition["vipVariableName"])
-            return templated_values
-
-        if template_value is None:
-            return template_definition
-
-        if template_definition["vipObjectType"] == "list":
-            current_nesting = get_nested_dict(templated_values, path[:-1])
-            current_nesting[field_key] = []
-            for item in template_value:
-                current_nesting[field_key].append(process_list_value(item))
-        elif template_definition["vipObjectType"] != "tree":
-            current_nesting = get_nested_dict(templated_values, path[:-1])
-            current_nesting[field_key] = template_value
-        elif isinstance(template_value, dict):
-            find_template_values(value, templated_values, path=path)
-        elif isinstance(template_value, list):
-            current_nesting = get_nested_dict(templated_values, path[:-1])
-            current_nesting[field_key] = []
-            for item in template_value:
-                item_value = find_template_values(item, {})
-                if item_value:
-                    current_nesting[field_key].append(item_value)
-        return templated_values
-
-    # iterate the dict to extract values and assign them to their fields
-    for key, value in template_definition.items():
-        if isinstance(value, dict) and value != target_key_value_to_ignore:
-            find_template_values(value, templated_values, path=path + [key])
-    return templated_values
-
-
-def get_nested_dict(d: dict, path: List[str], populate: bool = True):
-    current_dict = d
-    for path_key in path:
-        if path_key not in current_dict and populate:
-            current_dict[path_key] = {}
-        current_dict = current_dict[path_key]
-    return current_dict
-
-
-def process_list_value(item: Any, target_key: str = "vipType", target_key_for_template_value: str = "vipValue"):
-    if isinstance(item, dict):
-        if target_key in item:
-            if item["vipObjectType"] == "list":
-                result = []
-                for nested_item in item[target_key_for_template_value]:
-                    result.append(process_list_value(nested_item))
-                return result
-            elif item["vipObjectType"] == "tree":
-                return find_template_values(item[target_key_for_template_value])
-            else:
-                return item[target_key_for_template_value]
-        else:
-            return find_template_values(item)
-    else:
-        return item

catalystwan/utils/model.py

@@ -1,45 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from functools import lru_cache
-from inspect import isclass
-from typing import Any, List, Optional, Type, Union
-
-from pydantic import BaseModel
-from typing_extensions import Annotated, get_args, get_origin
-
-
-def resolve_nested_base_model_unions(
-    annotation: Any, models_types: List[Type[BaseModel]] = list()
-) -> List[Type[BaseModel]]:
-    """given something like AnyParcel produces flat list of BaseModel sub-types present in that union
-
-    Args:
-        annotation (Any): Union of BaseModels (could be Annotated and nested)
-        models_types (List[Type[BaseModel]], optional): used internally in recurence
-
-    Raises:
-        TypeError: when contents are not BaseModel (can be Annotated)
-
-    Returns:
-        List[Type[BaseModel]]: flat list of subclasses of BaseModel present in input
-    """
-
-    models_types = list(dict.fromkeys(models_types))
-
-    if isclass(annotation):
-        if issubclass(annotation, BaseModel):
-            return [annotation]
-
-    if get_origin(annotation) in [Annotated, Union]:
-        for arg in get_args(annotation):
-            models_types.extend(resolve_nested_base_model_unions(arg, models_types))
-        return list(dict.fromkeys(models_types))
-
-    return list()
-
-
-@lru_cache
-def get_model_type_field(model: Type[BaseModel]) -> Optional[str]:
-    if type_field := model.model_fields.get("type"):
-        if default_value := type_field.default:
-            return str(default_value)
-    return None

catalystwan/utils/operation_status.py

@@ -1,22 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-
-
-class OperationStatus(Enum):
-    IN_PROGRESS = "In progress"
-    FAILURE = "Failure"
-    SUCCESS = "Success"
-    SCHEDULED = "Scheduled"
-    SUCCESS_SCHEDULED = "Done - Scheduled"
-    VALIDATION_SUCCESS = "Validation success"
-    VALIDATION_FAILURE = "Validation failure"
-
-
-class OperationStatusId(Enum):
-    IN_PROGRESS = "in_progress"
-    FAILURE = "failure"
-    SUCCESS = "success"
-    SCHEDULED = "scheduled"
-    SUCCESS_SCHEDULED = "success_scheduled"
-    VALIDATION_SUCCESS = "validation_success"

catalystwan/utils/persona.py

@@ -1,5 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import Literal
-
-Persona = Literal["COMPUTE_AND_DATA", "COMPUTE", "DATA"]

catalystwan/utils/personality.py

@@ -1,10 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-
-
-class Personality(str, Enum):
-    VSMART = "vsmart"
-    VBOND = "vbond"
-    EDGE = "vedge"
-    VMANAGE = "vmanage"

catalystwan/utils/pydantic_field.py

@@ -1,12 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import Any, Optional
-
-from pydantic.fields import FieldInfo
-
-
-def get_extra_field(field_info: FieldInfo, key: str, default: Optional[Any] = None) -> Any:
-    try:
-        return field_info.json_schema_extra.get(key, default)  # type: ignore
-    except AttributeError:
-        return default

catalystwan/utils/reachability.py

@@ -1,14 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-
-
-class Reachability(str, Enum):
-    REACHABLE = "reachable"
-    UNREACHABLE = "unreachable"
-    UNKNOWN = "unknown"
-
-    @classmethod
-    def _missing_(cls, value):
-        # Value emitted by Manager ver. 20.10 can be None
-        return cls.UNKNOWN

catalystwan/utils/session_type.py

@@ -1,17 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum, auto
-
-
-class SessionType(Enum):
-    SINGLE_TENANT = auto()
-    PROVIDER = auto()
-    TENANT = auto()
-    PROVIDER_AS_TENANT = auto()
-    NOT_DEFINED = auto()
-
-
-ProviderView = SessionType.PROVIDER
-TenantView = SessionType.TENANT
-ProviderAsTenantView = SessionType.PROVIDER_AS_TENANT
-SingleTenantView = SessionType.SINGLE_TENANT

catalystwan/utils/template_type.py

@@ -1,8 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-
-
-class TemplateType(Enum):
-    CLI = "file"
-    FEATURE = "template"

catalystwan/utils/type_check.py

@@ -1,22 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-import uuid
-
-from pydantic import ValidationError
-
-from catalystwan.api.configuration_groups.parcel import Variable
-
-
-def is_str_uuid(value: str) -> bool:
-    try:
-        uuid_ = uuid.UUID(value)
-        return str(uuid_) == value or uuid_.hex == value
-    except ValueError:
-        return False
-
-
-def is_str_variable(value: str) -> bool:
-    try:
-        Variable(value=value)
-        return True
-    except ValidationError:
-        return False

catalystwan/utils/upgrades_helper.py

@@ -1,95 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-from pathlib import PurePath
-
-from attr import define  # type: ignore
-from clint.textui.progress import Bar as ProgressBar  # type: ignore
-from requests_toolbelt.multipart.encoder import MultipartEncoder, MultipartEncoderMonitor  # type: ignore
-
-from catalystwan.endpoints import CustomPayloadType, PreparedPayload
-from catalystwan.endpoints.configuration_device_inventory import DeviceDetailsResponse
-from catalystwan.exceptions import MultiplePersonalityError
-from catalystwan.typed_list import DataSequence
-from catalystwan.utils.personality import Personality
-
-
-class Family(Enum):
-    VEDGE = "vedge"
-    VMANAGE = "vmanage"
-    VEDGE_X86 = "vedge-x86"
-    C8000V = "c8000v"
-
-
-class VersionType(Enum):
-    VMANAGE = "vmanage"
-    REMOTE = "remote"
-
-
-class DeviceType(Enum):
-    CONTROLLER = "controller"
-    VEDGE = "vedge"
-    VMANAGE = "vmanage"
-
-
-@define
-class InstallSpecification:
-    family: Family
-    version_type: VersionType
-    device_type: DeviceType
-
-
-class InstallSpecHelper(Enum):
-    """
-    Container class for storage payload data for all personalities.
-    It's created, because personality is not clearly connected to Family, VersionType
-    or DeviceType
-    """
-
-    VMANAGE = InstallSpecification(Family.VMANAGE, VersionType.VMANAGE, DeviceType.VMANAGE)  # type: ignore
-    VSMART = InstallSpecification(Family.VEDGE, VersionType.VMANAGE, DeviceType.CONTROLLER)  # type: ignore
-    VBOND = InstallSpecification(Family.VEDGE, VersionType.VMANAGE, DeviceType.CONTROLLER)  # type: ignore
-    VEDGE = InstallSpecification(Family.VEDGE, VersionType.VMANAGE, DeviceType.VEDGE)  # type: ignore
-    REMOTE_VMANAGE = InstallSpecification(Family.VMANAGE, VersionType.REMOTE, DeviceType.VMANAGE)  # type: ignore
-    REMOTE_VSMART = InstallSpecification(Family.VEDGE_X86, VersionType.REMOTE, DeviceType.CONTROLLER)  # type: ignore
-    REMOTE_VBOND = InstallSpecification(Family.VEDGE_X86, VersionType.REMOTE, DeviceType.CONTROLLER)  # type: ignore
-    REMOTE_VEDGE = InstallSpecification(Family.C8000V, VersionType.REMOTE, DeviceType.VEDGE)  # type: ignore
-
-
-def get_install_specification(device: DeviceDetailsResponse, remote: bool = False):
-    specification_container = {
-        Personality.VMANAGE: InstallSpecHelper.REMOTE_VMANAGE.value if remote else InstallSpecHelper.VMANAGE.value,
-        Personality.VBOND: InstallSpecHelper.REMOTE_VBOND.value if remote else InstallSpecHelper.VBOND.value,
-        Personality.VSMART: InstallSpecHelper.REMOTE_VSMART.value if remote else InstallSpecHelper.VSMART.value,
-        Personality.EDGE: InstallSpecHelper.REMOTE_VEDGE.value if remote else InstallSpecHelper.VEDGE.value,
-    }
-    return specification_container[device.personality]  # type: ignore
-
-
-def validate_personality_homogeneity(devices: DataSequence[DeviceDetailsResponse]):
-    personalities = set([device.personality for device in devices])
-    if not len(personalities) == 1:
-        raise MultiplePersonalityError(
-            f"devices has got more than 1 personality, devices personalities: {personalities}"
-        )
-
-
-class SoftwarePackageUploadPayload(CustomPayloadType):
-    def __init__(self, image_path: str):
-        encoder = MultipartEncoder(
-            fields={"file": (PurePath(image_path).name, open(image_path, "rb"), "application/x-gzip")}
-        )
-        callback = self._create_callback(encoder)
-        monitor = MultipartEncoderMonitor(encoder, callback)
-        self.payload = PreparedPayload(data=monitor, headers={"content-type": monitor.content_type})
-
-    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 prepared(self) -> PreparedPayload:
-        return self.payload

catalystwan/utils/validate_status.py

@@ -1,8 +0,0 @@
-# Copyright 2022 Cisco Systems, Inc. and its affiliates
-
-from enum import Enum
-
-
-class ValidateStatus(Enum):
-    validate = "valid"
-    invalidate = "invalid"