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

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/policer.py

@@ -1,42 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal
-
-from pydantic import AliasPath, ConfigDict, Field, field_validator
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.policy.list.policer import PolicerExceedAction
-
-
-class PolicerEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    burst: Global[int]
-    exceed: Global[PolicerExceedAction]
-    rate: Global[int]
-
-    @field_validator("burst")
-    @classmethod
-    def check_burst(cls, burst_str: Global[int]):
-        assert 15000 <= burst_str.value <= 10_000_000
-        return burst_str
-
-    @field_validator("rate")
-    @classmethod
-    def check_rate(cls, rate_str: Global[int]):
-        assert 8 <= rate_str.value <= 100_000_000_000
-        return rate_str
-
-
-class PolicerParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["policer"] = Field(default="policer", exclude=True)
-    entries: List[PolicerEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_entry(self, burst: int, exceed: PolicerExceedAction, rate: int):
-        self.entries.append(
-            PolicerEntry(
-                burst=as_global(burst),
-                exceed=as_global(exceed, PolicerExceedAction),
-                rate=as_global(rate),
-            )
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/prefered_group_color.py

@@ -1,83 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator, model_validator
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.common import TLOCColor
-
-PathPreference = Literal[
-    "direct-path",
-    "multi-hop-path",
-    "all-paths",
-]
-
-
-class Preference(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-    color_preference: Global[List[TLOCColor]] = Field(
-        serialization_alias="colorPreference", validation_alias="colorPreference"
-    )
-    path_preference: Global[PathPreference] = Field(
-        serialization_alias="pathPreference", validation_alias="pathPreference"
-    )
-
-
-class PreferredColorGroupEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    primary_preference: Preference = Field(
-        serialization_alias="primaryPreference", validation_alias="primaryPreference"
-    )
-    secondary_preference: Optional[Preference] = Field(
-        None, serialization_alias="secondaryPreference", validation_alias="secondaryPreference"
-    )
-    tertiary_preference: Optional[Preference] = Field(
-        None, serialization_alias="tertiaryPreference", validation_alias="tertiaryPreference"
-    )
-
-    @model_validator(mode="after")
-    def check_passwords_match(self) -> "PreferredColorGroupEntry":
-        if not self.secondary_preference and self.tertiary_preference:
-            raise ValueError("Preference Entry has to have a secondary prefrence when assigning tertiary preference.")
-        return self
-
-    @field_validator("secondary_preference", "tertiary_preference", mode="before")
-    @classmethod
-    def remove_empty_preferences(cls, value):
-        """handle a situation when server returns empty json object: '{}'"""
-        if not value:
-            return None
-        return value
-
-
-class PreferredColorGroupParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["preferred-color-group"] = Field(default="preferred-color-group", exclude=True)
-    entries: List[PreferredColorGroupEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_primary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
-        self.entries.append(
-            PreferredColorGroupEntry(
-                primary_preference=Preference(
-                    color_preference=Global[List[TLOCColor]](value=color_preference),
-                    path_preference=as_global(path_preference, PathPreference),
-                ),
-                secondary_preference=None,
-                tertiary_preference=None,
-            )
-        )
-
-    def add_secondary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
-        preferred_color = self.entries[0]
-        preferred_color.secondary_preference = Preference(
-            color_preference=Global[List[TLOCColor]](value=color_preference),
-            path_preference=as_global(path_preference, PathPreference),
-        )
-
-    def add_tertiary(self, color_preference: List[TLOCColor], path_preference: PathPreference):
-        preferred_color = self.entries[0]
-        preferred_color.tertiary_preference = Preference(
-            color_preference=Global[List[TLOCColor]](value=color_preference),
-            path_preference=as_global(path_preference, PathPreference),
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/prefix_list.py

@@ -1,28 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from ipaddress import IPv4Address, IPv4Network
-from typing import List, Literal
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-
-
-class PrefixListEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    ipv4_address: Global[IPv4Address] = Field(serialization_alias="ipv4Address", validation_alias="ipv4Address")
-    ipv4_prefix_length: Global[int] = Field(serialization_alias="ipv4PrefixLength", validation_alias="ipv4PrefixLength")
-
-
-class PrefixListParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["prefix"] = Field(default="prefix", exclude=True)
-    entries: List[PrefixListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_prefix(self, ipv4_network: IPv4Network):
-        self.entries.append(
-            PrefixListEntry(
-                ipv4_address=as_global(ipv4_network.network_address),
-                ipv4_prefix_length=as_global(ipv4_network.prefixlen),
-            )
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/service_object_group.py

@@ -1,21 +0,0 @@
-# Copyright 2025 Cisco Systems, Inc. and its affiliates
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, Field
-
-from catalystwan.api.configuration_groups.parcel import _ParcelBase, _ParcelEntry
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
-
-
-class ServiceObjectGrouEntries(_ParcelEntry):
-    object_group: Optional[RefIdItem] = Field(
-        default=None, validation_alias="objectGroup", serialization_alias="objectGroup"
-    )
-
-
-class ServiceObjectGroupParcel(_ParcelBase):
-    type_: Literal["service-object-group"] = Field(default="service-object-group", exclude=True)
-    entries: List[ServiceObjectGrouEntries] = Field(
-        validation_alias=AliasPath("data", "entries"),
-        description="object-group Entries",
-    )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/sla_class.py

@@ -1,130 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal, Optional, Union
-from uuid import UUID
-
-from pydantic import AliasPath, BaseModel, ConfigDict, Field, field_validator
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.common import SLAClassCriteria
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
-
-
-def check_latency_ms(cls, latency: Optional[Global]):
-    if latency is not None:
-        assert 1 <= latency.value <= 1000
-        return latency
-
-
-def check_loss_percent(cls, loss: Optional[Global]):
-    if loss is not None:
-        assert 0 <= loss.value <= 100
-    return loss
-
-
-def check_jitter_ms(cls, jitter: Optional[Global]):
-    if jitter is not None:
-        assert 1 <= jitter.value <= 1000
-    return jitter
-
-
-class FallbackBestTunnel(BaseModel):
-    model_config = ConfigDict(populate_by_name=True)
-
-    criteria: Global[SLAClassCriteria]
-    jitter_variance: Optional[Global[int]] = Field(
-        default=None,
-        serialization_alias="jitterVariance",
-        validation_alias="jitterVariance",
-        description="jitter variance in ms",
-    )
-    latency_variance: Optional[Global[int]] = Field(
-        default=None,
-        serialization_alias="latencyVariance",
-        validation_alias="latencyVariance",
-        description="latency variance in ms",
-    )
-    loss_variance: Optional[Global[int]] = Field(
-        default=None,
-        serialization_alias="lossVariance",
-        validation_alias="lossVariance",
-        description="loss variance as percentage",
-    )
-    # validators
-    _jitter_validator = field_validator("jitter_variance")(check_jitter_ms)
-    _latency_validator = field_validator("latency_variance")(check_latency_ms)
-    _loss_validator = field_validator("loss_variance")(check_loss_percent)
-
-    def add_criteria(
-        self, jitter_variance: Union[int, None], latency_variance: Union[int, None], loss_variance: Union[int, None]
-    ):
-        expected_criteria = []
-        if jitter_variance:
-            self.jitter_variance = Global(value=jitter_variance)
-            expected_criteria.append("jitter")
-        if latency_variance:
-            self.latency_variance = Global(value=latency_variance)
-            expected_criteria.append("latency")
-        if loss_variance:
-            self.loss_variance = Global(value=loss_variance)
-            expected_criteria.append("loss")
-        for e in expected_criteria:
-            if e not in self.criteria.value:
-                raise ValueError(f"Criteria {e} is not in configured criteria {self.criteria.value}")
-
-
-class SLAClassListEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-
-    latency: Optional[Global[int]] = None
-    loss: Optional[Global[int]] = None
-    jitter: Optional[Global[int]] = None
-    app_probe_class: Optional[RefIdItem] = Field(
-        default=None, validation_alias="appProbeClass", serialization_alias="appProbeClass"
-    )
-    fallback_best_tunnel: Optional[FallbackBestTunnel] = Field(
-        default=None, validation_alias="fallbackBestTunnel", serialization_alias="fallbackBestTunnel"
-    )
-
-    # validators
-    _jitter_validator = field_validator("jitter")(check_jitter_ms)
-    _latency_validator = field_validator("latency")(check_latency_ms)
-    _loss_validator = field_validator("loss")(check_loss_percent)
-
-
-class SLAClassParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["sla-class"] = Field(default="sla-class", exclude=True)
-    entries: List[SLAClassListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_entry(
-        self,
-        app_probe_class_id: Optional[UUID] = None,
-        loss: Optional[int] = None,
-        jitter: Optional[int] = None,
-        latency: Optional[int] = None,
-    ):
-        ref = RefIdItem(ref_id=as_global(str(app_probe_class_id))) if app_probe_class_id is not None else None
-        self.entries.append(
-            SLAClassListEntry(
-                app_probe_class=ref,
-                loss=as_global(loss) if loss is not None else None,
-                jitter=as_global(jitter) if jitter is not None else None,
-                latency=as_global(latency) if latency is not None else None,
-            )
-        )
-
-    def add_fallback(
-        self,
-        criteria: SLAClassCriteria,
-        jitter_variance: Optional[int] = None,
-        latency_variance: Optional[int] = None,
-        loss_variance: Optional[int] = None,
-    ):
-        fallback = FallbackBestTunnel(
-            criteria=as_global(criteria, SLAClassCriteria),
-            jitter_variance=as_global(jitter_variance) if jitter_variance is not None else None,
-            latency_variance=as_global(latency_variance) if latency_variance is not None else None,
-            loss_variance=as_global(loss_variance) if loss_variance is not None else None,
-        )
-        self.entries[0].fallback_best_tunnel = fallback

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/standard_community.py

@@ -1,30 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.common import WellKnownBGPCommunities
-
-
-class StandardCommunityEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    standard_community: Global[str] = Field(
-        serialization_alias="standardCommunity", validation_alias="standardCommunity"
-    )
-
-
-class StandardCommunityParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["standard-community"] = Field(default="standard-community", exclude=True)
-    entries: List[StandardCommunityEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def _add_community(self, standard_community: str):
-        self.entries.append(StandardCommunityEntry(standard_community=as_global(standard_community)))
-
-    def add_well_known_community(self, standard_community: WellKnownBGPCommunities):
-        self._add_community(standard_community)
-
-    def add_community(self, as_number: int, community_number: int) -> None:
-        self._add_community(f"{as_number}:{community_number}")

catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/tloc_list.py

@@ -1,44 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from ipaddress import IPv4Address
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, ConfigDict, Field, field_validator
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.common import EncapType, TLOCColor
-
-
-class TlocEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    tloc: Global[IPv4Address]
-    color: Global[TLOCColor]
-    encapsulation: Global[EncapType] = Field(serialization_alias="encap", validation_alias="encap")
-    preference: Optional[Global[str]] = None
-
-    @field_validator("preference")
-    @classmethod
-    def ensure_correct_preference_value(cls, v: Global):
-        if not v:
-            return v
-        if not (0 <= int(v.value) < 4_294_967_295):
-            raise ValueError('"preference" not in range 0 - 4 294 967 295 (2 ** 32 - 1)')
-        return v
-
-
-class TlocParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["tloc"] = Field(default="tloc", exclude=True)
-    entries: List[TlocEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_entry(
-        self, tloc: IPv4Address, color: TLOCColor, encapsulation: EncapType, preference: Optional[str] = None
-    ):
-        self.entries.append(
-            TlocEntry(
-                tloc=as_global(tloc),
-                color=as_global(color, TLOCColor),
-                encapsulation=as_global(encapsulation, EncapType),
-                preference=as_global(preference) if preference is not None else None,
-            )
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/aip.py

@@ -1,64 +0,0 @@
-# Copyright 2023 Cisco Systems, Inc. and its affiliates
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import Literal, Optional
-from uuid import UUID
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase
-from catalystwan.models.configuration.feature_profile.common import RefIdItem
-
-TlsDecryptionAction = Literal["decrypt", "neverDecrypt", "skipDecrypt"]
-
-
-class AdvancedInspectionProfileParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["unified/advanced-inspection-profile"] = Field(
-        default="unified/advanced-inspection-profile", exclude=True
-    )
-    parcel_description: str = Field(
-        default="",
-        serialization_alias="description",
-        validation_alias="description",
-        description="Set the parcel description",
-    )
-    tls_decryption_action: Global[TlsDecryptionAction] = Field(
-        default=Global[TlsDecryptionAction](value="skipDecrypt"),
-        validation_alias=AliasPath("data", "tlsDecryptionAction"),
-    )
-    intrusion_prevention: Optional[RefIdItem] = Field(
-        default=None, validation_alias=AliasPath("data", "intrusionPrevention")
-    )
-    url_filtering: Optional[RefIdItem] = Field(default=None, validation_alias=AliasPath("data", "urlFiltering"))
-    advanced_malware_protection: Optional[RefIdItem] = Field(
-        default=None, validation_alias=AliasPath("data", "advancedMalwareProtection")
-    )
-    ssl_decryption_profile: Optional[RefIdItem] = Field(
-        default=None, validation_alias=AliasPath("data", "sslDecryptionProfile")
-    )
-
-    @classmethod
-    def create(
-        cls,
-        parcel_name: str,
-        parcel_description: str,
-        tls_decryption_action: TlsDecryptionAction = "skipDecrypt",
-        intrusion_prevention: Optional[UUID] = None,
-        url_filtering: Optional[UUID] = None,
-        advanced_malware_protection: Optional[UUID] = None,
-        ssl_decryption_profile: Optional[UUID] = None,
-    ) -> "AdvancedInspectionProfileParcel":
-        ip = RefIdItem.from_uuid(intrusion_prevention) if intrusion_prevention else None
-        uf = RefIdItem.from_uuid(url_filtering) if url_filtering else None
-        amp = RefIdItem.from_uuid(advanced_malware_protection) if advanced_malware_protection else None
-        sdp = RefIdItem.from_uuid(ssl_decryption_profile) if ssl_decryption_profile else None
-        return cls(
-            parcel_name=parcel_name,
-            parcel_description=parcel_description,
-            tls_decryption_action=Global[TlsDecryptionAction](value=tls_decryption_action),
-            intrusion_prevention=ip,
-            url_filtering=uf,
-            advanced_malware_protection=amp,
-            ssl_decryption_profile=sdp,
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/amp.py

@@ -1,79 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase
-from catalystwan.models.common import (
-    AmpFileAlertLevel,
-    AmpFileAnalysisFileTypes,
-    AmpFileAnalysisServer,
-    AmpFileReputationServer,
-)
-
-
-class AdvancedMalwareProtectionParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["unified/advanced-malware-protection"] = Field(
-        default="unified/advanced-malware-protection", exclude=True
-    )
-    description: str = "advancedMalwareProtection"
-    match_all_vpn: Global[Literal[True]] = Field(
-        default=Global[Literal[True]](value=True), validation_alias=AliasPath("data", "matchAllVpn")
-    )
-    file_reputation_cloud_server: Global[AmpFileReputationServer] = Field(
-        validation_alias=AliasPath("data", "fileReputationCloudServer")
-    )
-    file_reputation_est_server: Global[AmpFileReputationServer] = Field(
-        validation_alias=AliasPath("data", "fileReputationEstServer")
-    )
-    file_reputation_alert: Global[AmpFileAlertLevel] = Field(
-        default=Global[AmpFileAlertLevel](value="critical"),
-        validation_alias=AliasPath("data", "fileReputationAlert"),
-    )
-    file_analysis_enabled: Global[bool] = Field(
-        default=Global[bool](value=False), validation_alias=AliasPath("data", "fileAnalysisEnabled")
-    )
-    file_analysis_cloud_server: Optional[Global[AmpFileAnalysisServer]] = Field(
-        default=None, validation_alias=AliasPath("data", "fileAnalysisCloudServer")
-    )
-    file_analysis_file_types: Optional[Global[List[AmpFileAnalysisFileTypes]]] = Field(
-        default=None, validation_alias=AliasPath("data", "fileAnalysisFileTypes")
-    )
-    file_analysis_alert: Optional[Global[AmpFileAlertLevel]] = Field(
-        default=None, validation_alias=AliasPath("data", "fileAnalysisAlert")
-    )
-
-    @classmethod
-    def create(
-        cls,
-        parcel_name: str,
-        parcel_description: str,
-        file_reputation_cloud_server: AmpFileReputationServer,
-        file_reputation_est_server: AmpFileReputationServer,
-        file_reputation_alert: AmpFileAlertLevel,
-        file_analysis_enabled: bool = False,
-        file_analysis_alert: Optional[AmpFileAlertLevel] = None,
-        file_analysis_cloud_server: Optional[AmpFileAnalysisServer] = None,
-        file_analysis_file_types: List[AmpFileAnalysisFileTypes] = [],
-    ):
-        _file_analysis_alert = Global[AmpFileAlertLevel](value=file_analysis_alert) if file_analysis_alert else None
-        _file_analysis_cloud_server = (
-            Global[AmpFileAnalysisServer](value=file_analysis_cloud_server) if file_analysis_cloud_server else None
-        )
-        _file_analysis_file_types = (
-            Global[List[AmpFileAnalysisFileTypes]](value=file_analysis_file_types) if file_analysis_file_types else None
-        )
-
-        return cls(
-            parcel_name=parcel_name,
-            parcel_description=parcel_description,
-            file_reputation_cloud_server=Global[AmpFileReputationServer](value=file_reputation_cloud_server),
-            file_reputation_est_server=Global[AmpFileReputationServer](value=file_reputation_est_server),
-            file_analysis_alert=_file_analysis_alert,
-            file_analysis_cloud_server=_file_analysis_cloud_server,
-            file_reputation_alert=Global[AmpFileAlertLevel](value=file_reputation_alert),
-            file_analysis_enabled=Global[bool](value=file_analysis_enabled),
-            file_analysis_file_types=_file_analysis_file_types,
-        )

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/application_list.py

@@ -1,31 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal, Union
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-
-
-class SecurityApplicationListEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    app_list: Global[str] = Field(serialization_alias="app", validation_alias="app")
-
-
-class SecurityApplicationFamilyListEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    app_list_family: Global[str] = Field(serialization_alias="appFamily", validation_alias="appFamily")
-
-
-class SecurityApplicationListParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["security-localapp"] = Field(default="security-localapp", exclude=True)
-    entries: List[Union[SecurityApplicationFamilyListEntry, SecurityApplicationListEntry]] = Field(
-        default_factory=list, validation_alias=AliasPath("data", "entries")
-    )
-
-    def add_application(self, application: str):
-        self.entries.append(SecurityApplicationListEntry(app_list=as_global(application)))
-
-    def add_application_family(self, application_family: str):
-        self.entries.append(SecurityApplicationFamilyListEntry(app_list_family=as_global(application_family)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/data_prefix.py

@@ -1,22 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from ipaddress import IPv4Network
-from typing import List, Literal
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-
-
-class SecurityDataPrefixEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    ip_prefix: Global[IPv4Network] = Field(serialization_alias="ipPrefix", validation_alias="ipPrefix")
-
-
-class SecurityDataPrefixParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["security-data-ip-prefix"] = Field(default="security-data-ip-prefix", exclude=True)
-    entries: List[SecurityDataPrefixEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_prefix(self, ip_prefix: IPv4Network):
-        self.entries.append(SecurityDataPrefixEntry(ip_prefix=as_global(ip_prefix)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/fqdn.py

@@ -1,24 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal
-
-from pydantic import AliasPath, ConfigDict, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-
-
-class FQDNListEntry(_ParcelEntry):
-    model_config = ConfigDict(populate_by_name=True)
-    pattern: Global[str] = Field(
-        description="Ex: cisco.com, .*cisco.com, .*.cisco.com. Should not start with '*' or '+'"
-    )
-
-
-class FQDNDomainParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["security-fqdn"] = Field(default="security-fqdn", exclude=True)
-    entries: List[FQDNListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def from_fqdns(self, fqdns: List[str]):
-        for fqdn in fqdns:
-            self.entries.append(FQDNListEntry(pattern=as_global(fqdn)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/geolocation_list.py

@@ -1,32 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, ConfigDict, Field, model_validator
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_global
-from catalystwan.models.common import check_fields_exclusive
-
-
-class GeoLocationListEntry(_ParcelEntry):
-    country: Optional[Global[str]] = Field(default=None, description="ISO-3166 alpha-3 country code eg: FRA")
-    continent: Optional[Global[str]] = Field(
-        default=None, description="One of 2-letter continent codes: AF, NA, OC, AN, AS, EU, SA"
-    )
-
-    @model_validator(mode="after")
-    def check_country_xor_continent(self):
-        check_fields_exclusive(self.__dict__, {"country", "continent"}, True)
-        return self
-
-
-class GeoLocationListParcel(_ParcelBase):
-    model_config = ConfigDict(populate_by_name=True)
-    type_: Literal["security-geolocation"] = Field(default="security-geolocation", exclude=True)
-    entries: List[GeoLocationListEntry] = Field(default_factory=list, validation_alias=AliasPath("data", "entries"))
-
-    def add_country(self, country: str):
-        self.entries.append(GeoLocationListEntry(country=as_global(country)))
-
-    def add_continent(self, continent: str):
-        self.entries.append(GeoLocationListEntry(continent=as_global(continent)))

catalystwan/models/configuration/feature_profile/sdwan/policy_object/security/identity.py

@@ -1,30 +0,0 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
-from typing import List, Literal, Optional
-
-from pydantic import AliasPath, Field
-
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, _ParcelEntry, as_optional_global
-
-
-class IdentityEntry(_ParcelEntry):
-    user: Optional[Global[str]] = Field(default=None)
-    user_group: Optional[Global[str]] = Field(
-        default=None, validation_alias="userGroup", serialization_alias="userGroup"
-    )
-
-
-class IdentityParcel(_ParcelBase):
-    type_: Literal["security-identity"] = Field(default="security-identity", exclude=True)
-    entries: List[IdentityEntry] = Field(
-        validation_alias=AliasPath("data", "entries"),
-        default_factory=list,
-        description="Array of Users and User Groups",
-    )
-
-    def add_entry(self, user: Optional[str] = None, user_group: Optional[str] = None):
-        self.entries.append(
-            IdentityEntry(
-                user=as_optional_global(user),
-                user_group=as_optional_global(user_group),
-            )
-        )