acex-devkit 1.1.2__tar.gz → 1.2.1__tar.gz

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acex-devkit
-Version: 1.1.2
+Version: 1.2.1
 Summary: ACE-X DevKit - Development kit for building ACE-X drivers and plugins
 License: AGPL-3.0
 Keywords: automation,devkit,sdk,drivers,plugins

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "acex-devkit"
-version = "1.1.2"
+version = "1.2.1"
 description = "ACE-X DevKit - Development kit for building ACE-X drivers and plugins"
 authors = ["Johan Lahti <johan.lahti@acebit.se>"]
 readme = "README.md"

acex_devkit-1.2.1/src/acex_devkit/configdiffer/configdiffer.py

@@ -0,0 +1,158 @@
+from pydantic import BaseModel
+from typing import Any, Dict, List, Optional, get_origin, get_args
+
+from acex_devkit.models.composed_configuration import ComposedConfiguration
+from acex_devkit.models.attribute_value import AttributeValue
+from acex_devkit.configdiffer.diff import Diff, ComponentChange, AttributeChange, ComponentDiffOp
+
+
+class ConfigDiffer:
+
+    def _is_dict_of_models(self, annotation) -> bool:
+        """Check if a type annotation is Dict[str, SomeBaseModel]."""
+        origin = get_origin(annotation)
+        if origin is dict:
+            args = get_args(annotation)
+            if len(args) == 2 and isinstance(args[1], type) and issubclass(args[1], BaseModel):
+                return True
+        return False
+
+    def _is_base_model(self, annotation) -> bool:
+        """Check if a type annotation is a BaseModel subclass (not Dict, not AttributeValue)."""
+        return (
+            isinstance(annotation, type)
+            and issubclass(annotation, BaseModel)
+            and not issubclass(annotation, AttributeValue)
+        )
+
+    def _unwrap_optional(self, annotation):
+        """Unwrap Optional[X] to X. Returns the annotation unchanged if not Optional."""
+        origin = get_origin(annotation)
+        if origin is type(None):
+            return annotation
+        args = get_args(annotation)
+        if args:
+            # Optional[X] is Union[X, None]
+            non_none = [a for a in args if a is not type(None)]
+            if len(non_none) == 1:
+                return non_none[0]
+        return annotation
+
+    def _flatten(self, model: BaseModel, path: tuple = ()) -> Dict[tuple, BaseModel]:
+        """
+        Recursively walk a Pydantic model using type annotations to find
+        all components. Returns a flat mapping of path → model instance.
+
+        Rules:
+        - Dict[str, BaseModel] → component collection, each entry is a leaf
+        - BaseModel (not in Dict) → container, recurse deeper
+        - AttributeValue / primitives / None → skip (attributes, not components)
+        """
+        result = {}
+
+        for field_name, field_info in model.model_fields.items():
+            annotation = self._unwrap_optional(field_info.annotation)
+            value = getattr(model, field_name)
+
+            if value is None:
+                continue
+
+            if self._is_dict_of_models(annotation):
+                # Component collection: each entry is a diffable component
+                for key, component in value.items():
+                    component_path = path + (field_name, key)
+                    result[component_path] = component
+
+            elif self._is_base_model(annotation):
+                # Recurse deeper — if nothing found, this model itself is a leaf component
+                child_path = path + (field_name,)
+                deeper = self._flatten(value, child_path)
+                if deeper:
+                    result.update(deeper)
+                else:
+                    result[child_path] = value
+
+        return result
+
+    def _attribute_changes(self, before: BaseModel, after: BaseModel) -> List[AttributeChange]:
+        """
+        Compare two component model instances and return a list of changed attributes.
+        """
+        changes = []
+        all_fields = set(before.model_fields.keys()) | set(after.model_fields.keys())
+
+        for field_name in all_fields:
+            b = getattr(before, field_name, None)
+            a = getattr(after, field_name, None)
+            if b != a:
+                changes.append(AttributeChange(attribute_name=field_name, before=b, after=a))
+
+        return changes
+
+    def diff(self, *, desired_config: ComposedConfiguration, observed_config: ComposedConfiguration) -> Diff:
+        """
+        Compare two ComposedConfiguration objects and return a component-based diff.
+
+        Uses Pydantic model introspection to find all components (entries in
+        Dict[str, BaseModel] fields). Components are identified by their full
+        path, e.g. ('interfaces', 'GigabitEthernet0/0/1').
+        """
+        flat_desired = self._flatten(desired_config)
+        flat_observed = self._flatten(observed_config)
+
+        desired_paths = set(flat_desired.keys())
+        observed_paths = set(flat_observed.keys())
+
+        added = []
+        removed = []
+        changed = []
+
+        for path in desired_paths - observed_paths:
+            obj = flat_desired[path]
+            added.append(ComponentChange(
+                op=ComponentDiffOp.ADD,
+                path=list(path),
+                component_type=type(obj),
+                component_name=path[-1],
+                before=None,
+                after=obj,
+                before_dict=None,
+                after_dict=obj.model_dump(),
+            ))
+
+        for path in observed_paths - desired_paths:
+            obj = flat_observed[path]
+            removed.append(ComponentChange(
+                op=ComponentDiffOp.REMOVE,
+                path=list(path),
+                component_type=type(obj),
+                component_name=path[-1],
+                before=obj,
+                after=None,
+                before_dict=obj.model_dump(),
+                after_dict=None,
+            ))
+
+        for path in desired_paths & observed_paths:
+            desired_obj = flat_desired[path]
+            observed_obj = flat_observed[path]
+            if desired_obj != observed_obj:
+                changed.append(ComponentChange(
+                    op=ComponentDiffOp.CHANGE,
+                    path=list(path),
+                    component_type=type(desired_obj),
+                    component_name=path[-1],
+                    before=observed_obj,
+                    after=desired_obj,
+                    before_dict=observed_obj.model_dump(),
+                    after_dict=desired_obj.model_dump(),
+                    changed_attributes=self._attribute_changes(observed_obj, desired_obj),
+                ))
+
+        return Diff(
+            added=added,
+            removed=removed,
+            changed=changed,
+            total_desired=len(desired_paths),
+            total_observed=len(observed_paths),
+        )

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/src/acex_devkit/configdiffer/diff.py

