catalystwan 0.41.2__py3-none-any.whl → 0.41.2.dev0__py3-none-any.whl

catalystwan/api/template_api.py

@@ -5,13 +5,16 @@ from __future__ import annotations
 import json
 import logging
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Type, overload
+from typing import TYPE_CHECKING, Any, List, Optional, Type, overload
 
 from ciscoconfparse import CiscoConfParse  # type: ignore
+from typing_extensions import deprecated
 
 from catalystwan.api.task_status_api import Task
 from catalystwan.api.templates.cli_template import CLITemplate
 from catalystwan.api.templates.device_template.device_template import (
+    CreateDeviceInputPayload,
+    DeviceInputValues,
     DeviceSpecificValue,
     DeviceTemplate,
     GeneralTemplate,
@@ -19,6 +22,7 @@ from catalystwan.api.templates.device_template.device_template import (
 from catalystwan.api.templates.feature_template import FeatureTemplate
 from catalystwan.api.templates.feature_template_field import FeatureTemplateField
 from catalystwan.api.templates.feature_template_payload import FeatureTemplatePayload
+from catalystwan.api.templates.models.aaa_model import AAAModel
 from catalystwan.api.templates.models.cisco_aaa_model import CiscoAAAModel
 from catalystwan.api.templates.models.cisco_banner_model import CiscoBannerModel
 from catalystwan.api.templates.models.cisco_bfd_model import CiscoBFDModel
@@ -37,12 +41,15 @@ from catalystwan.api.templates.models.cli_template import CliTemplateModel
 from catalystwan.api.templates.models.omp_vsmart_model import OMPvSmart
 from catalystwan.api.templates.models.security_vsmart_model import SecurityvSmart
 from catalystwan.api.templates.models.system_vsmart_model import SystemVsmart
-from catalystwan.dataclasses import Device, DeviceTemplateInfo, FeatureTemplateInfo, FeatureTemplatesTypes, TemplateInfo
+from catalystwan.api.templates.models.vpn_vsmart_interface_model import VpnVsmartInterfaceModel
+from catalystwan.api.templates.models.vpn_vsmart_model import VpnVsmartModel
+from catalystwan.dataclasses import Device, FeatureTemplatesTypes
 from catalystwan.endpoints.configuration_device_template import FeatureToCLIPayload
-from catalystwan.exceptions import AttachedError, TemplateNotFoundError
+from catalystwan.exceptions import AttachedError, CatalystwanDeprecationWarning, TemplateNotFoundError
+from catalystwan.models.common import DeviceModel
+from catalystwan.models.templates import DeviceTemplateInformation, FeatureTemplateInformation, TemplateInformation
 from catalystwan.response import ManagerResponse
 from catalystwan.typed_list import DataSequence
-from catalystwan.utils.device_model import DeviceModel
 from catalystwan.utils.dict import merge
 from catalystwan.utils.pydantic_field import get_extra_field
 from catalystwan.utils.template_type import TemplateType
@@ -74,15 +81,15 @@ class TemplatesAPI:
         self.session = session
 
     @overload
-    def get(self, template: Type[DeviceTemplate]) -> DataSequence[DeviceTemplateInfo]:  # type: ignore
+    def get(self, template: Type[DeviceTemplate]) -> DataSequence[DeviceTemplateInformation]:
         ...
 
     @overload
-    def get(self, template: Type[FeatureTemplate]) -> DataSequence[FeatureTemplateInfo]:  # type: ignore
+    def get(self, template: Type[FeatureTemplate]) -> DataSequence[FeatureTemplateInformation]:
         ...
 
     @overload
-    def get(self, template: Type[CLITemplate]) -> DataSequence[TemplateInfo]:  # type: ignore
+    def get(self, template: Type[CLITemplate]) -> DataSequence[TemplateInformation]:
         ...
 
     def get(self, template):
@@ -100,33 +107,29 @@ class TemplatesAPI:
     def _get_feature_templates(
         self,
         summary: bool = True,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-    ) -> DataSequence[FeatureTemplateInfo]:
+    ) -> DataSequence[FeatureTemplateInformation]:
         """In a multitenant vManage system, this API is only available in the Provider view."""
-        endpoint = "/dataservice/template/feature"
-        params = {"summary": summary}
-
-        fr_templates = self.session.get(url=endpoint, params=params)
-
-        return fr_templates.dataseq(FeatureTemplateInfo)
+        return self.session.endpoints.configuration_general_template.get_feature_template_list(
+            params={"summary": summary}
+        )
 
     def _get_device_templates(
         self, feature: DeviceTemplateFeature = DeviceTemplateFeature.ALL
-    ) -> DataSequence[DeviceTemplateInfo]:
+    ) -> DataSequence[DeviceTemplateInformation]:
         """In a multitenant vManage system, this API is only available in the Provider view."""
