catalystwan 0.33.4.dev2__tar.gz → 0.33.4.dev3__tar.gz

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: catalystwan
-Version: 0.33.4.dev2
+Version: 0.33.4.dev3
 Summary: Cisco Catalyst WAN SDK for Python
 Home-page: https://github.com/cisco-open/cisco-catalyst-wan-sdk
 Author: kagorski

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/api/configuration_groups/parcel.py

@@ -1,7 +1,7 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 from enum import Enum
-from typing import Any, Dict, Generic, Literal, Optional, TypeVar, get_origin
+from typing import Any, Dict, Generic, List, Literal, Optional, Tuple, TypeVar, get_origin
 
 from pydantic import (
     AliasPath,
@@ -9,11 +9,13 @@ from pydantic import (
     ConfigDict,
     Field,
     PrivateAttr,
+    SerializationInfo,
     SerializerFunctionWrapHandler,
     model_serializer,
 )
 
 from catalystwan.exceptions import CatalystwanException
+from catalystwan.models.common import VersionedField
 
 T = TypeVar("T")
 
@@ -38,7 +40,7 @@ class _ParcelBase(BaseModel):
     _parcel_data_key: str = PrivateAttr(default="data")
 
     @model_serializer(mode="wrap")
-    def envelope_parcel_data(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
+    def envelope_parcel_data(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
         """
         serializes model fields with respect to field validation_alias,
         sub-classing parcel fields can be defined like following:
@@ -50,16 +52,23 @@ class _ParcelBase(BaseModel):
         model_dict = handler(self)
         model_dict[self._parcel_data_key] = {}
         remove_keys = []
+        replaced_keys: Dict[str, Tuple[str, str]] = {}
 
+        # enveloping
         for key in model_dict.keys():
             field_info = self.model_fields.get(key)
             if field_info and isinstance(field_info.validation_alias, AliasPath):
                 aliases = field_info.validation_alias.convert_to_aliases()
                 if aliases and aliases[0] == self._parcel_data_key and len(aliases) == 2:
                     model_dict[self._parcel_data_key][aliases[1]] = model_dict[key]
+                    replaced_keys[key] = (self._parcel_data_key, str(aliases[1]))
                     remove_keys.append(key)
         for key in remove_keys:
             del model_dict[key]
+
+        # versioned field update
+        model_dict = VersionedField.dump(self.model_fields, model_dict, info, replaced_keys)
+
         return model_dict
 
     @classmethod
@@ -120,7 +129,7 @@ class Default(ParcelAttribute, Generic[T]):
     option_type: OptionType = Field(
         default=OptionType.DEFAULT, serialization_alias="optionType", validation_alias="optionType"
     )
-    value: Optional[Any] = None
+    value: Optional[T] = None
 
 
 def as_global(value: Any, generic_alias: Any = None):
@@ -134,10 +143,14 @@ def as_global(value: Any, generic_alias: Any = None):
         Global[Any]: global option type object
     """
     if generic_alias is None:
+        if isinstance(value, list):
+            if len(value) == 0:
+                return Global[List](value=list())  # type: ignore
+            return Global[List[type(value[0])]](value=value)  # type: ignore
         return Global[type(value)](value=value)  # type: ignore
     elif get_origin(generic_alias) is Literal:
         return Global[generic_alias](value=value)  # type: ignore
-    TypeError("Inappropriate type for argument generic_alias")
+    raise TypeError("Inappropriate type for argument generic_alias")
 
 
 def as_variable(value: str):
@@ -163,7 +176,11 @@ def as_default(value: Any, generic_alias: Any = None):
         Default[Any]: default option type object
     """
     if generic_alias is None:
+        if isinstance(value, list):
+            if len(value) == 0:
+                return Default[List](value=list())  # type: ignore
+            return Default[List[type(value[0])]](value=value)  # type: ignore
         return Default[type(value)](value=value)  # type: ignore
     elif get_origin(generic_alias) is Literal:
         return Default[generic_alias](value=value)  # type: ignore
-    TypeError("Inappropriate type for argument generic_alias")
+    raise TypeError("Inappropriate type for argument generic_alias")

catalystwan-0.33.4.dev3/catalystwan/integration_tests/feature_profile/sdwan/test_transport.py

@@ -0,0 +1,164 @@
+from ipaddress import IPv4Address, IPv6Address
+
+from catalystwan.api.configuration_groups.parcel import as_global
+from catalystwan.integration_tests.feature_profile.sdwan.base import TestFeatureProfileModels
+from catalystwan.models.configuration.feature_profile.sdwan.transport.t1e1controller import (
+    E1,
+    T1,
+    CableLengthLong,
+    ChannelGroup,
+    ClockSource,
+    ControllerTxExList,
+    ControllerType,
+    E1Basic,
+    E1Framing,
+    E1Linecode,
+    LengthLong,
+    LineMode,
+    T1Basic,
+    T1E1ControllerParcel,
+    T1Framing,
+    T1Linecode,
+)
+from catalystwan.models.configuration.feature_profile.sdwan.transport.vpn_management import (
+    DnsIpv4,
+    DnsIpv6,
+    Ipv4RouteItem,
+    Ipv6RouteItem,
+    ManagementVpn,
+    NewHostMappingItem,
+    NextHopItem,
+    OneOfIpRouteNull0,
+    Prefix,
+    SubnetMask,
+)
+
+
+class TestTransportFeatureProfileModels(TestFeatureProfileModels):
+    @classmethod
+    def setUpClass(cls) -> None:
+        super().setUpClass()
+        cls.api = cls.session.api.sdwan_feature_profiles.transport
+        cls.profile_uuid = cls.api.create_profile("TestProfileService", "Description").id
+
+    def test_when_fully_specified_management_vpn_parcel_expect_successful_post(self):
+        # Arrange
+        management_vpn_parcel = ManagementVpn(
+            parcel_name="FullySpecifiedManagementVpnParcel",
+            description="Description",
+            dns_ipv6=DnsIpv6(
+                primary_dns_address_ipv6=as_global(IPv6Address("67ca:c2df:edfe:c8ec:b6cb:f9f4:eab0:ece6")),
+                secondary_dns_address_ipv6=as_global(IPv6Address("8989:8d33:c00a:4d13:324d:8b23:8d77:a289")),
+            ),
+            dns_ipv4=DnsIpv4(
+                primary_dns_address_ipv4=as_global(IPv4Address("68.138.29.222")),
+                secondary_dns_address_ipv4=as_global(IPv4Address("122.89.114.112")),
+            ),
+            new_host_mapping=[
+                NewHostMappingItem(
+                    host_name=as_global("FullySpecifiedHost"),
+                    list_of_ip=as_global(
+                        [
+                            "165.16.181.116",
+                            "7a4c:1d87:8587:a6ec:21a6:48a7:00e8:1fef",
+                        ]
+                    ),
+                )
+            ],
+            ipv6_route=[
+                Ipv6RouteItem(
+                    prefix=as_global("0::/16"),
+                    one_of_ip_route=OneOfIpRouteNull0(),
+                )
+            ],
+            ipv4_route=[
+                Ipv4RouteItem(
+                    prefix=Prefix(
+                        ip_address=as_global(IPv4Address("202.153.165.234")),
+                        subnet_mask=as_global("255.255.255.0", SubnetMask),
+                    ),
+                    next_hop=[
+                        NextHopItem(
+                            address=as_global(IPv4Address("1.1.1.1")),
+                        )
+                    ],
+                )
+            ],
+        )
+        # Act
+        parcel_id = self.api.create_parcel(self.profile_uuid, management_vpn_parcel).id
+        # Assert
+        assert parcel_id
+
+    def test_when_fully_specified_t1e1controller_type_e1_parcel_expect_successful_post(self):
+        # Arrange
+        t1e1controller = T1E1ControllerParcel(
+            parcel_name="FullySpecifiedT1E1ControllerParcel_type_e1",
+            description="Description",
+            type=as_global("e1", ControllerType),
+            slot=as_global("TypeEOne"),
+            controller_tx_ex_list=[
+                ControllerTxExList(
+                    basic=E1Basic(
+                        e1=E1(
+                            framing=as_global("crc4", E1Framing),
+                            linecode=as_global("ami", E1Linecode),
+                        )
+                    ),
+                    channel_group=[
+                        ChannelGroup(
+                            number=as_global(12),
+                            timeslots=as_global("1"),
+                        )
+                    ],
+                    clock_source=as_global("internal", ClockSource),
+                    description=as_global("FullySpecifiedDescription"),
+                    line_mode=as_global("primary", LineMode),
+                )
+            ],
+        )
+        # Act
+        parcel_id = self.api.create_parcel(self.profile_uuid, t1e1controller).id
+        # Assert
+        assert parcel_id
+
+    def test_when_fully_specified_t1e1controller_type_t1_parcel_expect_successful_post(self):
+        # Arrange
+        t1e1controller = T1E1ControllerParcel(
+            parcel_name="FullySpecifiedT1E1ControllerParcel_type_t1",
+            description="Description",
+            type=as_global("t1", ControllerType),
+            slot=as_global("TypeTOne"),
+            controller_tx_ex_list=[
+                ControllerTxExList(
+                    basic=T1Basic(
+                        t1=T1(
+                            framing=as_global("esf", T1Framing),
+                            linecode=as_global("b8zs", T1Linecode),
+                        )
+                    ),
+                    cable=CableLengthLong(
+                        cable_length=as_global("long", CableLengthLong),
+                        length_long=as_global("-15db", LengthLong),
+                    ),
+                    channel_group=[
+                        ChannelGroup(
+                            number=as_global(12),
+                            timeslots=as_global("1"),
+                        )
+                    ],
+                    clock_source=as_global("internal", ClockSource),
+                    description=as_global("FullySpecifiedDescription"),
+                    line_mode=as_global("primary", LineMode),
+                )
+            ],
+        )
+        # Act
+        parcel_id = self.api.create_parcel(self.profile_uuid, t1e1controller).id
+        # Assert
+        assert parcel_id
+
+    @classmethod
+    def tearDownClass(cls) -> None:
+        cls.api.delete_profile(cls.profile_uuid)
+        super().tearDownClass()

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/common.py

@@ -1,12 +1,12 @@
 # Copyright 2023 Cisco Systems, Inc. and its affiliates
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Dict, List, Literal, Optional, Sequence, Set, Tuple, Union
+from typing import Any, Dict, Iterator, List, Literal, Mapping, Optional, Sequence, Set, Tuple, Union
 from uuid import UUID
 
 from packaging.specifiers import SpecifierSet  # type: ignore
 from packaging.version import Version  # type: ignore
-from pydantic import PlainSerializer, SerializationInfo
+from pydantic import PlainSerializer, SerializationInfo, ValidationInfo
 from pydantic.fields import FieldInfo
 from pydantic.functional_validators import BeforeValidator
 from typing_extensions import Annotated
@@ -41,29 +41,54 @@ class VersionedField:
         self.versions_set = SpecifierSet(versions)
 
     @staticmethod
-    def update_model_fields(
-        model_fields: Dict[str, FieldInfo], model_dict: Dict[str, Any], serialization_info: SerializationInfo
+    def model_iterate(
+        model_fields: Dict[str, FieldInfo], info: Union[SerializationInfo, ValidationInfo]
+    ) -> Iterator[Tuple[str, FieldInfo, "VersionedField"]]:
+        """Itrerates over model fields that matches a version given in context (Serialization info or ValidationInfo)
+
+        Yields:
+            Tuple[str, FieldInfo, VersionedField]: a tuple containing field name, FieldInfo and VersionedField
+        """
+        if info.context is not None:
+            api_version: Optional[Version] = info.context.get("api_version")
+            if api_version is not None:
+                for field_name, field_info in model_fields.items():
+                    versioned_fields = [meta for meta in field_info.metadata if isinstance(meta, VersionedField)]
+                    for versioned_field in versioned_fields:
+                        if api_version in versioned_field.versions_set:
+                            yield (field_name, field_info, versioned_field)
+
+    @staticmethod
+    def dump(
+        model_fields: Dict[str, FieldInfo],
+        model_dict: Dict[str, Any],
+        info: SerializationInfo,
+        replaced_keys: Optional[Mapping[str, Tuple[Optional[str], str]]] = None,
     ) -> Dict[str, Any]:
         """To be reused in methods decorated with pydantic.model_serializer
         Args:
             model_fields (Dict[str, FieldInfo]): obtained from BaseModel class
             model_dict (Dict[str, Any]): obtained from serialized BaseModel instance
             serialization_info (SerializationInfo): passed from serializer
+            replaced_keys (Dict[str, Tuple(Optional[str], str)]): field names that were replaced
+                previously during serialization
+                (Tuple represent path and new field name - this currently supports up to 1 level deep alias path only)
 
         Returns:
             Dict[str, Any]: model_dict with updated field names according to matching runtime version
         """
-        if serialization_info.context is not None:
-            api_version: Optional[Version] = serialization_info.context.get("api_version")
-            if api_version is not None:
-                for field_name, field_info in model_fields.items():
-                    versioned_fields = [meta for meta in field_info.metadata if isinstance(meta, VersionedField)]
-                    for versioned_field in versioned_fields:
-                        if api_version in versioned_field.versions_set:
-                            current_field_name = field_info.serialization_alias or field_info.alias or field_name
-                            if model_dict.get(current_field_name) is not None:
-                                model_dict[versioned_field.serialization_alias] = model_dict[current_field_name]
-                                del model_dict[current_field_name]
+        for field_name, field_info, versioned_field in VersionedField.model_iterate(model_fields, info):
+            current_field_name = field_info.serialization_alias or field_info.alias or field_name
+            new_field_name = versioned_field.serialization_alias
+            if current_field_name in model_dict:
+                model_dict[new_field_name] = model_dict[current_field_name]
+                del model_dict[current_field_name]
+            elif replaced_keys is not None:
+                if current_field_path := replaced_keys.get(current_field_name):
+                    path, name = current_field_path
+                    dict_ = model_dict[path] if path is not None else model_dict
+                    dict_[new_field_name] = dict_[name]
+                    del dict_[name]
         return model_dict
 
 

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/configuration/feature_profile/sdwan/policy_object/policy/expanded_community_list.py

@@ -1,17 +1,17 @@
 # Copyright 2024 Cisco Systems, Inc. and its affiliates
 
-from typing import Literal
+from typing import List, Literal
 
 from pydantic import AliasPath, ConfigDict, Field, field_validator
 
-from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase, as_global
+from catalystwan.api.configuration_groups.parcel import Global, _ParcelBase
 
 
 class ExpandedCommunityParcel(_ParcelBase):
     type_: Literal["expanded-community"] = Field(default="expanded-community", exclude=True)
     model_config = ConfigDict(populate_by_name=True)
-    expanded_community_list: Global[list] = Field(
-        default=as_global([]),
+    expanded_community_list: Global[List[str]] = Field(
+        default=Global[List[str]](value=list()),
         serialization_alias="expandedCommunityList",
         validation_alias=AliasPath("data", "expandedCommunityList"),
     )

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/configuration/feature_profile/sdwan/service/appqoe.py

@@ -223,7 +223,7 @@ class ServiceNodeInformationExternal(BaseModel):
 
     address: Default[ServiceNodeExternalAddress] = Default[ServiceNodeExternalAddress](value="192.168.2.2")
     vpg_ip: Default[ServiceNodeExternalVpgIp] = Field(
-        default=Default[ServiceNodeExternalVpgIp](value="192.168.2.1"),
+        default=Default[ServiceNodeExternalVpgIp](value="192.168.2.1/24"),
         serialization_alias="vpgIp",
         validation_alias="vpgIp",
     )

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/configuration/feature_profile/sdwan/service/route_policy.py

@@ -227,7 +227,7 @@ class RoutePolicySequence(BaseModel):
         ..., serialization_alias="sequenceName", validation_alias="sequenceName", description="Sequence Name"
     )
     base_action: Union[Global[BaseAction], Default[BaseAction]] = Field(
-        default=as_default("Reject", BaseAction),
+        default=as_default("reject", BaseAction),
         serialization_alias="baseAction",
         validation_alias="baseAction",
         description="Base Action",

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/configuration/feature_profile/sdwan/system/aaa.py

@@ -37,7 +37,7 @@ class UserItem(BaseModel):
         )
     )
     privilege: Union[Global[str], Variable, Default[str], None] = Field(
-        None, description="Set Privilege Level for this user"
+        default=None, description="Set Privilege Level for this user"
     )
     pubkey_chain: Optional[List[PubkeyChainItem]] = Field(
         default=None,

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/models/configuration/feature_profile/sdwan/transport/__init__.py

@@ -7,11 +7,14 @@ from typing_extensions import Annotated
 
 from .bgp import WanRoutingBgpParcel as BGPParcel
 from .cellular_controller import CellularControllerParcel
+from .t1e1controller import T1E1ControllerParcel
 from .vpn_management import ManagementVpn
 
-AnyTransportParcel = Annotated[Union[BGPParcel, CellularControllerParcel, ManagementVpn], Field(discriminator="type_")]
+AnyTransportParcel = Annotated[
+    Union[BGPParcel, CellularControllerParcel, ManagementVpn, T1E1ControllerParcel], Field(discriminator="type_")
+]
 
-__all__ = ["BGPParcel", "CellularControllerParcel", "ManagementVpn", "AnyTransportParcel"]
+__all__ = ["BGPParcel", "CellularControllerParcel", "ManagementVpn", "AnyTransportParcel", "T1E1ControllerParcel"]
 
 
 def __dir__() -> "List[str]":

catalystwan-0.33.4.dev3/catalystwan/models/configuration/feature_profile/sdwan/transport/t1e1controller.py

@@ -0,0 +1,161 @@
+from typing import List, Literal, Optional, Union
+
+from pydantic import AliasPath, BaseModel, ConfigDict, Field
+
+from catalystwan.api.configuration_groups.parcel import Default, Global, Variable, _ParcelBase, as_global
+
+ControllerType = Literal[
+    "e1",
+    "t1",
+]
+
+
+T1Framing = Literal[
+    "esf",
+    "sf",
+]
+
+T1Linecode = Literal[
+    "ami",
+    "b8zs",
+]
+
+T1Name = Literal[
+    "T1",
+    # By default, the name is T1
+]
+
+
+class T1(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    framing: Optional[Union[Global[T1Framing], Variable, Default[None]]] = Field(default=None)
+    linecode: Optional[Union[Global[T1Linecode], Variable, Default[None]]] = Field(default=None)
+    name: Optional[Global[T1Name]] = Field(default=as_global("T1", T1Name))
+
+
+class T1Basic(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    t1: T1 = Field(validation_alias="T1", serialization_alias="T1")
+
+
+E1Framing = Literal[
+    "crc4",
+    "no-crc4",
+]
+
+E1Linecode = Literal[
+    "ami",
+    "hdb3",
+]
+
+E1Name = Literal[
+    "E1",
+    # By default, the name is E1
+]
+
+
+class E1(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    framing: Optional[Union[Global[E1Framing], Variable, Default[None]]] = Field(default=None)
+    linecode: Optional[Union[Global[E1Linecode], Variable, Default[None]]] = Field(default=None)
+    name: Optional[Global[E1Name]] = Field(default=as_global("E1", E1Name))
+
+
+class E1Basic(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    e1: E1 = Field(validation_alias="E1", serialization_alias="E1")
+
+
+class CableLength(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    cable_length: Optional[Default[None]] = Field(
+        default=None, validation_alias="cableLength", serialization_alias="cableLength"
+    )
+
+
+LengthShort = Literal[
+    "110ft",
+    "220ft",
+    "330ft",
+    "440ft",
+    "550ft",
+    "660ft",
+]
+
+
+class CableLengthShort(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    cable_length: Optional[Global[Literal["short"]]] = Field(
+        default=None, validation_alias="cableLength", serialization_alias="cableLength"
+    )
+    length_short: Optional[Union[Global[LengthShort], Variable]] = Field(
+        default=None, validation_alias="lengthShort", serialization_alias="lengthShort"
+    )
+
+
+Long = Literal["long"]
+
+LengthLong = Literal[
+    "-15db",
+    "-22.5db",
+    "-7.5db",
+    "0db",
+]
+
+
+class CableLengthLong(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    cable_length: Optional[Global[Long]] = Field(
+        default=as_global("long", Long), validation_alias="cableLength", serialization_alias="cableLength"
+    )
+    length_long: Optional[Union[Global[LengthLong], Variable]] = Field(
+        default=None, validation_alias="lengthLong", serialization_alias="lengthLong"
+    )
+
+
+ClockSource = Literal[
+    "internal",
+    "line",
+    "loop-timed",
+    "network",
+]
+
+LineMode = Literal[
+    "primary",
+    "secondary",
+]
+
+
+class ChannelGroup(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    number: Union[Global[int], Variable] = Field()
+    timeslots: Union[Global[str], Variable] = Field()
+
+
+class ControllerTxExList(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    basic: Union[T1Basic, E1Basic]
+    cable: Optional[Union[CableLength, CableLengthShort, CableLengthLong]] = Field(default=None)
+    channel_group: Optional[List[ChannelGroup]] = Field(
+        default=None,
+        validation_alias="channelGroup",
+        serialization_alias="channelGroup",
+        description="Channel Group List",
+    )
+    clock_source: Optional[Union[Global[ClockSource], Default[None]]] = Field(
+        default=None, validation_alias="clockSource", serialization_alias="clockSource"
+    )
+    description: Optional[Union[Global[str], Variable, Default[None]]] = Field(default=None)
+    line_mode: Optional[Union[Global[LineMode], Variable, Default[None]]] = Field(
+        default=None, validation_alias="lineMode", serialization_alias="lineMode"
+    )
+
+
+class T1E1ControllerParcel(_ParcelBase):
+    model_config = ConfigDict(populate_by_name=True, extra="forbid")
+    type_: Literal["t1-e1-controller"] = Field(default="t1-e1-controller", exclude=True)
+    controller_tx_ex_list: List[ControllerTxExList] = Field(
+        validation_alias=AliasPath("data", "controllerTxExList"), description="Controller tx-ex List"
+    )
+    slot: Union[Global[str], Variable] = Field(validation_alias=AliasPath("data", "slot"))
+    type: Optional[Global[ControllerType]] = Field(default=None, validation_alias=AliasPath("data", "type"))

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/tests/test_endpoints.py

@@ -890,7 +890,7 @@ class TestAPIEndpoints(unittest.TestCase):
 
             @model_serializer(mode="wrap")
             def serialize(self, handler, info):
-                return VersionedField.update_model_fields(self.model_fields, handler(self), info)
+                return VersionedField.dump(self.model_fields, handler(self), info)
 
         class ExampleAPI(APIEndpoints):
             @request("POST", "/v1/data")

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/tests/test_feature_profile_api.py

@@ -47,7 +47,7 @@ from catalystwan.models.configuration.feature_profile.sdwan.system import (
     SecurityParcel,
     SNMPParcel,
 )
-from catalystwan.models.configuration.feature_profile.sdwan.transport import ManagementVpn
+from catalystwan.models.configuration.feature_profile.sdwan.transport import ManagementVpn, T1E1ControllerParcel
 
 system_endpoint_mapping = {
     AAAParcel: "aaa",
@@ -242,6 +242,7 @@ class TestServiceFeatureProfileAPI(unittest.TestCase):
 
 transport_enpoint_mapping = {
     ManagementVpn: "management/vpn",
+    T1E1ControllerParcel: "t1-e1-controller",
 }
 
 

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/catalystwan/tests/test_models_common.py

@@ -28,7 +28,7 @@ class VersionedFieldsModel(BaseModel):
 
     @model_serializer(mode="wrap")
     def dump(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> Dict[str, Any]:
-        return VersionedField.update_model_fields(self.model_fields, handler(self), info)
+        return VersionedField.dump(self.model_fields, handler(self), info)
 
 
 class Payload(BaseModel):

{catalystwan-0.33.4.dev2 → catalystwan-0.33.4.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "catalystwan"
-version = "0.33.4dev2"
+version = "0.33.4dev3"
 description = "Cisco Catalyst WAN SDK for Python"
 authors = ["kagorski <kagorski@cisco.com>"]
 readme = "README.md"