@@ -22,9 +22,11 @@ class ComponentDiffOp(str, Enum):
 
 class AttributeChange(BaseModel):
     """Represents a change to a single attribute within a component"""
+    model_config = {"arbitrary_types_allowed": True}
+
     attribute_name: str
-    before: Optional[AttributeValue[Any]] = None
-    after: Optional[AttributeValue[Any]] = None
+    before: Optional[Any] = None
+    after: Optional[Any] = None
 
 
 class ComponentChange(BaseModel):

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/src/acex_devkit/models/acl_model.py

@@ -67,13 +67,13 @@ class Ipv6AclEntryAttributes(IpAclOptions):
 class Ipv4AclAttributes(BaseModel):
     name: AttributeValue[str]
     type: AttributeValue[str] = "ipv4_acl"
-    acl_entries: Optional[Dict[str, Ipv4AclEntryAttributes]] = {}
+    acl_entries: Optional[Dict[str, Ipv4AclEntryAttributes]] = None
 
 class Ipv6AclAttributes(BaseModel):
     name: AttributeValue[str]
     type: AttributeValue[str] = "ipv6_acl"
-    acl_entries: Optional[Dict[str, Ipv6AclEntryAttributes]] = {}
+    acl_entries: Optional[Dict[str, Ipv6AclEntryAttributes]] = None
     
 class Acl(BaseModel):
-    ipv4_acls: Optional[Dict[str, Ipv4AclAttributes]] = {}
-    ipv6_acls: Optional[Dict[str, Ipv6AclAttributes]] = {}
+    ipv4_acls: Optional[Dict[str, Ipv4AclAttributes]] = None
+    ipv6_acls: Optional[Dict[str, Ipv6AclAttributes]] = None

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/src/acex_devkit/models/composed_configuration.py

@@ -55,10 +55,10 @@ class SystemConfig(BaseModel):
 class LoggingComponents(BaseModel): 
     config: LoggingConfig = LoggingConfig()
     console: Optional[Console] = None