-        endpoint = "/dataservice/template/device"
-        params = {"feature": feature.value}
-
-        templates = self.session.get(url=endpoint, params=params)
-        return templates.dataseq(DeviceTemplateInfo)
+        return self.session.endpoints.configuration_template_master.get_device_template_list(
+            params={"feature": feature.value}
+        )
 
     def attach(self, name: str, device: Device, timeout_seconds: int = 300, **kwargs):
-        template_type = self.get(DeviceTemplate).filter(name=name).single_or_default().config_type
-        if template_type == TemplateType.CLI:
+        template_info = self.get(DeviceTemplate).filter(name=name).single_or_default()
+        if not template_info:
+            raise TemplateNotFoundError(f"Template with name [{name}] does not exists.")
+
+        if template_info.config_type == TemplateType.CLI.value:
             return self._attach_cli(name, device, timeout_seconds=timeout_seconds, **kwargs)
 
-        if template_type == TemplateType.FEATURE:
+        if template_info.config_type == TemplateType.FEATURE.value:
             return self._attach_feature(name, device, timeout_seconds=timeout_seconds, **kwargs)
 
         raise NotImplementedError()
@@ -175,17 +178,19 @@ class TemplatesAPI:
         }
 
         invalid = False
+        msg = {}
         for var in vars:
             if var.property not in payload["deviceTemplateList"][0]["device"][0]:
                 pointer = payload["deviceTemplateList"][0]["device"][0]
                 if var.property not in kwargs["device_specific_vars"]:
                     invalid = True
+                    msg[var.property] = "should be provided in attach method as device_specific_vars kwarg."
                     logger.error(f"{var.property} should be provided in attach method as device_specific_vars kwarg.")
                 else:
                     pointer[var.property] = kwargs["device_specific_vars"][var.property]  # type: ignore
 
         if invalid:
-            raise TypeError()
+            raise TypeError(f"{msg}")
 
         endpoint = "/dataservice/template/device/config/attachfeature"
         logger.info(f"Attaching a template: {name} to the device: {device.hostname}.")
@@ -278,7 +283,7 @@ class TemplatesAPI:
     def delete(self, template: Type[CLITemplate], name: str) -> bool:  # type: ignore
         ...
 
-    def delete(self, template, name):
+    def delete(self, template, name) -> bool:
         status = False
 
         if template is FeatureTemplate:
@@ -375,12 +380,15 @@ class TemplatesAPI:
         if isinstance(template, DeviceTemplate):
             return self._edit_device_template(template)
 
+        if isinstance(template, CLITemplate):
+            return self._edit_cli_template(template, template_info)
+
         raise NotImplementedError()
 
     def _edit_device_template(self, template: DeviceTemplate):
         self._create_device_template(template, True)
 
-    def _edit_feature_template(self, template: FeatureTemplate, data: FeatureTemplateInfo) -> ManagerResponse:
+    def _edit_feature_template(self, template: FeatureTemplate, data: FeatureTemplateInformation) -> ManagerResponse:
         if self.is_created_by_generator(template):
             debug = False
             schema = self.get_feature_template_schema(template, debug)
@@ -393,6 +401,11 @@ class TemplatesAPI:
         response = self.session.put(f"/dataservice/template/feature/{data.id}", json=payload)
         return response
 
+    def _edit_cli_template(self, template: CLITemplate, data: TemplateInformation) -> ManagerResponse:
+        response = self.session.put(f"/dataservice/template/device/{data.id}", json=template.generate_payload())
+
+        return response
+
     @overload
     def create(self, template: FeatureTemplate, debug=False) -> str:
         ...
@@ -437,6 +450,9 @@ class TemplatesAPI:
         logger.info(f"Template {template.template_name} ({template_type}) was created successfully ({template_id}).")
         return template_id
 
+    @deprecated(
+        "Obsolete way to use Feature Templates - only create_by_generator", category=CatalystwanDeprecationWarning
+    )
     def _create_feature_template(self, template: FeatureTemplate) -> str:
         payload = template.generate_payload(self.session)
         response = self.session.post("/dataservice/template/feature", json=json.loads(payload))
