annet 1.0.2__tar.gz → 1.0.4__tar.gz

{annet-1.0.2/annet.egg-info → annet-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 1.0.2
+Version: 1.0.4
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -23,7 +23,7 @@ Requires-Dist: yarl>=1.8.2
 Requires-Dist: adaptix==3.0.0b7
 Requires-Dist: dataclass-rest==0.4
 Provides-Extra: netbox
-Requires-Dist: annetbox[sync]>=0.1.13; extra == "netbox"
+Requires-Dist: annetbox[sync]>=0.2.0; extra == "netbox"
 Dynamic: home-page
 Dynamic: license
 Dynamic: provides-extra

{annet-1.0.2 → annet-1.0.4}/README.md

@@ -68,3 +68,8 @@ sphinx-build -M html docs docs-build
 ```
 
 3. Open rendered html in browser docs-build/html/index.html
+
+## Links
+
+* [Online Documentation](https://annetutil.github.io/annet/)
+* [Tutorial](https://annetutil.github.io/annet/main/usage/tutorial.html)

{annet-1.0.2 → annet-1.0.4}/annet/__init__.py

@@ -49,11 +49,6 @@ def init(options: Namespace):
         colorama.init = lambda *_, **__: None
     colorama.init()
 
-    # Workaround for Python 3.8.0: https://bugs.python.org/issue38529
-    import asyncio.streams
-    if hasattr(asyncio.streams.StreamReaderProtocol, "_on_reader_gc"):
-        asyncio.streams.StreamReaderProtocol._on_reader_gc = lambda *args, **kwargs: None  # pylint: disable=protected-access
-
 
 def assert_python_version():
     if sys.version_info < (3, 10, 0):

{annet-1.0.2 → annet-1.0.4}/annet/adapters/netbox/common/models.py

@@ -192,20 +192,25 @@ class NetboxDevice(Entity):
     breed: str
 
     interfaces: List[Interface]
-    neighbours: Optional[List["NetboxDevice"]]
+
+    @property
+    def neighbors(self) -> List["Entity"]:
+        return [
+            endpoint.device
+            for iface in self.interfaces
+            if iface.connected_endpoints
+            for endpoint in iface.connected_endpoints
+            if endpoint.device
+        ]
 
     # compat
     @property
     def neighbours_fqdns(self) -> list[str]:
-        if not self.neighbours:
-            return []
-        return [dev.fqdn for dev in self.neighbours]
+        return [dev.name for dev in self.neighbors]
 
     @property
     def neighbours_ids(self):
-        if not self.neighbours:
-            return []
-        return [dev.id for dev in self.neighbours]
+        return [dev.id for dev in self.neighbors]
 
     def __hash__(self):
         return hash((self.id, type(self)))

{annet-1.0.2 → annet-1.0.4}/annet/adapters/netbox/common/storage_opts.py

@@ -5,16 +5,25 @@ DEFAULT_URL = "http://localhost"
 
 
 class NetboxStorageOpts:
-    def __init__(self, url: str, token: str, insecure: bool = False, exact_host_filter: bool = False):
+    def __init__(
+            self,
+            url: str,
+            token: str,
+            insecure: bool = False,
+            exact_host_filter: bool = False,
+            threads: int = 1,
+    ):
         self.url = url
         self.token = token
         self.insecure = insecure
         self.exact_host_filter = exact_host_filter
+        self.threads = threads
 
     @classmethod
     def parse_params(cls, conf_params: Optional[dict[str, str]], cli_opts: Any):
         url = os.getenv("NETBOX_URL") or conf_params.get("url") or DEFAULT_URL
         token = os.getenv("NETBOX_TOKEN", "").strip() or conf_params.get("token") or ""
+        threads = os.getenv("NETBOX_CLIENT_THREADS", "").strip() or conf_params.get("threads") or "1"
         insecure = False
         if insecure_env := os.getenv("NETBOX_INSECURE", "").lower():
             insecure = insecure_env in ("true", "1", "t")
@@ -24,4 +33,10 @@ class NetboxStorageOpts:
             exact_host_filter = exact_host_filter_env in ("true", "1", "t")
         else:
             exact_host_filter = bool(conf_params.get("exact_host_filter") or False)
-        return cls(url=url, token=token, insecure=insecure, exact_host_filter=exact_host_filter)
+        return cls(
+            url=url,
+            token=token,
+            insecure=insecure,
+            exact_host_filter=exact_host_filter,
+            threads=int(threads),
+        )

{annet-1.0.2 → annet-1.0.4}/annet/adapters/netbox/v37/storage.py

@@ -24,7 +24,6 @@ logger = getLogger(__name__)
 @impl_converter(recipe=[
     link(P[api_models.Device].name, P[models.NetboxDevice].hostname),
     link(P[api_models.Device].name, P[models.NetboxDevice].fqdn),
-    link_constant(P[models.NetboxDevice].neighbours, value=None),
 ])
 def extend_device_base(
         device: api_models.Device,
@@ -39,7 +38,6 @@ def extend_device_base(
 def extend_device(
         device: api_models.Device,
         interfaces: List[models.Interface],
-        neighbours: Optional[List[models.NetboxDevice]],
         storage: Storage,
 ) -> models.NetboxDevice:
     platform_name: str = ""
@@ -64,7 +62,6 @@ def extend_device(
         hw=hw,
         storage=storage,
     )
-    res.neighbours = neighbours
     return res
 
 
@@ -91,6 +88,7 @@ class NetboxStorageV37(Storage):
         url = ""
         token = ""
         self.exact_host_filter = False
+        threads = 1
         if opts:
             if opts.insecure:
                 ctx = ssl.create_default_context()
@@ -98,8 +96,10 @@ class NetboxStorageV37(Storage):
                 ctx.verify_mode = ssl.CERT_NONE
             url = opts.url
             token = opts.token
+            threads = opts.threads
             self.exact_host_filter = opts.exact_host_filter
-        self.netbox = NetboxV37(url=url, token=token, ssl_context=ctx)
+
+        self.netbox = NetboxV37(url=url, token=token, ssl_context=ctx, threads=threads)
         self._all_fqdns: Optional[list[str]] = None
         self._id_devices: dict[int, models.NetboxDevice] = {}
         self._name_devices: dict[str, models.NetboxDevice] = {}
@@ -174,7 +174,6 @@ class NetboxStorageV37(Storage):
             device.id: extend_device(
                 device=device,
                 interfaces=[],
-                neighbours=[],
                 storage=self,
             )
             for device in self._load_devices(query)
@@ -186,16 +185,8 @@ class NetboxStorageV37(Storage):
             self._record_device(device)
 
         interfaces = self._load_interfaces(list(device_ids))
-        neighbours = {x.id: x for x in self._load_neighbours(interfaces)}
-        neighbours_seen: dict[str, set] = defaultdict(set)
-
         for interface in interfaces:
             device_ids[interface.device.id].interfaces.append(interface)
-            for e in interface.connected_endpoints or []:
-                neighbour = neighbours[e.device.id]
-                if neighbour.id not in neighbours_seen[interface.device.id]:
-                    neighbours_seen[interface.device.id].add(neighbour.id)
-                    device_ids[interface.device.id].neighbours.append(neighbour)
 
         return list(device_ids.values())
 
@@ -233,8 +224,7 @@ class NetboxStorageV37(Storage):
             extended_ifaces[ip.assigned_object_id].ip_addresses.append(ip)
         return list(extended_ifaces.values())
 
-    def _load_interfaces(self, device_ids: List[int]) -> List[
-        models.Interface]:
+    def _load_interfaces(self, device_ids: List[int]) -> List[models.Interface]:
         interfaces = self.netbox.dcim_all_interfaces(device_id=device_ids)
         return self._extend_interfaces(interfaces.results)
 
@@ -242,25 +232,6 @@ class NetboxStorageV37(Storage):
         interfaces = self.netbox.dcim_all_interfaces_by_id(id=ids)
         return self._extend_interfaces(interfaces.results)
 
-    def _load_neighbours(self, interfaces: List[models.Interface]) -> List[models.NetboxDevice]:
-        endpoints = [e for i in interfaces for e in i.connected_endpoints or []]
-        remote_interfaces_ids = [e.id for e in endpoints]
-        neighbours_ids = [e.device.id for e in endpoints]
-        neighbours_ifaces_dics = defaultdict(list)
-        # load only the connected interface to speed things up
-        for iface in self._load_interfaces_by_id(remote_interfaces_ids):
-            neighbours_ifaces_dics[iface.device.id].append(iface)
-        neighbours = []
-        for neighbour in self.netbox.dcim_all_devices_by_id(id=neighbours_ids).results:
-            extended_neighbour = extend_device(
-                device=neighbour,
-                storage=self,
-                interfaces=neighbours_ifaces_dics[neighbour.id],
-                neighbours=None,  # do not load recursively
-            )
-            neighbours.append(extended_neighbour)
-        return neighbours
-
     def get_device(
             self, obj_id, preload_neighbors=False, use_mesh=None,
             **kwargs,
@@ -270,13 +241,11 @@ class NetboxStorageV37(Storage):
 
         device = self.netbox.dcim_device(obj_id)
         interfaces = self._load_interfaces([device.id])
-        neighbours = self._load_neighbours(interfaces)
 
         res = extend_device(
             device=device,
             storage=self,
             interfaces=interfaces,
-            neighbours=neighbours,
         )
         self._record_device(res)
         return res

{annet-1.0.2 → annet-1.0.4}/annet/annlib/netdev/devdb/data/devdb.json

@@ -132,6 +132,9 @@
     "PC.Whitebox.Ufispace.S": " S",
     "PC.Whitebox.Ufispace.S.S9100": " S91\\d\\d",
     "PC.Whitebox.Ufispace.S.S9100.S9110_32X": " S9110-32X",
+    "PC.Whitebox.Ufispace.S.S9300": " S93\\d\\d",
+    "PC.Whitebox.Ufispace.S.S9300.S9301_32DB": " S9301-32DB",
+    "PC.Whitebox.Ufispace.S.S9300.S9321_64EO": " S9321-64EO",
     "PC.Nebius": "^Nebius",
     "PC.Nebius.NB-E-BR-DCU-AST2600": "^Nebius NB-E-BR-DCU-AST2600",
 

{annet-1.0.2 → annet-1.0.4}/annet/bgp_models.py

@@ -3,6 +3,77 @@ from dataclasses import dataclass, field
 from typing import Literal, Union, Optional
 
 
+class VidRange:
+    def __init__(self, start: int, stop: int) -> None:
+        self.start = start
+        self.stop = stop
+
+    def is_single(self):
+        return self.start == self.stop
+
+    def __iter__(self):
+        return iter(range(self.start, self.stop + 1))
+
+    def __str__(self):
+        if self.is_single():
+            return str(self.start)
+        return f"{self.start}-{self.stop}"
+
+    def __repr__(self):
+        return f"VlanRange({self.start}, {self.stop})"
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidRange:
+            return self.start == other.start and self.stop == other.stop
+        return NotImplemented
+
+
+def _parse_vlan_ranges(ranges: str) -> Iterable[VidRange]:
+    for range in ranges.split(","):
+        start, sep, stop = range.strip().partition("-")
+        try:
+            if not sep:
+                int_start = int(start)
+                yield VidRange(int_start, int_start)
+            elif not stop or not start:
+                raise ValueError(f"Cannot parse range {range!r}. Expected `start-stop`")
+            else:
+                yield VidRange(int(start), int(stop))
+        except ValueError:
+            raise ValueError(f"Cannot parse range {range!r}. Expected `vid1-vid2` or `vid`")
+
+
+class VidCollection:
+    @staticmethod
+    def parse(ranges: int | str) -> "VidCollection":
+        if isinstance(ranges, int):
+            return VidCollection([VidRange(ranges, ranges)])
+        elif isinstance(ranges, str):
+            return VidCollection(list(_parse_vlan_ranges(ranges)))
+        elif isinstance(ranges, VidCollection):
+            return VidCollection(ranges.ranges)
+        else:
+            raise TypeError(f"Expected str or int, got {type(ranges)}")
+
+    def __init__(self, ranges: list[VidRange]) -> None:
+        self.ranges = ranges
+
+    def __str__(self):
+        return ",".join(map(str, self.ranges))
+
+    def __repr__(self):
+        return f"VlanCollection({str(self)!r})"
+
+    def __iter__(self):
+        for range in self.ranges:
+            yield from range
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidCollection:
+            return self.ranges == other.ranges
+        return False
+
+
 class ASN(int):
     """
     Stores ASN number and formats it as в AS1.AS2
@@ -182,6 +253,7 @@ class PeerGroup:
     internal_name: str = ""
     description: str = ""
     update_source: str = ""
+    peer_filter: str = ""
     import_policy: str = ""
     export_policy: str = ""
 
@@ -234,6 +306,17 @@ class PeerGroup:
     mtu: int = 0
 
 
+@dataclass
+class L2VpnOptions:
+    name: str
+    vid: VidCollection
+    l2vni: int  # VNI, possible values are 1 to 2**24-1
+    route_distinguisher: str = ""  # like in VrfOptions
+    rt_import: list[str] = field(default_factory=list)  # like in VrfOptions
+    rt_export: list[str] = field(default_factory=list)  # like in VrfOptions
+    advertise_host_routes: bool = True  # advertise IP+MAC routes into L3VNI
+
+
 @dataclass
 class VrfOptions:
     vrf_name: str
@@ -273,8 +356,8 @@ class GlobalOptions:
     multipath: int = 0
     router_id: str = ""
     vrf: dict[str, VrfOptions] = field(default_factory=dict)
-
     groups: list[PeerGroup] = field(default_factory=list)
+    l2vpn: dict[str, L2VpnOptions] = field(default_factory=dict)
 
 
 @dataclass

{annet-1.0.2 → annet-1.0.4}/annet/connectors.py

@@ -111,33 +111,30 @@ class AdapterWithName(ABC):
 
 
 def get_connector_from_config(config_key: str, connectors: List[Type[Connector]]) -> Tuple[Connector, Dict[str, Any]]:
-    seen: list[str] = []
     if not connectors:
         raise Exception("empty connectors")
-    connector = connectors[0]  # default
-    connector_params: Dict[str, Any] = {}
+
+    # handle configuration
+    connector_params = dict[str, Any]()  # default
     if context_storage := get_context().get(config_key):
-        adapter_name = context_storage.get("adapter", None)
         connector_params = context_storage.get("params", {})
-        if adapter_name:
+        if adapter_name := context_storage.get("adapter", None):
+            seen = list[str]()
             for con in connectors:
-                con_name = connector.__name__
                 if issubclass(con, AdapterWithName):
                     con_name = con.name()
+                else:
+                    con_name = con.__name__
                 seen.append(con_name)
                 if adapter_name == con_name:
-                    connector = con
+                    connectors = [con]
                     break
             else:
                 raise Exception("unknown %s %s: seen %s" % (config_key, adapter_name, seen))
-        else:
-            connector = connectors[0]
-            if len(connectors) > 1:
-                warnings.warn(f"Please specify adapter for '{config_key}'. Found more than one classes {connectors}", UserWarning)
-    else:
-        connector = connectors[0]
-        if len(connectors) > 1:
-            warnings.warn(f"Please specify '{config_key}'. Found more than one classes {connectors}", UserWarning)
+
+    if len(connectors) > 1:
+        warnings.warn(f"Please specify adapter for '{config_key}'. Found more than one classes {connectors}", UserWarning)
+    connector = connectors[0]
     if issubclass(connector, AdapterWithConfig):
         connector_ins = connector.with_config(**connector_params)
     else:

{annet-1.0.2 → annet-1.0.4}/annet/mesh/device_models.py

@@ -76,10 +76,21 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
     groups: Annotated[dict[str, MeshPeerGroup], DictMerge(Merge())]
 
 
+class L2VpnOptions(BaseMeshModel):
+    name: str
+    vid: str | int  # VLAN ID, possible values are 1 to 4094, ranges can be set as strings
+    l2vni: int  # VNI, possible values are 1 to 2**24-1
+    route_distinguisher: str  # like in VrfOptions
+    rt_import: Annotated[tuple[str, ...], Concat()]  # like in VrfOptions
+    rt_export: Annotated[tuple[str, ...], Concat()]  # like in VrfOptions
+    advertise_host_routes: bool  # advertise IP+MAC routes into L3VNI
+
+
 class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
     def __init__(self, **kwargs):
         kwargs.setdefault("groups", KeyDefaultDict(lambda x: MeshPeerGroup(name=x)))
         kwargs.setdefault("vrf", KeyDefaultDict(lambda x: VrfOptions(vrf_name=x)))
+        kwargs.setdefault("l2vpn", KeyDefaultDict(lambda x: L2VpnOptions(name=x)))
         super().__init__(**kwargs)
 
     as_path_relax: bool
@@ -89,3 +100,4 @@ class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
     router_id: str
     vrf: Annotated[dict[str, VrfOptions], DictMerge(Merge())]
     groups: Annotated[dict[str, MeshPeerGroup], DictMerge(Merge())]
+    l2vpn: Annotated[dict[str, L2VpnOptions], DictMerge(Merge())]

{annet-1.0.2 → annet-1.0.4}/annet/mesh/executor.py

@@ -132,30 +132,30 @@ class MeshExecutor:
         # we can have multiple rules for the same pair
         # we merge them according to remote fqdn
         neighbor_peers: dict[PeerKey, Pair] = {}
-        # TODO batch resolve
         rules = self._registry.lookup_direct(device.fqdn, device.neighbours_fqdns)
         fqdns = {
             rule.name_right if rule.direct_order else rule.name_left
             for rule in rules
         }
-        neigbors = {
+        logger.debug("Loading neighbor devices: %s", fqdns)
+        neighbors = {
             d.fqdn: d for d in self._storage.make_devices(list(fqdns))
         }
         for rule in rules:
             handler_name = self._handler_name(rule.handler)
             if rule.direct_order:
-                if rule.name_right not in neigbors:
-                    print(list(neigbors), flush=True)
+                if rule.name_right not in neighbors:
                     raise ValueError(
-                        f"Device `{device.fqdn}` has no neighbor `{rule.name_right}` required for `{handler_name}`. {list(neigbors)}",
+                        f"Device `{device.fqdn}` has no neighbor `{rule.name_right}` "
+                        f"required for `{handler_name}`. {list(neighbors)}",
                     )
-                neighbor_device = neigbors[rule.name_right]
+                neighbor_device = neighbors[rule.name_right]
             else:
-                if rule.name_left not in neigbors:
+                if rule.name_left not in neighbors:
                     raise ValueError(
                         f"Device `{device.fqdn}` has no neighbor `{rule.name_left}` required for `{handler_name}`",
                     )
-                neighbor_device = neigbors[rule.name_left]
+                neighbor_device = neighbors[rule.name_left]
             all_connected_ports = [
                 (p1.name, p2.name)
                 for p1, p2 in self._storage.search_connections(device, neighbor_device)
@@ -238,6 +238,7 @@ class MeshExecutor:
             rule.name_right if rule.direct_order else rule.name_left
             for rule in rules
         }
+        logger.debug("Loading indirect connected devices: %s", fqdns)
         connected_devices = {
             d.fqdn: d for d in self._storage.make_devices(list(fqdns))
         }

{annet-1.0.2 → annet-1.0.4}/annet/mesh/models_converter.py

@@ -7,7 +7,7 @@ from adaptix import Retort, loader, Chain, name_mapping, as_is_loader
 from .peer_models import DirectPeerDTO, IndirectPeerDTO, VirtualPeerDTO, VirtualLocalDTO
 from ..bgp_models import (
     Aggregate, GlobalOptions, VrfOptions, FamilyOptions, Peer, PeerGroup, ASN, PeerOptions,
-    Redistribute, BFDTimers,
+    Redistribute, BFDTimers, L2VpnOptions, VidCollection,
 )
 
 
@@ -49,8 +49,10 @@ retort = Retort(
     recipe=[
         loader(InterfaceChanges, ObjMapping, Chain.FIRST),
         loader(ASN, ASN),
+        loader(VidCollection, VidCollection.parse),
         loader(GlobalOptions, ObjMapping, Chain.FIRST),
         loader(VrfOptions, ObjMapping, Chain.FIRST),
+        loader(L2VpnOptions, ObjMapping, Chain.FIRST),
         loader(FamilyOptions, ObjMapping, Chain.FIRST),
         loader(Aggregate, ObjMapping, Chain.FIRST),
         loader(PeerOptions, ObjMapping, Chain.FIRST),

{annet-1.0.2 → annet-1.0.4}/annet/mesh/peer_models.py

@@ -126,6 +126,7 @@ class MeshPeerGroup(_OptionsDTO):
     internal_name: str
     update_source: str
     description: str
+    peer_filter: str
 
     import_policy: str
     export_policy: str

annet-1.0.4/annet/rulebook/arista/aaa.py

@@ -0,0 +1,63 @@
+from dataclasses import dataclass
+
+from annet.annlib.types import Op
+
+
+@dataclass
+class UserConfig:
+    name: str
+    privilege: int
+    role: str
+    secret_type: str
+    secret: str
+
+
+def _parse_user_config(config_line):
+    """Convert a user config line into a dataclass. Config example:
+
+    username someuser privilege 15 role network-admin secret sha512 $6$....
+
+    privilege could be omitted if equal to 1
+    role could be omitted
+    secret could be omitted, 'nopassword' is provided instead
+    """
+    splstr = config_line.split()
+    name = splstr[1]
+    priv = 1
+    role = ""
+    secret_type = ""
+    secret = ""
+    if "privilege" in splstr:
+        pos = splstr.index("privilege")
+        priv = int(splstr[pos + 1])
+    if "role" in splstr:
+        pos = splstr.index("role")
+        role = splstr[pos + 1]
+    if "secret" in splstr:
+        pos = splstr.index("secret")
+        secret_type = splstr[pos + 1]
+        secret = splstr[pos + 2]
+    return UserConfig(name=name, privilege=priv, role=role, secret_type=secret_type, secret=secret)
+
+
+def user(key, diff, **_):
+    if diff[Op.ADDED] and not diff[Op.REMOVED]:
+        for add in diff[Op.ADDED]:
+            yield (True, add["row"], None)
+    elif diff[Op.REMOVED] and not diff[Op.ADDED]:
+        for _ in diff[Op.REMOVED]:
+            yield (False, f"no username {key[0]}", None)
+    else:
+        for num, add in enumerate(diff[Op.ADDED]):
+            new_user = _parse_user_config(add["row"])
+            old_user = _parse_user_config(diff[Op.REMOVED][num]["row"])
+            if new_user.privilege != old_user.privilege:
+                yield (True, f"username {key[0]} privilege {new_user.privilege}", None)
+            if new_user.role != old_user.role and not new_user.role:
+                yield (True, f"no username {key[0]} role", None)
+            elif new_user.role != old_user.role:
+                yield (True, f"username {key[0]} role {new_user.role}", None)
+            if new_user.secret != old_user.secret and not new_user.secret:
+                yield (True, f"username {key[0]} nopassword", None)
+            elif new_user.secret != old_user.secret:
+                yield (True, f"username {key[0]} secret {new_user.secret_type} {new_user.secret}", None)

{annet-1.0.2 → annet-1.0.4}/annet/rulebook/texts/arista.rul

@@ -5,7 +5,7 @@ qos profile *
     ~ %global
 
 username * ssh-key
-username *
+username *                %logic=arista.aaa.user
 
 aaa group ~
     ~ %global

{annet-1.0.2 → annet-1.0.4/annet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 1.0.2
+Version: 1.0.4
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -23,7 +23,7 @@ Requires-Dist: yarl>=1.8.2
 Requires-Dist: adaptix==3.0.0b7
 Requires-Dist: dataclass-rest==0.4
 Provides-Extra: netbox
-Requires-Dist: annetbox[sync]>=0.1.13; extra == "netbox"
+Requires-Dist: annetbox[sync]>=0.2.0; extra == "netbox"
 Dynamic: home-page
 Dynamic: license
 Dynamic: provides-extra

{annet-1.0.2 → annet-1.0.4}/annet.egg-info/SOURCES.txt

@@ -125,6 +125,7 @@ annet/rulebook/common.py
 annet/rulebook/deploying.py
 annet/rulebook/patching.py
 annet/rulebook/arista/__init__.py
+annet/rulebook/arista/aaa.py
 annet/rulebook/arista/iface.py
 annet/rulebook/aruba/__init__.py
 annet/rulebook/aruba/ap_env.py

{annet-1.0.2 → annet-1.0.4}/annet.egg-info/requires.txt

@@ -15,4 +15,4 @@ adaptix==3.0.0b7
 dataclass-rest==0.4
 
 [netbox]
-annetbox[sync]>=0.1.13
+annetbox[sync]>=0.2.0

{annet-1.0.2 → annet-1.0.4}/setup.py

@@ -44,7 +44,7 @@ if __name__ == "__main__":
           ],
         },
         extras_require={
-            "netbox": ["annetbox[sync]>=0.1.13"],
+            "netbox": ["annetbox[sync]>=0.2.0"],
         },
         python_requires=">=3.10",
         install_requires=requirements(),