-    remote_servers: Optional[Dict[str, RemoteServer]] = {}
+    remote_servers: Optional[Dict[str, RemoteServer]] = None
     events: Optional[LoggingEvents] = None
-    vty: Optional[Dict[str, VtyLine]] = {}
-    files: Optional[Dict[str, FileLogging]] = {}
+    vty: Optional[Dict[str, VtyLine]] = None
+    files: Optional[Dict[str, FileLogging]] = None
 
 class NtpConfig(BaseModel):
     enabled: AttributeValue[bool] = AttributeValue(value=False)
@@ -73,7 +73,7 @@ class NtpServer(BaseModel):
 
 class Ntp(BaseModel): 
     config: Optional[NtpConfig] = None
-    servers: Optional[Dict[str, NtpServer]] = {}
+    servers: Optional[Dict[str, NtpServer]] = None
 
 class SshServer(BaseModel): 
     enable: Optional[AttributeValue[bool]] = None
@@ -100,7 +100,7 @@ class AuthorizedKey(BaseModel):
 
 class Ssh(BaseModel): 
     config: Optional[SshServer] = None
-    host_keys: Optional[Dict[str, AuthorizedKey]] = {}
+    host_keys: Optional[Dict[str, AuthorizedKey]] = None
 
 class Lldp(BaseModel): ...
 
@@ -164,23 +164,22 @@ class EthernetCsmacdInterface(Interface):
     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"
+    stp_port_priority: Optional[AttributeValue[int]] = None
+    stp_cost: Optional[AttributeValue[int]] = None
+    stp_edge_port: Optional[AttributeValue[bool]] = None
+    stp_bpdu_filter: Optional[AttributeValue[bool]] = None
+    stp_bpdu_guard: Optional[AttributeValue[bool]] = None
+    stp_loop_guard: Optional[AttributeValue[bool]] = None
+    stp_root_guard: Optional[AttributeValue[bool]] = None
+    stp_portfast: Optional[AttributeValue[bool]] = None
+    stp_link_type: Optional[AttributeValue[Literal["point-to-point", "shared"]]] = None
 
 
 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)
+    aggregate_id: Optional[AttributeValue[int]] = None
+    members: Optional[AttributeValue[List[str]]] = None
     max_ports: Optional[AttributeValue[int]] = None
     switchport: Optional[AttributeValue[bool]] = None
     switchport_mode: Optional[AttributeValue[Literal["access", "trunk"]]] = None
@@ -226,15 +225,15 @@ class StaticRouteNextHop(BaseModel):
 class StaticRoute(BaseModel):
     route_name: Optional[AttributeValue[str]] = None
     prefix: AttributeValue[str]
-    next_hops: Optional[Dict[str, StaticRouteNextHop]] = {}
+    next_hops: Optional[Dict[str, StaticRouteNextHop]] = None
     network_instance: Optional[AttributeValue[str]] = None
 
 class Protocols(BaseModel):
-    static_routes: Optional[Dict[str, StaticRoute]] = {}
+    static_routes: Optional[Dict[str, StaticRoute]] = None
     # OSPF, BGP, etc. can be added here as needed
 
 class RouteTarget(BaseModel):
-    value: str # TODO: Add constraints and validators... 
+    value: Optional[AttributeValue[str]] = None
 
 class ImportExportPolicy(BaseModel):
     export_route_target: Optional[List[RouteTarget]] = None
@@ -246,9 +245,9 @@ class InterInstancePolicy(BaseModel):
 class NetworkInstance(BaseModel): 
     name: AttributeValue[str]
     description: Optional[AttributeValue[str]] = None
-    vlans: Optional[Dict[str, Vlan]] = {}
+    vlans: Optional[Dict[str, Vlan]] = None
     interfaces: Optional[Dict[str, Reference]] = {}
-    inter_instance_policies: Optional[Dict[str, InterInstancePolicy]] = {}
+    inter_instance_policies: Optional[Dict[str, InterInstancePolicy]] = None
     protocols: Optional[Protocols] = Protocols()
 
 class LacpConfig(BaseModel):
@@ -258,7 +257,7 @@ class LacpConfig(BaseModel):
 
 class Lacp(BaseModel):
     config: Optional[LacpConfig] = LacpConfig()
