annet 0.16.16__py3-none-any.whl → 0.16.18__py3-none-any.whl

annet/configs/context.yml

@@ -2,6 +2,7 @@ generators:
   default:
     - annet_generators.example
     - annet_generators.mesh_example
+    - annet_generators.rpl_example
 
 storage:
   default:

annet/rpl/__init__.py

@@ -0,0 +1,27 @@
+__all__ = [
+    "MatchField",
+    "ThenField",
+    "RouteMap",
+    "Route",
+    "ResultType",
+    "ActionType",
+    "Action",
+    "SingleAction",
+    "AndCondition",
+    "R",
+    "ConditionOperator",
+    "Condition",
+    "SingleCondition",
+    "RoutingPolicyStatement",
+    "RoutingPolicy",
+    "CommunityActionValue",
+    "PrefixMatchValue",
+]
+
+from .action import Action, ActionType, SingleAction
+from .condition import AndCondition, Condition, ConditionOperator, SingleCondition
+from .match_builder import R, MatchField, PrefixMatchValue
+from .policy import RoutingPolicyStatement, RoutingPolicy
+from .result import ResultType
+from .routemap import RouteMap, Route
+from .statement_builder import ThenField, CommunityActionValue

annet/rpl/action.py

@@ -0,0 +1,51 @@
+from collections.abc import Iterator, Iterable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar, Any
+
+
+class ActionType(Enum):
+    SET = "set"
+    ADD = "add"
+    REMOVE = "delete"
+
+    CUSTOM = "custom"
+
+
+ValueT = TypeVar("ValueT")
+
+
+@dataclass
+class SingleAction(Generic[ValueT]):
+    field: str
+    type: ActionType
+    value: ValueT
+
+
+class Action:
+    def __init__(self) -> None:
+        self.actions: list[SingleAction[Any]] = []
+
+    def append(self, action: SingleAction[Any]) -> None:
+        self.actions.append(action)
+
+    def __repr__(self):
+        actions = ", ".join(repr(c) for c in self.actions)
+        return f"Action({actions})"
+
+    def __getitem__(self, item: str) -> SingleAction[Any]:
+        return next(c for c in self.actions if c.field == item)
+
+    def __contains__(self, item: str) -> bool:
+        return any(c.field == item for c in self.actions)
+
+    def __len__(self) -> int:
+        return len(self.actions)
+
+    def __iter__(self) -> Iterator[SingleAction[Any]]:
+        return iter(self.actions)
+
+    def find_all(self, item: str) -> Iterable[SingleAction[Any]]:
+        for action in self.actions:
+            if action.field == item:
+                yield action

annet/rpl/condition.py

@@ -0,0 +1,94 @@
+from collections.abc import Iterator, Iterable
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, TypeVar, Sequence, Union, Any
+
+
+class ConditionOperator(Enum):
+    EQ = "=="
+    GE = ">="
+    GT = ">"
+    LE = "<="
+    LT = "<"
+    BETWEEN_INCLUDED = "BETWEEN_INCLUDED"
+
+    HAS = "has"
+    HAS_ANY = "has_any"
+
+    CUSTOM = "custom"
+
+
+ValueT = TypeVar("ValueT")
+
+
+@dataclass(frozen=True)
+class SingleCondition(Generic[ValueT]):
+    field: str
+    operator: ConditionOperator
+    value: ValueT
+
+    def __and__(self, other: "Condition") -> "Condition":
+        return AndCondition(self, other)
+
+    def merge(self, other: "SingleCondition[Any]") -> "SingleCondition[Any]":
+        if other.field != self.field:
+            raise ValueError(f"Cannot merge conditions with different fields: {self.field} != {other.field}")
+        if self.operator is ConditionOperator.LE:
+            if other.operator is ConditionOperator.GE:
+                return SingleCondition(self.field, ConditionOperator.BETWEEN_INCLUDED, (other.value, self.value))
+            elif other.operator is ConditionOperator.LE:
+                return SingleCondition(self.field, ConditionOperator.LE, min(self.value, other.value))
+        elif self.operator is ConditionOperator.GE:
+            if other.operator is ConditionOperator.LE:
+                return other.merge(self)
+            elif other.operator is ConditionOperator.GE:
+                return SingleCondition(self.field, ConditionOperator.GE, max(self.value, other.value))
+        elif self.operator is ConditionOperator.LT:
+            if other.operator is ConditionOperator.LT:
+                return SingleCondition(self.field, ConditionOperator.LT, min(self.value, other.value))
+        elif self.operator is ConditionOperator.GT:
+            if other.operator is ConditionOperator.GT:
+                return SingleCondition(self.field, ConditionOperator.GT, max(self.value, other.value))
+        raise ValueError(f"Cannot merge condition with operator {self.operator} and {other.operator}")
+
+
+Condition = Union[SingleCondition, "AndCondition"]
+
+
+class AndCondition:
+    def __init__(self, *conditions: Condition):
+        self.conditions: list[SingleCondition[Any]] = []
+        for c in conditions:
+            self.conditions.extend(self._unpack(c))
+
+    def _unpack(self, other: Condition) -> Sequence[SingleCondition]:
+        if isinstance(other, AndCondition):
+            return other.conditions
+        return [other]
+
+    def __and__(self, other: Condition) -> "AndCondition":
+        return AndCondition(*self.conditions, other)
+
+    def __iadd__(self, other):
+        self.conditions.extend(self._unpack(other))
+
+    def __repr__(self):
+        conditions = ", ".join(repr(c) for c in self.conditions)
+        return f"AndCondition({conditions})"
+
+    def __getitem__(self, item: str) -> SingleCondition[Any]:
+        return next(c for c in self.conditions if c.field == item)
+
+    def __contains__(self, item: str) -> bool:
+        return any(c.field == item for c in self.conditions)
+
+    def __len__(self) -> int:
+        return len(self.conditions)
+
+    def __iter__(self) -> Iterator[SingleCondition[Any]]:
+        return iter(self.conditions)
+
+    def find_all(self, item: str) -> Iterable[SingleCondition[Any]]:
+        for condition in self.conditions:
+            if condition.field == item:
+                yield condition

annet/rpl/match_builder.py

