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

catalystwan/models/policy/policy_list.py

@@ -1,60 +1,49 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 import datetime
-from typing import Any, List, Optional
+from typing import List, Optional, Protocol
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-
-class PolicyListBase(BaseModel):
-    name: str = Field(
-        pattern="^[a-zA-Z0-9._-]{1,32}$",
-        description="Can include only alpha-numeric characters, "
-        "dot '.' or hyphen '-' or underscore '_'; maximum 32 characters",
-    )
-    description: Optional[str] = "Desc Not Required"
-    entries: List[Any]
-
-    def _add_entry(self, entry: Any, single: bool = False) -> None:
-        if self.entries and single:
-            self.entries[0] = entry
-            del self.entries[1:]
-        else:
-            self.entries.append(entry)
+from catalystwan.models.policy import AnyPolicyList
+from catalystwan.typed_list import DataSequence
 
 
 class InfoTag(BaseModel):
-    info_tag: Optional[str] = Field("", serialization_alias="infoTag", validation_alias="infoTag")
+    info_tag: Optional[str] = Field("", alias="infoTag")
 
 
 class PolicyListId(BaseModel):
-    list_id: UUID = Field(serialization_alias="listId", validation_alias="listId")
-
-
-class PolicyListReference(BaseModel):
-    id: Optional[str] = Field(default=None)
-    type: Optional[str] = Field(default=None)
-
-    @property
-    def uuid(self) -> Optional[UUID]:
-        try:
-            return UUID(self.id)
-        except ValueError:
-            return None
+    list_id: UUID = Field(alias="listId")
 
 
 class PolicyListInfo(PolicyListId, InfoTag):
-    last_updated: datetime.datetime = Field(serialization_alias="lastUpdated", validation_alias="lastUpdated")
+    last_updated: datetime.datetime = Field(alias="lastUpdated")
     owner: str
-    read_only: bool = Field(serialization_alias="readOnly", validation_alias="readOnly")
+    read_only: bool = Field(alias="readOnly")
     version: str
-    reference_count: int = Field(serialization_alias="referenceCount", validation_alias="referenceCount")
-    references: List[PolicyListReference]
-    is_activated_by_vsmart: Optional[bool] = Field(
-        None, serialization_alias="isActivatedByVsmart", validation_alias="isActivatedByVsmart"
-    )
+    reference_count: int = Field(alias="referenceCount")
+    references: List
+    is_activated_by_vsmart: Optional[bool] = Field(None, alias="isActivatedByVsmart")
 
 
 class PolicyListPreview(BaseModel):
     preview: str
+
+
+class PolicyListEndpoints(Protocol):
+    def create_policy_list(self, payload: AnyPolicyList) -> PolicyListId:
+        ...
+
+    def delete_policy_list(self, id: UUID) -> None:
+        ...
+
+    def edit_policy_list(self, id: UUID, payload: AnyPolicyList) -> None:
+        ...
+
+    def get_lists_by_id(self, id: UUID) -> PolicyListInfo:
+        ...
+
+    def get_policy_lists(self) -> DataSequence[PolicyListInfo]:
+        ...

catalystwan/models/policy/security.py

@@ -1,13 +1,12 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
-from typing import Any, List, Literal, Optional, Set, Union
+from typing import List, Literal, Optional, Union
 from uuid import UUID
 