-    interfaces: Optional[Dict[str, Interface]] = {}
+    interfaces: Optional[Dict[str, Interface]] = None
 
 # SNMP
 class SnmpAccess(str, Enum):
@@ -323,7 +322,7 @@ class SnmpView(BaseModel):
 
 
 class SnmpServer(BaseModel):
-    name: str
+    name: Optional[AttributeValue[str]] = None
     address: AttributeValue[str]
     port: Optional[AttributeValue[int]] = AttributeValue(value=162)
     enabled: Optional[AttributeValue[bool]] = AttributeValue(value=True)
@@ -450,41 +449,41 @@ class TrapEventOptions(str, Enum):
 	BULKSTAT_TRANSFER = "bulkstat_transfer"
 
 class TrapEvent(BaseModel):
-    name: str
-    event_name: TrapEventOptions
+    name: Optional[AttributeValue[str]] = None
+    event_name: Optional[AttributeValue[TrapEventOptions]] = None
 
 #class SnmpTrap(BaseModel): ...
 
 class Snmp(BaseModel):
-    config: Optional[Dict[str, 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]] = {}
+    config: Optional[Dict[str, SnmpConfig]] = None
+    communities: Optional[Dict[str, SnmpCommunity]] = None
+    users: Optional[Dict[str, SnmpUser]] = None
+    trap_servers: Optional[Dict[str, SnmpServer]] = None
+    trap_events: Optional[Dict[str, TrapEvent]] = None
+    views: Optional[Dict[str, SnmpView]] = None
 
 # AAA
 class aaaBaseClass(BaseModel):
-    name: str = None
+    name: Optional[AttributeValue[str]] = None
 
 class aaaTacacsAttributes(BaseModel):
-    port: Optional[int] = 49
-    secret_key: Optional[str] = None
-    secret_key_hashed: Optional[str] = None
-    address: Optional[str] = None
-    timeout: Optional[int] = 30
-    source_interface: Optional[Reference] = None #Optional[Reference] = None # should be reference
+    port: Optional[AttributeValue[int]] = None
+    secret_key: Optional[AttributeValue[str]] = None
+    secret_key_hashed: Optional[AttributeValue[str]] = None
+    address: Optional[AttributeValue[str]] = None
+    timeout: Optional[AttributeValue[int]] = None
+    source_interface: Optional[Reference] = None
     server_group: Optional[AttributeValue[str]] = None
 
 class aaaRadiusAttributes(BaseModel):
-    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_interface: Optional[Reference] = None #Optional[Reference] = None # should be reference
-    retransmit_attempts: Optional[int] = 3
+    auth_port: Optional[AttributeValue[int]] = None
+    acct_port: Optional[AttributeValue[int]] = None
+    secret_key: Optional[AttributeValue[str]] = None
+    secret_key_hashed: Optional[AttributeValue[str]] = None
+    address: Optional[AttributeValue[str]] = None
+    timeout: Optional[AttributeValue[int]] = None
+    source_interface: Optional[Reference] = None
+    retransmit_attempts: Optional[AttributeValue[int]] = None
     server_group: Optional[AttributeValue[str]] = None
 
 class aaaServerGroupAttributes(BaseModel):
@@ -494,13 +493,13 @@ class aaaServerGroupAttributes(BaseModel):
     Type is used to tell future renderers what kind of server group this is.
     Example:
     type = 'tacacs' or type = 'radius'
-    
+
     The tacacs and radius attributes expect a reference to the aaaTacacs and aaaRadius models respectively.
 
     Example in config map:
     enable = True
     type = 'tacacs'
-    tacacs = [tacacs_server1, tacacs_server2] 
+    tacacs = [tacacs_server1, tacacs_server2]
     radius = radius_server1
 
     Cisco example:
