Skip to content

Config

High-level wrapper exposing query access over a parsed configuration.

Config 

Config(nodes: list[ConfigNode])

Bases: _Queryable

A parsed configuration: its ordered top-level lines and their subtrees.

Returned by parse. A configuration owns the top-level lines (those at column 0). find searches the whole tree, while find_child and has_child consider only top-level lines.

Create a configuration from its ordered top-level nodes.

Source code in networkconfparse/config.py 
21
22
23
def __init__(self, nodes: list[ConfigNode]) -> None:
    """Create a configuration from its ordered top-level nodes."""
    self.nodes = nodes

nodes instance-attribute 

nodes = nodes

walk 

walk() -> Iterator[ConfigNode]

Yield every descendant node, depth-first (pre-order).

The object itself is not yielded; iteration descends into the immediate child nodes in configuration order.

Source code in networkconfparse/node.py 
47
48
49
50
51
52
53
54
55
def walk(self) -> Iterator[ConfigNode]:
    """Yield every descendant node, depth-first (pre-order).

    The object itself is not yielded; iteration descends into the immediate
    child nodes in configuration order.
    """
    for node in self._query_nodes:
        yield node
        yield from node.walk()

find 

find(
    pattern: str | Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> list[ConfigNode]

Return all descendant nodes matching pattern and/or where.

Searches the entire subtree, not just immediate children.

Source code in networkconfparse/node.py 
57
58
59
60
61
62
63
64
65
66
67
68
def find(
    self,
    pattern: str | re.Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> list[ConfigNode]:
    """Return all descendant nodes matching ``pattern`` and/or ``where``.

    Searches the entire subtree, not just immediate children.
    """
    test = self._matcher(pattern, where)
    return [node for node in self.walk() if test(node)]

find_one 

find_one(
    pattern: str | Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> ConfigNode | None

Return the first descendant matching pattern/where, or None.

Searches the whole subtree in pre-order.

Source code in networkconfparse/node.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
def find_one(
    self,
    pattern: str | re.Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> ConfigNode | None:
    """Return the first descendant matching ``pattern``/``where``, or ``None``.

    Searches the whole subtree in pre-order.
    """
    test = self._matcher(pattern, where)
    for node in self.walk():
        if test(node):
            return node
    return None

find_child 

find_child(
    pattern: str | Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> ConfigNode | None

Return the first immediate child matching pattern/where.

Only immediate children are considered, in configuration order; returns None if none match.

Source code in networkconfparse/node.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def find_child(
    self,
    pattern: str | re.Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> ConfigNode | None:
    """Return the first immediate child matching ``pattern``/``where``.

    Only immediate children are considered, in configuration order; returns
    ``None`` if none match.
    """
    test = self._matcher(pattern, where)
    for node in self._query_nodes:
        if test(node):
            return node
    return None

has_child 

has_child(
    pattern: str | Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> bool

Return whether any immediate child matches pattern/where.

Source code in networkconfparse/node.py 
103
104
105
106
107
108
109
110
def has_child(
    self,
    pattern: str | re.Pattern[str] | None = None,
    *,
    where: Predicate | None = None,
) -> bool:
    """Return whether any immediate child matches ``pattern``/``where``."""
    return self.find_child(pattern, where=where) is not None

find_with_child 

find_with_child(
    pattern: str | Pattern[str] | None, child: Patterns
) -> list[ConfigNode]

Return nodes matching pattern that have child as direct children.

child is one regex or an iterable of them; every pattern must match some direct child (logical AND). Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
def find_with_child(
    self,
    pattern: str | re.Pattern[str] | None,
    child: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` that have ``child`` as direct children.

    ``child`` is one regex or an iterable of them; every pattern must match
    some direct child (logical AND). Implemented with `find` and a
    ``where`` predicate.
    """
    children = _as_list(child)
    return self.find(
        pattern,
        where=lambda node: all(node.has_child(c) for c in children),
    )

find_with_descendant 

find_with_descendant(
    pattern: str | Pattern[str] | None, descendant: Patterns
) -> list[ConfigNode]

Return nodes matching pattern with descendant anywhere below.

descendant is one regex or an iterable of them; every pattern must match some descendant at any depth (logical AND). Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
def find_with_descendant(
    self,
    pattern: str | re.Pattern[str] | None,
    descendant: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` with ``descendant`` anywhere below.

    ``descendant`` is one regex or an iterable of them; every pattern must
    match some descendant at any depth (logical AND). Implemented with
    `find` and a ``where`` predicate.
    """
    descendants = _as_list(descendant)
    return self.find(
        pattern,
        where=lambda node: all(node.find_one(d) is not None for d in descendants),
    )

find_with_parent 

find_with_parent(
    pattern: str | Pattern[str] | None, parent: Patterns
) -> list[ConfigNode]

Return nodes matching pattern whose direct parent matches parent.

parent is one regex or an iterable of them; every pattern must match the single parent line (logical AND). Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
def find_with_parent(
    self,
    pattern: str | re.Pattern[str] | None,
    parent: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` whose direct parent matches ``parent``.

    ``parent`` is one regex or an iterable of them; every pattern must match
    the single parent line (logical AND). Implemented with `find` and
    a ``where`` predicate.
    """
    parents = _as_list(parent)
    return self.find(
        pattern,
        where=lambda node: _parent_matches_all(node, parents),
    )

find_with_ancestor 

find_with_ancestor(
    pattern: str | Pattern[str] | None,
    ancestor: Patterns,
    *,
    adjacent: bool = False,
) -> list[ConfigNode]

Return nodes matching pattern with ancestor above them.

ancestor is one regex or an iterable of them, all required (AND). With adjacent=False (the default) each pattern must match some ancestor, in any order. With adjacent=True the patterns must form a consecutive chain matched nearest-first: the first against the direct parent, the next against its parent, and so on. Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
def find_with_ancestor(
    self,
    pattern: str | re.Pattern[str] | None,
    ancestor: Patterns,
    *,
    adjacent: bool = False,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` with ``ancestor`` above them.

    ``ancestor`` is one regex or an iterable of them, all required (AND).
    With ``adjacent=False`` (the default) each pattern must match some
    ancestor, in any order. With ``adjacent=True`` the patterns must form a
    consecutive chain matched nearest-first: the first against the direct
    parent, the next against its parent, and so on. Implemented with
    `find` and a ``where`` predicate.
    """
    ancestors = _as_list(ancestor)
    if adjacent:
        return self.find(
            pattern,
            where=lambda node: _adjacent_ancestors(node, ancestors),
        )
    return self.find(
        pattern,
        where=lambda node: _any_ancestor_each(node, ancestors),
    )

find_without_child 

find_without_child(
    pattern: str | Pattern[str] | None, child: Patterns
) -> list[ConfigNode]

Return nodes matching pattern that lack every child pattern.

The negative counterpart of find_with_child. child is one regex or an iterable of them; a node matches when none of them match any direct child (the "none present" / NOR rule). For [a, b] a node qualifies only if it has no direct child matching a and none matching b - so a node carrying just one of them is excluded. Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
def find_without_child(
    self,
    pattern: str | re.Pattern[str] | None,
    child: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` that lack every ``child`` pattern.

    The negative counterpart of `find_with_child`. ``child`` is one regex
    or an iterable of them; a node matches when **none** of them match any
    direct child (the "none present" / NOR rule). For ``[a, b]`` a node
    qualifies only if it has no direct child matching ``a`` and none
    matching ``b`` - so a node carrying just one of them is excluded.
    Implemented with `find` and a ``where`` predicate.
    """
    children = _as_list(child)
    return self.find(
        pattern,
        where=lambda node: not any(node.has_child(c) for c in children),
    )

find_without_descendant 

find_without_descendant(
    pattern: str | Pattern[str] | None, descendant: Patterns
) -> list[ConfigNode]

Return nodes matching pattern with none of descendant below.

The negative counterpart of find_with_descendant. descendant is one regex or an iterable of them; a node matches when none of them match any descendant at any depth (the "none present" / NOR rule). For [a, b] a node carrying just one of the two below it is excluded. Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
def find_without_descendant(
    self,
    pattern: str | re.Pattern[str] | None,
    descendant: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` with none of ``descendant`` below.

    The negative counterpart of `find_with_descendant`. ``descendant`` is
    one regex or an iterable of them; a node matches when **none** of them
    match any descendant at any depth (the "none present" / NOR rule). For
    ``[a, b]`` a node carrying just one of the two below it is excluded.
    Implemented with `find` and a ``where`` predicate.
    """
    descendants = _as_list(descendant)
    return self.find(
        pattern,
        where=lambda node: (
            not any(node.find_one(d) is not None for d in descendants)
        ),
    )

find_without_parent 

find_without_parent(
    pattern: str | Pattern[str] | None, parent: Patterns
) -> list[ConfigNode]

Return nodes matching pattern whose parent matches no parent.

The negative counterpart of find_with_parent. parent is one regex or an iterable of them; a node matches when its direct parent matches none of them (the "none present" / NOR rule). A top-level node has no parent, so it can never sit beneath a matching one and always qualifies. For [a, b] a node whose parent matches just one of the two is excluded. Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
def find_without_parent(
    self,
    pattern: str | re.Pattern[str] | None,
    parent: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` whose parent matches no ``parent``.

    The negative counterpart of `find_with_parent`. ``parent`` is one regex
    or an iterable of them; a node matches when its direct parent matches
    **none** of them (the "none present" / NOR rule). A top-level node has
    no parent, so it can never sit beneath a matching one and always
    qualifies. For ``[a, b]`` a node whose parent matches just one of the
    two is excluded. Implemented with `find` and a ``where`` predicate.
    """
    parents = _as_list(parent)
    return self.find(
        pattern,
        where=lambda node: _parent_matches_none(node, parents),
    )

find_without_ancestor 

find_without_ancestor(
    pattern: str | Pattern[str] | None, ancestor: Patterns
) -> list[ConfigNode]

Return nodes matching pattern with none of ancestor above.

The negative counterpart of find_with_ancestor. ancestor is one regex or an iterable of them; a node matches when none of them match any ancestor at any depth (the "none present" / NOR rule). A top-level node has no ancestors and always qualifies. For [a, b] a node with just one of the two anywhere above it is excluded.

Unlike find_with_ancestor, this takes no adjacent flag: negating an adjacent-chain match is rarely meaningful, so the only negative offered is "none of these appear anywhere in the ancestry." Implemented with find and a where predicate.

Source code in networkconfparse/node.py 
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
def find_without_ancestor(
    self,
    pattern: str | re.Pattern[str] | None,
    ancestor: Patterns,
) -> list[ConfigNode]:
    """Return nodes matching ``pattern`` with none of ``ancestor`` above.

    The negative counterpart of `find_with_ancestor`. ``ancestor`` is one
    regex or an iterable of them; a node matches when **none** of them
    match any ancestor at any depth (the "none present" / NOR rule). A
    top-level node has no ancestors and always qualifies. For ``[a, b]`` a
    node with just one of the two anywhere above it is excluded.

    Unlike `find_with_ancestor`, this takes no ``adjacent`` flag: negating
    an adjacent-chain match is rarely meaningful, so the only negative
    offered is "none of these appear anywhere in the ancestry." Implemented
    with `find` and a ``where`` predicate.
    """
    ancestors = _as_list(ancestor)
    return self.find(
        pattern,
        where=lambda node: _no_ancestor_matches(node, ancestors),
    )