-from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, IPvAnyAddress, RootModel, field_validator
+from pydantic import BaseModel, ConfigDict, Field, IPvAnyAddress, RootModel, field_validator
 from typing_extensions import Annotated
 
 from catalystwan.models.policy.policy import (
-    AdvancedInspectionProfileAssemblyItem,
     AdvancedMalwareProtectionAssemblyItem,
     DNSSecurityAssemblyItem,
     IntrusionPreventionAssemblyItem,
@@ -19,35 +18,23 @@ from catalystwan.models.policy.policy import (
     URLFilteringAssemblyItem,
     ZoneBasedFWAssemblyItem,
 )
-from catalystwan.typed_list import DataSequence
-
-
-def set_default_policy_mode_if_missing(values: Any):
-    if not isinstance(values, dict):
-        return values
-    if "policyMode" not in values.keys():
-        values["policyMode"] = None
-    return values
-
 
 SecurityPolicyAssemblyItem = Annotated[
     Union[
+        ZoneBasedFWAssemblyItem,
+        IntrusionPreventionAssemblyItem,
+        URLFilteringAssemblyItem,
         AdvancedMalwareProtectionAssemblyItem,
         DNSSecurityAssemblyItem,
-        IntrusionPreventionAssemblyItem,
         SSLDecryptionAssemblyItem,
-        URLFilteringAssemblyItem,
-        ZoneBasedFWAssemblyItem,
     ],
     Field(discriminator="type"),
 ]
 
 UnifiedSecurityPolicyAssemblyItem = Annotated[
     Union[
-        AdvancedInspectionProfileAssemblyItem,
-        DNSSecurityAssemblyItem,
         NGFirewallAssemblyItem,
-        SSLDecryptionAssemblyItem,
+        DNSSecurityAssemblyItem,
     ],
     Field(discriminator="type"),
 ]
@@ -65,11 +52,9 @@ ZoneToNoZoneInternet = Literal[
 
 class HighSpeedLoggingEntry(BaseModel):
     vrf: str
-    server_ip: IPvAnyAddress = Field(serialization_alias="serverIp", validation_alias="serverIp")
+    server_ip: IPvAnyAddress = Field(alias="serverIp")
     port: str
-    source_interface: Optional[str] = Field(
-        default=None, serialization_alias="sourceInterface", validation_alias="sourceInterface"
-    )
+    source_interface: Optional[str] = Field(alias="sourceInterface")
     model_config = ConfigDict(populate_by_name=True)
 
 
@@ -79,105 +64,66 @@ class HighSpeedLoggingList(BaseModel):
 
 class LoggingEntry(BaseModel):
     vpn: str
-    server_ip: IPvAnyAddress = Field(serialization_alias="serverIP", validation_alias="serverIP")
+    server_ip: IPvAnyAddress = Field(alias="serverIP")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class SecurityPolicySettings(BaseModel):
     logging: Optional[List[LoggingEntry]] = None
-    failure_mode: Optional[FailureMode] = Field(
-        default=None, serialization_alias="failureMode", validation_alias="failureMode"
-    )
-    zone_to_no_zone_internet: ZoneToNoZoneInternet = Field(
-        default="deny", serialization_alias="zoneToNozoneInternet", validation_alias="zoneToNozoneInternet"
-    )
-    tcp_syn_flood_limit: Optional[str] = Field(
-        default=None, serialization_alias="tcpSynFloodLimit", validation_alias="tcpSynFloodLimit"
-    )
-    high_speed_logging: Union[HighSpeedLoggingEntry, HighSpeedLoggingList, None] = Field(
-        default=None, serialization_alias="highSpeedLogging", validation_alias="highSpeedLogging"
-    )
-    audit_trail: Optional[str] = Field(default=None, serialization_alias="auditTrail", validation_alias="auditTrail")
-    platform_match: Optional[str] = Field(
-        default=None, serialization_alias="platformMatch", validation_alias="platformMatch"
-    )
+    failure_mode: Optional[FailureMode] = Field(default=None, alias="failureMode")
+    zone_to_no_zone_internet: ZoneToNoZoneInternet = Field(default="deny", alias="zoneToNozoneInternet")
+    tcp_syn_flood_limit: Optional[str] = Field(default=None, alias="tcpSynFloodLimit")
+    high_speed_logging: Optional[HighSpeedLoggingEntry] = Field(default=None, alias="highSpeedLogging")
+    audit_trail: Optional[str] = Field(default=None, alias="auditTrail")
+    platform_match: Optional[str] = Field(default=None, alias="platformMatch")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class UnifiedSecurityPolicySettings(BaseModel):
-    tcp_syn_flood_limit: Optional[str] = Field(
-        default=None, serialization_alias="tcpSynFloodLimit", validation_alias="tcpSynFloodLimit"
-    )
-    max_incomplete_tcp_limit: Optional[str] = Field(
-        default=None, serialization_alias="maxIncompleteTcpLimit", validation_alias="maxIncompleteTcpLimit"
-    )
-    max_incomplete_udp_limit: Optional[str] = Field(
-        default=None, serialization_alias="maxIncompleteUdpLimit", validation_alias="maxIncompleteUdpLimit"
-    )
-    max_incomplete_icmp_limit: Optional[str] = Field(
-        default=None, serialization_alias="maxIncompleteIcmpLimit", validation_alias="maxIncompleteIcmpLimit"
-    )
-    high_speed_logging: Union[HighSpeedLoggingEntry, HighSpeedLoggingList, None] = Field(
-        default=None, serialization_alias="highSpeedLogging", validation_alias="highSpeedLogging"
-    )
-    audit_trail: Optional[str] = Field(default=None, serialization_alias="auditTrail", validation_alias="auditTrail")
-    unified_logging: Optional[str] = Field(
-        default=None, serialization_alias="unifiedLogging", validation_alias="unifiedLogging"
-    )
-    session_reclassify_allow: Optional[str] = Field(
-        default=None, serialization_alias="sessionReclassifyAllow", validation_alias="sessionReclassifyAllow"
-    )
-    icmp_unreachable_allow: Optional[str] = Field(
-        default=None, serialization_alias="icmpUnreachableAllow", validation_alias="icmpUnreachableAllow"
-    )
+    tcp_syn_flood_limit: Optional[str] = Field(default=None, alias="tcpSynFloodLimit")
+    max_incomplete_tcp_limit: Optional[str] = Field(default=None, alias="maxIncompleteTcpLimit")
+    max_incomplete_udp_limit: Optional[str] = Field(default=None, alias="maxIncompleteUdpLimit")
+    max_incomplete_icmp_limit: Optional[str] = Field(default=None, alias="maxIncompleteIcmpLimit")
+    high_speed_logging: Optional[HighSpeedLoggingList] = Field(default=None, alias="highSpeedLogging")
     model_config = ConfigDict(populate_by_name=True)
 
 
 class SecurityPolicyDefinition(PolicyDefinition):
     assembly: List[SecurityPolicyAssemblyItem] = []
-    settings: SecurityPolicySettings = Field(default=SecurityPolicySettings())
+    settings: SecurityPolicySettings = SecurityPolicySettings()
 
 
 class UnifiedSecurityPolicyDefinition(PolicyDefinition):
     assembly: List[UnifiedSecurityPolicyAssemblyItem] = []
-    settings: UnifiedSecurityPolicySettings = Field(default=UnifiedSecurityPolicySettings())
+    settings: UnifiedSecurityPolicySettings = UnifiedSecurityPolicySettings()
 
 
 class SecurityPolicy(PolicyCreationPayload):
-    policy_mode: Literal[None, "", "security"] = Field(
-        default="security", serialization_alias="policyMode", validation_alias="policyMode"
-    )
-    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
-    policy_use_case: str = Field(
-        default="custom", serialization_alias="policyUseCase", validation_alias="policyUseCase"
-    )
-    policy_definition: SecurityPolicyDefinition = Field(
-        default=SecurityPolicyDefinition(), serialization_alias="policyDefinition", validation_alias="policyDefinition"
-    )
+    policy_mode: Literal["security"] = Field(default="security", alias="policyMode")
+    policy_type: str = Field(default="feature", alias="policyType")
+    policy_use_case: str = Field(default="custom", alias="policyUseCase")
+    policy_definition: SecurityPolicyDefinition = Field(default=SecurityPolicyDefinition(), alias="policyDefinition")
 
-    def get_assemby_item_uuids(self) -> Set[UUID]:
-        return set((item.definition_id for item in self.policy_definition.assembly))
-
-    def _add_item(self, item: SecurityPolicyAssemblyItem) -> None:
+    def add_item(self, item: SecurityPolicyAssemblyItem) -> None:
         self.policy_definition.assembly.append(item)
 
     def add_zone_based_fw(self, definition_id: UUID) -> None:
-        self._add_item(ZoneBasedFWAssemblyItem(definition_id=definition_id))
+        self.add_item(ZoneBasedFWAssemblyItem(definition_id=definition_id))
 
     def add_dns_security(self, definition_id: UUID) -> None:
-        self._add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
+        self.add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
 
     def add_intrusion_prevention(self, definition_id: UUID) -> None:
-        self._add_item(IntrusionPreventionAssemblyItem(definition_id=definition_id))
+        self.add_item(IntrusionPreventionAssemblyItem(definition_id=definition_id))
 
     def add_url_filtering(self, definition_id: UUID) -> None:
-        self._add_item(URLFilteringAssemblyItem(definition_id=definition_id))
+        self.add_item(URLFilteringAssemblyItem(definition_id=definition_id))
 
     def add_advanced_malware_protection(self, definition_id: UUID) -> None:
-        self._add_item(AdvancedMalwareProtectionAssemblyItem(definition_id=definition_id))
+        self.add_item(AdvancedMalwareProtectionAssemblyItem(definition_id=definition_id))
 
     def add_ssl_decryption(self, definition_id: UUID) -> None:
-        self._add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
+        self.add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
 
     @field_validator("policy_definition", mode="before")
     @classmethod
@@ -188,28 +134,16 @@ class SecurityPolicy(PolicyCreationPayload):
 
 
 class UnifiedSecurityPolicy(PolicyCreationPayload):
-    policy_mode: Literal["unified"] = Field(
-        default="unified", serialization_alias="policyMode", validation_alias="policyMode"
-    )
-    policy_type: str = Field(default="feature", serialization_alias="policyType", validation_alias="policyType")
-    policy_use_case: str = Field(
-        default="custom", serialization_alias="policyUseCase", validation_alias="policyUseCase"
-    )
+    policy_mode: Literal["unified"] = Field("unified", alias="policyMode")
+    policy_type: str = Field("feature", alias="policyType")
+    policy_use_case: str = Field("custom", alias="policyUseCase")
     policy_definition: UnifiedSecurityPolicyDefinition = Field(
-        default=UnifiedSecurityPolicyDefinition(),
-        serialization_alias="policyDefinition",
-        validation_alias="policyDefinition",
+        default=UnifiedSecurityPolicyDefinition(), alias="policyDefinition"
     )
 
-    def get_assemby_item_uuids(self) -> Set[UUID]:
-        return set((item.definition_id for item in self.policy_definition.assembly))
-
     def add_item(self, item: UnifiedSecurityPolicyAssemblyItem) -> None:
         self.policy_definition.assembly.append(item)
 
-    def add_advanced_inspection_profile(self, definition_id: UUID) -> None:
-        self.add_item(AdvancedInspectionProfileAssemblyItem(definition_id=definition_id))
-
     def add_ng_firewall(self, definition_id: UUID) -> NGFirewallAssemblyItem:
         ng_fw = NGFirewallAssemblyItem(definition_id=definition_id)
         self.add_item(ng_fw)
@@ -218,9 +152,6 @@ class UnifiedSecurityPolicy(PolicyCreationPayload):
     def add_dns_security(self, definition_id: UUID) -> None:
         self.add_item(DNSSecurityAssemblyItem(definition_id=definition_id))
 
-    def add_ssl_decryption(self, definition_id: UUID) -> None:
-        self.add_item(SSLDecryptionAssemblyItem(definition_id=definition_id))
-
     @field_validator("policy_definition", mode="before")
     @classmethod
     def try_parse(cls, policy_definition):
@@ -229,14 +160,7 @@ class UnifiedSecurityPolicy(PolicyCreationPayload):
         return policy_definition
 
 
-AnySecurityPolicy = Annotated[
-    Union[
-        SecurityPolicy,
-        UnifiedSecurityPolicy,
-    ],
-    Field(discriminator="policy_mode"),
-    BeforeValidator(set_default_policy_mode_if_missing),
-]
+AnySecurityPolicy = Annotated[Union[SecurityPolicy, UnifiedSecurityPolicy], Field(discriminator="policy_mode")]
 
 
 class SecurityPolicyRoot(RootModel):
@@ -244,46 +168,23 @@ class SecurityPolicyRoot(RootModel):
 
 
 class SecurityPolicyEditResponse(BaseModel):
-    master_templates_affected: List[str] = Field(
-        default_factory=list, serialization_alias="masterTemplatesAffected", validation_alias="masterTemplatesAffected"
-    )
+    master_templates_affected: List[str] = Field(default=[], alias="masterTemplatesAffected")
 
 
 class SecurityPolicyInfo(SecurityPolicy, PolicyInfo):
-    virtual_application_templates: List[str] = Field(
-        serialization_alias="virtualApplicationTemplates", validation_alias="virtualApplicationTemplates"
-    )
-    supported_devices: List[str] = Field(serialization_alias="supportedDevices", validation_alias="supportedDevices")
+    virtual_application_templates: List[str] = Field(alias="virtualApplicationTemplates")
+    supported_devices: List[str] = Field(alias="supportedDevices")
 
 
 class UnifiedSecurityPolicyInfo(UnifiedSecurityPolicy, PolicyInfo):
-    virtual_application_templates: List[str] = Field(
-        serialization_alias="virtualApplicationTemplates", validation_alias="virtualApplicationTemplates"
-    )
-    supported_devices: List[str] = Field(serialization_alias="supportedDevices", validation_alias="supportedDevices")
+    virtual_application_templates: List[str] = Field(alias="virtualApplicationTemplates")
+    supported_devices: List[str] = Field(alias="supportedDevices")
 
 
 AnySecurityPolicyInfo = Annotated[
-    Union[
-        SecurityPolicyInfo,
-        UnifiedSecurityPolicyInfo,
-    ],
-    Field(discriminator="policy_mode"),
-    BeforeValidator(set_default_policy_mode_if_missing),
+    Union[SecurityPolicyInfo, UnifiedSecurityPolicyInfo], Field(discriminator="policy_mode")
 ]
 
 
-class AnySecurityPolicyInfoList(RootModel):
-    root: List[AnySecurityPolicyInfo]
-
-    @property
-    def all(self) -> List[AnySecurityPolicyInfo]:
-        return self.root
-
-    @property
-    def security(self) -> DataSequence[SecurityPolicyInfo]:
-        return DataSequence(SecurityPolicyInfo, [p for p in self.root if p.policy_mode == "security"])
-
-    @property
-    def unified(self) -> DataSequence[UnifiedSecurityPolicyInfo]:
-        return DataSequence(UnifiedSecurityPolicyInfo, [p for p in self.root if p.policy_mode == "unified"])
+class SecurityPolicyInfoRoot(RootModel):
+    root: AnySecurityPolicyInfo

catalystwan/response.py

@@ -9,7 +9,7 @@ from pprint import pformat
 from typing import Any, Callable, Dict, Optional, Sequence, Type, TypeVar, Union, cast
 from urllib.parse import urlparse
 
-from pydantic import BaseModel, RootModel
+from pydantic import BaseModel
 from requests import PreparedRequest, Request, Response
 from requests.cookies import RequestsCookieJar
 from requests.exceptions import JSONDecodeError
@@ -236,11 +236,7 @@ class ManagerResponse(Response, APIEndpointClientResponse):
         if issubclass(cls, BaseModel):
             if validate:
                 return cls.model_validate(data)  # type: ignore[return-value]
-            else:
-                if issubclass(cls, RootModel):
-                    return cls.model_construct(data)  # type: ignore[return-value]
-                else:
-                    return cls.model_construct(**data)  # type: ignore[return-value]
+            return cls.model_construct(**data)  # type: ignore[return-value]
         return create_dataclass(cls, data)
 
     def get_error_info(self) -> ManagerErrorInfo:

catalystwan/session.py

@@ -1,4 +1,4 @@
-# Copyright 2024 Cisco Systems, Inc. and its affiliates
+# Copyright 2022 Cisco Systems, Inc. and its affiliates
 
 from __future__ import annotations
 

catalystwan/tests/templates/definitions/{cisco_vpn_basic.json → Basic_Cisco_VPN_Model.json}

@@ -1,5 +1,5 @@
 {
-    "templateName": "cisco_vpn_basic",
+    "templateName": "Basic_Cisco_VPN_Model",
     "templateDescription": "Primitive",
     "templateType": "cisco_vpn",
     "deviceType": [
@@ -14,4 +14,4 @@
             "vipValue": 0
         }
     }
-}
+}