@@ -453,8 +469,8 @@ class TemplatesAPI:
 
     def _create_device_template(self, device_template: DeviceTemplate, edit: bool = False) -> str:
         def get_general_template_info(
-            name: str, fr_templates: DataSequence[FeatureTemplateInfo]
-        ) -> FeatureTemplateInfo:
+            name: str, fr_templates: DataSequence[FeatureTemplateInformation]
+        ) -> FeatureTemplateInformation:
             _template = fr_templates.filter(name=name).single_or_default()
 
             if not _template:
@@ -464,19 +480,19 @@ class TemplatesAPI:
 
         def parse_general_template(
             general_template: GeneralTemplate,
-            fr_templates: DataSequence[FeatureTemplateInfo],
+            fr_templates: DataSequence[FeatureTemplateInformation],
         ) -> GeneralTemplate:
-            if general_template.subTemplates:
-                general_template.subTemplates = [
-                    parse_general_template(_t, fr_templates) for _t in general_template.subTemplates
+            if general_template.sub_templates:
+                general_template.sub_templates = [
+                    parse_general_template(_t, fr_templates) for _t in general_template.sub_templates
                 ]
             if general_template.name:
                 info = get_general_template_info(general_template.name, fr_templates)
                 return GeneralTemplate(
                     name=general_template.name,
-                    subTemplates=general_template.subTemplates,
-                    templateId=info.id,
-                    templateType=info.template_type,
+                    sub_templates=general_template.sub_templates,
+                    template_id=info.id,
+                    template_type=info.template_type,
                 )
             else:
                 return general_template
@@ -494,13 +510,18 @@ class TemplatesAPI:
                 .id
             )
             payload = json.loads(device_template.generate_payload())
-            response = self.session.put(f"/dataservice/template/device/{template_id}", json=payload)
+            response = self.session.endpoints.configuration_template_master.edit_template(
+                template_id=template_id, payload=payload
+            )
+            return response
         else:
-            endpoint = "/dataservice/template/device/feature/"
             payload = json.loads(device_template.generate_payload())
-            response = self.session.post(endpoint, json=payload)
-
-        return response.text
+            response = (
+                self.session.endpoints.configuration_template_master.create_device_template_from_feature_templates(
+                    payload=payload
+                )
+            )
+            return response.template_id
 
     def is_created_by_generator(self, template: FeatureTemplate) -> bool:
         """Checks if template is created by generator
@@ -508,6 +529,7 @@ class TemplatesAPI:
         Method will be deleted if every template's payload will be generated dynamically.
         """
         ported_templates = (
+            AAAModel,
             CiscoAAAModel,
             CiscoBFDModel,
             CiscoBannerModel,
@@ -526,6 +548,8 @@ class TemplatesAPI:
             CliTemplateModel,
             CiscoSecureInternetGatewayModel,
             CiscoOspfv3Model,
+            VpnVsmartModel,
+            VpnVsmartInterfaceModel,
         )
 
         return isinstance(template, ported_templates)
@@ -556,7 +580,7 @@ class TemplatesAPI:
             name=template.template_name,
             description=template.template_description,
             template_type=template.type,
-            device_types=[device_model.value for device_model in template.device_models],
+            device_types=[device_model for device_model in template.device_models],
             definition={},
         )  # type: ignore
 
@@ -566,6 +590,7 @@ class TemplatesAPI:
         for field in fr_template_fields:
             value = None
             priority_order = None
+            json_dumped_value = None
             # TODO How to discover Device specific variable
             if field.key in template.device_specific_variables:
                 value = template.device_specific_variables[field.key]
@@ -603,7 +628,7 @@ class TemplatesAPI:
         available_devices_for_template = [device["name"] for device in template_type.device_models]
 
         provided_device_models = [
-            dev_mod.value if type(dev_mod) is DeviceModel else dev_mod for dev_mod in template.device_models
+            dev_mod if type(dev_mod) is DeviceModel else dev_mod for dev_mod in template.device_models
         ]
 
         if not all(dev in available_devices_for_template for dev in provided_device_models):
@@ -698,3 +723,47 @@ class TemplatesAPI:
         config = CiscoConfParse(response["config"].splitlines())
         logger.debug(f"Template loaded from {device.hostname}.")
         return config
