From 1426f5e97e526a8729c1526981494842a7c5b605 Mon Sep 17 00:00:00 2001 From: Kiran K Kotari Date: Sat, 27 Dec 2025 19:55:48 -0500 Subject: [PATCH 1/3] adding xpath feature --- README.md | 56 +++++ docs/XPATH_GUIDE.md | 177 ++++++++++++++++ shconfparser/__init__.py | 4 + shconfparser/models.py | 25 +++ shconfparser/parser.py | 48 ++++- shconfparser/xpath.py | 292 ++++++++++++++++++++++++++ tests/test_xpath.py | 435 +++++++++++++++++++++++++++++++++++++++ 7 files changed, 1036 insertions(+), 1 deletion(-) create mode 100644 docs/XPATH_GUIDE.md create mode 100644 shconfparser/xpath.py create mode 100644 tests/test_xpath.py diff --git a/README.md b/README.md index 47ce2f9..a022ca6 100644 --- a/README.md +++ b/README.md @@ -43,6 +43,7 @@ Table Structure ๐Ÿ”’ **Type Safe** - Full type hints and py.typed marker ๐ŸŽฏ **Vendor Independent** - Works with any network device configuration ๐Ÿ“Š **Multiple Formats** - Parse trees, tables, and unstructured data +๐Ÿ” **XPath Queries** - Search configs with XPath-style syntax (NEW!) ๐Ÿงช **Well Tested** - 80%+ code coverage, tested on Python 3.8-3.13 ## Quick Start @@ -207,6 +208,61 @@ print(match) # {'Device ID': 'R2', 'Local Intrfce': 'Fas 0/0', ...} ``` +### XPath-Style Queries (New in 3.0!) + +Query parsed configuration trees using XPath-style syntax: + +```python +from shconfparser.parser import Parser + +p = Parser() +data = p.read('multiple_commands.txt') +data = p.split(data) + +# Parse the running config into a tree +data['running'] = p.parse_tree(data['running']) + +# Now use XPath queries on the parsed tree +# Find all IP addresses anywhere in config +result = p.xpath('//ip/address', tree=data['running']) +print(f"Found {result.count} IP addresses") + +# Get specific interface configuration +result = p.xpath('/interface/FastEthernet0-0/ip/address', tree=data['running']) +if result: + print(f"IP: {result.data}") + +# List all interface names using wildcard +result = p.xpath('/interface/*', tree=data['running']) +print(f"Interfaces: {', '.join(result.matches)}") + +# Filter interfaces by pattern +result = p.xpath('/interface[FastEthernet*]/description', tree=data['running']) +for desc in result.matches: + print(f" - {desc}") +``` + +**Supported XPath Features:** +- **Absolute paths**: `/interface/FastEthernet0-0/ip/address` +- **Recursive search**: `//ip/address` (find anywhere) +- **Wildcards**: `/interface/*/description` (all interfaces) +- **Predicates**: `/interface[GigabitEthernet*]` (pattern matching) +- **Root access**: `/` (entire tree) + +**Or use stored tree directly:** +```python +p = Parser() +data = p.read('running_config.txt') +p.parse_tree(data) # Stores in p.data + +# Query uses stored tree automatically +result = p.xpath('//ip/address') +for addr in result.matches: + print(addr) +``` + +See [docs/XPATH_GUIDE.md](docs/XPATH_GUIDE.md) for complete XPath documentation. + ### Alternative: Using Individual Components
diff --git a/docs/XPATH_GUIDE.md b/docs/XPATH_GUIDE.md new file mode 100644 index 0000000..179e5b2 --- /dev/null +++ b/docs/XPATH_GUIDE.md @@ -0,0 +1,177 @@ +# XPath Feature for shconfparser + +## Overview + +The XPath feature adds powerful querying capabilities to shconfparser, similar to Cisco NSO's XPath search functionality. It allows you to search and navigate through parsed configuration trees using XPath-style query syntax. + +## Installation + +Already included in shconfparser 3.0.0+ + +## Quick Start + +```python +from shconfparser import Parser + +# Parse configuration +p = Parser() +p.read('config.txt') +p.parse_tree() + +# Use XPath queries +result = p.xpath('//ip/address') # Find all IP addresses +print(f"Found {result.count} addresses") +for addr in result.matches: + print(addr) +``` + +## Supported XPath Features + +### 1. Absolute Paths +Navigate from root with specific path: +```python +result = p.xpath('/interface/GigabitEthernet0-0-1/ip/address') +``` + +### 2. Recursive Search (`//`) +Find matches anywhere in the tree: +```python +result = p.xpath('//address') # All addresses at any level +result = p.xpath('//ip/nat') # All NAT settings under ip +``` + +### 3. Wildcards (`*`) +Match any key at a level: +```python +# List all interface names +result = p.xpath('/interface/*') + +# Get descriptions from all interfaces +result = p.xpath('/interface/*/description') +``` + +### 4. Predicates (`[pattern]`) +Filter by pattern with wildcard support: +```python +# Get config for GigabitEthernet interfaces only +result = p.xpath('/interface[GigabitEthernet*]') + +# Get IPs from specific interface types +result = p.xpath('/interface[GigabitEthernet*]/ip/address') +``` + +### 5. Root Path +Get entire tree: +```python +result = p.xpath('/') +``` + +## XPathResult Object + +All queries return an `XPathResult` with: + +- `success` (bool): Whether query found matches +- `data` (Any): First match (primary result) +- `matches` (List): All matches found +- `count` (int): Number of matches +- `query` (str): Original query string +- `error` (str|None): Error message if failed + +### Boolean Evaluation + +```python +result = p.xpath('/hostname') +if result: # Evaluates to True if success + print(f"Hostname: {result.data}") +``` + +## Advanced Usage + +### Query Chaining +```python +# Get specific interface first +interface = p.xpath('/interface/GigabitEthernet0-0-1') + +# Then query within that interface +nat = p.xpath('/ip/nat', tree=interface.data) +``` + +### Custom Tree +```python +# Query a custom tree instead of stored one +result = p.xpath('//address', tree=custom_tree) +``` + +### Pattern Matching +Case-insensitive with wildcard support: +```python +# Matches Loopback0, Loopback1, etc. +result = p.xpath('/interface[Loopback*]') + +# Matches anything ending in 0 +result = p.xpath('/interface[*0]') +``` + +## Examples + +See `examples/xpath_demo.py` for comprehensive examples. + +## Comparison with Cisco NSO + +| Feature | Cisco NSO | shconfparser XPath | +|---------|-----------|-------------------| +| Absolute paths | โœ“ | โœ“ | +| Recursive search | โœ“ | โœ“ | +| Wildcards | โœ“ | โœ“ | +| Predicates | โœ“ | โœ“ (simplified) | +| Attributes | โœ“ | - | +| Functions | โœ“ | - | +| Axes | โœ“ | - | + +## Performance + +- Efficient for small to medium trees (< 10k nodes) +- Recursive searches scan entire tree +- Use absolute paths when possible for best performance + +## Testing + +31 comprehensive tests cover all functionality: +```bash +pytest tests/test_xpath.py -v +``` + +## API Reference + +### Parser.xpath() + +```python +def xpath(query: str, tree: Optional[TreeData] = None) -> XPathResult: + """Execute XPath-style query on configuration tree. + + Args: + query: XPath-style query string + tree: Optional tree to search (uses self.data if not provided) + + Returns: + XPathResult with matches, count, and metadata + """ +``` + +### XPath Class + +```python +from shconfparser.xpath import XPath + +xpath = XPath() +result = xpath.query(tree, '//ip/address') +``` + +## Future Enhancements + +Potential additions: +- XPath functions (count(), text(), etc.) +- Attribute filtering `[@attr='value']` +- Multiple predicates +- Parent/ancestor axes +- Index predicates `[1]`, `[last()]` diff --git a/shconfparser/__init__.py b/shconfparser/__init__.py index 762f96c..4630f30 100644 --- a/shconfparser/__init__.py +++ b/shconfparser/__init__.py @@ -30,6 +30,7 @@ TreeData, TreeParseResult, ValidationResult, + XPathResult, ) from .parser import Parser from .protocols import Parsable, Readable, Searchable, Splittable, Validatable @@ -38,6 +39,7 @@ from .shsplit import ShowSplit from .table_parser import TableParser from .tree_parser import TreeParser +from .xpath import XPath __version__ = "3.0.0" __author__ = "Kiran Kumar Kotari" @@ -51,6 +53,7 @@ "Reader", "Search", "ShowSplit", + "XPath", # Exceptions "ParserError", "InvalidDataError", @@ -68,6 +71,7 @@ "SearchResult", "ValidationResult", "FileReadResult", + "XPathResult", "TreeData", "TableData", "TableRow", diff --git a/shconfparser/models.py b/shconfparser/models.py index cecd1be..940c0f5 100644 --- a/shconfparser/models.py +++ b/shconfparser/models.py @@ -132,3 +132,28 @@ class FileReadResult: def __bool__(self) -> bool: """Allow boolean evaluation of result.""" return self.success + + +@dataclass +class XPathResult: + """Result of an XPath query operation. + + Attributes: + success: Whether query found matches + data: Primary match (first result) + matches: List of all matches found + count: Number of matches + query: Original XPath query string + error: Error message if query failed + """ + + success: bool + data: Any = None + matches: List[Any] = field(default_factory=list) + count: int = 0 + query: str = "" + error: Optional[str] = None + + def __bool__(self) -> bool: + """Allow boolean evaluation of result.""" + return self.success diff --git a/shconfparser/parser.py b/shconfparser/parser.py index 5022cd8..40c8762 100644 --- a/shconfparser/parser.py +++ b/shconfparser/parser.py @@ -12,12 +12,13 @@ from collections import OrderedDict from typing import Any, List, Optional -from .models import TableData, TableParseResult, TreeData, TreeParseResult +from .models import TableData, TableParseResult, TreeData, TreeParseResult, XPathResult from .reader import Reader from .search import Search from .shsplit import ShowSplit from .table_parser import TableParser from .tree_parser import TreeParser +from .xpath import XPath class Parser: @@ -57,6 +58,7 @@ def __init__(self, log_level: int = logging.INFO, log_format: Optional[str] = No self.search: Search = Search() self.tree_parser: TreeParser = TreeParser() self.table_parser: TableParser = TableParser() + self.xpath_engine: XPath = XPath() def __repr__(self) -> str: """Return string representation for debugging.""" @@ -247,3 +249,47 @@ def dump(self, data: Any, indent: Optional[int] = None) -> str: JSON string representation """ return json.dumps(data, indent=indent) + + def xpath(self, query: str, tree: Optional[TreeData] = None) -> XPathResult: + """Execute XPath-style query on configuration tree. + + Uses stored tree (self.data) by default, or accepts a custom tree. + + Supports: + - Absolute paths: /interface/GigabitEthernet0-0-1/ip/address + - Relative paths: //ip/address (find anywhere) + - Wildcards: /interface/*/ip + - Get all keys: /interface/* (list all interfaces) + - Predicates: /interface[GigabitEthernet*] + + Args: + query: XPath-style query string + tree: Optional tree to search (uses self.data if not provided) + + Returns: + XPathResult with matches, count, and metadata + + Example: + >>> p = Parser() + >>> p.read('config.txt') + >>> p.parse_tree() + >>> # Search using stored tree + >>> results = p.xpath('//ip/address') + >>> # Search custom tree + >>> results = p.xpath('//ip/address', tree=custom_tree) + """ + search_tree = tree if tree is not None else self.data + + if not search_tree: + self.logger.warning("No tree data available for XPath query") + return XPathResult( + success=False, + error="No tree data available. Parse a tree first or provide tree parameter.", + query=query, + ) + + try: + return self.xpath_engine.query(search_tree, query) + except Exception as e: + self.logger.error(f"XPath query failed: {str(e)}") + return XPathResult(success=False, error=str(e), query=query) diff --git a/shconfparser/xpath.py b/shconfparser/xpath.py new file mode 100644 index 0000000..890ae23 --- /dev/null +++ b/shconfparser/xpath.py @@ -0,0 +1,292 @@ +"""XPath-like query engine for parsed configuration trees. + +This module provides XPath-style querying capabilities for navigating +and searching through parsed network configuration data structures. +""" + +import logging +import re +from collections import OrderedDict +from typing import Any, List + +from .exceptions import SearchError +from .models import TreeData, XPathResult + +logger = logging.getLogger(__name__) + + +class XPath: + """XPath-like query engine for configuration trees. + + Supports: + - Absolute paths: /interface/GigabitEthernet0-0-1/ip/address + - Relative paths: //ip/address (find anywhere) + - Wildcards: /interface/*/ip + - Get all keys: /interface/* (list all interfaces) + - Predicates: /interface[GigabitEthernet*] + + Example: + >>> xpath = XPath() + >>> results = xpath.query(tree, '//ip/address') + >>> result = xpath.query(tree, '/interface/GigabitEthernet0-0-1') + """ + + def __init__(self) -> None: + """Initialize XPath engine.""" + pass + + def __repr__(self) -> str: + """Return string representation.""" + return "XPath()" + + def query(self, tree: TreeData, path: str) -> XPathResult: + """Execute XPath query on configuration tree. + + Args: + tree: Parsed configuration tree (OrderedDict) + path: XPath-style query string + + Returns: + XPathResult with found data and metadata + + Raises: + SearchError: If path syntax is invalid + """ + if not path: + raise SearchError("XPath query cannot be empty") + + if not isinstance(tree, OrderedDict): + raise SearchError("Tree must be an OrderedDict") + + # Normalize path + path = path.strip() + + # Handle different path types + if path.startswith("//"): + # Recursive search + return self._search_recursive(tree, path[2:]) + elif path.startswith("/"): + # Absolute path + return self._search_absolute(tree, path[1:]) + else: + # Relative path (treat as absolute) + return self._search_absolute(tree, path) + + def _search_absolute(self, tree: TreeData, path: str) -> XPathResult: + """Search using absolute path from root. + + Args: + tree: Configuration tree + path: Path without leading / + + Returns: + XPathResult with matches + """ + if not path: + return XPathResult(success=True, data=tree, matches=[tree], count=1, query=f"/{path}") + + parts = self._split_path(path) + matches = self._traverse_path(tree, parts, []) + + return XPathResult( + success=len(matches) > 0, + data=matches[0] if matches else None, + matches=matches, + count=len(matches), + query=f"/{path}", + ) + + def _search_recursive(self, tree: TreeData, path: str) -> XPathResult: + """Search recursively through entire tree. + + Args: + tree: Configuration tree + path: Path to search for + + Returns: + XPathResult with all matches + """ + parts = self._split_path(path) + all_matches: List[Any] = [] + + def recurse(node: Any, depth: int = 0) -> None: + """Recursively search tree for matching paths.""" + if not isinstance(node, OrderedDict): + return + + # Try to match from this node + matches = self._traverse_path(node, parts, []) + all_matches.extend(matches) + + # Recurse into children + for value in node.values(): + if isinstance(value, OrderedDict): + recurse(value, depth + 1) + + recurse(tree) + + return XPathResult( + success=len(all_matches) > 0, + data=all_matches[0] if all_matches else None, + matches=all_matches, + count=len(all_matches), + query=f"//{path}", + ) + + def _split_path(self, path: str) -> List[str]: + """Split path into components. + + Args: + path: XPath string + + Returns: + List of path components + """ + # Handle empty path + if not path: + return [] + + # Split by / but preserve predicates [...] + parts = [] + current = "" + in_predicate = False + + for char in path: + if char == "[": + in_predicate = True + current += char + elif char == "]": + in_predicate = False + current += char + elif char == "/" and not in_predicate: + if current: + parts.append(current) + current = "" + else: + current += char + + if current: + parts.append(current) + + return parts + + def _traverse_path( + self, tree: TreeData, parts: List[str], current_path: List[str] + ) -> List[Any]: + """Traverse tree following path components. + + Args: + tree: Current node in tree + parts: Remaining path components + current_path: Path traversed so far + + Returns: + List of matches + """ + if not parts: + return [tree] + + if not isinstance(tree, OrderedDict): + return [] + + part = parts[0] + remaining = parts[1:] + matches: List[Any] = [] + + # Handle wildcards + if part == "*": + # Return all keys at this level if no more parts + if not remaining: + return list(tree.keys()) + # Otherwise traverse all children + for key, value in tree.items(): + if isinstance(value, OrderedDict): + child_matches = self._traverse_path(value, remaining, current_path + [key]) + matches.extend(child_matches) + elif not remaining: # Leaf node + matches.append(value) + return matches + + # Handle predicates [pattern] + if "[" in part: + key_pattern, predicate = self._parse_predicate(part) + + # Check if key exists in tree + if key_pattern in tree: + value = tree[key_pattern] + + # If value is OrderedDict, filter its children by predicate + if isinstance(value, OrderedDict): + for child_key, child_value in value.items(): + if self._match_key(child_key, predicate): + if not remaining: + matches.append(child_value) + elif isinstance(child_value, OrderedDict): + child_matches = self._traverse_path( + child_value, remaining, current_path + [key_pattern, child_key] + ) + matches.extend(child_matches) + return matches + + # Direct key lookup + if part in tree: + value = tree[part] + if not remaining: + return [value] + if isinstance(value, OrderedDict): + return self._traverse_path(value, remaining, current_path + [part]) + + # Try pattern matching on keys + for key, value in tree.items(): + if self._match_key(key, part): + if not remaining: + matches.append(value) + elif isinstance(value, OrderedDict): + child_matches = self._traverse_path(value, remaining, current_path + [key]) + matches.extend(child_matches) + + return matches + + def _parse_predicate(self, part: str) -> tuple[str, str]: + """Parse predicate from path component. + + Args: + part: Path component with predicate like 'interface[Gig*]' + + Returns: + Tuple of (key_pattern, predicate_pattern) + """ + match = re.match(r"^([^\[]+)\[([^\]]+)\]$", part) + if match: + return match.group(1), match.group(2) + return part, "" + + def _check_predicate(self, key: str, _value: Any, predicate: str) -> bool: + """Check if key/value matches predicate. + + Args: + key: Dictionary key + _value: Dictionary value (unused but kept for future use) + predicate: Predicate pattern + + Returns: + True if matches + """ + if not predicate: + return True + return self._match_key(key, predicate) + + def _match_key(self, key: str, pattern: str) -> bool: + """Match key against pattern with wildcard support. + + Args: + key: Dictionary key to match + pattern: Pattern (supports * wildcard) + + Returns: + True if key matches pattern + """ + # Convert glob pattern to regex + regex_pattern = pattern.replace("*", ".*") + regex_pattern = f"^{regex_pattern}$" + return bool(re.match(regex_pattern, key, re.IGNORECASE)) diff --git a/tests/test_xpath.py b/tests/test_xpath.py new file mode 100644 index 0000000..02cd3bd --- /dev/null +++ b/tests/test_xpath.py @@ -0,0 +1,435 @@ +"""Tests for XPath query functionality.""" + +from collections import OrderedDict + +import pytest + +from shconfparser.exceptions import SearchError +from shconfparser.parser import Parser +from shconfparser.xpath import XPath + + +@pytest.fixture +def sample_tree(): + """Create a sample configuration tree for testing.""" + tree = OrderedDict( + [ + ( + "interface", + OrderedDict( + [ + ( + "GigabitEthernet0-0-1", + OrderedDict( + [ + ("description", "WAN Interface"), + ( + "ip", + OrderedDict( + [ + ("address", "192.168.1.1 255.255.255.0"), + ("nat", "outside"), + ] + ), + ), + ("shutdown", ""), + ] + ), + ), + ( + "GigabitEthernet0-0-2", + OrderedDict( + [ + ("description", "LAN Interface"), + ( + "ip", + OrderedDict( + [ + ("address", "10.0.0.1 255.255.255.0"), + ("nat", "inside"), + ] + ), + ), + ] + ), + ), + ( + "Loopback0", + OrderedDict( + [ + ("description", "Loopback"), + ( + "ip", + OrderedDict( + [ + ("address", "1.1.1.1 255.255.255.255"), + ] + ), + ), + ] + ), + ), + ] + ), + ), + ("hostname", "Router1"), + ( + "router", + OrderedDict( + [ + ( + "bgp", + OrderedDict( + [ + ( + "65000", + OrderedDict( + [ + ( + "neighbor", + OrderedDict( + [ + ( + "10.0.0.2", + OrderedDict( + [ + ("remote-as", "65001"), + ] + ), + ), + ] + ), + ), + ] + ), + ), + ] + ), + ), + ] + ), + ), + ] + ) + return tree + + +class TestXPath: + """Test XPath query engine.""" + + def test_xpath_init(self): + """Test XPath initialization.""" + xpath = XPath() + assert repr(xpath) == "XPath()" + + def test_empty_query(self, sample_tree): + """Test empty query raises error.""" + xpath = XPath() + with pytest.raises(SearchError, match="XPath query cannot be empty"): + xpath.query(sample_tree, "") + + def test_invalid_tree_type(self): + """Test invalid tree type raises error.""" + xpath = XPath() + with pytest.raises(SearchError, match="Tree must be an OrderedDict"): + xpath.query({"key": "value"}, "/test") + + def test_absolute_path_single_key(self, sample_tree): + """Test absolute path to single key.""" + xpath = XPath() + result = xpath.query(sample_tree, "/hostname") + assert result.success + assert result.data == "Router1" + assert result.count == 1 + assert result.query == "/hostname" + + def test_absolute_path_nested(self, sample_tree): + """Test absolute path to nested key.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-1/ip/address") + assert result.success + assert result.data == "192.168.1.1 255.255.255.0" + assert result.count == 1 + + def test_absolute_path_dict(self, sample_tree): + """Test absolute path returning dictionary.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-1/ip") + assert result.success + assert isinstance(result.data, OrderedDict) + assert "address" in result.data + assert "nat" in result.data + + def test_absolute_path_not_found(self, sample_tree): + """Test absolute path that doesn't exist.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-99") + assert not result.success + assert result.count == 0 + + def test_recursive_search(self, sample_tree): + """Test recursive search finds all matches.""" + xpath = XPath() + result = xpath.query(sample_tree, "//address") + assert result.success + assert result.count == 3 # Three interfaces with addresses + assert "192.168.1.1" in result.matches[0] + + def test_recursive_search_nested(self, sample_tree): + """Test recursive search for nested path.""" + xpath = XPath() + result = xpath.query(sample_tree, "//ip/address") + assert result.success + assert result.count == 3 + + def test_wildcard_single_level(self, sample_tree): + """Test wildcard at single level.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/*") + # Should return interface names + assert result.success + assert result.count == 3 + assert "GigabitEthernet0-0-1" in result.matches + assert "GigabitEthernet0-0-2" in result.matches + assert "Loopback0" in result.matches + + def test_wildcard_with_continuation(self, sample_tree): + """Test wildcard with path continuation.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/*/description") + assert result.success + assert result.count == 3 + assert "WAN Interface" in result.matches + assert "LAN Interface" in result.matches + + def test_wildcard_nested(self, sample_tree): + """Test wildcard in nested path.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface/*/ip/address") + assert result.success + assert result.count == 3 + + def test_predicate_exact_match(self, sample_tree): + """Test predicate with exact match.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface[GigabitEthernet0-0-1]") + assert result.success + assert result.count == 1 + assert isinstance(result.data, OrderedDict) + + def test_predicate_wildcard(self, sample_tree): + """Test predicate with wildcard pattern.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface[GigabitEthernet*]/ip/address") + assert result.success + assert result.count == 2 # Two GigabitEthernet interfaces + assert "192.168.1.1" in result.matches[0] + + def test_predicate_wildcard_prefix(self, sample_tree): + """Test predicate with wildcard prefix.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface[*0]/ip/address") + assert result.success + assert result.count == 1 # Only Loopback0 + + def test_root_path(self, sample_tree): + """Test root path returns entire tree.""" + xpath = XPath() + result = xpath.query(sample_tree, "/") + assert result.success + assert result.data == sample_tree + + def test_relative_path_treated_as_absolute(self, sample_tree): + """Test relative path (no leading /) treated as absolute.""" + xpath = XPath() + result = xpath.query(sample_tree, "hostname") + assert result.success + assert result.data == "Router1" + + def test_case_insensitive_matching(self, sample_tree): + """Test pattern matching is case insensitive.""" + xpath = XPath() + result = xpath.query(sample_tree, "/interface[gigabit*]") + assert result.success + assert result.count == 2 + + +class TestParserXPath: + """Test XPath integration with Parser class.""" + + def test_parser_xpath_with_stored_tree(self, sample_tree): + """Test Parser.xpath uses stored tree.""" + parser = Parser() + parser.data = sample_tree # Simulate parsed tree + + result = parser.xpath("//ip/address") + assert result.success + assert result.count == 3 + + def test_parser_xpath_with_custom_tree(self, sample_tree): + """Test Parser.xpath with custom tree parameter.""" + parser = Parser() + # Don't set parser.data + + result = parser.xpath("//ip/address", tree=sample_tree) + assert result.success + assert result.count == 3 + + def test_parser_xpath_no_tree(self): + """Test Parser.xpath without tree data.""" + parser = Parser() + + result = parser.xpath("//test") + assert not result.success + assert "No tree data available" in result.error + + def test_parser_xpath_invalid_query(self, sample_tree): + """Test Parser.xpath with invalid query.""" + parser = Parser() + parser.data = sample_tree + + result = parser.xpath("") + assert not result.success + assert result.error is not None + + def test_parser_xpath_result_attributes(self, sample_tree): + """Test XPathResult attributes.""" + parser = Parser() + parser.data = sample_tree + + result = parser.xpath("/hostname") + assert result.success + assert result.data == "Router1" + assert result.count == 1 + assert len(result.matches) == 1 + assert result.query == "/hostname" + assert result.error is None + + def test_parser_xpath_boolean_evaluation(self, sample_tree): + """Test XPathResult boolean evaluation.""" + parser = Parser() + parser.data = sample_tree + + result = parser.xpath("/hostname") + assert result # Should evaluate to True + + result = parser.xpath("/nonexistent") + assert not result # Should evaluate to False + + def test_parser_workflow_integration(self, tmp_path): + """Test complete workflow with file reading and parsing.""" + # Create test config file + config_file = tmp_path / "config.txt" + config_file.write_text( + """interface GigabitEthernet0/0/1 + description WAN + ip address 192.168.1.1 255.255.255.0 +interface GigabitEthernet0/0/2 + description LAN + ip address 10.0.0.1 255.255.255.0 +hostname TestRouter +""" + ) + + parser = Parser() + data = parser.read(str(config_file)) + parser.parse_tree(data) + + # Now use xpath - note the tree structure has full lines as keys + result = parser.xpath("//description WAN") + assert result.success + assert result.count == 1 + + def test_xpath_chaining(self, sample_tree): + """Test chaining multiple xpath queries.""" + parser = Parser() + parser.data = sample_tree + + # First query + result1 = parser.xpath("/interface/GigabitEthernet0-0-1") + assert result1.success + + # Query on result + result2 = parser.xpath("/ip/address", tree=result1.data) + assert result2.success + assert "192.168.1.1" in result2.data + + +class TestXPathEdgeCases: + """Test edge cases and complex scenarios.""" + + def test_deep_nesting(self): + """Test very deep nesting.""" + tree = OrderedDict( + [("a", OrderedDict([("b", OrderedDict([("c", OrderedDict([("d", "value")]))]))]))] + ) + xpath = XPath() + result = xpath.query(tree, "/a/b/c/d") + assert result.success + assert result.data == "value" + + def test_empty_tree(self): + """Test query on empty tree.""" + tree = OrderedDict() + xpath = XPath() + result = xpath.query(tree, "/test") + assert not result.success + + def test_special_characters_in_keys(self): + """Test keys with special characters.""" + tree = OrderedDict( + [ + ( + "interface-vlan-100", + OrderedDict( + [ + ("ip_address", "10.0.0.1"), + ] + ), + ), + ] + ) + xpath = XPath() + result = xpath.query(tree, "/interface-vlan-100/ip_address") + assert result.success + assert result.data == "10.0.0.1" + + def test_numeric_keys(self): + """Test numeric keys.""" + tree = OrderedDict( + [ + ( + "vlan", + OrderedDict( + [ + ("100", OrderedDict([("name", "DATA")])), + ("200", OrderedDict([("name", "VOICE")])), + ] + ), + ), + ] + ) + xpath = XPath() + result = xpath.query(tree, "/vlan/100/name") + assert result.success + assert result.data == "DATA" + + def test_multiple_wildcard_levels(self): + """Test multiple wildcards in path.""" + tree = OrderedDict( + [ + ( + "level1", + OrderedDict( + [ + ("a", OrderedDict([("target", "value1")])), + ("b", OrderedDict([("target", "value2")])), + ] + ), + ), + ] + ) + xpath = XPath() + result = xpath.query(tree, "/level1/*/target") + assert result.success + assert result.count == 2 From c717cd38c3a34b4d2863d46fc3ecc9b8f50697f3 Mon Sep 17 00:00:00 2001 From: Kiran K Kotari Date: Sun, 28 Dec 2025 11:14:01 -0500 Subject: [PATCH 2/3] feature Yaml + XPath search --- CHANGELOG.md | 4 + README.md | 197 ++++++++--- asserts/img/sh_run_yaml.png | Bin 0 -> 347264 bytes docs/QUICKSTART.md | 20 ++ docs/README.md | 3 + docs/XPATH_GUIDE.md | 562 ++++++++++++++++++++++++------ shconfparser/models.py | 3 + shconfparser/parser.py | 180 ++++++++-- shconfparser/xpath.py | 511 ++++++++++++++++------------ tests/test_xpath.py | 656 +++++++++++++----------------------- 10 files changed, 1314 insertions(+), 822 deletions(-) create mode 100644 asserts/img/sh_run_yaml.png diff --git a/CHANGELOG.md b/CHANGELOG.md index e132e0c..ce8c75c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,10 @@ This is a major release focused on modernizing the project infrastructure and to - โœจ **Type hints** - Improved IDE support and type safety - โœจ **py.typed** marker - PEP 561 compliance - โœจ **Modern CI/CD** - GitHub Actions with uv +- โœจ **YAML output format** - Cleaner hierarchical structure with two-level split optimization +- โœจ **XPath queries** - NSO-style queries for YAML-formatted configurations +- โœจ **XPath context tracking** - Three context options (none/partial/full) to identify wildcard match sources +- โœจ **XPath path tracking** - XPathResult.paths shows path components to each match - โœจ **MODERNIZATION_GUIDE.md** - Comprehensive migration guide - โœจ **BUSINESS_STANDARDS.md** - Enterprise compliance documentation - โœจ **PYTHON_COMPATIBILITY.md** - Version support documentation diff --git a/README.md b/README.md index a022ca6..68f08fa 100644 --- a/README.md +++ b/README.md @@ -28,6 +28,10 @@ shconfparser is a vendor independent library where you can parse the following f - Table structure *`i.e. show ip interface`* - Data *`i.e. show version`* +YAML Format Output + +![show run to YAML structure](https://raw.githubusercontent.com/kirankotari/shconfparser/master/asserts/img/sh_run_yaml.png) + Tree Structure ![show run to tree structure](https://raw.githubusercontent.com/kirankotari/shconfparser/master/asserts/img/sh_run.png) @@ -43,7 +47,8 @@ Table Structure ๐Ÿ”’ **Type Safe** - Full type hints and py.typed marker ๐ŸŽฏ **Vendor Independent** - Works with any network device configuration ๐Ÿ“Š **Multiple Formats** - Parse trees, tables, and unstructured data -๐Ÿ” **XPath Queries** - Search configs with XPath-style syntax (NEW!) +๐Ÿ“„ **Format Flexibility** - Output as JSON or YAML structures +๐Ÿ” **XPath Queries** - NSO-style queries with context tracking (NEW!) ๐Ÿงช **Well Tested** - 80%+ code coverage, tested on Python 3.8-3.13 ## Quick Start @@ -62,27 +67,30 @@ uv pip install shconfparser ### Basic Usage -**Single show command:** +**Single show command with YAML format (recommended):** ```python from shconfparser.parser import Parser -p = Parser() +# Use YAML format for cleaner output and XPath support +p = Parser(output_format='yaml') data = p.read('running_config.txt') # Parse directly (no split needed for single show running command) tree = p.parse_tree(data) print(p.dump(tree, indent=2)) + +# Query with XPath +result = p.xpath('/hostname') +print(result.data) # 'R1' ```
-Alternative: Access internal properties +Alternative: JSON format (backward compatible) ```python -p = Parser() -p.read('running_config.txt') - -# Access reader data directly -tree = p.parse_tree(p.r.data) +p = Parser() # Default is JSON format (OrderedDict) +data = p.read('running_config.txt') +tree = p.parse_tree(data) print(p.dump(tree, indent=4)) ```
@@ -91,7 +99,7 @@ print(p.dump(tree, indent=4)) ```python from shconfparser.parser import Parser -p = Parser() +p = Parser(output_format='yaml') # YAML format recommended data = p.read('multiple_commands.txt') # Contains multiple show outputs data = p.split(data) # Split into separate commands data.keys() @@ -208,60 +216,157 @@ print(match) # {'Device ID': 'R2', 'Local Intrfce': 'Fas 0/0', ...} ``` -### XPath-Style Queries (New in 3.0!) +### Output Format Selection (New in 3.0!) -Query parsed configuration trees using XPath-style syntax: +Parse configurations to JSON (OrderedDict) or YAML-friendly dict structures: ```python from shconfparser.parser import Parser +# Default: JSON format (OrderedDict - backward compatible) p = Parser() -data = p.read('multiple_commands.txt') -data = p.split(data) +data = p.read('running_config.txt') +tree = p.parse_tree(data) # Returns OrderedDict +print(type(tree)) # -# Parse the running config into a tree -data['running'] = p.parse_tree(data['running']) +# YAML format: cleaner hierarchical structure +p = Parser(output_format='yaml') +data = p.read('running_config.txt') +tree_yaml = p.parse_tree(data) # Returns dict with nested structure +print(type(tree_yaml)) # + +# Override format per call +p = Parser() # Default is JSON +tree_json = p.parse_tree(data) # OrderedDict +tree_yaml = p.parse_tree(data, format='yaml') # dict + +# YAML structure example: +# Input: "interface FastEthernet0/0" with nested config +# JSON: {"interface FastEthernet0/0": {...}} +# YAML: {"interface": {"FastEthernet0/0": {...}}} +``` -# Now use XPath queries on the parsed tree -# Find all IP addresses anywhere in config -result = p.xpath('//ip/address', tree=data['running']) -print(f"Found {result.count} IP addresses") +**Format Comparison:** -# Get specific interface configuration -result = p.xpath('/interface/FastEthernet0-0/ip/address', tree=data['running']) -if result: - print(f"IP: {result.data}") +```python +# JSON format (default) - preserves exact CLI structure +{ + "interface FastEthernet0/0": { + "ip address 1.1.1.1 255.255.255.0": "", + "duplex auto": "" + } +} + +# YAML format - hierarchical and human-readable +{ + "interface": { + "FastEthernet0/0": { + "ip": { + "address": "1.1.1.1 255.255.255.0" + }, + "duplex": "auto" + } + } +} +``` -# List all interface names using wildcard -result = p.xpath('/interface/*', tree=data['running']) -print(f"Interfaces: {', '.join(result.matches)}") +**Benefits of YAML format:** +- Cleaner hierarchy for nested configurations +- Better for programmatic access +- Easier to convert to actual YAML files +- Natural structure for complex configs +- Required for XPath queries -# Filter interfaces by pattern -result = p.xpath('/interface[FastEthernet*]/description', tree=data['running']) -for desc in result.matches: - print(f" - {desc}") -``` +### XPath Queries (New in 3.0!) -**Supported XPath Features:** -- **Absolute paths**: `/interface/FastEthernet0-0/ip/address` -- **Recursive search**: `//ip/address` (find anywhere) -- **Wildcards**: `/interface/*/description` (all interfaces) -- **Predicates**: `/interface[GigabitEthernet*]` (pattern matching) -- **Root access**: `/` (entire tree) +Query YAML-formatted configurations using NSO-style XPath with optional context tracking: -**Or use stored tree directly:** ```python -p = Parser() +from shconfparser.parser import Parser + +# XPath requires YAML format +p = Parser(output_format='yaml') data = p.read('running_config.txt') -p.parse_tree(data) # Stores in p.data +tree = p.parse_tree(data) + +# Simple queries +result = p.xpath('/hostname') +print(result.data) # 'R1' -# Query uses stored tree automatically -result = p.xpath('//ip/address') -for addr in result.matches: - print(addr) +# Wildcards - find all interface duplex settings +result = p.xpath('/interface/*/duplex') +print(result.matches) # ['auto', 'auto'] +print(result.count) # 2 + +# Predicates with slashes (network interface names) +result = p.xpath('/interface[FastEthernet0/0]/duplex') +print(result.data) # 'auto' + +# Recursive search - find anywhere in tree +result = p.xpath('//duplex') +print(result.matches) # ['auto', 'auto'] + +# Predicate wildcards +result = p.xpath('/interface[FastEthernet*]/ip/address') +print(result.data) # '1.1.1.1 255.255.255.0' +``` + +**Context Options** - Solve the "which interface?" problem: + +```python +# Problem: Can't identify source with wildcards +result = p.xpath('/interface/*/duplex') +print(result.matches) # ['auto', 'auto'] - Which interface? + +# Solution 1: context='none' (default - just values) +result = p.xpath('/interface/*/duplex', context='none') +print(result.matches) # ['auto', 'auto'] + +# Solution 2: context='partial' (from wildcard match point) +result = p.xpath('/interface/*/duplex', context='partial') +print(result.matches) +# [{'FastEthernet0/0': {'duplex': 'auto'}}, +# {'FastEthernet0/1': {'duplex': 'auto'}}] + +# Solution 3: context='full' (complete tree hierarchy) +result = p.xpath('/interface/*/duplex', context='full') +print(result.matches) +# [{'interface': {'FastEthernet0/0': {'duplex': 'auto'}}}, +# {'interface': {'FastEthernet0/1': {'duplex': 'auto'}}}] + +# Path tracking (always available) +result = p.xpath('/interface/*/speed') +print(result.paths) +# [['interface', 'FastEthernet0/0', 'speed'], +# ['interface', 'FastEthernet0/1', 'speed']] +``` + +**XPath Features:** +- โœ… Absolute paths: `/interface/FastEthernet0/0/duplex` +- โœ… Recursive search: `//duplex` (find anywhere) +- โœ… Wildcards: `/interface/*/duplex` +- โœ… Predicates: `/interface[FastEthernet0/0]` +- โœ… Predicate wildcards: `/interface[FastEthernet*]` +- โœ… Context tracking: See which match came from where +- โœ… Path tracking: `result.paths` shows path components + +**XPathResult Structure:** +```python +result = p.xpath('//duplex') +print(result.success) # True +print(result.data) # First match: 'auto' +print(result.matches) # All matches: ['auto', 'auto'] +print(result.count) # Number of matches: 2 +print(result.query) # Original query: '//duplex' +print(result.paths) # Path to each match +print(result.error) # Error message if failed + +# Boolean check +if result: + print(f"Found {result.count} matches") ``` -See [docs/XPATH_GUIDE.md](docs/XPATH_GUIDE.md) for complete XPath documentation. +**Note:** XPath queries only work with `output_format='yaml'`. JSON format (OrderedDict) preserves exact CLI structure and should use traditional dict navigation. ### Alternative: Using Individual Components diff --git a/asserts/img/sh_run_yaml.png b/asserts/img/sh_run_yaml.png new file mode 100644 index 0000000000000000000000000000000000000000..45c2587b9ecea77106a9ac0e78b1b3f0f980c0b6 GIT binary patch literal 347264 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%0Dx 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≫;z?X_ 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 literal 0 HcmV?d00001 diff --git a/docs/QUICKSTART.md b/docs/QUICKSTART.md index 864fc36..05e90cb 100644 --- a/docs/QUICKSTART.md +++ b/docs/QUICKSTART.md @@ -91,4 +91,24 @@ make check-all 3. **Write tests** - For any new features or bug fixes 4. **Keep it simple** - Small, focused commits are easier to review +## Quick Feature Test + +Try the XPath feature: +```python +from shconfparser import Parser + +p = Parser(output_format='yaml') +data = p.read('data/shrun.txt') +tree = p.parse_tree(data) + +# Simple query +result = p.xpath('/hostname') +print(f"Hostname: {result.data}") + +# Query with context +result = p.xpath('/interface/*/duplex', context='partial') +for match in result.matches: + print(match) # Shows which interface +``` + Happy coding! ๐Ÿš€ diff --git a/docs/README.md b/docs/README.md index 512bfc6..6e63051 100644 --- a/docs/README.md +++ b/docs/README.md @@ -14,6 +14,7 @@ Welcome to the shconfparser documentation! | Document | Description | Audience | |----------|-------------|----------| +| [XPath Guide](XPATH_GUIDE.md) | Complete XPath query documentation | All users | | [Modernization Guide](MODERNIZATION_GUIDE.md) | Complete v2.x to v3.0 migration guide | Existing users, developers | | [Architecture](ARCHITECTURE.md) | Visual architecture diagrams and structure | Developers, architects | | [Business Standards](BUSINESS_STANDARDS.md) | Enterprise compliance documentation | Maintainers, enterprises | @@ -31,6 +32,7 @@ Welcome to the shconfparser documentation! 1. Start with the main [README.md](../README.md) 2. Follow [Installation instructions](../README.md#installation-and-downloads) 3. Check [Usage Examples](../README.md#usage-examples) +4. Try [XPath Queries](../README.md#xpath-queries-new-in-30) for advanced querying ### For Contributors 1. Read [QUICKSTART.md](QUICKSTART.md) (5 minutes) @@ -95,6 +97,7 @@ Detailed summary of the modernization project: ### I want to... - **Get started contributing** โ†’ [QUICKSTART.md](QUICKSTART.md) +- **Learn XPath queries** โ†’ [XPATH_GUIDE.md](XPATH_GUIDE.md) - **Understand v3.0 changes** โ†’ [MODERNIZATION_GUIDE.md](MODERNIZATION_GUIDE.md) - **Migrate from v2.x** โ†’ [MODERNIZATION_GUIDE.md](MODERNIZATION_GUIDE.md#migration-from-v2x-to-v30) - **Learn about the architecture** โ†’ [ARCHITECTURE.md](ARCHITECTURE.md) diff --git a/docs/XPATH_GUIDE.md b/docs/XPATH_GUIDE.md index 179e5b2..a74f05c 100644 --- a/docs/XPATH_GUIDE.md +++ b/docs/XPATH_GUIDE.md @@ -1,177 +1,533 @@ -# XPath Feature for shconfparser +# XPath Query Guide + +Complete guide for using XPath queries with shconfparser to query network configuration data. + +## Table of Contents + +- [Overview](#overview) +- [Quick Start](#quick-start) +- [Query Syntax](#query-syntax) +- [Context Options](#context-options) +- [XPathResult Structure](#xpathresult-structure) +- [Examples](#examples) +- [Best Practices](#best-practices) +- [Limitations](#limitations) ## Overview -The XPath feature adds powerful querying capabilities to shconfparser, similar to Cisco NSO's XPath search functionality. It allows you to search and navigate through parsed configuration trees using XPath-style query syntax. +XPath queries provide a powerful way to search and extract data from network configurations parsed in YAML format. Inspired by Cisco NSO, shconfparser's XPath implementation supports hierarchical queries with wildcards, predicates, and context tracking. + +### Key Features + +- โœ… **Absolute paths** - Direct navigation to specific nodes +- โœ… **Recursive search** - Find patterns anywhere in the tree +- โœ… **Wildcards** - Match multiple similar paths +- โœ… **Predicates** - Handle identifiers with special characters +- โœ… **Context tracking** - Identify match sources in wildcard queries +- โœ… **Path tracking** - Full path to each match -## Installation +### Requirements -Already included in shconfparser 3.0.0+ +**XPath queries only work with YAML format:** + +```python +# โœ… Correct - YAML format required +p = Parser(output_format='yaml') +tree = p.parse_tree(data) +result = p.xpath('/hostname') + +# โŒ Wrong - JSON format not supported +p = Parser(output_format='json') +result = p.xpath('/hostname') # Returns error +``` ## Quick Start ```python from shconfparser import Parser -# Parse configuration -p = Parser() -p.read('config.txt') -p.parse_tree() +# Initialize parser with YAML format +p = Parser(output_format='yaml') +data = p.read('running_config.txt') +tree = p.parse_tree(data) + +# Simple query +result = p.xpath('/hostname') +print(result.data) # 'R1' -# Use XPath queries -result = p.xpath('//ip/address') # Find all IP addresses -print(f"Found {result.count} addresses") -for addr in result.matches: - print(addr) +# Wildcard query with context +result = p.xpath('/interface/*/duplex', context='partial') +for match in result.matches: + print(match) # Shows which interface each match came from ``` -## Supported XPath Features +## Query Syntax + +### Absolute Paths + +Navigate directly to a specific node: -### 1. Absolute Paths -Navigate from root with specific path: ```python -result = p.xpath('/interface/GigabitEthernet0-0-1/ip/address') +# Single level +result = p.xpath('/hostname') +# Result: "R1" + +# Nested path +result = p.xpath('/interface/FastEthernet0/0/duplex') +# Note: Won't work because "/" in "FastEthernet0/0" splits incorrectly + +# Use predicates for identifiers with special characters +result = p.xpath('/interface[FastEthernet0/0]/duplex') +# Result: "auto" + +# Deep nesting +result = p.xpath('/interface[FastEthernet0/0]/ip/address') +# Result: "1.1.1.1 255.255.255.0" ``` -### 2. Recursive Search (`//`) -Find matches anywhere in the tree: +### Recursive Search (`//`) + +Find a key anywhere in the configuration tree: + ```python -result = p.xpath('//address') # All addresses at any level -result = p.xpath('//ip/nat') # All NAT settings under ip +# Find all occurrences of "duplex" +result = p.xpath('//duplex') +print(result.matches) # ['auto', 'auto'] +print(result.count) # 2 + +# Find hostname anywhere +result = p.xpath('//hostname') +# Result: "R1" ``` -### 3. Wildcards (`*`) -Match any key at a level: +### Wildcards (`*`) + +Match any key at a specific level: + ```python -# List all interface names +# All interfaces result = p.xpath('/interface/*') +# Returns: All interface configurations + +# Specific attribute across all interfaces +result = p.xpath('/interface/*/duplex') +# Returns: ['auto', 'auto'] -# Get descriptions from all interfaces -result = p.xpath('/interface/*/description') +# Multiple wildcards +result = p.xpath('/interface/*/ip/*') +# Returns: All IP configuration values ``` -### 4. Predicates (`[pattern]`) -Filter by pattern with wildcard support: +### Predicates (`[...]`) + +Match specific keys or patterns, especially useful for identifiers with special characters: + ```python -# Get config for GigabitEthernet interfaces only -result = p.xpath('/interface[GigabitEthernet*]') +# Exact match - handles slashes in interface names +result = p.xpath('/interface[FastEthernet0/0]') +# Returns: FastEthernet0/0 configuration dict -# Get IPs from specific interface types -result = p.xpath('/interface[GigabitEthernet*]/ip/address') +# With continuation path +result = p.xpath('/interface[FastEthernet0/0]/duplex') +# Returns: "auto" + +# Predicate with wildcard pattern +result = p.xpath('/interface[FastEthernet*]') +# Returns: All FastEthernet interfaces + +result = p.xpath('/interface[FastEthernet*]/duplex') +# Returns: ['auto', 'auto'] + +# Match pattern +result = p.xpath('/interface[*0/0]') +# Returns: All interfaces ending with "0/0" ``` -### 5. Root Path -Get entire tree: +## Context Options + +Context options solve the problem of identifying which match came from where when using wildcards. + +### The Problem + ```python -result = p.xpath('/') +result = p.xpath('/interface[FastEthernet*]/ip') +print(result.data) +# {'address': '1.1.1.1 255.255.255.0'} +# โŒ Which FastEthernet interface is this from? ``` -## XPathResult Object +### The Solution: Three Context Options -All queries return an `XPathResult` with: +#### 1. `context='none'` (Default) -- `success` (bool): Whether query found matches -- `data` (Any): First match (primary result) -- `matches` (List): All matches found -- `count` (int): Number of matches -- `query` (str): Original query string -- `error` (str|None): Error message if failed +Returns just the matched values - backward compatible behavior. -### Boolean Evaluation +```python +result = p.xpath('/interface/*/duplex', context='none') +print(result.matches) +# ['auto', 'auto'] +# โŒ Can't tell which interface +``` + +**Use when:** +- You only care about the values, not the source +- Maintaining backward compatibility +- Processing simple, unambiguous queries + +#### 2. `context='partial'` (Recommended) + +Shows from the wildcard/predicate match point to the value. ```python -result = p.xpath('/hostname') -if result: # Evaluates to True if success - print(f"Hostname: {result.data}") +result = p.xpath('/interface/*/duplex', context='partial') +print(result.matches) +# [{'FastEthernet0/0': {'duplex': 'auto'}}, +# {'FastEthernet0/1': {'duplex': 'auto'}}] +# โœ… Can see which interface each match came from +``` + +**Use when:** +- You need to identify the source of wildcard matches +- You want minimal context (just what's necessary) +- Processing interface-specific or device-specific configs + +#### 3. `context='full'` + +Shows the complete tree hierarchy from root to value. + +```python +result = p.xpath('/interface/*/duplex', context='full') +print(result.matches) +# [{'interface': {'FastEthernet0/0': {'duplex': 'auto'}}}, +# {'interface': {'FastEthernet0/1': {'duplex': 'auto'}}}] +# โœ… Full path context included +``` + +**Use when:** +- You need complete hierarchical context +- Building configuration diffs or comparisons +- Generating configuration documentation + +### Context Comparison + +```python +query = '/interface[FastEthernet*]/ip' + +# none: Just the IP config +{'address': '1.1.1.1 255.255.255.0'} + +# partial: From interface name down +{'FastEthernet0/0': {'ip': {'address': '1.1.1.1 255.255.255.0'}}} + +# full: Complete hierarchy +{'interface': {'FastEthernet0/0': {'ip': {'address': '1.1.1.1 255.255.255.0'}}}} +``` + +## XPathResult Structure + +Every XPath query returns an `XPathResult` object: + +```python +@dataclass +class XPathResult: + success: bool # True if query succeeded + data: Any # First match (primary result) + matches: List[Any] # All matches + count: int # Number of matches + query: str # Original query string + error: Optional[str] # Error message if failed + paths: List[List[str]] # Path components to each match +``` + +### Field Descriptions + +**`success`** - Boolean indicating if query found results +```python +if result: # or: if result.success: + print("Found matches!") ``` -## Advanced Usage +**`data`** - First match (convenience for single-result queries) +```python +hostname = p.xpath('/hostname').data # Direct access +``` -### Query Chaining +**`matches`** - List of all matches ```python -# Get specific interface first -interface = p.xpath('/interface/GigabitEthernet0-0-1') +for duplex in p.xpath('//duplex').matches: + print(duplex) +``` -# Then query within that interface -nat = p.xpath('/ip/nat', tree=interface.data) +**`count`** - Number of matches found +```python +result = p.xpath('/interface/*') +print(f"Found {result.count} interfaces") ``` -### Custom Tree +**`query`** - Original query string (useful for debugging) ```python -# Query a custom tree instead of stored one -result = p.xpath('//address', tree=custom_tree) +print(f"Query: {result.query}") ``` -### Pattern Matching -Case-insensitive with wildcard support: +**`error`** - Error message if query failed ```python -# Matches Loopback0, Loopback1, etc. -result = p.xpath('/interface[Loopback*]') +if not result.success: + print(f"Error: {result.error}") +``` -# Matches anything ending in 0 -result = p.xpath('/interface[*0]') +**`paths`** - List of path components to each match +```python +result = p.xpath('/interface/*/duplex') +for path in result.paths: + print(path) +# ['interface', 'FastEthernet0/0', 'duplex'] +# ['interface', 'FastEthernet0/1', 'duplex'] ``` ## Examples -See `examples/xpath_demo.py` for comprehensive examples. +### Example 1: Find All Interface IP Addresses -## Comparison with Cisco NSO +```python +result = p.xpath('/interface/*/ip/address', context='partial') + +for match in result.matches: + # Each match shows interface name and IP + interface_name = list(match.keys())[0] + ip_address = match[interface_name]['ip']['address'] + print(f"{interface_name}: {ip_address}") +# FastEthernet0/0: 1.1.1.1 255.255.255.0 +``` -| Feature | Cisco NSO | shconfparser XPath | -|---------|-----------|-------------------| -| Absolute paths | โœ“ | โœ“ | -| Recursive search | โœ“ | โœ“ | -| Wildcards | โœ“ | โœ“ | -| Predicates | โœ“ | โœ“ (simplified) | -| Attributes | โœ“ | - | -| Functions | โœ“ | - | -| Axes | โœ“ | - | +### Example 2: Find All Auto-Negotiating Interfaces -## Performance +```python +result = p.xpath('//duplex', context='partial') -- Efficient for small to medium trees (< 10k nodes) -- Recursive searches scan entire tree -- Use absolute paths when possible for best performance +auto_interfaces = [] +for match, path in zip(result.matches, result.paths): + if match == 'auto' or (isinstance(match, dict) and 'auto' in str(match)): + # path contains: ['interface', 'FastEthernet0/0', 'duplex'] + interface = path[1] + auto_interfaces.append(interface) -## Testing +print(f"Auto-negotiating interfaces: {auto_interfaces}") +``` + +### Example 3: Configuration Validation + +```python +# Check if all interfaces have IP addresses +result = p.xpath('/interface/*', context='partial') -31 comprehensive tests cover all functionality: -```bash -pytest tests/test_xpath.py -v +for match in result.matches: + interface_name = list(match.keys())[0] + interface_config = match[interface_name] + + if 'ip' not in interface_config: + print(f"Warning: {interface_name} has no IP configuration") + elif 'address' not in interface_config.get('ip', {}): + print(f"Warning: {interface_name} has no IP address") ``` -## API Reference +### Example 4: Bulk Configuration Changes + +```python +# Find all interfaces with speed setting +result = p.xpath('/interface/*/speed', context='partial') + +changes = [] +for match in result.matches: + interface_name = list(match.keys())[0] + current_speed = match[interface_name]['speed'] + + if current_speed != '1000': + changes.append(f"interface {interface_name}\n speed 1000") + +print("Proposed changes:") +print("\n".join(changes)) +``` -### Parser.xpath() +### Example 5: Recursive Search with Filtering ```python -def xpath(query: str, tree: Optional[TreeData] = None) -> XPathResult: - """Execute XPath-style query on configuration tree. +# Find all "auto" settings anywhere in config +result = p.xpath('//auto', context='partial') + +# Group by setting type +settings = {} +for match, path in zip(result.matches, result.paths): + setting_type = path[-1] # Last element is the setting name + if setting_type not in settings: + settings[setting_type] = [] + settings[setting_type].append(path[1] if len(path) > 1 else 'global') + +for setting, locations in settings.items(): + print(f"{setting}: {', '.join(locations)}") +``` + +## Best Practices + +### 1. Choose the Right Context + +```python +# For simple value extraction +result = p.xpath('/hostname', context='none') + +# For identifying wildcard match sources +result = p.xpath('/interface/*/duplex', context='partial') + +# For complete hierarchy preservation +result = p.xpath('//important-setting', context='full') +``` + +### 2. Always Check Success + +```python +result = p.xpath('/some/path') +if result.success: + process_data(result.matches) +else: + print(f"Query failed: {result.error}") +``` + +### 3. Use Predicates for Special Characters + +```python +# โŒ Wrong - slashes will split incorrectly +result = p.xpath('/interface/FastEthernet0/0/duplex') + +# โœ… Correct - use predicates +result = p.xpath('/interface[FastEthernet0/0]/duplex') +``` + +### 4. Leverage Path Tracking + +```python +result = p.xpath('//duplex') +for value, path in zip(result.matches, result.paths): + full_path = '/'.join(path) + print(f"{full_path}: {value}") +``` + +### 5. Combine with Python Processing + +```python +# XPath for querying, Python for complex logic +result = p.xpath('/interface/*', context='partial') + +for match in result.matches: + interface = list(match.keys())[0] + config = match[interface] - Args: - query: XPath-style query string - tree: Optional tree to search (uses self.data if not provided) - - Returns: - XPathResult with matches, count, and metadata - """ + # Apply complex business logic + if needs_update(config): + generate_config_change(interface, config) +``` + +## Limitations + +### 1. YAML Format Only + +```python +# โŒ Won't work with JSON format +p = Parser(output_format='json') +result = p.xpath('/hostname') # Returns error +``` + +**Solution:** Use `output_format='yaml'` + +### 2. No Attribute Selection + +XPath in shconfparser doesn't support attribute selection syntax like `@attribute`. + +```python +# โŒ Not supported +result = p.xpath('/interface[@name="FastEthernet0/0"]') + +# โœ… Use predicates instead +result = p.xpath('/interface[FastEthernet0/0]') ``` -### XPath Class +### 3. No Complex Expressions + +Boolean logic, arithmetic, and functions are not supported. ```python -from shconfparser.xpath import XPath +# โŒ Not supported +result = p.xpath('/interface[speed > 100]') +result = p.xpath('/interface[duplex="auto" and speed="auto"]') + +# โœ… Filter in Python instead +result = p.xpath('/interface/*', context='partial') +filtered = [m for m in result.matches + if list(m.values())[0].get('speed') == 'auto'] +``` + +### 4. Case Sensitive + +All queries are case-sensitive with case-insensitive matching for wildcards. -xpath = XPath() -result = xpath.query(tree, '//ip/address') +```python +result = p.xpath('/Interface') # Won't match 'interface' +result = p.xpath('/interface[FastEthernet*]') # Case-insensitive pattern match ``` -## Future Enhancements +## Error Handling + +```python +# Empty query +result = p.xpath('') +# result.error: "XPath query cannot be empty" + +# Invalid query format +result = p.xpath('hostname') # Missing leading / +# result.error: "XPath query must start with / or //" + +# Invalid context +result = p.xpath('/hostname', context='invalid') +# result.error: "Invalid context 'invalid'. Must be 'none', 'partial', or 'full'" + +# JSON format error +p = Parser(output_format='json') +result = p.xpath('/hostname') +# result.error: "XPath queries only work with output_format='yaml'..." +``` -Potential additions: -- XPath functions (count(), text(), etc.) -- Attribute filtering `[@attr='value']` -- Multiple predicates -- Parent/ancestor axes -- Index predicates `[1]`, `[last()]` +## Performance Tips + +1. **Use absolute paths** when you know the exact location + ```python + # Faster + result = p.xpath('/interface[FastEthernet0/0]/duplex') + + # Slower (searches entire tree) + result = p.xpath('//duplex') + ``` + +2. **Minimize context when possible** + ```python + # Lighter processing + result = p.xpath('/interface/*', context='none') + + # More processing for structure building + result = p.xpath('/interface/*', context='full') + ``` + +3. **Use specific predicates over wildcards** + ```python + # More specific, faster + result = p.xpath('/interface[FastEthernet0/0]') + + # Less specific, may return more results + result = p.xpath('/interface[*0/0]') + ``` + +--- + +**For more examples, see:** +- [Main README](../README.md) +- [Quick Start Guide](QUICKSTART.md) +- [Test Suite](../tests/test_xpath.py) + +**Need help?** Open an issue on [GitHub](https://github.com/network-tools/shconfparser/issues) diff --git a/shconfparser/models.py b/shconfparser/models.py index 940c0f5..5729bbc 100644 --- a/shconfparser/models.py +++ b/shconfparser/models.py @@ -10,6 +10,7 @@ # Type aliases for complex structures TreeData = OrderedDict[str, Union[str, "TreeData"]] +TreeDataOrDict = Union[TreeData, Dict[str, Any]] # For format flexibility TableRow = Dict[str, str] TableData = List[TableRow] @@ -145,6 +146,7 @@ class XPathResult: count: Number of matches query: Original XPath query string error: Error message if query failed + paths: List of paths to each match (when context tracking enabled) """ success: bool @@ -153,6 +155,7 @@ class XPathResult: count: int = 0 query: str = "" error: Optional[str] = None + paths: List[List[str]] = field(default_factory=list) def __bool__(self) -> bool: """Allow boolean evaluation of result.""" diff --git a/shconfparser/parser.py b/shconfparser/parser.py index 40c8762..8f28895 100644 --- a/shconfparser/parser.py +++ b/shconfparser/parser.py @@ -10,9 +10,16 @@ import re import sys from collections import OrderedDict -from typing import Any, List, Optional - -from .models import TableData, TableParseResult, TreeData, TreeParseResult, XPathResult +from typing import Any, Dict, List, Optional + +from .models import ( + TableData, + TableParseResult, + TreeData, + TreeDataOrDict, + TreeParseResult, + XPathResult, +) from .reader import Reader from .search import Search from .shsplit import ShowSplit @@ -39,17 +46,26 @@ class Parser: name: str = "shconfparser" - def __init__(self, log_level: int = logging.INFO, log_format: Optional[str] = None) -> None: + def __init__( + self, + log_level: int = logging.INFO, + log_format: Optional[str] = None, + output_format: str = "json", + ) -> None: """Initialize the Parser. Args: log_level: Logging level (default: INFO) log_format: Custom log format string + output_format: Default output format for parse_tree ('json' or 'yaml', default: 'json') """ # State for backward compatibility self.data: TreeData = OrderedDict() self.table: TableData = [] + # Output format configuration + self.output_format: str = output_format + # Logging self.format: Optional[str] = log_format self.logger: logging.Logger = self._set_logger_level(log_level) @@ -80,7 +96,7 @@ def _set_logger_level(self, log_level: int) -> logging.Logger: logger.setLevel(log_level) return logger - def parse_tree(self, lines: List[str]) -> TreeData: + def parse_tree(self, lines: List[str], format: Optional[str] = None) -> TreeDataOrDict: """Parse hierarchical configuration into tree structure. Delegates to TreeParser for processing. Maintains state for @@ -88,17 +104,30 @@ def parse_tree(self, lines: List[str]) -> TreeData: Args: lines: Configuration lines with indentation + format: Output format ('json' or 'yaml'). If None, uses self.output_format Returns: - Nested OrderedDict representing configuration hierarchy + Nested OrderedDict (json format) or dict (yaml format) representing configuration hierarchy Example: >>> parser = Parser() >>> config = ['interface Ethernet0', ' ip address 1.1.1.1'] - >>> tree = parser.parse_tree(config) + >>> tree = parser.parse_tree(config) # Returns OrderedDict (JSON) + >>> tree_yaml = parser.parse_tree(config, format='yaml') # Returns dict (YAML-friendly) """ - self.data = self.tree_parser.parse_tree(lines) - return self.data + # Parse to OrderedDict first + ordered_tree = self.tree_parser.parse_tree(lines) + + # Transform based on format + output_format = format if format is not None else self.output_format + + if output_format == "yaml": + yaml_tree = self._tree_to_yaml_structure(ordered_tree) + self.data = yaml_tree # type: ignore[assignment] # Store YAML format for xpath + return yaml_tree + else: + self.data = ordered_tree # Store JSON format + return ordered_tree def parse_tree_safe(self, lines: List[str]) -> TreeParseResult: """Parse tree structure with structured result. @@ -250,33 +279,112 @@ def dump(self, data: Any, indent: Optional[int] = None) -> str: """ return json.dumps(data, indent=indent) - def xpath(self, query: str, tree: Optional[TreeData] = None) -> XPathResult: - """Execute XPath-style query on configuration tree. + def _tree_to_yaml_structure(self, tree: TreeData) -> Dict[str, Any]: + """Transform OrderedDict tree to YAML-friendly structure. + + Converts flat keys into nested dict structure with smart depth limiting: + - Containers (OrderedDict): Split fully, last word = identifier + - Leaves (empty string): Max 2 levels, rest = value + + Examples: + "interface FastEthernet0/0" (container) โ†’ + {"interface": {"FastEthernet0/0": {...}}} + + "hostname R1" (leaf) โ†’ + {"hostname": "R1"} - Uses stored tree (self.data) by default, or accepts a custom tree. + "ip address 1.1.1.1 255.255.255.0" (leaf) โ†’ + {"ip": {"address": "1.1.1.1 255.255.255.0"}} + + Args: + tree: OrderedDict tree from parse_tree + + Returns: + Nested dict suitable for YAML serialization + """ + result: Dict[str, Any] = {} + + for key, value in tree.items(): + # Split key by spaces + parts = key.split() + + if len(parts) == 1: + # Single word key + if isinstance(value, OrderedDict): + result[key] = self._tree_to_yaml_structure(value) + else: + result[key] = value if value else None + + elif isinstance(value, OrderedDict): + # Container with nested OrderedDict - split fully + # Last word becomes identifier, rest is path + *path_parts, identifier = parts + + # Build nested structure + current: Dict[str, Any] = result + for part in path_parts: + if part not in current: + current[part] = {} + current = current[part] + + # Add the identifier with its nested value + current[identifier] = self._tree_to_yaml_structure(value) + + else: + # Leaf value (empty string) - limit to 2 levels max + if len(parts) == 2: + # Two words: first is key, second is value + # "hostname R1" โ†’ hostname: R1 + # "duplex auto" โ†’ duplex: auto + result[parts[0]] = parts[1] + + elif len(parts) > 2: + # More than 2 words: first is level 1, second is level 2, rest is value + # "ip address 1.1.1.1 255.255.255.0" โ†’ + # ip: {address: "1.1.1.1 255.255.255.0"} + level1, level2 = parts[0], parts[1] + value_str = " ".join(parts[2:]) + + if level1 not in result: + result[level1] = {} + elif not isinstance(result[level1], dict): + # Key exists as non-dict, convert to dict + result[level1] = {} + result[level1][level2] = value_str + + return result + + def xpath(self, query: str, tree: Optional[Dict[str, Any]] = None, context: str = 'none') -> XPathResult: + """Execute XPath-style query on YAML configuration tree. + + XPath queries work on YAML format (dict) trees. If tree is not provided, + uses self.data. For best results, parse with output_format='yaml'. Supports: - - Absolute paths: /interface/GigabitEthernet0-0-1/ip/address - - Relative paths: //ip/address (find anywhere) - - Wildcards: /interface/*/ip - - Get all keys: /interface/* (list all interfaces) - - Predicates: /interface[GigabitEthernet*] + - Absolute paths: /interface/FastEthernet0/0/duplex + - Recursive search: //duplex (find anywhere) + - Wildcards: /interface/*/duplex + - Predicates: /interface[FastEthernet0/0] Args: query: XPath-style query string - tree: Optional tree to search (uses self.data if not provided) + tree: Optional dict tree to search (uses self.data if not provided) + context: How much context to include in matches: + - 'none': Just matched values (default) + - 'partial': From wildcard match point to value + - 'full': Full tree hierarchy from root Returns: XPathResult with matches, count, and metadata Example: - >>> p = Parser() - >>> p.read('config.txt') - >>> p.parse_tree() - >>> # Search using stored tree - >>> results = p.xpath('//ip/address') - >>> # Search custom tree - >>> results = p.xpath('//ip/address', tree=custom_tree) + >>> p = Parser(output_format='yaml') + >>> lines = p.read('config.txt') + >>> p.parse_tree(lines) + >>> result = p.xpath('/interface/FastEthernet0/0/duplex') + >>> result.data # 'auto' + >>> result = p.xpath('/interface/*/duplex', context='partial') + >>> # Shows which interface each match came from """ search_tree = tree if tree is not None else self.data @@ -288,8 +396,28 @@ def xpath(self, query: str, tree: Optional[TreeData] = None) -> XPathResult: query=query, ) + # XPath only works with YAML format (dict, not OrderedDict) + if self.output_format != 'yaml': + return XPathResult( + success=False, + error=f"XPath queries only work with output_format='yaml', current format is '{self.output_format}'", + query=query, + ) + + # Ensure search_tree is a dict + if not isinstance(search_tree, dict): + self.logger.warning( + "XPath requires dict structure. " + f"Got {type(search_tree).__name__}." + ) + return XPathResult( + success=False, + error=f"XPath requires dict structure, got {type(search_tree).__name__}", + query=query, + ) + try: - return self.xpath_engine.query(search_tree, query) + return self.xpath_engine.query(search_tree, query, context) except Exception as e: self.logger.error(f"XPath query failed: {str(e)}") return XPathResult(success=False, error=str(e), query=query) diff --git a/shconfparser/xpath.py b/shconfparser/xpath.py index 890ae23..5a084cf 100644 --- a/shconfparser/xpath.py +++ b/shconfparser/xpath.py @@ -1,34 +1,30 @@ -"""XPath-like query engine for parsed configuration trees. +"""XPath-style query engine for YAML/dict configuration trees with context tracking. -This module provides XPath-style querying capabilities for navigating -and searching through parsed network configuration data structures. +This module provides XPath-like querying capabilities for parsed network +configurations in YAML format (dict structures). """ -import logging +import fnmatch import re -from collections import OrderedDict -from typing import Any, List +from typing import Any, Dict, List, Optional, Tuple, Union from .exceptions import SearchError -from .models import TreeData, XPathResult - -logger = logging.getLogger(__name__) +from .models import XPathResult class XPath: - """XPath-like query engine for configuration trees. + """XPath-style query engine for YAML dict structures. - Supports: - - Absolute paths: /interface/GigabitEthernet0-0-1/ip/address - - Relative paths: //ip/address (find anywhere) - - Wildcards: /interface/*/ip - - Get all keys: /interface/* (list all interfaces) - - Predicates: /interface[GigabitEthernet*] + Supports NSO-style XPath queries on clean hierarchical dict structures + with optional context tracking for wildcard matches. - Example: + Examples: >>> xpath = XPath() - >>> results = xpath.query(tree, '//ip/address') - >>> result = xpath.query(tree, '/interface/GigabitEthernet0-0-1') + >>> tree = {'interface': {'FastEthernet0/0': {'duplex': 'auto'}}} + >>> result = xpath.query(tree, '/interface/FastEthernet0/0/duplex') + >>> result.data # 'auto' + >>> result = xpath.query(tree, '/interface/*/duplex', context='partial') + >>> result.matches # [{'FastEthernet0/0': {'duplex': 'auto'}}] """ def __init__(self) -> None: @@ -39,254 +35,325 @@ def __repr__(self) -> str: """Return string representation.""" return "XPath()" - def query(self, tree: TreeData, path: str) -> XPathResult: - """Execute XPath query on configuration tree. + def query(self, tree: Dict[str, Any], query: str, context: str = 'none') -> XPathResult: + """Execute XPath-style query on dict tree. Args: - tree: Parsed configuration tree (OrderedDict) - path: XPath-style query string + tree: Dictionary tree to search + query: XPath query string + context: How much context to include in matches: + - 'none': Just matched values (default) + - 'partial': From wildcard match point to value + - 'full': Full tree hierarchy from root Returns: - XPathResult with found data and metadata + XPathResult with matches and metadata - Raises: - SearchError: If path syntax is invalid + Examples: + >>> result = xpath.query(tree, '/interface/FastEthernet0/0/duplex') + >>> result = xpath.query(tree, '//duplex', context='partial') + >>> result = xpath.query(tree, '/interface/*/duplex', context='full') + >>> result = xpath.query(tree, '/interface[FastEthernet*]', context='partial') """ - if not path: - raise SearchError("XPath query cannot be empty") - - if not isinstance(tree, OrderedDict): - raise SearchError("Tree must be an OrderedDict") - - # Normalize path - path = path.strip() - - # Handle different path types - if path.startswith("//"): - # Recursive search - return self._search_recursive(tree, path[2:]) - elif path.startswith("/"): - # Absolute path - return self._search_absolute(tree, path[1:]) - else: - # Relative path (treat as absolute) - return self._search_absolute(tree, path) - - def _search_absolute(self, tree: TreeData, path: str) -> XPathResult: - """Search using absolute path from root. + if not query: + return XPathResult( + success=False, + error="XPath query cannot be empty", + query=query, + ) + + # Validate query format + if not (query.startswith('/') or query.startswith('//')): + return XPathResult( + success=False, + error="XPath query must start with / or //", + query=query, + ) + + if not isinstance(tree, dict): + return XPathResult( + success=False, + error=f"Tree must be a dict, got {type(tree).__name__}", + query=query, + ) + + # Validate context parameter + if context not in ('none', 'partial', 'full'): + return XPathResult( + success=False, + error=f"Invalid context '{context}'. Must be 'none', 'partial', or 'full'", + query=query, + ) + + try: + # Handle root path + if query == "/": + return XPathResult( + success=True, + data=tree, + matches=[tree], + count=1, + query=query, + paths=[[]], + ) + + # Parse query + is_recursive = query.startswith("//") + path = query.lstrip("/") + + if is_recursive: + # Recursive search with path tracking + matches, paths = self._search_recursive_with_paths(tree, path, []) + else: + # Absolute path with path tracking + matches, paths = self._search_absolute_with_paths(tree, path, []) + + if matches: + # Apply context if needed + if context != 'none' and paths: + final_matches = [ + self._build_context(match, path_components, context) + for match, path_components in zip(matches, paths) + ] + else: + final_matches = matches + + return XPathResult( + success=True, + data=final_matches[0] if final_matches else None, + matches=final_matches, + count=len(final_matches), + query=query, + paths=paths, + ) + else: + return XPathResult( + success=False, + data=None, + matches=[], + count=0, + query=query, + paths=[], + ) + + except Exception as e: + return XPathResult( + success=False, + error=f"XPath query failed: {str(e)}", + query=query, + ) + + def _build_context(self, match: Any, path: List[str], context_type: str) -> Any: + """Build context structure around a match. Args: - tree: Configuration tree - path: Path without leading / + match: The matched value + path: Full path components from root to match + context_type: 'partial' or 'full' Returns: - XPathResult with matches + Dict with context hierarchy or original match value + + For 'partial' context with path ['interface', 'FastEthernet0/0', 'ip']: + Returns: {'FastEthernet0/0': {'ip': match}} + For 'full' context: + Returns: {'interface': {'FastEthernet0/0': {'ip': match}}} """ - if not path: - return XPathResult(success=True, data=tree, matches=[tree], count=1, query=f"/{path}") - - parts = self._split_path(path) - matches = self._traverse_path(tree, parts, []) - - return XPathResult( - success=len(matches) > 0, - data=matches[0] if matches else None, - matches=matches, - count=len(matches), - query=f"/{path}", - ) + if context_type == 'none' or not path: + return match + + if context_type == 'partial': + # For partial context, skip the first component (container level) + # This shows from the wildcard/predicate match point + if len(path) > 1: + path_to_use = path[1:] # Skip first level (e.g., 'interface') + else: + path_to_use = path + else: # 'full' + path_to_use = path + + # Build nested dict from path + if not path_to_use: + return match - def _search_recursive(self, tree: TreeData, path: str) -> XPathResult: - """Search recursively through entire tree. + result = match + for component in reversed(path_to_use): + result = {component: result} + + return result + + def _search_absolute_with_paths( + self, tree: Dict[str, Any], path: str, current_path: List[str] + ) -> Tuple[List[Any], List[List[str]]]: + """Search using absolute path, tracking paths to matches. Args: - tree: Configuration tree - path: Path to search for + tree: Current dict to search + path: Path segments (without leading /) + current_path: Path components from root to current position Returns: - XPathResult with all matches + Tuple of (matches list, paths list) """ - parts = self._split_path(path) - all_matches: List[Any] = [] - - def recurse(node: Any, depth: int = 0) -> None: - """Recursively search tree for matching paths.""" - if not isinstance(node, OrderedDict): - return - - # Try to match from this node - matches = self._traverse_path(node, parts, []) - all_matches.extend(matches) - - # Recurse into children - for value in node.values(): - if isinstance(value, OrderedDict): - recurse(value, depth + 1) - - recurse(tree) - - return XPathResult( - success=len(all_matches) > 0, - data=all_matches[0] if all_matches else None, - matches=all_matches, - count=len(all_matches), - query=f"//{path}", - ) + segments = self._parse_path(path) + + if not segments: + return [tree], [current_path] + + return self._traverse_path_with_tracking(tree, segments, current_path) - def _split_path(self, path: str) -> List[str]: - """Split path into components. + def _search_recursive_with_paths( + self, tree: Dict[str, Any], pattern: str, current_path: List[str] + ) -> Tuple[List[Any], List[List[str]]]: + """Recursively search for pattern anywhere in tree, tracking paths. Args: - path: XPath string + tree: Current dict to search + pattern: Pattern to match + current_path: Path components from root to current position Returns: - List of path components + Tuple of (matches list, paths list) """ - # Handle empty path - if not path: - return [] + all_matches = [] + all_paths = [] - # Split by / but preserve predicates [...] - parts = [] - current = "" - in_predicate = False - - for char in path: - if char == "[": - in_predicate = True - current += char - elif char == "]": - in_predicate = False - current += char - elif char == "/" and not in_predicate: - if current: - parts.append(current) - current = "" - else: - current += char + # Try to match at current level + current_matches, current_match_paths = self._search_absolute_with_paths( + tree, pattern, current_path + ) + all_matches.extend(current_matches) + all_paths.extend(current_match_paths) - if current: - parts.append(current) + # Recursively search in nested dicts + for key, value in tree.items(): + if isinstance(value, dict): + nested_path = current_path + [key] + nested_matches, nested_paths = self._search_recursive_with_paths( + value, pattern, nested_path + ) + all_matches.extend(nested_matches) + all_paths.extend(nested_paths) - return parts + return all_matches, all_paths - def _traverse_path( - self, tree: TreeData, parts: List[str], current_path: List[str] - ) -> List[Any]: - """Traverse tree following path components. + def _parse_path(self, path: str) -> List[Tuple[str, Optional[str]]]: + """Parse path into segments with predicates. Args: - tree: Current node in tree - parts: Remaining path components - current_path: Path traversed so far + path: Path string like "interface/FastEthernet0/0" or "interface[FastEthernet0/0]" Returns: - List of matches + List of (segment, predicate) tuples """ - if not parts: - return [tree] + segments = [] + predicate_pattern = r"([^/\[]+)\[([^\]]+)\]" - if not isinstance(tree, OrderedDict): - return [] + parts = [] + current_pos = 0 - part = parts[0] - remaining = parts[1:] - matches: List[Any] = [] + while current_pos < len(path): + match = re.search(predicate_pattern, path[current_pos:]) - # Handle wildcards - if part == "*": - # Return all keys at this level if no more parts - if not remaining: - return list(tree.keys()) - # Otherwise traverse all children - for key, value in tree.items(): - if isinstance(value, OrderedDict): - child_matches = self._traverse_path(value, remaining, current_path + [key]) - matches.extend(child_matches) - elif not remaining: # Leaf node - matches.append(value) - return matches - - # Handle predicates [pattern] - if "[" in part: - key_pattern, predicate = self._parse_predicate(part) - - # Check if key exists in tree - if key_pattern in tree: - value = tree[key_pattern] - - # If value is OrderedDict, filter its children by predicate - if isinstance(value, OrderedDict): - for child_key, child_value in value.items(): - if self._match_key(child_key, predicate): - if not remaining: - matches.append(child_value) - elif isinstance(child_value, OrderedDict): - child_matches = self._traverse_path( - child_value, remaining, current_path + [key_pattern, child_key] - ) - matches.extend(child_matches) - return matches - - # Direct key lookup - if part in tree: - value = tree[part] - if not remaining: - return [value] - if isinstance(value, OrderedDict): - return self._traverse_path(value, remaining, current_path + [part]) - - # Try pattern matching on keys - for key, value in tree.items(): - if self._match_key(key, part): - if not remaining: - matches.append(value) - elif isinstance(value, OrderedDict): - child_matches = self._traverse_path(value, remaining, current_path + [key]) - matches.extend(child_matches) + if match: + before = path[current_pos : current_pos + match.start()] + if before: + parts.extend([p for p in before.split("/") if p]) - return matches + segment = match.group(1) + predicate = match.group(2) + segments.append((segment, predicate)) - def _parse_predicate(self, part: str) -> tuple[str, str]: - """Parse predicate from path component. + current_pos += match.end() - Args: - part: Path component with predicate like 'interface[Gig*]' + if current_pos < len(path) and path[current_pos] == "/": + current_pos += 1 + else: + remaining = path[current_pos:] + parts.extend([p for p in remaining.split("/") if p]) + break - Returns: - Tuple of (key_pattern, predicate_pattern) - """ - match = re.match(r"^([^\[]+)\[([^\]]+)\]$", part) - if match: - return match.group(1), match.group(2) - return part, "" + for part in parts: + if part: + segments.append((part, None)) - def _check_predicate(self, key: str, _value: Any, predicate: str) -> bool: - """Check if key/value matches predicate. + return segments + + def _traverse_path_with_tracking( + self, + tree: Dict[str, Any], + segments: List[Tuple[str, Optional[str]]], + current_path: List[str], + ) -> Tuple[List[Any], List[List[str]]]: + """Traverse path through tree, tracking paths to matches. Args: - key: Dictionary key - _value: Dictionary value (unused but kept for future use) - predicate: Predicate pattern + tree: Current dict + segments: List of (segment, predicate) tuples + current_path: Path components from root to current position Returns: - True if matches + Tuple of (matches list, paths list) """ - if not predicate: - return True - return self._match_key(key, predicate) + if not segments: + return [tree], [current_path] - def _match_key(self, key: str, pattern: str) -> bool: - """Match key against pattern with wildcard support. + current_segment, predicate = segments[0] + remaining_segments = segments[1:] - Args: - key: Dictionary key to match - pattern: Pattern (supports * wildcard) + all_matches = [] + all_paths = [] - Returns: - True if key matches pattern - """ - # Convert glob pattern to regex - regex_pattern = pattern.replace("*", ".*") - regex_pattern = f"^{regex_pattern}$" - return bool(re.match(regex_pattern, key, re.IGNORECASE)) + # Handle wildcards + if "*" in current_segment: + pattern = current_segment.replace("*", ".*") + for key, value in tree.items(): + if re.match(pattern, str(key), re.IGNORECASE): + new_path = current_path + [key] + if remaining_segments: + if isinstance(value, dict): + nested_matches, nested_paths = self._traverse_path_with_tracking( + value, remaining_segments, new_path + ) + all_matches.extend(nested_matches) + all_paths.extend(nested_paths) + else: + all_matches.append(value) + all_paths.append(new_path) + + elif predicate: + # Handle predicate: /interface[FastEthernet0/0] + if current_segment in tree and isinstance(tree[current_segment], dict): + container = tree[current_segment] + predicate_pattern = predicate.replace("*", ".*") + for key, value in container.items(): + if re.match(predicate_pattern, str(key), re.IGNORECASE): + new_path = current_path + [current_segment, key] + if remaining_segments: + if isinstance(value, dict): + nested_matches, nested_paths = self._traverse_path_with_tracking( + value, remaining_segments, new_path + ) + all_matches.extend(nested_matches) + all_paths.extend(nested_paths) + else: + all_matches.append(value) + all_paths.append(new_path) + + else: + # Exact match + if current_segment in tree: + value = tree[current_segment] + new_path = current_path + [current_segment] + if remaining_segments: + if isinstance(value, dict): + nested_matches, nested_paths = self._traverse_path_with_tracking( + value, remaining_segments, new_path + ) + all_matches.extend(nested_matches) + all_paths.extend(nested_paths) + else: + all_matches.append(value) + all_paths.append(new_path) + + return all_matches, all_paths diff --git a/tests/test_xpath.py b/tests/test_xpath.py index 02cd3bd..617aca2 100644 --- a/tests/test_xpath.py +++ b/tests/test_xpath.py @@ -1,435 +1,241 @@ -"""Tests for XPath query functionality.""" +"""Tests for XPath functionality on YAML dict structures.""" +import unittest from collections import OrderedDict -import pytest - -from shconfparser.exceptions import SearchError -from shconfparser.parser import Parser -from shconfparser.xpath import XPath - - -@pytest.fixture -def sample_tree(): - """Create a sample configuration tree for testing.""" - tree = OrderedDict( - [ - ( - "interface", - OrderedDict( - [ - ( - "GigabitEthernet0-0-1", - OrderedDict( - [ - ("description", "WAN Interface"), - ( - "ip", - OrderedDict( - [ - ("address", "192.168.1.1 255.255.255.0"), - ("nat", "outside"), - ] - ), - ), - ("shutdown", ""), - ] - ), - ), - ( - "GigabitEthernet0-0-2", - OrderedDict( - [ - ("description", "LAN Interface"), - ( - "ip", - OrderedDict( - [ - ("address", "10.0.0.1 255.255.255.0"), - ("nat", "inside"), - ] - ), - ), - ] - ), - ), - ( - "Loopback0", - OrderedDict( - [ - ("description", "Loopback"), - ( - "ip", - OrderedDict( - [ - ("address", "1.1.1.1 255.255.255.255"), - ] - ), - ), - ] - ), - ), - ] - ), - ), - ("hostname", "Router1"), - ( - "router", - OrderedDict( - [ - ( - "bgp", - OrderedDict( - [ - ( - "65000", - OrderedDict( - [ - ( - "neighbor", - OrderedDict( - [ - ( - "10.0.0.2", - OrderedDict( - [ - ("remote-as", "65001"), - ] - ), - ), - ] - ), - ), - ] - ), - ), - ] - ), - ), - ] - ), - ), - ] - ) - return tree - - -class TestXPath: - """Test XPath query engine.""" - - def test_xpath_init(self): - """Test XPath initialization.""" - xpath = XPath() - assert repr(xpath) == "XPath()" - - def test_empty_query(self, sample_tree): - """Test empty query raises error.""" - xpath = XPath() - with pytest.raises(SearchError, match="XPath query cannot be empty"): - xpath.query(sample_tree, "") - - def test_invalid_tree_type(self): - """Test invalid tree type raises error.""" - xpath = XPath() - with pytest.raises(SearchError, match="Tree must be an OrderedDict"): - xpath.query({"key": "value"}, "/test") - - def test_absolute_path_single_key(self, sample_tree): - """Test absolute path to single key.""" - xpath = XPath() - result = xpath.query(sample_tree, "/hostname") - assert result.success - assert result.data == "Router1" - assert result.count == 1 - assert result.query == "/hostname" - - def test_absolute_path_nested(self, sample_tree): - """Test absolute path to nested key.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-1/ip/address") - assert result.success - assert result.data == "192.168.1.1 255.255.255.0" - assert result.count == 1 - - def test_absolute_path_dict(self, sample_tree): - """Test absolute path returning dictionary.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-1/ip") - assert result.success - assert isinstance(result.data, OrderedDict) - assert "address" in result.data - assert "nat" in result.data - - def test_absolute_path_not_found(self, sample_tree): - """Test absolute path that doesn't exist.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/GigabitEthernet0-0-99") - assert not result.success - assert result.count == 0 - - def test_recursive_search(self, sample_tree): - """Test recursive search finds all matches.""" - xpath = XPath() - result = xpath.query(sample_tree, "//address") - assert result.success - assert result.count == 3 # Three interfaces with addresses - assert "192.168.1.1" in result.matches[0] - - def test_recursive_search_nested(self, sample_tree): - """Test recursive search for nested path.""" - xpath = XPath() - result = xpath.query(sample_tree, "//ip/address") - assert result.success - assert result.count == 3 - - def test_wildcard_single_level(self, sample_tree): - """Test wildcard at single level.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/*") - # Should return interface names - assert result.success - assert result.count == 3 - assert "GigabitEthernet0-0-1" in result.matches - assert "GigabitEthernet0-0-2" in result.matches - assert "Loopback0" in result.matches - - def test_wildcard_with_continuation(self, sample_tree): - """Test wildcard with path continuation.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/*/description") - assert result.success - assert result.count == 3 - assert "WAN Interface" in result.matches - assert "LAN Interface" in result.matches - - def test_wildcard_nested(self, sample_tree): - """Test wildcard in nested path.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface/*/ip/address") - assert result.success - assert result.count == 3 - - def test_predicate_exact_match(self, sample_tree): - """Test predicate with exact match.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface[GigabitEthernet0-0-1]") - assert result.success - assert result.count == 1 - assert isinstance(result.data, OrderedDict) - - def test_predicate_wildcard(self, sample_tree): - """Test predicate with wildcard pattern.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface[GigabitEthernet*]/ip/address") - assert result.success - assert result.count == 2 # Two GigabitEthernet interfaces - assert "192.168.1.1" in result.matches[0] - - def test_predicate_wildcard_prefix(self, sample_tree): - """Test predicate with wildcard prefix.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface[*0]/ip/address") - assert result.success - assert result.count == 1 # Only Loopback0 - - def test_root_path(self, sample_tree): - """Test root path returns entire tree.""" - xpath = XPath() - result = xpath.query(sample_tree, "/") - assert result.success - assert result.data == sample_tree - - def test_relative_path_treated_as_absolute(self, sample_tree): - """Test relative path (no leading /) treated as absolute.""" - xpath = XPath() - result = xpath.query(sample_tree, "hostname") - assert result.success - assert result.data == "Router1" - - def test_case_insensitive_matching(self, sample_tree): - """Test pattern matching is case insensitive.""" - xpath = XPath() - result = xpath.query(sample_tree, "/interface[gigabit*]") - assert result.success - assert result.count == 2 - - -class TestParserXPath: - """Test XPath integration with Parser class.""" - - def test_parser_xpath_with_stored_tree(self, sample_tree): - """Test Parser.xpath uses stored tree.""" - parser = Parser() - parser.data = sample_tree # Simulate parsed tree - - result = parser.xpath("//ip/address") - assert result.success - assert result.count == 3 - - def test_parser_xpath_with_custom_tree(self, sample_tree): - """Test Parser.xpath with custom tree parameter.""" - parser = Parser() - # Don't set parser.data - - result = parser.xpath("//ip/address", tree=sample_tree) - assert result.success - assert result.count == 3 - - def test_parser_xpath_no_tree(self): - """Test Parser.xpath without tree data.""" - parser = Parser() - - result = parser.xpath("//test") - assert not result.success - assert "No tree data available" in result.error - - def test_parser_xpath_invalid_query(self, sample_tree): - """Test Parser.xpath with invalid query.""" - parser = Parser() - parser.data = sample_tree - - result = parser.xpath("") - assert not result.success - assert result.error is not None - - def test_parser_xpath_result_attributes(self, sample_tree): - """Test XPathResult attributes.""" - parser = Parser() - parser.data = sample_tree +from shconfparser import Parser, XPathResult - result = parser.xpath("/hostname") - assert result.success - assert result.data == "Router1" - assert result.count == 1 - assert len(result.matches) == 1 - assert result.query == "/hostname" - assert result.error is None - - def test_parser_xpath_boolean_evaluation(self, sample_tree): - """Test XPathResult boolean evaluation.""" - parser = Parser() - parser.data = sample_tree - - result = parser.xpath("/hostname") - assert result # Should evaluate to True - - result = parser.xpath("/nonexistent") - assert not result # Should evaluate to False - - def test_parser_workflow_integration(self, tmp_path): - """Test complete workflow with file reading and parsing.""" - # Create test config file - config_file = tmp_path / "config.txt" - config_file.write_text( - """interface GigabitEthernet0/0/1 - description WAN - ip address 192.168.1.1 255.255.255.0 -interface GigabitEthernet0/0/2 - description LAN - ip address 10.0.0.1 255.255.255.0 -hostname TestRouter -""" - ) - - parser = Parser() - data = parser.read(str(config_file)) - parser.parse_tree(data) - - # Now use xpath - note the tree structure has full lines as keys - result = parser.xpath("//description WAN") - assert result.success - assert result.count == 1 - - def test_xpath_chaining(self, sample_tree): - """Test chaining multiple xpath queries.""" - parser = Parser() - parser.data = sample_tree - # First query - result1 = parser.xpath("/interface/GigabitEthernet0-0-1") - assert result1.success +class TestXPath(unittest.TestCase): + """Test XPath queries on YAML format data.""" - # Query on result - result2 = parser.xpath("/ip/address", tree=result1.data) - assert result2.success - assert "192.168.1.1" in result2.data + def setUp(self): + """Set up parser with YAML format and parse test data.""" + self.parser = Parser(output_format="yaml") + lines = self.parser.read("data/shrun.txt") + self.tree = self.parser.parse_tree(lines) + def test_xpath_result_dataclass(self): + """Test XPathResult dataclass structure.""" + result = self.parser.xpath("/hostname") + self.assertIsInstance(result, XPathResult) + self.assertTrue(hasattr(result, "success")) + self.assertTrue(hasattr(result, "data")) + self.assertTrue(hasattr(result, "matches")) + self.assertTrue(hasattr(result, "count")) + self.assertTrue(hasattr(result, "query")) + self.assertTrue(hasattr(result, "error")) -class TestXPathEdgeCases: - """Test edge cases and complex scenarios.""" - - def test_deep_nesting(self): - """Test very deep nesting.""" - tree = OrderedDict( - [("a", OrderedDict([("b", OrderedDict([("c", OrderedDict([("d", "value")]))]))]))] - ) - xpath = XPath() - result = xpath.query(tree, "/a/b/c/d") - assert result.success - assert result.data == "value" - - def test_empty_tree(self): - """Test query on empty tree.""" - tree = OrderedDict() - xpath = XPath() - result = xpath.query(tree, "/test") - assert not result.success - - def test_special_characters_in_keys(self): - """Test keys with special characters.""" - tree = OrderedDict( - [ - ( - "interface-vlan-100", - OrderedDict( - [ - ("ip_address", "10.0.0.1"), - ] - ), - ), - ] - ) - xpath = XPath() - result = xpath.query(tree, "/interface-vlan-100/ip_address") - assert result.success - assert result.data == "10.0.0.1" - - def test_numeric_keys(self): - """Test numeric keys.""" - tree = OrderedDict( - [ - ( - "vlan", - OrderedDict( - [ - ("100", OrderedDict([("name", "DATA")])), - ("200", OrderedDict([("name", "VOICE")])), - ] - ), - ), - ] - ) - xpath = XPath() - result = xpath.query(tree, "/vlan/100/name") - assert result.success - assert result.data == "DATA" - - def test_multiple_wildcard_levels(self): + def test_xpath_result_bool(self): + """Test XPathResult boolean evaluation.""" + result_success = self.parser.xpath("/hostname") + result_failure = self.parser.xpath("/nonexistent") + self.assertTrue(result_success) + self.assertFalse(result_failure) + + def test_simple_absolute_path(self): + """Test simple absolute path query.""" + result = self.parser.xpath("/hostname") + self.assertTrue(result.success) + self.assertEqual(result.data, "R1") + self.assertEqual(result.count, 1) + self.assertEqual(result.query, "/hostname") + + def test_nested_absolute_path(self): + """Test nested absolute path query.""" + result = self.parser.xpath("/interface/FastEthernet0/0/duplex") + # Should fail because FastEthernet0/0 requires predicate syntax + self.assertFalse(result.success) + + def test_predicate_with_slash(self): + """Test predicate syntax with identifier containing slash.""" + result = self.parser.xpath("/interface[FastEthernet0/0]") + self.assertTrue(result.success) + self.assertIsInstance(result.data, dict) + self.assertIn("duplex", result.data) + self.assertIn("ip", result.data) + + def test_predicate_with_continuation(self): + """Test predicate followed by path continuation.""" + result = self.parser.xpath("/interface[FastEthernet0/0]/duplex") + self.assertTrue(result.success) + self.assertEqual(result.data, "auto") + + def test_deep_nested_with_predicate(self): + """Test deep nested path with predicate.""" + result = self.parser.xpath("/interface[FastEthernet0/0]/ip/address") + self.assertTrue(result.success) + self.assertEqual(result.data, "1.1.1.1 255.255.255.0") + + def test_recursive_search(self): + """Test recursive search (// operator).""" + result = self.parser.xpath("//duplex") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + self.assertIsInstance(result.matches, list) + self.assertEqual(len(result.matches), 2) + self.assertIn("auto", result.matches) + + def test_recursive_search_single_result(self): + """Test recursive search returning single result.""" + result = self.parser.xpath("//hostname") + self.assertTrue(result.success) + self.assertEqual(result.count, 1) + self.assertEqual(result.data, "R1") + + def test_wildcard_in_path(self): + """Test wildcard (*) in path.""" + result = self.parser.xpath("/interface/*/duplex") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + self.assertIsInstance(result.matches, list) + self.assertEqual(len(result.matches), 2) + + def test_wildcard_in_predicate(self): + """Test wildcard pattern in predicate.""" + result = self.parser.xpath("/interface[FastEthernet*]/duplex") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + self.assertIsInstance(result.matches, list) + + def test_predicate_pattern_matching(self): + """Test predicate with partial pattern match.""" + result = self.parser.xpath("/interface[*0/0]") + self.assertTrue(result.success) + self.assertIsInstance(result.data, dict) + + def test_nonexistent_path(self): + """Test query for nonexistent path.""" + result = self.parser.xpath("/nonexistent") + self.assertFalse(result.success) + self.assertIsNone(result.data) + self.assertEqual(result.count, 0) + self.assertIsNone(result.error) + + def test_invalid_query_format(self): + """Test invalid query format.""" + result = self.parser.xpath("invalid") + self.assertFalse(result.success) + self.assertIsNotNone(result.error) + self.assertIn("must start with", result.error.lower()) + + def test_empty_query(self): + """Test empty query string.""" + result = self.parser.xpath("") + self.assertFalse(result.success) + self.assertIsNotNone(result.error) + + def test_multiple_wildcards(self): """Test multiple wildcards in path.""" - tree = OrderedDict( - [ - ( - "level1", - OrderedDict( - [ - ("a", OrderedDict([("target", "value1")])), - ("b", OrderedDict([("target", "value2")])), - ] - ), - ), - ] + result = self.parser.xpath("/interface/*/ip/*") + self.assertTrue(result.success) + self.assertGreater(result.count, 0) + + def test_xpath_on_json_format(self): + """Test XPath on JSON format (should return error).""" + parser = Parser(output_format="json") + lines = parser.read("data/shrun.txt") + tree = parser.parse_tree(lines) + result = parser.xpath("/hostname") + # XPath only works with YAML format + self.assertFalse(result.success) + self.assertIsNotNone(result.error) + self.assertIn("yaml", result.error.lower()) + + def test_predicate_exact_match(self): + """Test predicate with exact identifier match.""" + result1 = self.parser.xpath("/interface[FastEthernet0/0]") + result2 = self.parser.xpath("/interface[FastEthernet0/1]") + self.assertTrue(result1.success) + self.assertTrue(result2.success) + self.assertNotEqual(result1.data, result2.data) + + def test_recursive_with_wildcard(self): + """Test recursive search combined with wildcard.""" + result = self.parser.xpath("//ip/*") + self.assertTrue(result.success) + self.assertGreater(result.count, 0) + + def test_yaml_structure_preserved(self): + """Test that YAML structure maintains clean format without nulls.""" + # Verify the tree doesn't have unnecessary null values + self.assertIsInstance(self.tree, dict) + if "hostname" in self.tree: + # Should be string, not dict with null + self.assertIsInstance(self.tree["hostname"], str) + + def test_two_level_split(self): + """Test that leaf values are split max 2 levels deep.""" + result = self.parser.xpath("/interface[FastEthernet0/0]/ip/address") + # Address should be a single string, not nested dict + self.assertIsInstance(result.data, str) + self.assertIn("1.1.1.1", result.data) + + def test_context_none(self): + """Test context='none' returns just matched values.""" + result = self.parser.xpath("/interface/*/duplex", context="none") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + # Should return just the values + self.assertEqual(result.matches[0], "auto") + self.assertEqual(result.matches[1], "auto") + + def test_context_partial(self): + """Test context='partial' includes path from wildcard match.""" + result = self.parser.xpath("/interface/*/duplex", context="partial") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + # Should include interface name + self.assertIsInstance(result.matches[0], dict) + self.assertIn("FastEthernet0/0", result.matches[0]) + self.assertEqual(result.matches[0]["FastEthernet0/0"]["duplex"], "auto") + + def test_context_full(self): + """Test context='full' includes full tree hierarchy.""" + result = self.parser.xpath("/interface/*/duplex", context="full") + self.assertTrue(result.success) + self.assertEqual(result.count, 2) + # Should include full path from root + self.assertIsInstance(result.matches[0], dict) + self.assertIn("interface", result.matches[0]) + self.assertIn("FastEthernet0/0", result.matches[0]["interface"]) + + def test_context_with_predicate_wildcard(self): + """Test context with predicate containing wildcard.""" + result = self.parser.xpath("/interface[FastEthernet*]/ip", context="partial") + self.assertTrue(result.success) + # Should show which FastEthernet interface + self.assertIsInstance(result.data, dict) + self.assertTrue( + "FastEthernet0/0" in result.data or "FastEthernet0/1" in result.data ) - xpath = XPath() - result = xpath.query(tree, "/level1/*/target") - assert result.success - assert result.count == 2 + + def test_context_invalid(self): + """Test invalid context parameter.""" + result = self.parser.xpath("/hostname", context="invalid") + self.assertFalse(result.success) + self.assertIsNotNone(result.error) + self.assertIn("Invalid context", result.error) + + def test_paths_tracking(self): + """Test that paths are tracked in results.""" + result = self.parser.xpath("/interface/*/duplex") + self.assertTrue(result.success) + self.assertEqual(len(result.paths), result.count) + # Paths should contain path components + for path in result.paths: + self.assertIsInstance(path, list) + self.assertIn("interface", path) + self.assertIn("duplex", path) + + def test_context_recursive_search(self): + """Test context with recursive search.""" + result = self.parser.xpath("//duplex", context="partial") + self.assertTrue(result.success) + self.assertGreater(result.count, 0) + # With context, should show parent structure + self.assertIsInstance(result.matches[0], dict) + + +if __name__ == "__main__": + unittest.main() From 47aaa0fcc7b1a543b7d6ed4a324386ce4793aac0 Mon Sep 17 00:00:00 2001 From: Kiran K Kotari Date: Sun, 28 Dec 2025 11:19:23 -0500 Subject: [PATCH 3/3] update code with ruff check --- shconfparser/parser.py | 9 +++++---- shconfparser/xpath.py | 27 +++++++++++---------------- tests/test_xpath.py | 7 ++----- 3 files changed, 18 insertions(+), 25 deletions(-) diff --git a/shconfparser/parser.py b/shconfparser/parser.py index 8f28895..16d071e 100644 --- a/shconfparser/parser.py +++ b/shconfparser/parser.py @@ -354,7 +354,9 @@ def _tree_to_yaml_structure(self, tree: TreeData) -> Dict[str, Any]: return result - def xpath(self, query: str, tree: Optional[Dict[str, Any]] = None, context: str = 'none') -> XPathResult: + def xpath( + self, query: str, tree: Optional[Dict[str, Any]] = None, context: str = "none" + ) -> XPathResult: """Execute XPath-style query on YAML configuration tree. XPath queries work on YAML format (dict) trees. If tree is not provided, @@ -397,7 +399,7 @@ def xpath(self, query: str, tree: Optional[Dict[str, Any]] = None, context: str ) # XPath only works with YAML format (dict, not OrderedDict) - if self.output_format != 'yaml': + if self.output_format != "yaml": return XPathResult( success=False, error=f"XPath queries only work with output_format='yaml', current format is '{self.output_format}'", @@ -407,8 +409,7 @@ def xpath(self, query: str, tree: Optional[Dict[str, Any]] = None, context: str # Ensure search_tree is a dict if not isinstance(search_tree, dict): self.logger.warning( - "XPath requires dict structure. " - f"Got {type(search_tree).__name__}." + "XPath requires dict structure. " f"Got {type(search_tree).__name__}." ) return XPathResult( success=False, diff --git a/shconfparser/xpath.py b/shconfparser/xpath.py index 5a084cf..8bd1f72 100644 --- a/shconfparser/xpath.py +++ b/shconfparser/xpath.py @@ -4,11 +4,9 @@ configurations in YAML format (dict structures). """ -import fnmatch import re -from typing import Any, Dict, List, Optional, Tuple, Union +from typing import Any, Dict, List, Optional, Tuple -from .exceptions import SearchError from .models import XPathResult @@ -35,7 +33,7 @@ def __repr__(self) -> str: """Return string representation.""" return "XPath()" - def query(self, tree: Dict[str, Any], query: str, context: str = 'none') -> XPathResult: + def query(self, tree: Dict[str, Any], query: str, context: str = "none") -> XPathResult: """Execute XPath-style query on dict tree. Args: @@ -63,7 +61,7 @@ def query(self, tree: Dict[str, Any], query: str, context: str = 'none') -> XPat ) # Validate query format - if not (query.startswith('/') or query.startswith('//')): + if not (query.startswith("/") or query.startswith("//")): return XPathResult( success=False, error="XPath query must start with / or //", @@ -78,7 +76,7 @@ def query(self, tree: Dict[str, Any], query: str, context: str = 'none') -> XPat ) # Validate context parameter - if context not in ('none', 'partial', 'full'): + if context not in ("none", "partial", "full"): return XPathResult( success=False, error=f"Invalid context '{context}'. Must be 'none', 'partial', or 'full'", @@ -110,7 +108,7 @@ def query(self, tree: Dict[str, Any], query: str, context: str = 'none') -> XPat if matches: # Apply context if needed - if context != 'none' and paths: + if context != "none" and paths: final_matches = [ self._build_context(match, path_components, context) for match, path_components in zip(matches, paths) @@ -159,17 +157,14 @@ def _build_context(self, match: Any, path: List[str], context_type: str) -> Any: For 'full' context: Returns: {'interface': {'FastEthernet0/0': {'ip': match}}} """ - if context_type == 'none' or not path: + if context_type == "none" or not path: return match - if context_type == 'partial': - # For partial context, skip the first component (container level) - # This shows from the wildcard/predicate match point - if len(path) > 1: - path_to_use = path[1:] # Skip first level (e.g., 'interface') - else: - path_to_use = path - else: # 'full' + # For partial context, skip the first component (container level) + # This shows from the wildcard/predicate match point + if context_type == "partial": # noqa: SIM108 + path_to_use = path[1:] if len(path) > 1 else path + else: path_to_use = path # Build nested dict from path diff --git a/tests/test_xpath.py b/tests/test_xpath.py index 617aca2..682b0e4 100644 --- a/tests/test_xpath.py +++ b/tests/test_xpath.py @@ -1,7 +1,6 @@ """Tests for XPath functionality on YAML dict structures.""" import unittest -from collections import OrderedDict from shconfparser import Parser, XPathResult @@ -135,7 +134,7 @@ def test_xpath_on_json_format(self): """Test XPath on JSON format (should return error).""" parser = Parser(output_format="json") lines = parser.read("data/shrun.txt") - tree = parser.parse_tree(lines) + parser.parse_tree(lines) result = parser.xpath("/hostname") # XPath only works with YAML format self.assertFalse(result.success) @@ -206,9 +205,7 @@ def test_context_with_predicate_wildcard(self): self.assertTrue(result.success) # Should show which FastEthernet interface self.assertIsInstance(result.data, dict) - self.assertTrue( - "FastEthernet0/0" in result.data or "FastEthernet0/1" in result.data - ) + self.assertTrue("FastEthernet0/0" in result.data or "FastEthernet0/1" in result.data) def test_context_invalid(self): """Test invalid context parameter."""