@@ -508,10 +507,10 @@ class aaaServerGroupAttributes(BaseModel):
      server name tacacs_server1
      server name tacacs_server2
     """
-    enable: Optional[bool] = False
-    type: Optional[Literal['tacacs','radius']] = None
-    tacacs: Optional[Dict[str, aaaTacacsAttributes]] = {} #Optional[Dict[str, Reference]] = None
-    radius: Optional[Dict[str, aaaRadiusAttributes]] = {} #Optional[Dict[str, Reference]] = None
+    enable: Optional[AttributeValue[bool]] = None
+    type: Optional[AttributeValue[Literal['tacacs','radius']]] = None
+    tacacs: Optional[Dict[str, aaaTacacsAttributes]] = None
+    radius: Optional[Dict[str, aaaRadiusAttributes]] = None
 
 # Authentication Models
 class aaaAuthenticationMethods(aaaBaseClass):
@@ -534,26 +533,26 @@ class aaaAuthenticationMethods(aaaBaseClass):
     # aaa authentication enable default group TACACS-GROUP-NEW enable
 
 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
+    username: Optional[AttributeValue[str]] = None
+    password: Optional[AttributeValue[str]] = None
+    password_hahsed: Optional[AttributeValue[str]] = None
+    ssh_key: Optional[AttributeValue[str]] = None
+    role: Optional[AttributeValue[str]] = None
 
 class aaaAuthenticationUsers(aaaBaseClass):
-    username: Optional[Dict[str, authenticationUser]] = {}
+    username: Optional[Dict[str, authenticationUser]] = None
 
-class adminUser(aaaBaseClass): # when to use this?
-    admin_password: Optional[str] = None
-    admin_password_hashed: Optional[str] = None
+class adminUser(aaaBaseClass):
+    admin_password: Optional[AttributeValue[str]] = None
+    admin_password_hashed: Optional[AttributeValue[str]] = None
 
 class aaaAuthenticationAdminUsers(BaseModel):
-    config: Optional[Dict[str, adminUser]] = {}
+    config: Optional[Dict[str, adminUser]] = None
 
 class aaaAuthentication(BaseModel):
-    config: Optional[Dict[str, aaaAuthenticationMethods]] = {}
-    admin_user: Optional[Dict[str, aaaAuthenticationAdminUsers]] = {}
-    users: Optional[Dict[str, aaaAuthenticationUsers]] = {}
+    config: Optional[Dict[str, aaaAuthenticationMethods]] = None
+    admin_user: Optional[Dict[str, aaaAuthenticationAdminUsers]] = None
+    users: Optional[Dict[str, aaaAuthenticationUsers]] = None
 
 # Authorization Models
 class aaaAuthorizationMethods(aaaBaseClass):
@@ -583,10 +582,8 @@ class aaaAuthorizationEvents(aaaBaseClass):
     event: Optional[AttributeValue[str]] = None
 
 class aaaAuthorization(BaseModel):
-    #config: Optional[Dict[str, aaaAuthorizationMethods]] = {}
-    config: Optional[Dict[str, aaaAuthorizationMethods]] = {}
-    #events: Optional[Dict[str, aaaAuthorizationEvents]] = {}
-    events: Optional[Dict[str, aaaAuthorizationEvents]] = {}
+    config: Optional[Dict[str, aaaAuthorizationMethods]] = None
+    events: Optional[Dict[str, aaaAuthorizationEvents]] = None
 
 # Accounting Models
 class aaaAccountingMethods(BaseModel):
@@ -614,17 +611,15 @@ class aaaAccountingEvents(BaseModel):
     event: Optional[AttributeValue[str]] = None
 
 class aaaAccounting(BaseModel):
-    #config: aaaAccountingMethods = aaaAccountingMethods()
-    config: Optional[Dict[str, aaaAccountingMethods]] = {}
-    #events: aaaAccountingEvents = aaaAccountingEvents()
-    events: Optional[Dict[str, aaaAccountingEvents]] = {}
+    config: Optional[Dict[str, aaaAccountingMethods]] = None
+    events: Optional[Dict[str, aaaAccountingEvents]] = None
 
 class aaaGlobalAttributes(BaseModel):
     enabled: Optional[AttributeValue[bool]] = False # default False
 
 class TripleA(BaseModel):
     config: aaaGlobalAttributes = aaaGlobalAttributes()
-    server_groups: Optional[Dict[str, aaaServerGroupAttributes]] = {}
+    server_groups: Optional[Dict[str, aaaServerGroupAttributes]] = None
     authentication: aaaAuthentication = aaaAuthentication()
     authorization: aaaAuthorization = aaaAuthorization()
     accounting: aaaAccounting = aaaAccounting()
@@ -654,4 +649,14 @@ class ComposedConfiguration(BaseModel):
     lacp: Optional[Lacp] = Lacp()
     interfaces: Dict[str, InterfaceType] = {}
     network_instances: Dict[str, NetworkInstance] = {"global": NetworkInstance(name="global")}
-    stp: Optional[SpanningTree] = SpanningTree()
+    stp: Optional[SpanningTree] = SpanningTree()
+
+
+""" 
+GUIDELINES FOR COMPOSED CONFIGURATION:
+
+1. All values must always be typed as AttributeValue.
+2. Containers must always be defined as hierarchical pydantic types, no dicts as placeholders.
+3. Component collections are always Dict[str, BaseModel] — the key identifies the component
+4. Default values for Optional is always None.
+"""

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/src/acex_devkit/models/logging.py

@@ -42,36 +42,36 @@ class LoggingConfig(BaseModel):
     buffer_size: Optional[AttributeValue[int]] = None
 
 class Console(BaseModel):
-    name: str = None
-    line_number: int = None
-    logging_synchronous: bool = True
+    name: Optional[AttributeValue[str]] = None
+    line_number: Optional[AttributeValue[int]] = None
+    logging_synchronous: Optional[AttributeValue[bool]] = None
 
 class RemoteServer(BaseModel):
-    name: str = None
-    host: str = None
-    port: Optional[int] = 514
-    transfer: Optional[str] = 'udp'
+    name: Optional[AttributeValue[str]] = None
+    host: Optional[AttributeValue[str]] = None
+    port: Optional[AttributeValue[int]] = None
+    transfer: Optional[AttributeValue[str]] = None
     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.
+    name: Optional[AttributeValue[str]] = None
+    line_number: Optional[AttributeValue[int]] = None
+    logging_synchronous: Optional[AttributeValue[bool]] = None
+    transport_input: Optional[AttributeValue[str]] = None # 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
+    name: Optional[AttributeValue[str]] = None # object name
+    filename: Optional[AttributeValue[str]] = None # name of the file
+    rotate: Optional[AttributeValue[int]] = None # How many versions to keep. Juniper specific.
+    max_size: Optional[AttributeValue[int]] = None # Max size in bytes. Used both for Cisco and Juniper.
+    min_size: Optional[AttributeValue[int]] = None # Min size in bytes. Only used for Cisco.
+    facility: Optional[AttributeValue[LoggingFacility]] = None # Type of log
+    severity: Optional[AttributeValue[LoggingSeverity]] = None # Severity level
 
 class LoggingEvent(BaseModel):
-    enabled: bool
-    severity: LoggingSeverity
+    enabled: Optional[AttributeValue[bool]] = None
+    severity: Optional[AttributeValue[LoggingSeverity]] = None
 
 
 class LoggingEvents(BaseModel):
-    events: Optional[Dict[str, LoggingEvent]] = {}
+    events: Optional[Dict[str, LoggingEvent]] = None

{acex_devkit-1.1.2 → acex_devkit-1.2.1}/src/acex_devkit/models/spanning_tree.py

@@ -4,27 +4,27 @@ 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]] = {}
+    mode: Optional[AttributeValue[str]] = None # Needs to be defined by user. Default for Cisco is RAPID-PVST and for Juniper it's just RSTP
+    bpdu_filter: Optional[AttributeValue[bool]] = None # Disabled by default
+    bpdu_guard: Optional[AttributeValue[bool]] = None # Disabled by default
+    loop_guard: Optional[AttributeValue[bool]] = None # Disabled by default
+    portfast: Optional[AttributeValue[bool]] = None # Disabled by default. Global setting for access ports.
+    bridge_assurance: Optional[AttributeValue[bool]] = None # Disabled by default. Only supported by MST and PVRST+
+    #interfaces: Optional[Dict[str, Reference]] = None
 
 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
+    hello_time: Optional[AttributeValue[int]] = None
+    max_age: Optional[AttributeValue[int]] = None
+    forward_delay: Optional[AttributeValue[int]] = None
+    bridge_priority: Optional[AttributeValue[int]] = None
+    hold_count: Optional[AttributeValue[int]] = None # Range 1..10
 
 ## RSTP
 class RstpAttributes(SpanningTreeModeConfig): ...
 
 class RSTPConfig(BaseModel):
     #config: RstpAttributes = RstpAttributes()
-    config: Optional[Dict[str, RstpAttributes]] = {}
+    config: Optional[Dict[str, RstpAttributes]] = None
 
 ### MSTP
 class MstpInstanceAttributes(SpanningTreeModeConfig):
@@ -38,8 +38,8 @@ class MstpAttributes(SpanningTreeModeConfig):
 
 class MSTPConfig(BaseModel):
     #config: MstpAttributes = MstpAttributes()
-    config: Optional[Dict[str, MstpAttributes]] = {}
-    mst_instances: Optional[Dict[str, MstpInstanceAttributes]] = {}
+    config: Optional[Dict[str, MstpAttributes]] = None
+    mst_instances: Optional[Dict[str, MstpInstanceAttributes]] = None
 
 ### Rapid PVST
 class RapidPVSTAttributes(SpanningTreeModeConfig):
@@ -57,10 +57,10 @@ class RapidPVSTAttributes(SpanningTreeModeConfig):
     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]] = {}
+    vlan: Optional[Dict[str, RapidPVSTAttributes]] = None
 
 class SpanningTree(BaseModel):
-    config: Optional[Dict[str, SpanningTreeGlobalAttributes]] = {}#SpanningTreeGlobalAttributes()
+    config: Optional[Dict[str, SpanningTreeGlobalAttributes]] = None#SpanningTreeGlobalAttributes()
     rstp: Optional[RSTPConfig] = RSTPConfig()
     mstp: Optional[MSTPConfig] = MSTPConfig()
     rapidpvst: Optional[RapidPVSTConfig] = RapidPVSTConfig()

acex_devkit-1.1.2/src/acex_devkit/configdiffer/configdiffer.py

@@ -1,178 +0,0 @@
-from pydantic import BaseModel
-from typing import Any, Dict, List, Iterator, Tuple
-
-from acex_devkit.models.composed_configuration import ComposedConfiguration, Reference, ReferenceTo, ReferenceFrom, Metadata
-from acex_devkit.models.attribute_value import AttributeValue
-from acex_devkit.configdiffer.diff import Diff, ComponentChange, AttributeChange, ComponentDiffOp
-
-import json
-
-
-class ConfigDiffer:
-
-    IGNORED_KEYS = ["metadata", "logging", "ssh", "snmp", "network_instances", "interfaces", "ntp", "domain_name", "location", "contact", "motd_banner"]
-
-    def _clean_metadata(self, obj: dict) -> dict:
-        """
-        Recursively ignored keys.
-        """
-        if not isinstance(obj, dict):
-            return obj
-        cleaned = {}
-        for k, v in obj.items():
-            if k in self.__class__.IGNORED_KEYS:
-                continue
-            if isinstance(v, dict):
-                cleaned[k] = self._clean_metadata(v)
-            elif isinstance(v, list):
-                cleaned[k] = [self._clean_metadata(item) if isinstance(item, dict) else item for item in v]
-            else:
-                cleaned[k] = v
-        return cleaned
-
-
-    def _dump_to_dicts(self, config: ComposedConfiguration) -> dict:
-        """
-        Dumps to dict, removes unnecessary keys except component_class. 
-        """
-        # Remove most metadata, but keep component_class for type identification
-        config_dict = config.model_dump(exclude_unset=True)
-        return self._clean_metadata(config_dict)
-
-
-    def _flatten(self, d: dict, path: tuple = ()) -> Dict[tuple, dict]:
-        """
-        Recursively walk the tree and collect every component (dict with
-        'component_class') into a flat mapping of path → component_dict.
-
-        Example result:
-            {
-                ('interfaces', 'GigabitEthernet0/0/1'): {...},
-                ('network_instances', 'default', 'vlans', '100'): {...},
-            }
-        """
-        result = {}
-        for key, value in d.items():
-            current_path = path + (key,)
-            if not isinstance(value, dict):
-                continue
-            # Try to find deeper components first
-            deeper = self._flatten(value, current_path)
-            if deeper:
-                # Sub-components found — use those (don't emit current level)
-                result.update(deeper)
-            elif any(isinstance(v, dict) and 'value' in v for v in value.values()):
-                # No sub-components, but this dict has AttributeValue fields → it's a leaf
-                result[current_path] = value
-        return result
-
-
-
-    def _get_by_path(self, config: ComposedConfiguration, path: tuple) -> Any:
-        """
-        Traverse the ComposedConfiguration object using a path tuple and return
-        the actual Pydantic model instance (or primitive) at that location.
-
-        Example:
-            path = ('interfaces', 'GigabitEthernet0/0/1')
-            → returns the actual SoftwareLoopbackInterface / EthernetCsmacdInterface etc.
-        """
-        obj = config
-        for key in path:
-            if isinstance(obj, dict):
-                obj = obj[key]
-            else:
-                obj = getattr(obj, key)
-        return obj
-
-    def _attribute_changes(self, before: dict, after: dict) -> List[AttributeChange]:
-        """
-        Compare two component dicts and return a list of changed attributes.
-        """
-        changes = []
-        for key in set(before.keys()) | set(after.keys()):
-            b = before.get(key)
-            a = after.get(key)
-            if b != a:
-                changes.append(AttributeChange(attribute_name=key, before=b, after=a))
-        return changes
-
-    def diff(self, *, desired_config: ComposedConfiguration, observed_config: ComposedConfiguration) -> Diff:
-        """
-        Compare two ComposedConfiguration objects and return a component-based diff.
-
-        Walks both configs using Pydantic model structure (not heuristics) to find
-        all named components inside Dict[str, Model] containers. Components are
-        identified by their full path, e.g. ('interfaces', 'GigabitEthernet0/0/1').
-
-        Args:
-            desired_config: The target configuration we want to achieve.
-            observed_config: The current configuration as observed on the device.
-
-        Returns:
-            Diff: A structured diff showing added, removed, and changed components.
-        """
-        flat_observed = self._flatten(self._dump_to_dicts(observed_config))
-        flat_desired = self._flatten(self._dump_to_dicts(desired_config))
-
-        observed_paths = set(flat_observed.keys())
-        desired_paths = set(flat_desired.keys())
-
-
-        added = []
-        removed = []
-        changed = []
-
-        for path in desired_paths - observed_paths:
-            obj = self._get_by_path(desired_config, path)
-            added.append(ComponentChange(
-                op=ComponentDiffOp.ADD,
-                path=list(path),
-                component_type=type(obj),
-                component_name=path[-1],
-                before=None,
-                after=obj,
-                before_dict=None,
-                after_dict=flat_desired[path],
-            ))
-
-        for path in observed_paths - desired_paths:
-            obj = self._get_by_path(observed_config, path)
-            removed.append(ComponentChange(
-                op=ComponentDiffOp.REMOVE,
-                path=list(path),
-                component_type=type(obj),
-                component_name=path[-1],
-                before=obj,
-                after=None,
-                before_dict=flat_observed[path],
-                after_dict=None,
-            ))
-
-        for path in desired_paths & observed_paths:
-            desired_comp = flat_desired[path]
-            observed_comp = flat_observed[path]
-            if desired_comp != observed_comp:
-                desired_obj = self._get_by_path(desired_config, path)
-                observed_obj = self._get_by_path(observed_config, path)
-                changed.append(ComponentChange(
-                    op=ComponentDiffOp.CHANGE,
-                    path=list(path),
-                    component_type=type(desired_obj),
-                    component_name=path[-1],
-                    before=observed_obj,
-                    after=desired_obj,
-                    before_dict=observed_comp,
-                    after_dict=desired_comp,
-                    changed_attributes=self._attribute_changes(observed_comp, desired_comp),
-                ))
-
-        return Diff(
-            added=added,
-            removed=removed,
-            changed=changed,
-            total_desired=len(desired_paths),
-            total_observed=len(observed_paths),
-        )
-
-