+
+    def get_feature_templates(self) -> DataSequence[FeatureTemplateInformation]:
+        endpoint = "/dataservice/template/feature"
+        fr_templates = self.session.get(endpoint)
+        return fr_templates.dataseq(FeatureTemplateInformation)
+
+    def get_device_templates(self) -> DataSequence[DeviceTemplateInformation]:
+        endpoint = "/dataservice/template/device"
+        params = {"feature": "all"}
+        templates = self.session.get(url=endpoint, params=params)
+        return templates.dataseq(DeviceTemplateInformation)
+
+    def get_device_template(self, template_id: str) -> DeviceTemplate:
+        endpoint = f"/dataservice/template/device/object/{template_id}"
+        response = self.session.get(endpoint)
+        return DeviceTemplate(**response.json())
+
+    def get_device_template_attached_devices_variables(self, template_id: str) -> List[DeviceInputValues]:
+        """
+        Fetches and processes attached device variables for a given device template.
+
+        Args:
+            template_id (str): The ID of the device template.
+
+        Returns:
+            List[DeviceInputValues]: A list of DeviceInputValues objects containing device variables.
+        """
+        api = self.session.endpoints.configuration_device_template
+
+        # Fetch attached devices for the template
+        attached_devices = api.get_device_config_attached(template_id)
+
+        # Prepare payload for fetching device variables
+        payload = CreateDeviceInputPayload(
+            template_id=template_id,
+            device_ids=[d.uuid for d in attached_devices if d.uuid],
+            is_edited=False,
+            is_master_edited=False,
+        )
+
+        # Fetch device variables
+        result = api.create_device_input(payload).data
+
+        return result

catalystwan/api/templates/README.md

@@ -3,10 +3,12 @@
 ## Feature Template Creation
 
 ```python
+from catalystwan.api.templates.models.omp_vsmart_model import OMPvSmart
+
 omp_vsmart = OMPvSmart(
     name="my_first_template",
     description="NA",
-    device_models=[DeviceModel.VSMART]
+    device_models=["vsmart"]
     
 )
 
@@ -14,74 +16,86 @@ session.api.templates.create(omp_vsmart)
 ```
 
 ## Add new Feature Template in Cisco Catalyst WAN SDK
-These steps will help you to automate feature template creation. We'll explain what to do and why, so everyone will have deep understanding how our templates work. In the example we will try to create `OMP` Feature Template for vSmart. 
 
-1. Get your template type name and version. 
+These steps will help you to automate feature template creation. We'll explain what to do and why, so everyone will have deep understanding how our templates work. In the example we will try to create `OMP` Feature Template for vSmart.
+
+1. Get your template type name and version.
     >Note: display name is not template type name!
+
 - For example, you could extract it from response body. Go to your Manager and create any template which you would like to automate in catalystwan. Send template creation request and check for `templateType` and `templateMinVersion` variable names. `OMP` (display name) for vSmart has `omp-vsmart` template type name.
 
 2. With corresponding `templateType` we are able to create new class which implements `FeatureTemplate` interface. Create new file in `catalystwan\api\templates\models\` and copy-paste the code and change name of the class with its type attribute.
 
-	```python
-	from pathlib import Path
-	from typing import ClassVar
-	from pydantic import ConfigDict
-	from catalystwan.api.templates.feature_template import FeatureTemplate
+```python
+from pathlib import Path
+from typing import ClassVar
+from pydantic import ConfigDict
+from catalystwan.api.templates.feature_template import FeatureTemplate
+
+
+class OMPvSmart(FeatureTemplate):
+    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
 
+    payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
+    type: ClassVar[str] = "omp-vsmart"
+```
 
-	class OMPvSmart(FeatureTemplate):
-		model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
-			
-		payload_path: ClassVar[Path] = Path(__file__).parent / "DEPRECATED"
-		type: ClassVar[str] = "omp-vsmart"
-	```
 3. (This step is temporary) Find `is_created_by_generator` method in `template_api` and add your new template class.
 
-	```python
-	ported_templates = (..., OMPvSmart)
-	```
-	NOTE: This step will be removed once all template payloads will be generated automatically.
+```python
+ported_templates = (..., OMPvSmart)
+```
+
+NOTE: This step will be removed once all template payloads will be generated automatically.
+
 4. (This step is temporary) Find `available_models` definition in 'supported' and add your new template class.
-	```python
-	available_models = {
-		(...)
-		'omp_vsmart': OMPvSmart
-	}
-	```
-	NOTE: This step will be removed once all template payloads will be generated dynamically.
+
+```python
+available_models = {
+    (...)
+    'omp_vsmart': OMPvSmart
+}
+```
+
+NOTE: This step will be removed once all template payloads will be generated dynamically.
+
 5. We can try to create our first template with default values.
-   ```python
-	omp_vsmart = OMPvSmart(
-		name="my_first_template",
-		description="NA",
-		device_models=[DeviceModel.VSMART]
-	)
 