@@ -0,0 +1,103 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Generic, Sequence, Callable, Optional, TypeVar, Any
+
+from .condition import SingleCondition, ConditionOperator, AndCondition
+
+
+class MatchField(str, Enum):
+    community = "community"
+    extcommunity = "extcommunity"
+    rd = "rd"
+    interface = "interface"
+    protocol = "protocol"
+    net_len = "net_len"
+    local_pref = "local_pref"
+    metric = "metric"
+    family = "family"
+
+    as_path_length = "as_path_length"
+    as_path_filter = "as_path_filter"
+    ipv6_prefix = "ipv6_prefix"
+    ip_prefix = "ip_prefix"
+
+
+ValueT = TypeVar("ValueT")
+_ConditionMethod = Callable[["ConditionFactory[ValueT]", ValueT], SingleCondition[ValueT]]
+
+
+def condition_method(operator: ConditionOperator) -> _ConditionMethod:
+    def method(self: "ConditionFactory[ValueT]", other: ValueT) -> SingleCondition[ValueT]:
+        if operator.value not in self.supported_ops:
+            raise NotImplementedError(f"Operator {operator.value} is not supported for field {self.field}")
+        return SingleCondition(self.field, operator, other)
+
+    method.__name__ = operator.value
+    return method
+
+
+class ConditionFactory(Generic[ValueT]):
+    def __init__(self, field: str, supported_ops: list[str]):
+        self.field = field
+        self.supported_ops = supported_ops
+
+    # https://github.com/python/typeshed/issues/3685
+    eq = __eq__ = condition_method(ConditionOperator.EQ)  # type: ignore[assignment]
+    gt = __gt__ = condition_method(ConditionOperator.GT)
+    ge = __ge__ = condition_method(ConditionOperator.GE)
+    lt = __lt__ = condition_method(ConditionOperator.LT)
+    le = __le__ = condition_method(ConditionOperator.LE)
+    between_included = condition_method(ConditionOperator.BETWEEN_INCLUDED)
+
+
+class SetConditionFactory(Generic[ValueT]):
+    def __init__(self, field: str) -> None:
+        self.field = field
+
+    def has(self, *values: ValueT) -> SingleCondition[Sequence[ValueT]]:
+        return SingleCondition(self.field, ConditionOperator.HAS, values)
+
+    def has_any(self, *values: ValueT) -> SingleCondition[Sequence[ValueT]]:
+        return SingleCondition(self.field, ConditionOperator.HAS_ANY, values)
+
+
+@dataclass(frozen=True)
+class PrefixMatchValue:
+    names: Sequence[str]
+    or_longer: Optional[tuple[int, int]]  # ????
+
+
+class Checkable:
+    def __init__(self):
+        self.community = SetConditionFactory[str](MatchField.community)
+        self.extcommunity = SetConditionFactory[str](MatchField.extcommunity)
+        self.rd = SetConditionFactory[str](MatchField.rd)
+        self.interface = ConditionFactory[str](MatchField.interface, ["=="])
+        self.protocol = ConditionFactory[str](MatchField.protocol, ["=="])
+        self.net_len = ConditionFactory[int](MatchField.net_len, ["==", "!="])
+        self.local_pref = ConditionFactory[int](MatchField.local_pref, ["<"])
+        self.metric = ConditionFactory[int](MatchField.metric, ["=="])
+        self.family = ConditionFactory[int](MatchField.family, ["=="])
+        self.as_path_length = ConditionFactory[int](MatchField.as_path_length, ["==", ">=", "<=", "BETWEEN_INCLUDED"])
+
+    def as_path_filter(self, name: str) -> SingleCondition[str]:
+        return SingleCondition(MatchField.as_path_filter, ConditionOperator.EQ, name)
+
+    def match_v6(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(MatchField.ipv6_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
+
+    def match_v4(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(MatchField.ip_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
+
+
+def merge_conditions(and_condition: AndCondition) -> AndCondition:
+    conditions: dict[str, SingleCondition[Any]] = {}
+    for condition in and_condition.conditions:
+        if condition.field in conditions:
+            conditions[condition.field] = conditions[condition.field].merge(condition)
+        else:
+            conditions[condition.field] = condition
+    return AndCondition(*conditions.values())
+
+
+R = Checkable()

annet/rpl/policy.py

@@ -0,0 +1,22 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Optional
+
+from .action import Action
+from .condition import AndCondition
+from .result import ResultType
+
+
+@dataclass
+class RoutingPolicyStatement:
+    name: Optional[str]
+    number: Optional[int]
+    match: AndCondition
+    then: Action
+    result: ResultType
+
+
+@dataclass
+class RoutingPolicy:
+    name: str
+    statements: Sequence[RoutingPolicyStatement]

annet/rpl/result.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ResultType(str, Enum):
+    ALLOW = "allow"
+    DENY = "deny"
+    NEXT = "next"
+    NEXT_POLICY = "next_policy"

annet/rpl/routemap.py

@@ -0,0 +1,76 @@
+from dataclasses import dataclass
+from typing import Optional, Callable, Generic, TypeVar, Union
+
+from .action import Action
+from .condition import AndCondition, Condition
+from .match_builder import merge_conditions
+from .policy import RoutingPolicy, RoutingPolicyStatement
+from .result import ResultType
+from .statement_builder import StatementBuilder
+
+
+class Route:
+    def __init__(self, name: str):
+        self.name = name
+        self.statements: list[RoutingPolicyStatement] = []
+
+    def __call__(
+            self,
+            *conditions: Condition,
+            name: Optional[str] = None,
+            number: Optional[int] = None,
+    ) -> "StatementBuilder":
+        statement = RoutingPolicyStatement(
+            name=name,
+            number=number,
+            match=merge_conditions(AndCondition(*conditions)),
+            then=Action(),
+            result=ResultType.NEXT,
+        )
+        self.statements.append(statement)
+        return StatementBuilder(statement=statement)
+
+
+DeviceT = TypeVar("DeviceT")
+RouteHandlerFunc = Callable[[DeviceT, Route], None]
+Decorator = Callable[[RouteHandlerFunc[DeviceT]], RouteHandlerFunc[DeviceT]]
+
+
+@dataclass
+class Handler(Generic[DeviceT]):
+    name: str
+    func: RouteHandlerFunc[DeviceT]
+
+
+class RouteMap(Generic[DeviceT]):
+    def __init__(self) -> None:
+        self.handlers: list[Handler[DeviceT]] = []
+        self.submaps: list[RouteMap[DeviceT]] = []
+
+    def __call__(
+            self, func: Optional[RouteHandlerFunc[DeviceT]] = None, *, name: str = "",
+    ) -> Union[RouteHandlerFunc[DeviceT], Decorator[DeviceT]]:
+        def decorator(func: RouteHandlerFunc[DeviceT]) -> RouteHandlerFunc[DeviceT]:
+            nonlocal name
+            if not name:
+                name = func.__name__
+            self.handlers.append(Handler(name, func))
+            return func
+
+        if func is None:
+            return decorator
+        return decorator(func)
+
+    def include(self, other: "RouteMap[DeviceT]") -> None:
+        self.submaps.append(other)
+
+    def apply(self, device: DeviceT) -> list[RoutingPolicy]:
+        result: list[RoutingPolicy] = []
+
+        for handler in self.handlers:
+            route = Route(handler.name)
+            handler.func(device, route)
+            result.append(RoutingPolicy(route.name, route.statements))
+        for submap in self.submaps:
+            result.extend(submap.apply(device))
+        return result

annet/rpl/statement_builder.py

@@ -0,0 +1,267 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from dataclasses import field
+from enum import Enum
+from typing import Optional, Literal, TypeVar, Union, Any
+
+from .action import SingleAction, ActionType
+from .policy import RoutingPolicyStatement
+from .result import ResultType
+
+
+class ThenField(str, Enum):
+    community = "community"
+    extcommunity = "extcommunity"
+    as_path = "as_path"
+    local_pref = "local_pref"
+    metric = "metric"
+    rpki_valid_state = "rpki_valid_state"
+    resolution = "resolution"
+    mpls_label = "mpls_label"
+    metric_type = "metric_type"
+    origin = "origin"
+    tag = "tag"
+
+    next_hop = "next_hop"
+
+
+ValueT = TypeVar("ValueT")
+_Setter = Callable[[ValueT], SingleAction[ValueT]]
+
+
+@dataclass
+class CommunityActionValue:
+    replaced: Optional[list[str]] = None  # None means no replacement is done
+    added: list[str] = field(default_factory=list)
+    removed: list[str] = field(default_factory=list)
+
+    def __bool__(self) -> bool:  # check if any action required
+        return bool(self.replaced is not None or self.added or self.removed)
+
+
+class CommunityActionBuilder:
+    def __init__(self, community: CommunityActionValue):
+        self._community = community
+
+    def add(self, *community: str) -> None:
+        for c in community:
+            self._community.added.append(c)
+
+    def remove(self, *community: str) -> None:
+        for c in community:
+            self._community.removed.append(c)
+
+    def set(self, *community: str) -> None:
+        self._community.added.clear()
+        self._community.removed.clear()
+        self._community.replaced = list(community)
+
+
+@dataclass
+class AsPathActionValue:
+    set: Optional[list[str]] = None  # None means no replacement is done
+    prepend: list[str] = field(default_factory=list)
+    expand: list[str] = field(default_factory=list)
+    expand_last_as: str = ""
+    delete: list[str] = field(default_factory=list)
+
+    def __bool__(self) -> bool:  # check if any action required
+        return bool(
+            self.set is not None or self.prepend or self.expand or self.expand_last_as or self.delete
+        )
+
+
+RawAsNum = Union[str, int]
+
+
+class AsPathActionBuilder:
+    def __init__(self, as_path_value: AsPathActionValue):
+        self._as_path_value = as_path_value
+
+    def prepend(self, *values: RawAsNum) -> None:
+        self._as_path_value.prepend = list(map(str, values))
+
+    def delete(self, *values: RawAsNum) -> None:
+        self._as_path_value.delete = list(map(str, values))
+
+    def expand(self, *values: RawAsNum) -> None:
+        self._as_path_value.expand = list(map(str, values))
+
+    def expand_last_as(self, value: RawAsNum) -> None:
+        self._as_path_value.expand_last_as = str(value)
+
+    def set(self, *values: RawAsNum) -> None:
+        self._as_path_value.expand.clear()
+        self._as_path_value.expand_last_as = ""
+        self._as_path_value.delete.clear()
+        self._as_path_value.prepend.clear()
+        self._as_path_value.set = list(map(str, values))
+
+
+@dataclass
+class NextHopActionValue:
+    target: Optional[Literal["self", "discard", "peer", "ipv4_addr", "ipv6_addr", "mapped_ipv4"]] = None
+    addr: str = ""
+
+    def __bool__(self) -> bool:
+        return bool(self.target)
+
+
+class NextHopActionBuilder:
+    def __init__(self, next_hop_value: NextHopActionValue):
+        self._next_hop_value = next_hop_value
+
+    def ipv4_addr(self, value: str) -> None:
+        self._next_hop_value.target = "ipv4_addr"
+        self._next_hop_value.addr = value
+
+    def ipv6_addr(self, value: str) -> None:
+        self._next_hop_value.target = "ipv6_addr"
+        self._next_hop_value.addr = value
+
+    def mapped_ipv4(self, value: str) -> None:
+        self._next_hop_value.target = "mapped_ipv4"
+        self._next_hop_value.addr = value
+
+    def self(self) -> None:
+        self._next_hop_value.target = "self"
+        self._next_hop_value.addr = ""
+
+    def peer(self) -> None:
+        self._next_hop_value.target = "peer"
+        self._next_hop_value.addr = ""
+
+    def discard(self) -> None:
+        self._next_hop_value.target = "discard"
+        self._next_hop_value.addr = ""
+
+
+class StatementBuilder:
+    def __init__(self, statement: RoutingPolicyStatement) -> None:
+        self._statement = statement
+        self._added_as_path: list[int] = []
+        self._community = CommunityActionValue()
+        self._extcommunity = CommunityActionValue()
+        self._as_path = AsPathActionValue()
+        self._next_hop = NextHopActionValue()
+
+    @property
+    def next_hop(self) -> NextHopActionBuilder:
+        return NextHopActionBuilder(self._next_hop)
+
+    @property
+    def as_path(self) -> AsPathActionBuilder:
+        return AsPathActionBuilder(self._as_path)
+
+    @property
+    def community(self) -> CommunityActionBuilder:
+        return CommunityActionBuilder(self._community)
+
+    @property
+    def extcommunity(self) -> CommunityActionBuilder:
+        return CommunityActionBuilder(self._extcommunity)
+
+    def _set(self, field: str, value: ValueT) -> None:
+        action = self._statement.then
+        if field in action:
+            action[field].type = ActionType.SET
+            action[field].value = value
+        else:
+            action.append(SingleAction(
+                field=field,
+                type=ActionType.SET,
+                value=value,
+            ))
+
+    def set_local_pref(self, value: int) -> None:
+        self._set(ThenField.local_pref, value)
+
+    def set_metric_type(self, value: str) -> None:
+        self._set(ThenField.metric_type, value)
+
+    def set_metric(self, value: int) -> None:
+        self._set(ThenField.metric, value)
+
+    def add_metric(self, value: int) -> None:
+        action = self._statement.then
+        field = ThenField.metric
+        if field in action:
+            old_action = action[field]
+            if old_action.type == ActionType.SET:
+                action[field].value += value
+            elif old_action.type == ActionType.ADD:
+                action[field].value = value
+            else:
+                raise RuntimeError(f"Unknown action type {old_action.type} for metric")
+        else:
+            action.append(SingleAction(
+                field=field,
+                type=ActionType.ADD,
+                value=value,
+            ))
+
+    def set_rpki_valid_state(self, value: str) -> None:
+        self._set(ThenField.rpki_valid_state, value)
+
+    def set_resolution(self, value: str) -> None:
+        self._set(ThenField.resolution, value)
+
+    def set_mpls_label(self) -> None:
+        self._set(ThenField.mpls_label, True)
+
+    def set_origin(self, value: str) -> None:
+        self._set(ThenField.origin, value)
+
+    def set_tag(self, value: int) -> None:
+        self._set(ThenField.tag, value)
+
+    def set_next_hop(self, value: Literal["self", "peer"]) -> None:  # ???
+        self._set(ThenField.next_hop, value)
+
+    def __enter__(self) -> "StatementBuilder":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._community:
+            self._statement.then.append(SingleAction(
+                field=ThenField.community,
+                type=ActionType.CUSTOM,
+                value=self._community,
+            ))
+        if self._extcommunity:
+            self._statement.then.append(SingleAction(
+                field=ThenField.extcommunity,
+                type=ActionType.CUSTOM,
+                value=self._extcommunity,
+            ))
+        if self._as_path:
+            self._statement.then.append(SingleAction(
+                field=ThenField.as_path,
+                type=ActionType.CUSTOM,
+                value=self._as_path,
+            ))
+        if self._next_hop:
+            self._statement.then.append(SingleAction(
+                field=ThenField.next_hop,
+                type=ActionType.CUSTOM,
+                value=self._next_hop,
+            ))
+        return None
+
+    def allow(self) -> None:
+        self._statement.result = ResultType.ALLOW
+
+    def deny(self) -> None:
+        self._statement.result = ResultType.DENY
+
+    def next(self) -> None:
+        self._statement.result = ResultType.NEXT
+
+    def next_policy(self) -> None:
+        self._statement.result = ResultType.NEXT_POLICY
+
+    def add_as_path(self, *as_path: int) -> None:
+        self._added_as_path.extend(as_path)
+
+    def custom_action(self, action: SingleAction[Any]) -> None:
+        self._statement.then.append(action)

annet/rulebook/cisco/misc.py

@@ -1,4 +1,6 @@
 import re
+from collections import OrderedDict
+from typing import Any
 
 from annet.annlib.types import Op
 
@@ -55,3 +57,93 @@ def banner_login(rule, key, diff, **_):
         yield (False, f"banner login {key}", None)
     else:
         yield from common.default(rule, key, diff)
+
+
+def bgp_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
+    """
+    Some oder versions of Cisco IOS doesn't create subsection for address family block.
+
+    it looks like:
+
+    router bgp 65111
+     bgp router-id 1.1.1.1
+     bgp log-neighbor-changes
+     neighbor SPINE peer-group
+     !
+     address-family ipv4
+     neighbor SPINE send-community both
+     neighbor SPINE soft-reconfiguration inbound
+     neighbor SPINE route-map TOR_IMPORT_SPINE in
+     neighbor SPINE route-map TOR_EXPORT_SPINE out
+     exit-address-family
+
+    but should be
+
+    router bgp 65111
+     bgp router-id 1.1.1.1
+     bgp log-neighbor-changes
+     neighbor SPINE peer-group
+     !
+     address-family ipv4
+      neighbor SPINE send-community both
+      neighbor SPINE soft-reconfiguration inbound
+      neighbor SPINE route-map TOR_IMPORT_SPINE in
+      neighbor SPINE route-map TOR_EXPORT_SPINE out
+     exit-address-family
+
+    The diff_logic func do it before make diff.
+    """
+    corrected_old = _create_subsections(old, "address-family")
+
+    yield from common.default_diff(corrected_old, new, diff_pre, _pops)
+
+
+def _create_subsections(data: OrderedDict[str, Any], sub_section_prefix: str) -> OrderedDict[str, Any]:
+    """
+    Reorganizes the given OrderedDict to nest commands under their respective
+    sub_section_prefix keys.
+
+    This function traverses the entries in the provided OrderedDict and groups
+    together all entries that are between keys with sub_section_prefix under those
+    keys as nested OrderedDicts. The reorganization keeps the order of entries
+    stable, only adding nesting where appropriate.
+
+    Args:
+        data (OrderedDict): The original configuration to be transformed.
+        sub_section_prefix (str): Prefix of subsection key
+
+    Returns:
+        OrderedDict: A new OrderedDict with nested 'address-family' sections.
+    """
+
+    result = OrderedDict()
+    sub_section = None
+    temp: OrderedDict = OrderedDict()
+
+    for key, value in data.items():
+        # make nested loop if found nested values
+        if value:
+            fixed_value: OrderedDict[str, Any] = _create_subsections(value, sub_section_prefix)
+        else:
+            fixed_value = value
+        if key.startswith(sub_section_prefix):
+            # in case of data has already had subsections
+            if value:
+                result[key] = fixed_value
+                continue
+            # if previous subsection present save collected data from temporary dict
+            if sub_section:
+                result[sub_section] = temp
+            # find a new subsection and initialize new dict
+            sub_section = key
+            temp = OrderedDict()
+        # put found data to temporary dict
+        elif sub_section:
+            temp[key] = fixed_value
+        else:
+            result[key] = fixed_value
+    # if data is finished save collected data from temporary dict
+    if sub_section:
+        result[sub_section] = temp
+
+    return result

annet/rulebook/texts/arista.rul

@@ -47,6 +47,7 @@ router bfd
 router bgp *
     no bgp default *
     neighbor * maximum-routes
+    ! no neighbor * shutdown
     ~ %global
 
 ip load-sharing trident fields *              %logic=common.default_instead_undo

annet/rulebook/texts/cisco.rul

@@ -73,7 +73,7 @@ interface */\w*Ethernet[0-9\/]+$/     %logic=common.permanent %diff_logic=cisco.
     storm-control * level
     spanning-tree portfast
 
-router bgp *
+router bgp *     %diff_logic=cisco.misc.bgp_diff
     router-id
     vrf *
         router-id

annet-0.16.18.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.1
+Name: annet
+Version: 0.16.18
+Summary: annet
+Home-page: https://github.com/annetutil/annet
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: AUTHORS
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: tabulate>=0.9.0
+Requires-Dist: jsonpatch>=1.33
+Requires-Dist: jsonpointer>=2.4
+Requires-Dist: PyYAML>=6.0.1
+Requires-Dist: Pygments>=2.14.0
+Requires-Dist: Mako>=1.2.4
+Requires-Dist: Jinja2>=3.1.2
+Requires-Dist: psutil>=5.8.0
+Requires-Dist: packaging>=23.2
+Requires-Dist: contextlog>=1.1
+Requires-Dist: valkit>=0.1.4
+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.8; extra == "netbox"

{annet-0.16.16.dist-info → annet-0.16.18.dist-info}/RECORD

@@ -68,7 +68,7 @@ annet/annlib/rbparser/syntax.py,sha256=iZ7Y-4QQBw4L3UtjEh54qisiRDhobl7HZxFNdP8mi
 annet/annlib/rulebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/rulebook/common.py,sha256=Kd9Xout0xC6ZZDnyaORx0W-1kSM-gTgjQbp1iIXWxic,16489
 annet/api/__init__.py,sha256=7EB3d89kGXKf4Huw7cqyOULTGC9ydL4sHiVw8K0Aeqg,33722
-annet/configs/context.yml,sha256=mzJF3K9lM-Fvj9oFOZrDEjQHWJ4W5t96ewMeeWbKDAY,224
+annet/configs/context.yml,sha256=RVLrKLIHpCty7AGwOnmqf7Uu0iZQCn-AjYhophDJer8,259
 annet/configs/logging.yaml,sha256=EUagfir99QqA73Scc3k7sfQccbU3E1SvEQdyhLFtCl4,997
 annet/generators/__init__.py,sha256=rVHHDTPKHPZsml1eNEAj3o-8RweFTN8J7LX3tKMXdIY,16402
 annet/generators/base.py,sha256=rgQLcQBPZm4ecbKmRhVOpBR-GFJAiVfdb_y5f2-LUR8,3670
@@ -89,6 +89,14 @@ annet/mesh/match_args.py,sha256=CR3kdIV9NGtyk9E2JbcOQ3TRuYEryTWP3m2yCo2VCWg,5751
 annet/mesh/models_converter.py,sha256=3q2zs7K8S3pfYSUKKRdtl5CJGbeg4TtYxofAVs_MBsk,3085
 annet/mesh/peer_models.py,sha256=xyLbWtwJ5Y4OLf-OVZeHwRn2qyWhipOvhD4pDHTbvTE,2665
 annet/mesh/registry.py,sha256=G-FszWc_VKeN3eVpb-MRGbAGzbcSuEVAzbDC2k747XA,8611
+annet/rpl/__init__.py,sha256=0kcIktE3AmS0rlm9xzVDf53xk08OeZXgD-6ZLCt_KCs,731
+annet/rpl/action.py,sha256=PY6W66j908RuqQ1_ioxayqVN-70rxDk5Z59EGHtxI98,1246
+annet/rpl/condition.py,sha256=MJri4MbWtPkLHIsLMAtsIEF7e8IAS9dIImjmJs5vS5U,3418
+annet/rpl/match_builder.py,sha256=6uutlI9TU75ClpcKZx0t8pqYxr20vr0h9itBrtrm_tQ,4194
+annet/rpl/policy.py,sha256=P1Kt-8fHFxEczeP-RwkK_wrGN0p7IR-hOApEd2vC55E,448
+annet/rpl/result.py,sha256=PHFn1zhDeqLBn07nkYw5vsoXew4nTwkklOwqvFWzBLg,141
+annet/rpl/routemap.py,sha256=ZxYSRXWtk3CG5OQuVVVYePpPP9Zbwk-ajWvQ0wqWP_8,2422
+annet/rpl/statement_builder.py,sha256=dSYrLosInUb4ewHzX4PeEzbRlIaz6Df4N1EytIJGccQ,8442
 annet/rulebook/__init__.py,sha256=14IpOfTbeJtre7JKrfXVYiH0qAXsUSOL7AatUFmSQs0,3847
 annet/rulebook/common.py,sha256=zK1s2c5lc5HQbIlMUQ4HARQudXSgOYiZ_Sxc2I_tHqg,721
 annet/rulebook/deploying.py,sha256=XV0XQvc3YvwM8SOgOQlc-fCW4bnjQg_1CTZkTwMp14A,2972
@@ -102,7 +110,7 @@ annet/rulebook/b4com/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 annet/rulebook/b4com/file.py,sha256=zK7RwBk1YaVoDSFSg1u7Pt8u0Fk3nhhu27aJRngemwc,137
 annet/rulebook/cisco/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/rulebook/cisco/iface.py,sha256=WISkzjp_G7WKPpg098FCIm4b7ipOxtRLOQbu-7gMUL0,1792
-annet/rulebook/cisco/misc.py,sha256=l9NTR6cAsrfFyeC_yoOeQ0fOFoPiJfFwnRva5W9vyL0,2259
+annet/rulebook/cisco/misc.py,sha256=KBnxBw5vs-GSoldMBzEB8ygyHEntiydn1vchZDBA3No,5286
 annet/rulebook/cisco/vlandb.py,sha256=pdQ0Ca976_5_cNBbTI6ADN1SP8aAngVBs1AZWltmpsw,3319
 annet/rulebook/huawei/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/rulebook/huawei/aaa.py,sha256=Xi8nWyBFaUz4SgoN1NQeOcXzBGCfINQDNiC-crq08uA,3445
@@ -118,7 +126,7 @@ annet/rulebook/routeros/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 annet/rulebook/routeros/file.py,sha256=zK7RwBk1YaVoDSFSg1u7Pt8u0Fk3nhhu27aJRngemwc,137
 annet/rulebook/texts/arista.deploy,sha256=OS9eFyJpEPztcOHkBwajw_RTJfTT7ivaMHfx4_HXaUg,792
 annet/rulebook/texts/arista.order,sha256=TKy3S56tIypwfVaw0akK1sXGatCpLVwpB4Jvq-dIu90,1457
-annet/rulebook/texts/arista.rul,sha256=HUYiN55s8Y6Wrd5q1Awe7-o5BYBh7gIxthUC5NvrfJI,786
+annet/rulebook/texts/arista.rul,sha256=QQbro8eFlc7DCHk0-CTHX_rnj5rqumRzXlY60ga72jo,815
 annet/rulebook/texts/aruba.deploy,sha256=hI432Bq-of_LMXuUflCu7eNSEFpx6qmj0KItEw6sgHI,841
 annet/rulebook/texts/aruba.order,sha256=ZMakkn0EJ9zomgY6VssoptJImrHrUmYnCqivzLBFTRo,1158
 annet/rulebook/texts/aruba.rul,sha256=zvGVpoYyJvMoL0fb1NQ8we_GCLZXno8nwWpZIOScLQQ,2584
@@ -127,7 +135,7 @@ annet/rulebook/texts/b4com.order,sha256=G3aToAIHHzKzDCM3q7_lyr9wJvuVOXVbVvF3wm5P
 annet/rulebook/texts/b4com.rul,sha256=5mqyUg_oLRSny2iH6QdhfDWVu6kzgDURtlSATD7DFno,1056
 annet/rulebook/texts/cisco.deploy,sha256=XvXWeOMahE8Uc9RF0xkJj8jGknD4vit8H_f24ubPX7w,1226
 annet/rulebook/texts/cisco.order,sha256=OvNHMNqkCc-DN2dEjLCTKv_7ZhiaHt4q2X4Y4Z8dvR4,1901
-annet/rulebook/texts/cisco.rul,sha256=FvMxKy4FOcFvFYdmcye5RZkWkU8mxIwmEedN83fM82I,3019
+annet/rulebook/texts/cisco.rul,sha256=xMJJgTGmg5wZXTIp5SUdLJIgwka7AIv9Uj6-DWBV3UQ,3055
 annet/rulebook/texts/huawei.deploy,sha256=azEC6_jQRzwnTSrNgag0hHh6L7hezS_eMk6ZDZfWyXI,10444
 annet/rulebook/texts/huawei.order,sha256=ENllPX4kO6xNw2mUQcx11yhxo3tKStZ5mUyc0C6s3d0,10657
 annet/rulebook/texts/huawei.rul,sha256=02Fi1RG4YYea2clHCluBuJDKNbT0hS9jtsk6_h6GK8k,12958
@@ -152,10 +160,14 @@ annet_generators/example/lldp.py,sha256=24bGvShxbio-JxUdaehyPRu31LhH9YwSwFDrWVRn
 annet_generators/mesh_example/__init__.py,sha256=NfNWgXn1TNiWI6A5tmU6Y-4QV2i33td0Qs3re0MNNMo,218
 annet_generators/mesh_example/bgp.py,sha256=jzyDndSSGYyYBquDnLlR-7P5lzmUKcSyYCml3VsoMC0,1385
 annet_generators/mesh_example/mesh_logic.py,sha256=DJS5JMCTs0rs0LN__0LulNgo2ekUcWiOMe02BlOeFas,1454
-annet-0.16.16.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-0.16.16.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-0.16.16.dist-info/METADATA,sha256=HWT2ARwNTk_WK4FcwEtWOa2FrkPAYRZ5BUwr3--hrNA,746
-annet-0.16.16.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-annet-0.16.16.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-0.16.16.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-0.16.16.dist-info/RECORD,,
+annet_generators/rpl_example/__init__.py,sha256=z4-gsDv06BBpgTwRohc50VBQYFD26QVu8Zr8Ngi_iqY,244
+annet_generators/rpl_example/items.py,sha256=6x7b0wZ7Vjn6yCaJ-aGbpTHm7fyqO77b-LRqzzhEbh4,615
+annet_generators/rpl_example/policy_generator.py,sha256=KFCqn347CIPcnllOHfINYeKgNSr6Wl-bdM5Xj_YKhYM,11183
+annet_generators/rpl_example/route_policy.py,sha256=QjxFjkePHfTo2CpMeRVaDqZXNXLM-gGlE8EocHuOR4Y,1189
+annet-0.16.18.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-0.16.18.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-0.16.18.dist-info/METADATA,sha256=pB-87I1B1EvDeahyJFJD6j2DxvPEBYfWT44e8D0a-8U,728
+annet-0.16.18.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+annet-0.16.18.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-0.16.18.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-0.16.18.dist-info/RECORD,,

{annet-0.16.16.dist-info → annet-0.16.18.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

annet_generators/rpl_example/__init__.py

@@ -0,0 +1,9 @@
+from typing import List
+
+from annet.generators import BaseGenerator
+from annet.storage import Storage
+from . import policy_generator
+
+
+def get_generators(store: Storage) -> List[BaseGenerator]:
+    return policy_generator.get_generators(store)

annet_generators/rpl_example/items.py

@@ -0,0 +1,31 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+AS_PATH_FILTERS = {
+    "ASP_EXAMPLE": [".*123456.*"],
+}
+
+IPV6_PREFIX_LISTS = {
+    "IPV6_LIST_EXAMPLE": ["2a13:5941::/32"],
+}
+
+
+@dataclass(frozen=True)
+class Community:
+    values: Sequence[str]
+
+
+@dataclass(frozen=True)
+class ExtCommunity:
+    values: Sequence[str]
+
+
+COMMUNITIES = {
+    "COMMUNITY_EXAMPLE_ADD": Community(["1234:1000"]),
+    "COMMUNITY_EXAMPLE_REMOVE": Community(["12345:999"]),
+}
+
+EXT_COMMUNITIES = {
+    "COMMUNITY_EXAMPLE_ADD": ExtCommunity(["1234:1000"]),
+    "COMMUNITY_EXAMPLE_REMOVE": ExtCommunity(["12345:999"]),
+}

annet_generators/rpl_example/policy_generator.py

@@ -0,0 +1,233 @@
+from collections.abc import Iterator, Sequence
+from typing import Any, cast
+
+from annet.generators import PartialGenerator, BaseGenerator
+from annet.rpl import (
+    CommunityActionValue,
+    ResultType, RoutingPolicyStatement, RoutingPolicy, ConditionOperator, SingleCondition, SingleAction, ActionType,
+)
+from annet.rpl.statement_builder import AsPathActionValue, NextHopActionValue
+from annet.storage import Storage
+from .items import AS_PATH_FILTERS, COMMUNITIES, EXT_COMMUNITIES
+from .route_policy import routemap
+
+HUAWEI_MATCH_COMMAND_MAP = {
+    "as_path_filter": "as-path-filter {option_value}",
+    "metric": "cost {option_value}",
+    "protocol": "protocol {option_value}",
+    "interface": "interface {option_value}",
+}
+
+HUAWEI_THEN_COMMAND_MAP = {
+    "metric": "cost {option_value}",
+    "local_pref": "local-preference {option_value}",
+    "metric_type": "cost-type {option_value}",
+    "mpls_label": "mpls-label",
+    "origin": "origin {option_value}",
+    "tag": "tag {option_value}",
+    # unsupported: resolution
+    # unsupported: rpki_valid_state
+}
+HUAWEI_RESULT_MAP = {
+    ResultType.ALLOW: "permit",
+    ResultType.DENY: "deny",
+    ResultType.NEXT: ""
+}
+
+
+class RoutingPolicyGenerator(PartialGenerator):
+    TAGS = ["policy", "rpl", "routing"]
+
+    def acl_huawei(self, _):
+        return r"""
+        ip as-path-filter
+        route-policy *
+            ~ %global=1
+        """
+
+    def _huawei_match(self, device, condition: SingleCondition[Any]) -> Iterator[Sequence[str]]:
+        if condition.field == "community":
+            if condition.operator is ConditionOperator.HAS:
+                if len(condition.value) > 1:
+                    raise NotImplementedError("Multiple HAS for communities is not supported for huawei")
+            elif condition.operator is not ConditionOperator.HAS_ANY:
+                raise NotImplementedError("Community operator %r not supported for huawei" % condition.operator)
+            for comm_name in condition.value:
+                yield "if-match community-filter", comm_name
+            return
+        if condition.field == "extcommunity":
+            if condition.operator is ConditionOperator.HAS:
+                if len(condition.value) > 1:
+                    raise NotImplementedError("Multiple HAS for extcommunities is not supported for huawei")
+            elif condition.operator is not ConditionOperator.HAS_ANY:
+                raise NotImplementedError("Extcommunity operator %r not supported for huawei" % condition.operator)
+            for comm_name in condition.value:
+                yield "if-match extcommunity-filter", comm_name
+            return
+        if condition.field == "ip_prefix":
+            for name in condition.value.names:
+                yield "if-match", "ip-prefix-filter", name
+            return
+        if condition.field == "ipv6_prefix":
+            for name in condition.value.names:
+                yield "if-match", "ipv6 address prefix-list", name
+            return
+        if condition.field == "as_path_length":
+            if condition.operator is ConditionOperator.EQ:
+                yield "if-match", "as-path length", condition.value
+            elif condition.operator is ConditionOperator.LE:
+                yield "if-match", "as-path length less-equal", condition.value
+            elif condition.operator is ConditionOperator.GE:
+                yield "if-match", "as-path length greater-equal", condition.value
+            elif condition.operator is ConditionOperator.BETWEEN_INCLUDED:
+                yield "if-match", "as-path length greater-equal", condition.value[0], "less-equal", condition.value[1]
+            else:
+                raise NotImplementedError(
+                    f"as_path_length operator {condition.operator} not supported for huawei",
+                )
+            return
+        if condition.operator is not ConditionOperator.EQ:
+            raise NotImplementedError(
+                f"`{condition.field}` with operator {condition.operator} is not supported for huawei",
+            )
+        if condition.field not in HUAWEI_MATCH_COMMAND_MAP:
+            raise NotImplementedError(f"Match using `{condition.field}` is not supported for huawei")
+        cmd = HUAWEI_MATCH_COMMAND_MAP[condition.field]
+        yield "if-match", cmd.format(option_value=condition.value)
+
+    def _huawei_then_community(self, action: SingleAction[CommunityActionValue]) -> Iterator[Sequence[str]]:
+        if action.value.replaced is not None:
+            if not action.value.replaced:
+                yield "apply", "community", "none"
+            first = True
+            for community_name in action.value.replaced:
+                community = COMMUNITIES[community_name]
+                for comm_value in community.values:
+                    if first:
+                        yield "apply", "community", comm_value
+                        first = False
+                    else:
+                        yield "apply", "community", comm_value, "additive"
+        for community_name in action.value.added:
+            community = COMMUNITIES[community_name]
+            for comm_value in community.values:
+                yield "apply", "community", comm_value, "additive"
+        for community_name in action.value.removed:
+            yield "apply comm-filter", community_name, "delete"
+
+    def _huawei_then_extcommunity(self, action: SingleAction[CommunityActionValue]) -> Iterator[Sequence[str]]:
+        if action.value.replaced is not None:
+            if not action.value.replaced:
+                yield "apply", "extcommunity", "none"
+            first = True
+            for community_name in action.value.replaced:
+                community = EXT_COMMUNITIES[community_name]
+                for comm_value in community.values:
+                    if first:
+                        yield "apply", "extcommunity", comm_value
+                        first = False
+                    else:
+                        yield "apply", "extcommunity", comm_value, "additive"
+        for community_name in action.value.added:
+            community = EXT_COMMUNITIES[community_name]
+            for comm_value in community.values:
+                yield "apply", "extcommunity", comm_value, "additive"
+        for community_name in action.value.removed:
+            yield "apply extcommunity-filter", community_name, "delete"
+
+    def _huawei_then(self, device, action: SingleAction[Any]) -> Iterator[Sequence[str]]:
+        if action.field == "community":
+            yield from self._huawei_then_community(cast(SingleAction[CommunityActionValue], action))
+            return
+        if action.field == "extcommunity":
+            yield from self._huawei_then_extcommunity(cast(SingleAction[CommunityActionValue], action))
+            return
+        if action.field == "metric":
+            if action.type is ActionType.ADD:
+                yield "apply", f"cost + {action.value}"
+            elif action.type is ActionType.SET:
+                yield "apply", f"cost {action.value}"
+            else:
+                raise NotImplementedError(f"Action type {action.type} for metric is not supported for huawei")
+            return
+        if action.field == "as_path":
+            as_path_action_value = cast(AsPathActionValue, action.value)
+            if as_path_action_value.set is not None:
+                if not as_path_action_value.set:
+                    yield "apply", "as_path", "none overwrite"
+                first = True
+                for path_item in as_path_action_value.set:
+                    if first:
+                        yield "apply as-path", path_item, "overwrite"
+                        first = False
+                    else:
+                        yield "apply as-path", path_item, "additive"
+            if as_path_action_value.prepend:
+                for path_item in as_path_action_value.prepend:
+                    yield "apply as-path", path_item, "additive"
+            if as_path_action_value.expand:  # same as prepend?
+                for path_item in as_path_action_value.expand:
+                    yield "apply as-path", path_item, "additive"
+            if as_path_action_value.delete:
+                for path_item in as_path_action_value.delete:
+                    yield "apply as-path", path_item, "delete"
+            if as_path_action_value.expand_last_as:
+                raise RuntimeError("asp_path.expand_last_as is not supported for huawei")
+            return
+        if action.field == "next_hop":
+            next_hop_action_value = cast(NextHopActionValue, action.value)
+            if next_hop_action_value.target == "self":
+                yield "apply", "cost 1"
+            elif next_hop_action_value.target == "discard":
+                pass
+            elif next_hop_action_value.target == "peer":
+                pass
+            elif next_hop_action_value.target == "ipv4_addr":
+                yield "apply", f"ip-address next-hop {next_hop_action_value.addr}"
+            elif next_hop_action_value.target == "ipv6_addr":
+                yield "apply", f"ipv6 next-hop {next_hop_action_value.addr}"
+            elif next_hop_action_value.target == "mapped_ipv4":
+                yield "apply", f"ipv6 next-hop ::FFFF:{next_hop_action_value.addr}"
+            else:
+                raise RuntimeError(f"Next_hop target {next_hop_action_value.target} is not supported for huawei")
+
+        if action.type is not ActionType.SET:
+            raise NotImplementedError(f"Action type {action.type} for `{action.field}` is not supported for huawei")
+        if action.field not in HUAWEI_THEN_COMMAND_MAP:
+            raise NotImplementedError(f"Then action using `{action.field}` is not supported for huawei")
+        cmd = HUAWEI_THEN_COMMAND_MAP[action.field]
+        yield "apply", cmd.format(option_value=action.value)
+
+    def _huawei_statement(
+            self, device, policy: RoutingPolicy, statement: RoutingPolicyStatement,
+    ) -> Iterator[Sequence[str]]:
+        if "as_path_filter" in statement.match:
+            as_path_condition = statement.match["as_path_filter"]
+            as_filter_value = AS_PATH_FILTERS[as_path_condition.value]
+            yield "ip as-path-filter", \
+                as_path_condition.value, \
+                "index 10 permit", \
+                "_{}_".format("_".join(("%s" % x for x in as_filter_value if x != ".*")))
+
+        with self.block(
+                "route-policy", policy.name,
+                HUAWEI_RESULT_MAP[statement.result],
+                "node", statement.number
+        ):
+            for condition in statement.match:
+                yield from self._huawei_match(device, condition)
+            for action in statement.then:
+                yield from self._huawei_then(device, action)
+            if statement.result is ResultType.NEXT:
+                yield "goto next-node"
+
+    def run_huawei(self, device):
+        for policy in routemap.apply(device):
+            for statement in policy.statements:
+                yield from self._huawei_statement(device, policy, statement)
+
+
+def get_generators(store: Storage) -> list[BaseGenerator]:
+    return [
+        RoutingPolicyGenerator(store),
+    ]

annet_generators/rpl_example/route_policy.py

@@ -0,0 +1,33 @@
+from annet.adapters.netbox.common.models import NetboxDevice
+from annet.rpl import R, RouteMap, Route
+
+routemap = RouteMap[NetboxDevice]()
+
+
+@routemap
+def example1(device: NetboxDevice, route: Route):
+    condition = (R.interface == "l0.0") & (R.protocol == "bgp")
+    with route(condition, number=1, name="n1") as rule:
+        rule.set_local_pref(100)
+        rule.set_metric(100)
+        rule.add_metric(200)
+        rule.community.set("COMMUNITY_EXAMPLE_ADD")
+        rule.as_path.set(12345, "123456")
+        rule.allow()
+    with route(R.protocol == "bgp", R.community.has("comm_name"), number=2, name="n2") as rule:
+        rule.set_local_pref(100)
+        rule.add_metric(200)
+        rule.community.add("COMMUNITY_EXAMPLE_ADD")
+        rule.community.remove("COMMUNITY_EXAMPLE_REMOVE")
+        rule.allow()
+
+
+@routemap
+def example2(device: NetboxDevice, route: Route):
+    with route(R.as_path_filter("ASP_EXAMPLE"), number=3, name="n3") as rule:
+        rule.deny()
+    with route(R.match_v6("IPV6_LIST_EXAMPLE"), number=4, name="n4") as rule:
+        rule.allow()
+
+    with route(R.as_path_length >= 1, R.as_path_length <= 20, number=4, name="n4") as rule:
+        rule.allow()

annet-0.16.16.dist-info/METADATA

@@ -1,27 +0,0 @@
-Metadata-Version: 2.1
-Name: annet
-Version: 0.16.16
-Summary: annet
-Home-page: https://github.com/annetutil/annet
-License: MIT
-Requires-Python: >=3.10
-License-File: LICENSE
-License-File: AUTHORS
-Requires-Dist: colorama >=0.4.6
-Requires-Dist: tabulate >=0.9.0
-Requires-Dist: jsonpatch >=1.33
-Requires-Dist: jsonpointer >=2.4
-Requires-Dist: PyYAML >=6.0.1
-Requires-Dist: Pygments >=2.14.0
-Requires-Dist: Mako >=1.2.4
-Requires-Dist: Jinja2 >=3.1.2
-Requires-Dist: psutil >=5.8.0
-Requires-Dist: packaging >=23.2
-Requires-Dist: contextlog >=1.1
-Requires-Dist: valkit >=0.1.4
-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.8 ; extra == 'netbox'
-