acex-devkit 1.0.0__tar.gz → 1.0.2__tar.gz

{acex_devkit-1.0.0 → acex_devkit-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acex-devkit
-Version: 1.0.0
+Version: 1.0.2
 Summary: ACE-X DevKit - Development kit for building ACE-X drivers and plugins
 License: AGPL-3.0
 Keywords: automation,devkit,sdk,drivers,plugins
@@ -11,6 +11,7 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: deepdiff (>=8.6.1,<9.0.0)
 Requires-Dist: pydantic (>=2.12.5,<3.0.0)
 Requires-Dist: typing-extensions (>=4.0.0,<5.0.0)
 Project-URL: Homepage, https://github.com/acex-labs/acex

{acex_devkit-1.0.0 → acex_devkit-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "acex-devkit"
-version = "1.0.0"
+version = "1.0.2"
 description = "ACE-X DevKit - Development kit for building ACE-X drivers and plugins"
 authors = ["Johan Lahti <johan.lahti@acebit.se>"]
 readme = "README.md"
@@ -16,6 +16,7 @@ packages = [
 python = "^3.13"
 pydantic = "^2.12.5"
 typing-extensions = "^4.0.0"
+deepdiff = "^8.6.1"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.0.0"

acex_devkit-1.0.2/src/acex_devkit/configdiffer/__init__.py

@@ -0,0 +1,2 @@
+
+from .configdiffer import Diff, ConfigDiffer, DiffNode, DiffOp

acex_devkit-1.0.2/src/acex_devkit/configdiffer/configdiffer.py

@@ -0,0 +1,230 @@
+from enum import Enum
+from typing import Any, Dict, Optional
+from pydantic import BaseModel, model_validator
+from deepdiff import DeepDiff
+
+
+class DiffOp(str, Enum):
+    ADD = "add"
+    REMOVE = "remove"
+    CHANGE = "change"
+
+
+class DiffNode(BaseModel):
+    op: DiffOp
+    before: Optional[Any] = None
+    after: Optional[Any] = None
+    children: Optional[Dict[str, "DiffNode"]] = None
+
+    @model_validator(mode="after")
+    def validate_invariants(self):
+        if self.op == DiffOp.ADD:
+            assert self.before is None and self.after is not None
+        elif self.op == DiffOp.REMOVE:
+            assert self.before is not None and self.after is None
+        elif self.op == DiffOp.CHANGE:
+            assert self.before is not None and self.after is not None
+        return self
+
+
+class Diff(BaseModel):
+    root: DiffNode
+
+    def is_empty(self) -> bool:
+        return not bool(self.root.children)
+
+    def summary(self) -> dict[str, int]:
+        stats = {"add": 0, "remove": 0, "change": 0}
+
+        def walk(node: DiffNode):
+            stats[node.op.value] += 1
+            if node.children:
+                for child in node.children.values():
+                    walk(child)
+
+        walk(self.root)
+        return stats
+
+
+
+class ConfigDiffer:
+
+    def diff(self, *, desired_config: dict, observed_config: dict) -> Diff:
+        children = self._diff_dicts(
+            desired=desired_config,
+            observed=observed_config,
+        )
+
+        root = DiffNode(
+            op=DiffOp.CHANGE,
+            before=observed_config,
+            after=desired_config,
+            children=children or None,
+        )
+
+        return Diff(root=root)
+
+    def _remove_keys(self, obj: dict, keys_to_remove: list[str]) -> dict:
+        cleaned = {}
+
+        for k, v in obj.items():
+            if k in keys_to_remove:
+                continue
+
+            if isinstance(v, dict):
+                cleaned[k] = self._remove_keys(v, keys_to_remove)
+            else:
+                cleaned[k] = v
+
+        return cleaned
+
+    def _diff_dicts(
+        self,
+        *,
+        desired: dict,
+        observed: dict,
+    ) -> Dict[str, DiffNode]:
+        """
+        Diff two dicts by traversing down to 'value' attributes and comparing them.
+        Returns a hierarchical structure of DiffNodes.
+        """
+
+        # Remove metadata:
+        ignored_keys = ["metadata"]
+        observed = self._remove_keys(observed.model_dump(), ignored_keys)
+        desired = self._remove_keys(desired.model_dump(), ignored_keys)
+
+        # Diff
+        diff = DeepDiff(
+            observed,
+            desired
+        )
+
+        result: Dict[str, DiffNode] = {}
+
+        # Handle added items
+        items_added = diff.get("dictionary_item_added", set())
+        for path in items_added:
+            keys = self._parse_path(path)
+            if keys:
+                value = self._get_nested_value(desired, keys)
+                self._add_to_result(result, keys, DiffNode(
+                    op=DiffOp.ADD,
+                    after=value
+                ))
+
+        # Handle removed items
+        items_removed = diff.get("dictionary_item_removed", set())
+        for path in items_removed:
+            keys = self._parse_path(path)
+            if keys:
+                value = self._get_nested_value(observed, keys)
+                self._add_to_result(result, keys, DiffNode(
+                    op=DiffOp.REMOVE,
+                    before=value
+                ))
+
+        # Handle changed values
+        values_changed = diff.get("values_changed", {})
+        for path, change in values_changed.items():
+            keys = self._parse_path(path)
+            if keys:
+                self._add_to_result(result, keys, DiffNode(
+                    op=DiffOp.CHANGE,
+                    before=change["old_value"],
+                    after=change["new_value"]
+                ))
+
+        return result
+
+    def _parse_path(self, path: str) -> list[str]:
+        """Parse DeepDiff path like "root['key1']['key2']" into ['key1', 'key2']"""
+        import re
+        matches = re.findall(r"\['([^']+)'\]|\[\"([^\"]+)\"\]", path)
+        return [m[0] or m[1] for m in matches]
+
+    def _get_nested_value(self, obj: dict, keys: list[str]) -> Any:
+        """Get value from nested dict using list of keys"""
+        current = obj
+        for key in keys:
+            if isinstance(current, dict):
+                current = current.get(key)
+            else:
+                return None
+        return current
+
+    def _add_to_result(self, result: Dict[str, DiffNode], keys: list[str], node: DiffNode):
+        """Add a DiffNode to the result dict at the appropriate nested location"""
+        if not keys:
+            return
+
+        if len(keys) == 1:
+            # Leaf node
+            result[keys[0]] = node
+        else:
+            # Need to create intermediate nodes
+            if keys[0] not in result:
+                # Create a CHANGE node as intermediate
+                result[keys[0]] = DiffNode(
+                    op=DiffOp.CHANGE,
+                    before={},
+                    after={},
+                    children={}
+                )
+            
+            # Ensure it has children dict
+            if result[keys[0]].children is None:
+                result[keys[0]].children = {}
+            
+            # Recursively add to children
+            self._add_to_result(result[keys[0]].children, keys[1:], node)
+
+    def apply_diff(self, config, diff: Diff):
+        """
+        Apply a diff to a configuration.
+        
+        Args:
+            config: The base configuration (ComposedConfiguration or dict)
+            diff: The diff to apply
+            
+        Returns:
+            A new configuration of the same type with the diff applied
+        """
+        import copy
+        from acex_devkit.models.composed_configuration import ComposedConfiguration
+        
+        # Convert to dict if it's a ComposedConfiguration
+        is_composed = isinstance(config, ComposedConfiguration)
+        config_dict = config.model_dump(mode="python") if is_composed else config
+        
+        # Deep copy to avoid modifying the original
+        result = copy.deepcopy(config_dict)
+        
+        def apply_node(target: dict, node: DiffNode, key: str):
+            """Apply a single diff node to the target dict."""
+            if node.op == DiffOp.ADD:
+                target[key] = node.after
+            elif node.op == DiffOp.REMOVE:
+                if key in target:
+                    del target[key]
+            elif node.op == DiffOp.CHANGE:
+                if node.children:
+                    # Has children - recurse deeper
+                    if key not in target:
+                        target[key] = {}
+                    for child_key, child_node in node.children.items():
+                        apply_node(target[key], child_node, child_key)
+                else:
+                    # Leaf value change
+                    target[key] = node.after
+        
+        # Apply all root-level changes
+        if diff.root.children:
+            for key, node in diff.root.children.items():
+                apply_node(result, node, key)
+        
+        # Return same type as input
+        if is_composed:
+            return ComposedConfiguration(**result)
+        return result
+        

{acex_devkit-1.0.0 → acex_devkit-1.0.2}/src/acex_devkit/drivers/base.py

@@ -3,8 +3,6 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict
 
-from acex_devkit.models.logical_node import LogicalNode
-
 
 class ParserBase(ABC):
     """Base class for configuration parsers."""
@@ -98,7 +96,7 @@ class NetworkElementDriver:
         self.parser = self.parser_class()
 
     @abstractmethod
-    def render(self, logical_node: LogicalNode, asset: Any = None) -> Any:
+    def render(self, logical_node: "LogicalNode", asset: Any = None) -> Any:
         """Render logical node to device configuration.
         
         Args:

{acex_devkit-1.0.0 → acex_devkit-1.0.2}/src/acex_devkit/drivers/base_driver.py

@@ -39,15 +39,14 @@ class NetworkElementDriver:
         self.parser = self.parser_class()
 
     @abstractmethod
-    def render(self, logical_node: "LogicalNode") -> Any:
-        """Tar en LogicalNode och returnerar en konfigurationsrepresentation."""
-        return self.renderer.render(logical_node.model_dump())
-
-
-    # def apply(self, model: Dict[str, Any]) -> None:
-    #     cfg = self.renderer.render(model)
-    #     self.transport.connect()
-    #     self.transport.send(cfg)
-    #     if not self.transport.verify():
-    #         self.transport.rollback()
-    #         raise RuntimeError("Verification failed – rollback executed")
+    def render(self, configuration: ComposedConfiguration, asset: "Asset") -> Any:
+        """Render configuration from composedconfig and asset."""
+        pass
+
+    @abstractmethod
+    def parse(self, configuration: str) -> ComposedConfiguration:
+        """
+        Parse observed configuration into a composedconfiguration object.
+        """
+
+    

{acex_devkit-1.0.0 → acex_devkit-1.0.2}/src/acex_devkit/models/__init__.py

@@ -3,5 +3,7 @@
 # TODO: Move all models to this package
 # TODO: Move all base classes to this package
 
+from .external_value import ExternalValue
+from .attribute_value import AttributeValue
 
 __all__ = []

acex_devkit-1.0.2/src/acex_devkit/models/attribute_value.py

@@ -0,0 +1,108 @@
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator, field_serializer
+from typing import Union, TypeVar, Generic, Optional, Dict, Any, get_args, get_origin
+from acex_devkit.models import ExternalValue
+
+T = TypeVar('T')
+
+class AttributeValue(BaseModel, Generic[T]):
+    """
+    A generic wrapper for values that may be concrete or external.
+    """
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    value: Union[T, ExternalValue]
+    metadata: Optional[Dict[str, Any]] = None
+
+    # ---------------------------------------------------------
+    # 1) PRE-PROCESSOR: Tillåt råa värden, ExternalValue direkt,
+    #    eller dict → AttributeValue
+    # ---------------------------------------------------------
+    @model_validator(mode="before")
+    @classmethod
+    def preprocess_raw(cls, data):
+        """
+        Gör varje typ av input till en fullvärdig {"value": ...} dict
+        så att Pydantic kan fortsätta normalt.
+        """
+        # 1) Rått värde (str, int, ExternalValue etc)
+        if not isinstance(data, dict):
+            return {"value": data}
+
+        # 2) Dict som representerar ExternalValue
+        if "value" not in data and "ref" in data:
+            return {"value": ExternalValue(**data)}
+
+        # 3) Dict som redan har value → låt vara
+        return data
+
+    # ---------------------------------------------------------
+    # 2) VALIDATOR för value
+    # ---------------------------------------------------------
+    @field_validator("value", mode="before")
+    @classmethod
+    def normalize_value(cls, v):
+        if isinstance(v, cls):
+            return v.value
+        if isinstance(v, ExternalValue):
+            return v
+        if isinstance(v, dict) and "ref" in v:
+            return ExternalValue(**v)
+        return v
+
+    # ---------------------------------------------------------
+    # 3) METADATA-generator (after)
+    #    Bevarar redan satt metadata!
+    # ---------------------------------------------------------
+    @model_validator(mode="after")
+    def set_automatic_metadata(self):
+        """
+        Lägg till metadata utan att ta bort användarens egna.
+        """
+        self.metadata = dict(self.metadata or {})  # KOPIA – ändra inte originalet
+
+        if isinstance(self.value, ExternalValue):
+            self.metadata.setdefault("value_type", "external")
+            self.metadata.setdefault("attr_ptr", self.value.attr_ptr)
+            self.metadata.setdefault("plugin", self.value.plugin)
+            self.metadata.setdefault(
+                "ev_type",
+                self.value.ev_type.value
+                if hasattr(self.value.ev_type, "value")
+                else self.value.ev_type,
+            )
+            self.metadata.setdefault("query", self.value.query)
+            self.metadata.setdefault("resolved", self.value.resolved)
+
+            if self.value.kind:
+                self.metadata.setdefault("kind", self.value.kind)
+
+            if self.value.resolved and self.value.resolved_at:
+                self.metadata.setdefault(
+                    "resolved_at",
+                    self.value.resolved_at.isoformat()
+                    if hasattr(self.value.resolved_at, "isoformat")
+                    else str(self.value.resolved_at),
+                )
+
+        else:
+            self.metadata.setdefault("value_type", "concrete")
+            self.metadata.setdefault("type", type(self.value).__name__)
+
+        return self
+
+    # ---------------------------------------------------------
+    # 4) SERIALIZER – external value → returnera dess "value"
+    # ---------------------------------------------------------
+    @field_serializer("value")
+    def serialize_value(self, value):
+        if isinstance(value, ExternalValue):
+            return value.value
+        return value
+
+    # Convenience helpers
+    def is_external(self) -> bool:
+        return isinstance(self.value, ExternalValue)
+
+    def get_value(self) -> T:
+        return self.value.value if isinstance(self.value, ExternalValue) else self.value
+

acex_devkit-1.0.2/src/acex_devkit/models/composed_configuration.py

@@ -0,0 +1,579 @@
+
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, List, Literal, ClassVar, Union, Any
+from enum import Enum
+
+from acex_devkit.models.external_value import ExternalValue
+from acex_devkit.models.attribute_value import AttributeValue
+from acex_devkit.models.logging import (
+    LoggingConfig,
+    Console,
+    RemoteServer,
+    VtyLine,
+    FileLogging,
+    LoggingEvents
+)
+from acex_devkit.models.spanning_tree import SpanningTree
+
+class MetadataValueType(str, Enum):
+    CONCRETE = "concrete"
+    EXTERNALVALUE = "externalValue"
+    REFERENCE = "reference"
+
+class Metadata(BaseModel):
+    type: Optional[str] = "str"
+    value_source: MetadataValueType = MetadataValueType.CONCRETE 
+
+class Reference(BaseModel): 
+    pointer: str
+    metadata: Metadata = Metadata(type="str", value_source="reference")
+
+class ReferenceTo(Reference):
+    pointer: str
+    metadata: Optional[Dict] = {}
+
+class ReferenceFrom(Reference):
+    pointer: str
+    metadata: Optional[Dict] = {}
+
+class RenderedReference(BaseModel):
+    from_ptr: str
+    to_ptr: str
+
+class SystemConfig(BaseModel):
+    contact: Optional[AttributeValue[str]] = None
+    domain_name: Optional[AttributeValue[str]] = None
+    hostname: Optional[AttributeValue[str]] = None
+    location: Optional[AttributeValue[str]] = None
+
+class TripleA(BaseModel): ...
+
+# Trying to avoid using "Logging" or "logging" as names for anything due to conflicts with standard lib.
+class LoggingComponents(BaseModel): 
+    config: LoggingConfig = LoggingConfig()
+    console: Optional[Console] = None
+    remote_servers: Optional[Dict[str, RemoteServer]] = {}
+    events: Optional[LoggingEvents] = None
+    vty: Optional[Dict[str, VtyLine]] = {}
+    files: Optional[Dict[str, FileLogging]] = {}
+
+class NtpConfig(BaseModel):
+    enabled: AttributeValue[bool] = AttributeValue(value=False)
+
+class NtpServer(BaseModel):
+    address: AttributeValue[str]
+    port: Optional[AttributeValue[int]] = None
+    version: Optional[AttributeValue[int]] = None
+    association_typ: Optional[AttributeValue[str]] = None
+    prefer: Optional[AttributeValue[bool]] = None
+    source_interface: Optional[AttributeValue[str]] = None
+
+class Ntp(BaseModel): 
+    config: Optional[NtpConfig] = None
+    servers: Optional[Dict[str, NtpServer]] = {}
+
+class SshServer(BaseModel): 
+    enable: Optional[AttributeValue[bool]] = None
+    protocol_version: Optional[AttributeValue[int]] = AttributeValue(value=2)
+    timeout: Optional[AttributeValue[int]] = None
+    auth_retries: Optional[AttributeValue[int]] = None
+    source_interface: Optional[Reference] = None
+
+class AuthorizedKeyAlgorithms(str, Enum):
+    SSH_ED25519 = "ssh-ed25519"
+    ECDSA_NISTP256 = "ecdsa-sha2-nistp256"
+    ECDSA_NISTP384 = "ecdsa-sha2-nistp384"
+    ECDSA_NISTP521 = "ecdsa-sha2-nistp521"
+    RSA_SHA2_256 = "rsa-sha2-256"
+    RSA_SHA2_512 = "rsa-sha2-512"
+    SK_SSH_ED25519 = "sk-ssh-ed25519@openssh.com"
+    SK_ECDSA_NISTP256 = "sk-ecdsa-sha2-nistp256@openssh.com"
+    SSH_RSA = "ssh-rsa"
+    SSH_DSS = "ssh-dss"
+
+class AuthorizedKey(BaseModel):
+    algorithm: AuthorizedKeyAlgorithms
+    public_key: str
+
+class Ssh(BaseModel): 
+    config: Optional[SshServer] = None
+    host_keys: Optional[Dict[str, AuthorizedKey]] = {}
+
+class Acl(BaseModel): ...
+class Lldp(BaseModel): ...
+
+class Vlan(BaseModel):
+    name: AttributeValue[str]
+    vlan_id: Optional[AttributeValue[int]] = None
+    vlan_name: Optional[AttributeValue[str]] = None
+    network_instance: Optional[AttributeValue[str]] = None
+    metadata: Optional[Metadata] = Metadata()
+
+class Interface(BaseModel): 
+    "Base class for all interfaces"
+    index: AttributeValue[int]
+    name: AttributeValue[str]
+
+    description: Optional[AttributeValue[str]] = None
+    enabled: Optional[AttributeValue[bool]] = None
+    ipv4: Optional[AttributeValue[str]] = None
+    
+    metadata: Optional[Metadata] = Metadata()
+    type: Literal[
+        "ethernetCsmacd",
+        "ieee8023adLag",
+        "l3ipvlan",
+        "softwareLoopback",
+        "subinterface",
+        "managementInterface"
+        ] = "ethernetCsmacd"
+    
+    model_config = {
+        "discriminator": "type"
+    }
+    
+
+class EthernetCsmacdInterface(Interface):
+    "Physical Interface"
+    type: Literal["ethernetCsmacd"] = "ethernetCsmacd"
+
+    # Egenskaper för fysiska interface
+    stack_index: Optional[AttributeValue[int]] = None
+    module_index: Optional[AttributeValue[int]] = None
+    subinterfaces: list["SubInterface"] = Field(default_factory=list)
+    speed: Optional[AttributeValue[int]] = None
+    duplex: Optional[AttributeValue[str]] = None
+    switchport: Optional[AttributeValue[bool]] = None
+    switchport_mode: Optional[AttributeValue[Literal["access", "trunk"]]] = None
+    trunk_allowed_vlans: Optional[AttributeValue[List[int]]] = None
+    native_vlan: Optional[AttributeValue[int]] = None
+    access_vlan: Optional[AttributeValue[int]] = None
+    vlan_id: Optional[AttributeValue[int]] = None
+    voice_vlan: Optional[AttributeValue[int]] = None
+    mtu: Optional[AttributeValue[int]] = None # No default set as it differs between devices and vendors
+    negotiation: Optional[AttributeValue[bool]] = None
+
+    # LACP relaterade attribut
+    aggregate_id: Optional[AttributeValue[int]] = None
+    lacp_enabled: Optional[AttributeValue[bool]] = None
+    lacp_mode: Optional[AttributeValue[Literal["active", "passive", "on", "auto"]]] = None
+    lacp_port_priority: Optional[AttributeValue[int]] = None
+    #lacp_system_id_mac: Optional[AttributeValue[str]] = None
+    lacp_interval: Optional[AttributeValue[Literal["fast", "slow"]]] = None
+
+    # Spanning-tree relaterade attribut
+    stp_port_priority: Optional[int] = None
+    stp_cost: Optional[int] = None
+    stp_edge_port: Optional[bool] = False # Disabled by default
+    stp_bpdu_filter: Optional[bool] = False # Disabled by default
+    stp_bpdu_guard: Optional[bool] = False # Disabled by default
+    stp_loop_guard: Optional[bool] = False # Disabled by default
+    stp_root_guard: Optional[bool] = False # Disabled by default
+    stp_portfast: Optional[bool] = False # Disabled by default
+    stp_link_type: Optional[Literal["point-to-point", "shared"]] = None  # e.g., "point-to-point", "shared"
+
+
+class Ieee8023adLagInterface(Interface):
+    "LAG Interface"
+    type: Literal["ieee8023adLag"] = "ieee8023adLag"
+    #aggregate_id: AttributeValue[int] = None
+    aggregate_id: int = None
+    members: list[str] = Field(default_factory=list)
+    max_ports: Optional[AttributeValue[int]] = None
+    switchport: Optional[AttributeValue[bool]] = None
+    switchport_mode: Optional[AttributeValue[Literal["access", "trunk"]]] = None
+    trunk_allowed_vlans: Optional[AttributeValue[List[int]]] = None
+    native_vlan: Optional[AttributeValue[int]] = None
+    mtu: Optional[AttributeValue[int]] = None # No default set as it differs between devices and vendors
+
+class L3IpvlanInterface(Interface):
+    "SVI Interface"
+    type: Literal["l3ipvlan"] = "l3ipvlan"
+    vlan_id: Optional[int] = None
+
+class SoftwareLoopbackInterface(Interface):
+    "Loopback Interface"
+    type: Literal["softwareLoopback"] = "softwareLoopback"
+
+    # Loopback har varken vlan, duplex eller speed
+    vlan_id: Optional[int] = None
+    ipv4: Optional[AttributeValue[str]] = None
+
+class SubInterface(Interface):
+    "Subinterface"
+    type: Literal["subinterface"] = "subinterface"
+
+    vlan_id: Optional[int] = None
+    ipv4: Optional[AttributeValue[str]] = None
+
+class ManagementInterface(Interface):
+    "Management Interface"
+    type: Literal["managementInterface"] = "managementInterface"
+
+    # Mgmt har inte vlan
+    vlan_id: Optional[int] = None
+
+class RouteTarget(BaseModel):
+    value: str # TODO: Add constraints and validators... 
+
+class ImportExportPolicy(BaseModel):
+    export_route_target: Optional[List[RouteTarget]] = None
+    import_route_target: Optional[List[RouteTarget]] = None
+
+class InterInstancePolicy(BaseModel):
+    import_export_policy: ImportExportPolicy
+
+class NetworkInstance(BaseModel): 
+    name: AttributeValue[str]
+    description: Optional[AttributeValue[str]] = None
+    vlans: Optional[Dict[str, Vlan]] = {}
+    interfaces: Optional[Dict[str, Reference]] = {}
+    inter_instance_policies: Optional[Dict[str, InterInstancePolicy]] = {}
+
+class LacpConfig(BaseModel):
+    system_priority: Optional[AttributeValue[int]] = None
+    system_id_mac: Optional[AttributeValue[str]] = None
+    load_balance_algorithm: Optional[AttributeValue[list[Literal["src-mac", "dst-mac", "src-dst-mac", "src-ip", "dst-ip", "src-dst-ip", "src-port", "dst-port", "src-dst-port"]]]] = None
+
+class Lacp(BaseModel):
+    config: Optional[LacpConfig] = LacpConfig()
+    interfaces: Optional[Dict[str, Interface]] = {}
+
+# SNMP
+class SnmpAccess(str, Enum):
+	READ_ONLY = "READ_ONLY"
+	READ_WRITE = "READ_WRITE"
+
+
+class SnmpSecurityLevel(str, Enum):
+	NO_AUTH_NO_PRIV = "NO_AUTH_NO_PRIV"
+	AUTH_NO_PRIV = "AUTH_NO_PRIV"
+	AUTH_PRIV = "AUTH_PRIV"
+
+
+class SnmpAuthProtocol(str, Enum):
+	MD5 = "MD5"
+	SHA1 = "SHA"
+	SHA224 = "SHA-224"
+	SHA256 = "SHA-256"
+	SHA384 = "SHA-384"
+	SHA512 = "SHA-512"
+
+
+class SnmpPrivProtocol(str, Enum):
+	DES = "DES"
+	TRIPLE_DES = "3DES"
+	AES128 = "AES128"
+	AES192 = "AES192"
+	AES256 = "AES256"
+
+
+class SnmpConfig(BaseModel):
+	enabled: AttributeValue[bool] = AttributeValue(value=False)
+	engine_id: Optional[AttributeValue[str]] = None
+	location: Optional[AttributeValue[str]] = None
+	contact: Optional[AttributeValue[str]] = None
+
+
+class SnmpCommunity(BaseModel):
+    name: AttributeValue[str]
+    community: Optional[AttributeValue[str]] = None # Community string
+    access: Optional[AttributeValue[SnmpAccess]] = AttributeValue(value=SnmpAccess.READ_ONLY)
+    view: Optional[AttributeValue[str]] = None
+    ipv4_acl: Optional[AttributeValue[str]] = None # Cisco and "liknande" vendors 
+    ipv6_acl: Optional[AttributeValue[str]] = None
+    source_interface: Optional[Reference] = None
+    clients: Optional[AttributeValue[List[str]]] = None # Juniper specific
+
+
+class SnmpUser(BaseModel):
+	username: AttributeValue[str]
+	security_level: Optional[AttributeValue[SnmpSecurityLevel]] = AttributeValue(value=SnmpSecurityLevel.NO_AUTH_NO_PRIV)
+	auth_protocol: Optional[AttributeValue[SnmpAuthProtocol]] = None
+	auth_password: Optional[AttributeValue[str]] = None
+	priv_protocol: Optional[AttributeValue[SnmpPrivProtocol]] = None
+	priv_password: Optional[AttributeValue[str]] = None
+
+
+class SnmpView(BaseModel):
+	name: AttributeValue[str]
+	oid: AttributeValue[str]
+	included: Optional[AttributeValue[bool]] = AttributeValue(value=True)
+
+
+class SnmpServer(BaseModel):
+    name: str
+    address: AttributeValue[str]
+    port: Optional[AttributeValue[int]] = AttributeValue(value=162)
+    enabled: Optional[AttributeValue[bool]] = AttributeValue(value=True)
+    version: Optional[AttributeValue[Literal["v2c", "v3"]]] = None
+    community: Optional[AttributeValue[str]] = None
+    username: Optional[AttributeValue[str]] = None
+    security_level: Optional[AttributeValue[SnmpSecurityLevel]] = None
+    source_interface: Optional[Reference] = None
+    network_instance: Optional[AttributeValue[str]] = None
+
+# ----------------------------
+# Enum-based trap groups
+# ----------------------------
+# En stor class med Enum	
+class TrapEventOptions(str, Enum):
+	VRF_UP = "vrf-up"
+	VRF_DOWN = "vrf-down"
+	VNET_TRUNK_UP = "vnet-trunk-up"
+	VNET_TRUNK_DOWN = "vnet-trunk-down"
+	ALL = "all"
+	RfEvent = 'enabled'
+	VlanMembershipEvent = 'enabled'
+	ErrdisableEvent = 'enabled'
+	CHANGE = "change"
+	MOVE = "move"
+	THRESHOLD = "threshold"
+	AUTHENTICATION = "authentication"
+	LINKDOWN = "linkdown"
+	LINKUP = "linkup"
+	COLDSTART = "coldstart"
+	WARMSTART = "warmstart"
+	FLOWMONEVENT = "trapflowmonevent"
+	ENTITYPERFEVENT = "trapentityperfevent"
+	PCALLHOMEEVENT_MESSAGE_SEND_FAIL = "trapcallhomeevent_MESSAGE_SEND_FAIL"
+	CALLHOMEEVENT_SERVER_FAIL = "trapcallhomeevent_SERVER_FAIL"	
+	TTYEVENT = "trapttyevent"
+	EIGRPEVENT = "trapeigrpevent"
+	OSPF_STATE_CHANGE = "ospf_state_change"
+	OSPF_ERRORS = "ospf_errors"
+	OSPF_RETRANSMIT = "ospf_retransmit"
+	OSPF_LSA = "ospf_lsa"
+	OSPF_CISCO_TRANS_CHANGE = "ospf_cisco_trans_change"
+	OSPF_CISCO_SHAMLINK_INTERFACE = "ospf_cisco_shamlink_interface"
+	OSPF_CISCO_SHAMLINK_NEIGHBOR = "ospf_cisco_shamlink_neighbor"
+	BFD_EVENT = "bfd_event"
+	CISCO_SMART_LICENSE_EVENT = "cisco_smart_license_event"
+	AUTH_FRAMEWORK_SEC_VIOLATION = "auth_framework_sec_violation"
+	REP_EVENT = "rep_event"
+	MEMORY_BUFFERPEAK = "memory_bufferpeak"
+	CONFIG_COPY = "config_copy"
+	CONFIG = "config"
+	CONFIG_CTID = "config_ctid"
+	ENERGYWISE_EVENT = "energy_wise_event"
+	FRU_CTRL_EVENT = "fru_ctrl_event"
+	ENTITY_EVENT = "entity_event"
+	FLASH_INSERTION = "flash_insertion"
+	FLASH_REMOVAL = "flash_removal"
+	FLASH_LOWSPACE = "flash_lowspace"
+	POWER_ETHERNET_POLICE = "power_ethernet_police"
+	POWER_ETHERNET_GROUP_THRESHOLD = "power_ethernet_group_threshold"
+	CPU_THRESHOLD = "cpu_threshold"
+	SYSLOG = "syslog"
+	UDLD_LINK_FAIL_RPT = "udld_link_fail_rpt"
+	UDLD_STATUS_CHANGE = "udld_status_change"
+	VTP_EVENT = "vtp_event"
+	VLAN_CREATE = "vlancreate"
+	VLAN_DELETE = "vlandelete"
+	PORT_SECURITY = "port_security"
+	ENV_MON = "env_mon"
+	STACKWISE = "stackwise"
+	MVPN = "mvpn"
+	PW_VC = "pw_vc"	
+	IPSLA = "ipsla"
+	DHCP = "dhcp"
+	EVENT_MANAGER = "event_manager"
+	IKE_POLICY_ADD = "ike_policy_add"
+	IKE_POLICY_DELETE = "ike_policy_delete"
+	IKE_TUNNEL_START = "ike_tunnel_start"
+	IKE_TUNNEL_STOP = "ike_tunnel_stop"
+	IPSEC_CRYPTOMAP_ADD = "ipsec_cryptomap_add"
+	IPSEC_CRYPTOMAP_DELETE = "ipsec_cryptomap_delete"
+	IPSEC_CRYPTOMAP_ATTACH = "ipsec_cryptomap_attach"
+	IPSEC_CRYPTOMAP_DETACH = "ipsec_cryptomap_detach"
+	IPSEC_TUNNEL_START = "ipsec_tunnel_start"
+	IPSEC_TUNNEL_STOP = "ipsec_tunnel_stop"
+	IPSEC_TOO_MANY_SAS = "ipsec_too_many_sas"
+	OSPFV3_STATE_CHANGE = "ospfv3_state_change"
+	OSPFV3_ERRORS = "ospfv3_errors"
+	IP_MULTICAST = "ip_multicast"
+	MSDP = "msdp"
+	PIM_NEIGHBOR_CHANGE = "pim_neighbor_change"
+	PIM_RP_MAPPING_CHANGE = "pim_rp_mapping_change"
+	INVALID_PIM_MESSAGE = "invalid_pim_message"
+	BRIDGE_NEWROOT = "bridge_newroot"
+	BRIDGE_TOPOLOGYCHANGE = "bridge_topologychange"
+	STPX_INCONSISTENCY = "stpx_inconsistency"
+	STPX_ROOT_INCONSISTENCY = "stpx_root_inconsistency"
+	STPX_LOOP_INCONSISTENCY = "stpx_loop_inconsistency"
+	BGP_CBG2 = "bgp_cbg2"
+	HSRP = "hsrp"
+	ISIS = "isis"
+	CEF_RESOURCE_FAILURE = "cef_resource_failure"
+	CEF_PEER_STATE_CHANGE = "cef_peer_state_change"
+	CEF_PEER_FIB_STATE_CHANGE = "cef_peer_fib_state_change"
+	CEF_INCONSISTENCY = "cef_inconsistency"
+	LISP = "lisp"
+	NHRP_NHS = "nhrp_nhs"
+	NHRP_NHC = "nhrp_nhc"
+	NHRP_NHP = "nhrp_nhp"
+	NHRP_QUOTA_EXCEEDED = "nhrp_quota_exceeded"
+	LOCAL_AUTH = "local_auth"
+	ENTITY_DIAG_BOOT_UP_FAIL = "entity_diag_boot_up_fail"
+	ENTITY_DIAG_HM_TEST_RECOVER = "entity_diag_hm_test_recover"
+	ENTITY_DIAG_HM_THRESH_REACHED = "entity_diag_hm_thresh_reached"
+	ENTITY_DIAG_SCHEDULED_TEST_FAIL = "entity_diag_scheduled_test_fail"
+	MPLS_RFC_LDP = "mpls_rfc_ldp"
+	MPLS_LDP = "mpls_ldp"
+	MPLS_RFC_TRAFFIC_ENG = "mpls_rfc_traffic_eng"
+	MPLS_TRAFFIC_ENG = "mpls_traffic_eng"
+	MPLS_FAST_REROUTE_PROTECTED = "mpls_fast_reroute_protected"
+	MPLS_VPN = "mpls_vpn"
+	MPLS_RFC_VPN = "mpls_rfc_vpn"
+	BULKSTAT_COLLECTION = "bulkstat_collection"
+	BULKSTAT_TRANSFER = "bulkstat_transfer"
+
+class TrapEvent(BaseModel):
+    name: str
+    event_name: TrapEventOptions
+
+#class SnmpTrap(BaseModel): ...
+
+class Snmp(BaseModel):
+    config: SnmpConfig = SnmpConfig()
+    communities: Optional[Dict[str, SnmpCommunity]] = {}
+    users: Optional[Dict[str, SnmpUser]] = {}
+    trap_servers: Optional[Dict[str, SnmpServer]] = {}
+    trap_events: Optional[Dict[str, TrapEvent]] = {}
+    views: Optional[Dict[str, SnmpView]] = {}
+
+# AAA
+class aaaBaseClass(BaseModel):
+    name: str = None
+
+class aaaTacacsAttributes(aaaBaseClass):
+    port: Optional[int] = 49
+    secret_key: Optional[str] = None
+    secret_key_hashed: Optional[str] = None
+    address: Optional[str] = None
+    timeout: Optional[int] = 30
+    source_address: Optional[str] = None #Optional[Reference] = None # should be reference
+
+class aaaRadiusAttributes(aaaBaseClass):
+    auth_port: Optional[int] = 1812
+    acct_port: Optional[int] = 1813
+    secret_key: Optional[str] = None
+    secret_key_hashed: Optional[str] = None
+    address: Optional[str] = None
+    timeout: Optional[int] = 30
+    source_address: Optional[str] = None #Optional[Reference] = None # should be reference
+    retransmit_attempts: Optional[int] = 3
+
+class aaaServerGroupAttributes(BaseModel):
+    enable: Optional[bool] = False
+    type: Optional[Literal['tacacs','radius']] = None
+    #servers: Optional[list] = None 
+    #address: Optional[str] = None 
+    #timeout: Optional[int] = 30
+    tacacs: Optional[Reference] = None
+    radius: Optional[Reference] = None
+
+# Authentication Models
+class aaaAuthenticationMethods(aaaBaseClass):
+    method: Optional[List[str]] = None # Ex. ['TACACS_GROUP','LOCAL'], TACACS_GROUP is reference to server group
+
+class authenticationUser(aaaBaseClass):
+    username: Optional[str] = None
+    password: Optional[str] = None
+    password_hahsed: Optional[str] = None
+    ssh_key: Optional[str] = None
+    role: Optional[str] = None
+
+class aaaAuthenticationUsers(aaaBaseClass):
+    username: Optional[Dict[str, authenticationUser]] = {}
+
+class adminUser(aaaBaseClass): # when to use this?
+    admin_password: Optional[str] = None
+    admin_password_hashed: Optional[str] = None
+
+class aaaAuthenticationAdminUsers(BaseModel):
+    config: Optional[Dict[str, adminUser]] = {}
+
+class aaaAuthentication(BaseModel):
+    config: Optional[Dict[str, aaaAuthenticationMethods]] = {}
+    admin_user: Optional[Dict[str, aaaAuthenticationAdminUsers]] = {}
+    users: Optional[Dict[str, aaaAuthenticationUsers]] = {}
+
+# Authorization Models
+class aaaAuthorizationMethods(aaaBaseClass):
+    method: Optional[List[str]] = None # Ex. ['TACACS_GROUP','LOCAL']
+
+class aaaAuthorizationEvent(aaaBaseClass):
+    event_type: dict = {
+        'event-type':'command',
+        'method':['tacacs_group']
+    }
+
+class aaaAuthorizationEvents(BaseModel):
+    event: Optional[Dict[str, aaaAuthorizationEvent]] = {}
+
+class aaaAuthorization(BaseModel):
+    config: Optional[Dict[str, aaaAuthorizationMethods]] = {}
+    events: Optional[Dict[str, aaaAuthorizationEvents]] = {}
+
+# Accounting Models
+class aaaAccountingMethods(BaseModel):
+    method: Optional[List[str]] = None # Ex. ['TACACS_GROUP','LOCAL']
+
+class aaaAccountingEvents(BaseModel):
+    event: list = [
+        {
+        'event-type': 'command',
+        'config': {
+            'event-type': 'command',
+            'method': ['tacacs_group']
+            }
+        },
+        {
+        'event-type': 'system',
+        'config': {
+            'event-type': 'system',
+            'method': ['tacacs_group']
+            }
+        }
+    ]
+
+class aaaAccounting(BaseModel):
+    config: aaaAccountingMethods = aaaAccountingMethods()
+    events: aaaAccountingEvents = aaaAccountingEvents()
+
+class TripleA(BaseModel):
+    #config: dict = None
+    server_groups: Optional[Dict[str, aaaServerGroupAttributes]] = {}
+    tacacs: Optional[Dict[str, aaaTacacsAttributes]] = {}
+    radius: Optional[Dict[str, aaaRadiusAttributes]] = {}
+    authentication: aaaAuthentication = aaaAuthentication()
+    authorization: aaaAuthorization = aaaAuthorization()
+    accounting: aaaAccounting = aaaAccounting()
+
+class System(BaseModel):
+    config: SystemConfig = SystemConfig()
+    aaa: Optional[TripleA] = TripleA()
+    logging: Optional[LoggingComponents] = LoggingComponents() # Trying to avoid using "Logging" or "logging" as names for anything due to conflicts with standard lib.
+    ntp: Optional[Ntp] = Ntp()
+    ssh: Optional[Ssh] = Ssh()
+    snmp: Optional[Snmp] = {}
+
+# For different types of interfaces that are fine for response model:
+InterfaceType = Union[
+    EthernetCsmacdInterface,
+    Ieee8023adLagInterface,
+    L3IpvlanInterface,
+    SoftwareLoopbackInterface,
+    SubInterface,
+    ManagementInterface,
+]
+
+class ComposedConfiguration(BaseModel):
+    system: Optional[System] = System()
+    acl: Optional[Acl] = Acl()
+    lldp: Optional[Lldp] = Lldp()
+    lacp: Optional[Lacp] = Lacp()
+    interfaces: Dict[str, InterfaceType] = {}
+    network_instances: Dict[str, NetworkInstance] = {"global": NetworkInstance(name="global")}
+    stp: Optional[SpanningTree] = {}

acex_devkit-1.0.2/src/acex_devkit/models/external_value.py

@@ -0,0 +1,42 @@
+from pydantic import BaseModel, ConfigDict, field_validator, field_serializer, PrivateAttr
+from sqlmodel import SQLModel, Field
+from typing import Literal, Callable, Optional, Any
+from datetime import datetime, timezone
+from enum import Enum
+
+
+class EVType(Enum):
+    data = "data"
+    resource = "resource"
+
+class ExternalValue(SQLModel, table=True):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    attr_ptr: str = Field(default=None, primary_key=True)
+    
+    # query: dict # same query as was used for fetching the data
+    query: str = '{"json_query": "in_stringformat"}'
+    value: Optional[str] = None
+    kind: str # object kind/type
+    ev_type: EVType = Field(default=EVType.data)
+    plugin: str
+    resolved: bool = Field(default=False)  # True when value has been resolved
+    resolved_at: Optional[datetime] = Field(default=None)  # Only set when resolved
+    
+    # Privat attribut för callable (inte i JSON eller databas)
+    _callable: Optional[Callable] = PrivateAttr(default=None)
+    
+    @field_validator('ev_type', mode='before')
+    @classmethod
+    def validate_ev_type(cls, v):
+        if isinstance(v, str):
+            return EVType(v)
+        return v
+
+    @field_serializer('ev_type')
+    def serialize_ev_type(self, value) -> str:
+        if isinstance(value, EVType):
+            return value.value
+        if isinstance(value, str):
+            return value
+        return str(value)
+

acex_devkit-1.0.2/src/acex_devkit/models/logging.py

@@ -0,0 +1,77 @@
+from pydantic import BaseModel
+from acex_devkit.models.attribute_value import AttributeValue
+from enum import Enum
+from typing import Optional, Dict
+
+
+class LoggingServerBase(BaseModel): ...
+    #name: str = None
+
+
+class LoggingSeverity(str, Enum): 
+    EMERGENCY = "EMERGENCY"
+    ALERT = "ALERT"
+    CRITICAL = "CRITICAL"
+    ERROR = "ERROR"
+    WARNING = "WARNING"
+    NOTICE = "NOTICE"
+    INFORMATIONAL = "INFORMATIONAL"
+    DEBUG = "DEBUG"
+
+class LoggingFacility(str, Enum):
+    # Some are specific for Juniper devices and are taken directly from their documentation.
+    KERN = "KERN"
+    USER = "USER"
+    DAEMON = "DAEMON"
+    AUTHORIZATION = "AUTHORIZATION"
+    FTP = "FTP"
+    NTP = "NTP"
+    DFC = "DFC"
+    EXTERNAL = "EXTERNAL"
+    FIREWALL = "FIREWALL"
+    PFE = "PFE"
+    CONFLICTLOG = "CONFLICTLOG"
+    CHANGELOG = "CHANGELOG"
+    INTERACTIVE_COMMANDS = "INTERACTIVE_COMMANDS"
+
+class Reference(BaseModel): ...
+
+class LoggingConfig(BaseModel):
+    rate_limit: Optional[AttributeValue[int]] = None
+    severity: Optional[AttributeValue[LoggingSeverity]] = None
+    buffer_size: Optional[AttributeValue[int]] = None
+
+class Console(BaseModel):
+    name: str = None
+    line_number: int = None
+    logging_synchronous: bool = True
+
+class RemoteServer(BaseModel):
+    name: str = None
+    host: str = None
+    port: Optional[int] = 514
+    transfer: Optional[str] = 'udp'
+    source_address: Optional[AttributeValue[str]] = None # Can be an IP address or an interface reference
+
+class VtyLine(BaseModel):
+    name: str = None
+    line_number: int = None
+    logging_synchronous: bool = True
+    transport_input: Optional[str] = 'ssh' # default is SSH. Mostly used by Cisco.
+
+class FileLogging(BaseModel):
+    name: str = None # object name
+    filename: str = None # name of the file
+    rotate: Optional[int] = None # How many versions to keep. Juniper specific. 
+    max_size: Optional[int] = None # Max size in bytes. Used both for Cisco and Juniper. 
+    min_size: Optional[int] = None # Min size in bytes. Only used for Cisco.
+    facility: LoggingFacility # Type of log
+    severity: LoggingSeverity # Severity level
+
+class LoggingEvent(BaseModel):
+    enabled: bool
+    severity: LoggingSeverity
+
+
+class LoggingEvents(BaseModel):
+    events: Optional[Dict[str, LoggingEvent]] = {}

acex_devkit-1.0.2/src/acex_devkit/models/ned.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class Ned(BaseModel):
+    name: str
+    package_name: str
+    version: str
+    description: str
+    filename: str

acex_devkit-1.0.2/src/acex_devkit/models/node_response.py

@@ -0,0 +1,22 @@
+
+
+from acex_devkit.models.composed_configuration import ComposedConfiguration
+
+
+class LogicalNodeResponse(BaseModel):
+    hostname: Optional[str] = Field('R1', title='Hostname')
+    role: Optional[str] = Field('core', title='Role')
+    site: Optional[str] = Field('HQ', title='Site')
+    sequence: Optional[int] = Field(1, title='Sequence')
+    id: Optional[int] = Field(None, title='Id')
+    configuration: Optional[ComposedConfiguration] = ComposedConfiguration()
+    meta_data: Optional[Dict[str, Any]] = Field(None, title='Meta Data')
+
+class NodeResponse(BaseModel):
+    asset_ref_id: int = Field(..., title='Asset Ref Id')
+    asset_ref_type: Optional[AssetRefType] = 'asset'
+    logical_node_id: int = Field(..., title='Logical Node Id')
+    asset: AssetResponse
+    logical_node: LogicalNodeResponse
+
+

acex_devkit-1.0.2/src/acex_devkit/models/spanning_tree.py

@@ -0,0 +1,64 @@
+from pydantic import BaseModel
+from acex_devkit.models.attribute_value import AttributeValue
+from enum import Enum
+from typing import Optional, Dict
+
+class SpanningTreeGlobalAttributes(BaseModel):
+    mode: Optional[str] = None # Needs to be defined by user. Default for Cisco is RAPID-PVST and for Juniper it's just RSTP
+    bpdu_filter: Optional[bool] = False # Disabled by default
+    bpdu_guard: Optional[bool] = False # Disabled by default
+    loop_guard: Optional[bool] = False # Disabled by default
+    portfast: Optional[bool] = False # Disabled by default. Global setting for access ports.
+    bridge_assurance: Optional[bool] = False # Disabled by default. Only supported by MST and PVRST+
+    #interfaces: Optional[Dict[str, Reference]] = {}
+
+class SpanningTreeModeConfig(BaseModel):
+    hello_time: Optional[int] = None
+    max_age: Optional[int] = None
+    forward_delay: Optional[int] = None
+    bridge_priority: Optional[int] = None
+    hold_count: Optional[int] = None # Range 1..10
+
+## RSTP
+class RstpAttributes(SpanningTreeModeConfig): ...
+
+class RSTPConfig(BaseModel):
+    config: RstpAttributes = RstpAttributes()
+
+### MSTP
+class MstpInstanceAttributes(SpanningTreeModeConfig):
+    instance_id: AttributeValue[int] # range: 1..4094
+    name: Optional[AttributeValue[str]] = None
+    vlan: Optional[AttributeValue[list[int]]] = None # List of VLANs mapped to the MST instance
+
+class MstpAttributes(SpanningTreeModeConfig):
+    revision: Optional[AttributeValue[int]] = None
+    max_hop: Optional[AttributeValue[int]] = None # Range 1..255
+
+class MSTPConfig(BaseModel):
+    config: MstpAttributes = MstpAttributes()
+    mst_instances: Optional[Dict[str, MstpInstanceAttributes]] = {}
+
+### Rapid PVST
+class RapidPVSTAttributes(SpanningTreeModeConfig):
+    """
+    Docstring for RapidPVSTAttributes
+    vlan can be a string or list. Depending on how NED is built it will check wether it's a single VLAN or multiple VLANs and then format the data to the correct format
+    for the command of the specific vendor.
+    For example for Cisco:
+    * Single VLAN
+        spanning-tree vlan 10 priority 8192
+    * Multiple VLANs
+        spanning-tree vlan 10-30 priority 8192
+    """
+    #vlan_id: Optional[AttributeValue[int]] = None  # Single VLAN ID or list of VLANs using Rapid PVST+
+    vlan: Optional[AttributeValue[int | list[int]]] = None  # Single VLAN ID or list of VLANs using Rapid PVST+
+
+class RapidPVSTConfig(BaseModel):
+    vlan: Optional[Dict[str, RapidPVSTAttributes]] = {}
+
+class SpanningTree(BaseModel):
+    config: SpanningTreeGlobalAttributes = SpanningTreeGlobalAttributes()
+    rstp: RSTPConfig = RSTPConfig()
+    mstp: MSTPConfig = MSTPConfig()
+    rapidpvst: RapidPVSTConfig = RapidPVSTConfig()