catalystwan 0.41.2.dev9__py3-none-any.whl → 0.41.3__py3-none-any.whl

catalystwan/models/configuration/feature_profile/parcel.py

@@ -1,245 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from functools import lru_cache
-from typing import Generic, List, Literal, Optional, Sequence, Type, TypeVar, Union, cast
-from uuid import UUID
-
-from pydantic import AliasChoices, BaseModel, ConfigDict, Field, model_validator
-from typing_extensions import Annotated
-
-from catalystwan.api.configuration_groups.parcel import _ParcelBase
-from catalystwan.exceptions import ModelNotFound
-from catalystwan.models.configuration.feature_profile.sdwan.application_priority import AnyApplicationPriorityParcel
-from catalystwan.models.configuration.feature_profile.sdwan.cli import AnyCliParcel
-from catalystwan.models.configuration.feature_profile.sdwan.dns_security import AnyDnsSecurityParcel
-from catalystwan.models.configuration.feature_profile.sdwan.embedded_security import AnyEmbeddedSecurityParcel
-from catalystwan.models.configuration.feature_profile.sdwan.other import AnyOtherParcel
-from catalystwan.models.configuration.feature_profile.sdwan.policy_object import AnyPolicyObjectParcel
-from catalystwan.models.configuration.feature_profile.sdwan.routing import AnyRoutingParcel
-from catalystwan.models.configuration.feature_profile.sdwan.service import AnyServiceParcel
-from catalystwan.models.configuration.feature_profile.sdwan.sig_security import AnySIGSecurityParcel
-from catalystwan.models.configuration.feature_profile.sdwan.system import AnySystemParcel
-from catalystwan.models.configuration.feature_profile.sdwan.topology import AnyTopologyParcel
-from catalystwan.models.configuration.feature_profile.sdwan.trackers import AnyTrackerParcel
-from catalystwan.models.configuration.feature_profile.sdwan.transport import AnyTransportParcel
-from catalystwan.models.configuration.feature_profile.sdwan.uc_voice import AnyUcVoiceParcel
-from catalystwan.models.configuration.network_hierarchy import AnyNetworkHierarchyParcel
-from catalystwan.utils.model import resolve_nested_base_model_unions
-
-ParcelType = Literal[
-    "aaa",
-    "analog-interface",
-    "app-list",
-    "app-probe",
-    "appqoe",
-    "as-path",
-    "banner",
-    "basic",
-    "bfd",
-    "bgp",
-    "call-routing",
-    "cellular-controller",
-    "cellular-profile",
-    "cflowd",
-    "class",
-    "color",
-    "config",
-    "custom-control",
-    "data-ipv6-prefix",
-    "data-prefix",
-    "dhcp-server",
-    "digital-interface",
-    "dns",
-    "dsp-farm",
-    "expanded-community",
-    "ext-community",
-    "full-config",
-    "global",
-    "gps",
-    "hubspoke",
-    "ipv4-acl",
-    "ipv6-acl",
-    "ipv6-prefix",
-    "lan/vpn",
-    "lan/vpn/interface/ethernet",
-    "lan/vpn/interface/gre",
-    "lan/vpn/interface/ipsec",
-    "lan/vpn/interface/multilink",
-    "lan/vpn/interface/svi",
-    "logging",
-    "management/vpn",
-    "management/vpn/interface/ethernet",
-    "media-profile",
-    "mesh",
-    "mirror",
-    "mrf",
-    "ntp",
-    "omp",
-    "policer",
-    "policy-settings",
-    "policy",
-    "preferred-color-group",
-    "prefix",
-    "qos-policy",
-    "route-policy",
-    "routing/bgp",
-    "routing/eigrp",
-    "routing/multicast",
-    "routing/ospf",
-    "routing/ospfv3/ipv4",
-    "routing/ospfv3/ipv6",
-    "security-data-ip-prefix",
-    "security-fqdn",
-    "security-geolocation",
-    "security-identity",
-    "security-ipssignature",
-    "security-localapp",
-    "security-localdomain",
-    "security-logging",
-    "security-port",
-    "security-protocolname",
-    "security-scalablegrouptag",
-    "security-urllist",
-    "security-zone",
-    "security",
-    "server-group",
-    "sig",
-    "sla-class",
-    "snmp",
-    "standard-community",
-    "strt",
-    "supervisory-disconnect",
-    "switchport",
-    "t1-e1-controller",
-    "tloc",
-    "tracker",
-    "trackergroup",
-    "ipv6-tracker",
-    "ipv6-trackergroup",
-    "traffic-policy",
-    "trunk-group",
-    "unified/advanced-inspection-profile",
-    "unified/advanced-malware-protection",
-    "unified/intrusion-prevention",
-    "unified/ngfirewall",
-    "unified/ssl-decryption-profile",
-    "unified/ssl-decryption",
-    "unified/url-filtering",
-    "voice-global",
-    "voice-tenant",
-    "wan/vpn",
-    "wan/vpn/interface/cellular",
-    "wan/vpn/interface/dsl-ipoe",
-    "wan/vpn/interface/dsl-pppoa",
-    "wan/vpn/interface/dsl-pppoe",
-    "wan/vpn/interface/ethernet",
-    "wan/vpn/interface/ethpppoe",
-    "wan/vpn/interface/gre",
-    "wan/vpn/interface/ipsec",
-    "wan/vpn/interface/multilink",
-    "wan/vpn/interface/serial",
-    "wirelesslan",
-]
-
-
-AnyParcel = Annotated[
-    Union[
-        AnyApplicationPriorityParcel,
-        AnyCliParcel,
-        AnyDnsSecurityParcel,
-        AnyEmbeddedSecurityParcel,
-        AnyNetworkHierarchyParcel,
-        AnyOtherParcel,
-        AnyPolicyObjectParcel,
-        AnyRoutingParcel,
-        AnyTrackerParcel,
-        AnyServiceParcel,
-        AnySIGSecurityParcel,
-        AnySystemParcel,
-        AnyTopologyParcel,
-        AnyTransportParcel,
-        AnyUcVoiceParcel,
-    ],
-    Field(discriminator="type_"),
-]
-
-T = TypeVar("T", bound=AnyParcel)
-UT = TypeVar("UT", bound=_ParcelBase)
-
-
-class Parcel(BaseModel, Generic[T]):
-    parcel_id: UUID = Field(alias="parcelId")
-    parcel_type: ParcelType = Field(alias="parcelType")
-    created_by: str = Field(alias="createdBy")
-    last_updated_by: Optional[str] = Field(default=None, alias="lastUpdatedBy")
-    created_on: int = Field(alias="createdOn")
-    last_updated_on: Optional[int] = Field(default=None, alias="lastUpdatedOn")
-    origin: Optional[str] = Field(default=None)
-    payload: T
-
-    @model_validator(mode="before")
-    def validate_payload(cls, data):
-        if not isinstance(data, dict):
-            return data
-        type_ = data.get("parcelType") or data.get("type")
-        id_ = data.get("parcelId") or data.get("id")
-        assert type_ is not None
-        assert id_ is not None
-        data["parcelType"] = type_
-        data["payload"]["type_"] = type_
-        data["parcelId"] = id_
-        return data
-
-    def model_post_init(self, __context):
-        """We do not want to store the JSON as dict data in the 'data' field, as it is already deserialized"""
-        self.payload.data = None
-
-
-class Header(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-
-    generated_on: int = Field(alias="generatedOn")
-
-
-class ParcelInfo(BaseModel, Generic[T]):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    header: Header
-    data: List[Parcel[T]]
-
-
-class ParcelSequence(BaseModel, Generic[T]):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    header: Header
-    data: List[Parcel[T]]
-
-
-class ParcelCreationResponse(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-
-    id: UUID = Field(validation_alias=AliasChoices("parcelId", "featureId"))  # Accept both keys
-
-
-class ParcelAssociationPayload(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-    parcel_id: UUID = Field(serialization_alias="parcelId", validation_alias="parcelId")
-
-
-class ParcelId(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    id: UUID = Field(serialization_alias="parcelId", validation_alias="parcelId")
-
-
-@lru_cache
-def list_types(any_union: Type[UT]) -> Sequence[UT]:
-    return cast(Sequence[UT], resolve_nested_base_model_unions(any_union))
-
-
-@lru_cache
-def find_type(name: str, any_union: Type[UT]) -> UT:
-    parcel_types = list_types(any_union)
-    try:
-        parcel_type = next(t for t in parcel_types if t._get_parcel_type() == name)
-    except StopIteration:
-        raise ModelNotFound(name, any_union)
-    return cast(UT, parcel_type)

catalystwan/models/configuration/feature_profile/sdwan/acl/__init__.py

@@ -1,13 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-from typing import Union
-
-from pydantic import Field
-from typing_extensions import Annotated
-
-from .ipv4acl import Ipv4AclParcel
-from .ipv6acl import Ipv6AclParcel
-
-AnyAclParcel = Annotated[
-    Union[Ipv4AclParcel, Ipv6AclParcel],
-    Field(discriminator="type_"),
-]

catalystwan/models/configuration/feature_profile/sdwan/acl/ipv4acl.py

@@ -1,298 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from ipaddress import IPv4Address, IPv4Interface
-from typing import List, Literal, Optional, Tuple, Union
-from uuid import UUID
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, model_validator
-
-from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase, as_global, as_variable
-from catalystwan.models.common import AcceptDropActionType, IcmpMsgType, check_fields_exclusive
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
-
-
-class SourceDataPrefixList(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    source_data_prefix_list: Optional[RefIdItem] = Field(
-        default=None, validation_alias="sourceDataPrefixList", serialization_alias="sourceDataPrefixList"
-    )
-
-
-class SourceDataPrefix(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    source_ip_prefix: Union[Variable, Global[str]] = Field(
-        validation_alias="sourceIpPrefix", serialization_alias="sourceIpPrefix"
-    )
-
-
-class SourcePorts(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    source_port: Union[Global[str], Global[int], None] = Field(
-        default=None, validation_alias="sourcePort", serialization_alias="sourcePort"
-    )
-
-
-class DestinationDataPrefixList(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    destination_data_prefix_list: Optional[RefIdItem] = Field(
-        default=None, validation_alias="destinationDataPrefixList", serialization_alias="destinationDataPrefixList"
-    )
-
-
-class DestinationDataPrefix(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    destination_ip_prefix: Union[Variable, Global[str]] = Field(
-        validation_alias="destinationIpPrefix", serialization_alias="destinationIpPrefix"
-    )
-
-
-class DestinationPorts(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    destination_port: Union[Global[str], Global[int], None] = Field(
-        default=None, validation_alias="destinationPort", serialization_alias="destinationPort"
-    )
-
-
-class MatchEntry(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
-    destination_data_prefix: Union[DestinationDataPrefix, DestinationDataPrefixList, None] = Field(
-        default=None, validation_alias="destinationDataPrefix", serialization_alias="destinationDataPrefix"
-    )
-    destination_ports: Optional[List[DestinationPorts]] = Field(
-        default=None,
-        validation_alias="destinationPorts",
-        serialization_alias="destinationPorts",
-        description="Destination Port List",
-    )
-    dscp: Optional[Global[List[int]]] = Field(default=None)
-    icmp_msg: Optional[Global[List[IcmpMsgType]]] = Field(
-        default=None, validation_alias="icmpMsg", serialization_alias="icmpMsg"
-    )
-    packet_length: Union[Global[str], Global[int], None] = Field(
-        default=None, validation_alias="packetLength", serialization_alias="packetLength"
-    )
-    protocol: Optional[Global[List[int]]] = Field(default=None)
-    source_data_prefix: Union[SourceDataPrefix, SourceDataPrefixList, None] = Field(
-        default=None, validation_alias="sourceDataPrefix", serialization_alias="sourceDataPrefix"
-    )
-    source_ports: Optional[List[SourcePorts]] = Field(
-        default=None,
-        validation_alias="sourcePorts",
-        serialization_alias="sourcePorts",
-        description="Source Port List",
-    )
-    tcp: Optional[Global[Literal["syn"]]] = Field(default=None)
-
-
-class Accept(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    counter_name: Optional[Global[str]] = Field(
-        default=None, validation_alias="counterName", serialization_alias="counterName"
-    )
-    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
-    mirror: Optional[RefIdItem] = Field(default=None)
-    policer: Optional[RefIdItem] = Field(default=None)
-    set_dscp: Optional[Global[int]] = Field(default=None, validation_alias="setDscp", serialization_alias="setDscp")
-    set_next_hop: Optional[Global[str]] = Field(
-        default=None, validation_alias="setNextHop", serialization_alias="setNextHop"
-    )
-
-
-class AcceptAction(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
-    accept: Accept = Field(description="Accept Action")
-
-
-class Drop(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    counter_name: Optional[Global[str]] = Field(
-        default=None, validation_alias="counterName", serialization_alias="counterName"
-    )
-    log: Optional[Union[Global[bool], Default[bool]]] = Field(default=None)
-
-
-class DropAction(BaseModel):
-    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
-    drop: Drop = Field(description="Drop Action")
-
-
-class Sequence(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    actions: Optional[List[Union[AcceptAction, DropAction]]] = Field(
-        default=None, description="Define list of actions", max_length=1, min_length=1
-    )
-    base_action: Optional[Union[Global[AcceptDropActionType], Default[Literal["accept"]]]] = Field(
-        default=None, validation_alias="baseAction", serialization_alias="baseAction"
-    )
-    match_entries: Optional[List[MatchEntry]] = Field(
-        default=None,
-        validation_alias="matchEntries",
-        serialization_alias="matchEntries",
-        description="Define match conditions",
-        max_length=1,
-        min_length=1,
-    )
-    sequence_id: Optional[Global[int]] = Field(
-        default=None, validation_alias="sequenceId", serialization_alias="sequenceId"
-    )
-    sequence_name: Optional[Global[str]] = Field(
-        default=None, validation_alias="sequenceName", serialization_alias="sequenceName"
-    )
-
-    @model_validator(mode="after")
-    def check_base_action_xor_actions(self):
-        check_fields_exclusive(self.__dict__, {"base_action", "actions"}, True)
-        return self
-
-    def _action(self, mode: Optional[AcceptDropActionType] = None) -> Union[AcceptAction, DropAction]:
-        if mode is None and self.base_action is not None:
-            _mode = self.base_action.value
-        else:
-            _mode = mode
-        self.base_action = None
-        if self.actions is None:
-            if _mode == "drop":
-                self.actions = [(DropAction(drop=Drop()))]
-            else:
-                self.actions = [(AcceptAction(accept=Accept()))]
-        return self.actions[0]
-
-    @property
-    def _accept_action(self) -> Accept:
-        action = self._action("accept")
-        assert isinstance(action, AcceptAction), "Sequence action must be set to accept"
-        return action.accept
-
-    @property
-    def _drop_action(self) -> Drop:
-        action = self._action("drop")
-        assert isinstance(action, DropAction), "Sequence action must be set to drop"
-        return action.drop
-
-    @property
-    def _entry(self) -> MatchEntry:
-        if self.match_entries is None:
-            self.match_entries = [MatchEntry()]
-        return self.match_entries[0]
-
-    def match_destination_data_prefix(self, prefix: IPv4Interface):
-        value = as_global(str(prefix))
-        self._entry.destination_data_prefix = DestinationDataPrefix(destination_ip_prefix=value)
-
-    def match_destination_data_prefix_variable(self, prefix: str):
-        value = as_variable(prefix)
-        self._entry.destination_data_prefix = DestinationDataPrefix(destination_ip_prefix=value)
-
-    def match_destination_data_prefix_list(self, prefix: UUID):
-        self._entry.destination_data_prefix = DestinationDataPrefixList(
-            destination_data_prefix_list=RefIdItem.from_uuid(prefix)
-        )
-
-    def match_destination_ports(self, ports: List[Union[int, Tuple[int, int]]]):
-        """
-        ports argument example: [1, 3, (10,100), (50,200), 600]
-        """
-        destination_ports = []
-        for port in ports:
-            if isinstance(port, int):
-                value = as_global(port)
-            else:
-                value = as_global(f"{port[0]}-{port[1]}")
-            destination_ports.append(DestinationPorts(destination_port=value))
-        self._entry.destination_ports = destination_ports
-
-    def match_dscp(self, dscp: List[int]):
-        self._entry.dscp = as_global(dscp)
-
-    def match_icmp_msg(self, icmp: List[IcmpMsgType]):
-        self._entry.icmp_msg = Global[List[IcmpMsgType]](value=icmp)
-
-    def match_packet_length(self, len: Union[int, Tuple[int, int]]):
-        if isinstance(len, int):
-            value = as_global(len)
-        else:
-            value = as_global(f"{len[0]}-{len[1]}")
-        self._entry.packet_length = value
-
-    def match_protocol(self, protocols: List[int]):
-        self._entry.protocol = as_global(protocols)
-
-    def match_source_data_prefix(self, prefix: IPv4Interface):
-        value = as_global(str(prefix))
-        self._entry.source_data_prefix = SourceDataPrefix(source_ip_prefix=value)
-
-    def match_source_data_prefix_variable(self, prefix: str):
-        value = as_variable(prefix)
-        self._entry.source_data_prefix = SourceDataPrefix(source_ip_prefix=value)
-
-    def match_source_data_prefix_list(self, prefix: UUID):
-        self._entry.source_data_prefix = SourceDataPrefixList(source_data_prefix_list=RefIdItem.from_uuid(prefix))
-
-    def match_source_ports(self, ports: List[Union[int, Tuple[int, int]]]):
-        """
-        ports argument example: [1, 3, (10,100), (50,200), 600]
-        """
-        source_ports = []
-        for port in ports:
-            if isinstance(port, int):
-                value = as_global(port)
-            else:
-                value = as_global(f"{port[0]}-{port[1]}")
-            source_ports.append(SourcePorts(source_port=value))
-        self._entry.source_ports = source_ports
-
-    def match_tcp(self):
-        self._entry.tcp = as_global("syn", Literal["syn"])
-
-    def associate_log_action(self):
-        if isinstance(self._action(), DropAction):
-            self._drop_action.log = as_global(True)
-        else:
-            self._accept_action.log = as_global(True)
-
-    def associate_counter_action(self, name: str):
-        if isinstance(self._action(), DropAction):
-            self._drop_action.counter_name = as_global(name)
-        else:
-            self._accept_action.counter_name = as_global(name)
-
-    def associate_mirror_action(self, mirror: UUID):
-        self._accept_action.mirror = RefIdItem(ref_id=as_global(str(mirror)))
-
-    def associate_policer_action(self, policer: UUID):
-        self._accept_action.policer = RefIdItem(ref_id=as_global(str(policer)))
-
-    def associate_set_dscp_action(self, dscp: int):
-        self._accept_action.set_dscp = as_global(dscp)
-
-    def associate_set_next_hop_action(self, next_hop: IPv4Address):
-        self._accept_action.set_next_hop = as_global(str(next_hop))
-
-
-class Ipv4AclParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True, validate_assignment=True)
-    type_: Literal["ipv4-acl"] = Field(default="ipv4-acl", exclude=True)
-    default_action: Union[Global[AcceptDropActionType], Default[Literal["drop"]]] = Field(
-        default=Default[Literal["drop"]](value="drop"), validation_alias=AliasPath("data", "defaultAction")
-    )
-    sequences: List[Sequence] = Field(
-        default_factory=list, validation_alias=AliasPath("data", "sequences"), description="Access Control List"
-    )
-
-    def set_default_action(self, action: AcceptDropActionType):
-        self.default_action = as_global(action, AcceptDropActionType)
-
-    def add_sequence(self, name: str, id_: int, base_action: Optional[AcceptDropActionType] = None) -> Sequence:
-        if base_action is not None:
-            _base_action = as_global(base_action, AcceptDropActionType)
-        else:
-            _base_action = Default[Literal["accept"]](value="accept")
-        seq = Sequence(
-            base_action=_base_action,
-            sequence_id=as_global(id_),
-            sequence_name=as_global(name),
-        )
-        if self.sequences is None:
-            self.sequences = [seq]
-        else:
-            self.sequences.append(seq)
-        return seq