-	session.api.templates.create(omp_vsmart)
-	```
-	If everything went successfuly, we will get similar message 
+```python
+omp_vsmart = OMPvSmart(
+    name="my_first_template",
+    description="NA",
+    device_models=["vsmart"]
+)
 
-	`Template my_first_template (FeatureTemplate) was created successfully (7e56acdd-640e-45dc-9335-87abc697995f).`
+session.api.templates.create(omp_vsmart)
+```
+
+If everything went successfuly, we will get similar message:
+
+`Template my_first_template (FeatureTemplate) was created successfully (7e56acdd-640e-45dc-9335-87abc697995f).`
 
 6. We can check whether our template is created sucessfully in Manager manually. If there is an error, please create an issue with error and try go to the 7th step.
-   
-### Customize Feature Template fields.
+
+### Customize Feature Template fields
+
 7. Run below code with already created session and changed corresponding variables.
 
-    ```python
-    # TODO: Use 2nd layer.
-    import json
+```python
+# TODO: Use 2nd layer.
+import json
 
 
-    template_type = "omp-vsmart" # Change this value
-    template_version = "15.0.0" # Change this value
-    endpoint = f"/dataservice/template/feature/types/definition/{template_type}/{template_version}"
+template_type = "omp-vsmart" # Change this value
+template_version = "15.0.0" # Change this value
+endpoint = f"/dataservice/template/feature/types/definition/{template_type}/{template_version}"
 
-    schema = session.get(url=endpoint).json()
+schema = session.get(url=endpoint).json()
 
-    with open(f"response_{template_type}.json", "w") as f:
-        f.write(json.dumps(schema, indent=4))
-    ```
+with open(f"response_{template_type}.json", "w") as f:
+    f.write(json.dumps(schema, indent=4))
+```
 
 8. Open `response_{template_type}.json` file.
+
 9. Find `fields` key. The value should be list of dictionaries. Get every possible key in the dictionary and fill our class with every possible key. You can find the code in `catalystwan\api\templates\models\omp_vsmart_model.py` file.

catalystwan/api/templates/cli_template.py

@@ -13,7 +13,7 @@ from requests.exceptions import HTTPError
 
 from catalystwan.dataclasses import Device
 from catalystwan.exceptions import TemplateTypeError
-from catalystwan.utils.device_model import DeviceModel
+from catalystwan.models.common import DeviceModel
 from catalystwan.utils.template_type import TemplateType
 
 logger = logging.getLogger(__name__)
@@ -62,21 +62,31 @@ class CLITemplate:
         logger.debug(f"Template loaded from {device.hostname}.")
         return self.config
 
+    def load_from_file(self, file: str) -> CiscoConfParse:
+        """Load CLI config from file.
+        Args:
+            file: The path of the file to be loaded.
+        Returns:
+            CiscoConfParse: Loaded template.
+        """
+        self.config = CiscoConfParse(file)
+        return self.config
+
     def generate_payload(self) -> dict:
         config_str = "\n".join(self.config.ioscfg)
         payload = {
             "templateName": self.template_name,
             "templateDescription": self.template_description,
-            "deviceType": self.device_model.value,
+            "deviceType": self.device_model,
             "templateConfiguration": config_str,
             "factoryDefault": False,
             "configType": "file",
         }
         if self.device_model not in [
-            DeviceModel.VEDGE,
-            DeviceModel.VSMART,
-            DeviceModel.VMANAGE,
-            DeviceModel.VBOND,
+            "vedge",
+            "vsmart",
+            "vmanage",
+            "vedge-cloud",
         ]:
             payload["cliType"] = "device"
             payload["draftMode"] = False
@@ -100,7 +110,7 @@ class CLITemplate:
             "templateId": id,
             "templateName": self.template_name,
             "templateDescription": self.template_description,
-            "deviceType": self.device_model.value,
+            "deviceType": self.device_model,
             "templateConfiguration": config_str,
             "factoryDefault": False,
             "configType": "file",