`99fc848`

I forget

Authored by

espadonne 8 months ago

SHA: 99fc848819cd7f81efeb4a52ba8507c766d264c5
Parents: 15f21e0
Tree: 00b83ee

6 changed files

Status	File	+	-
M	`Makefile`	9	1
A	`src/sultree/arg_definitions.py`	209	0
A	`src/sultree/constants.py`	106	0
A	`src/sultree/tree_renderer.py`	333	0
A	`src/sultree/validators.py`	228	0
M	`sultree.spec`	5	3

Makefilemodified

  PACKAGE = sultree
  VERSION = 0.0.8
--.PHONY: help build install test clean dist rpm dev-install check format
++.PHONY: help build install uninstall test clean dist rpm dev-install check format
  help:
  	@echo "Available targets:"
  	@echo "  build       - Build the package"
  	@echo "  install     - Install the package"
++	@echo "  uninstall   - Uninstall the package"
  	@echo "  dev-install - Install in development mode"
  	@echo "  test        - Run tests"
  	@echo "  check       - Run code quality checks"
  install:
  	$(PYTHON) -m pip install .
++uninstall:
++	@echo "Uninstalling $(PACKAGE)..."
++	$(PYTHON) -m pip uninstall $(PACKAGE) -y || echo "Package not installed via pip"
++	@echo "Removing any remaining executables..."
++	@rm -f ~/.local/bin/$(PACKAGE) 2>/dev/null || true
++	@echo "Uninstall complete!"
++
  dev-install:
  	$(PYTHON) -m pip install -e .[dev]

src/sultree/arg_definitions.pyadded

++"""
++Data-driven argument definitions for sultree.
++
++This module contains all command-line argument definitions in a clean,
++table-driven format to eliminate repetitive argparse code.
++"""
++
++from dataclasses import dataclass
++from typing import List, Optional, Callable, Any, Dict
++
++from .validators import (
++    validate_depth,
++    validate_file_limit,
++    validate_pattern,
++    validate_selinux_pattern,
++    validate_path
++)
++
++
++@dataclass
++class ArgumentDefinition:
++    """Defines a command-line argument."""
++    short_name: Optional[str] = None
++    long_name: str = ''
++    action: str = 'store'
++    type_func: Optional[Callable] = None
++    dest: Optional[str] = None
++    metavar: Optional[str] = None
++    help_text: str = ''
++    default: Any = None
++    nargs: Optional[str] = None
++
++
++# Data-driven argument definitions table
++ARGUMENT_DEFINITIONS = [
++    # Positional arguments
++    ArgumentDefinition(
++        long_name='directories',
++        action='store',
++        nargs='*',
++        type_func=validate_path,
++        help_text='directories to tree (default: current directory)',
++        default=None  # Will be set to [Path('.')] in parsing
++    ),
++
++    # Basic listing options
++    ArgumentDefinition(
++        short_name='-a',
++        long_name='--all',
++        action='store_true',
++        help_text='show all files (including hidden files)'
++    ),
++    ArgumentDefinition(
++        short_name='-d',
++        long_name='--dirs-only',
++        action='store_true',
++        help_text='list directories only'
++    ),
++    ArgumentDefinition(
++        short_name='-l',
++        long_name='--follow-links',
++        action='store_true',
++        help_text='follow symbolic links like directories'
++    ),
++    ArgumentDefinition(
++        short_name='-f',
++        long_name='--full-path',
++        action='store_true',
++        help_text='print full path prefix for each file'
++    ),
++    ArgumentDefinition(
++        short_name='-x',
++        long_name='--one-file-system',
++        action='store_true',
++        help_text='stay on current filesystem only'
++    ),
++
++    # Depth control
++    ArgumentDefinition(
++        short_name='-L',
++        long_name='--level',
++        type_func=validate_depth,
++        metavar='level',
++        help_text='descend only level directories deep'
++    ),
++
++    # Pattern filtering
++    ArgumentDefinition(
++        short_name='-P',
++        long_name='--pattern',
++        type_func=validate_pattern,
++        action='append',
++        dest='include_patterns',
++        metavar='pattern',
++        help_text='list only files that match the pattern'
++    ),
++    ArgumentDefinition(
++        short_name='-I',
++        long_name='--ignore',
++        type_func=validate_pattern,
++        action='append',
++        dest='exclude_patterns',
++        metavar='pattern',
++        help_text='do not list files that match the pattern'
++    ),
++    ArgumentDefinition(
++        long_name='--match-dirs',
++        action='store_true',
++        help_text='include directory names in pattern matching'
++    ),
++    ArgumentDefinition(
++        long_name='--ignore-case',
++        action='store_true',
++        help_text='ignore case when pattern matching'
++    ),
++
++    # File limits
++    ArgumentDefinition(
++        long_name='--filelimit',
++        type_func=validate_file_limit,
++        metavar='N',
++        help_text='do not descend dirs with more than N files'
++    ),
++
++    # SELinux options
++    ArgumentDefinition(
++        short_name='-S',
++        long_name='--selinux',
++        type_func=validate_selinux_pattern,
++        action='append',
++        dest='selinux_patterns',
++        metavar='pattern',
++        help_text='show only files matching SELinux pattern (can be used multiple times)'
++    ),
++
++    # Output options
++    ArgumentDefinition(
++        long_name='--no-report',
++        action='store_true',
++        help_text='turn off file/directory count at end of tree listing'
++    ),
++    ArgumentDefinition(
++        long_name='--version',
++        action='version',
++        help_text='show version information',
++        # Note: version string will be set dynamically
++    ),
++]
++
++
++def build_argument_kwargs(arg_def: ArgumentDefinition) -> Dict[str, Any]:
++    """
++    Convert ArgumentDefinition to kwargs for argparse.add_argument().
++
++    Args:
++        arg_def: Argument definition
++
++    Returns:
++        Dictionary of kwargs for add_argument()
++    """
++    kwargs = {}
++
++    # Action
++    if arg_def.action:
++        kwargs['action'] = arg_def.action
++
++    # Type function
++    if arg_def.type_func:
++        kwargs['type'] = arg_def.type_func
++
++    # Destination
++    if arg_def.dest:
++        kwargs['dest'] = arg_def.dest
++
++    # Metavar
++    if arg_def.metavar:
++        kwargs['metavar'] = arg_def.metavar
++
++    # Help text
++    if arg_def.help_text:
++        kwargs['help'] = arg_def.help_text
++
++    # Default value
++    if arg_def.default is not None:
++        kwargs['default'] = arg_def.default
++
++    # Nargs
++    if arg_def.nargs:
++        kwargs['nargs'] = arg_def.nargs
++
++    return kwargs
++
++
++def get_argument_names(arg_def: ArgumentDefinition) -> List[str]:
++    """
++    Get the argument names (short and long) for an ArgumentDefinition.
++
++    Args:
++        arg_def: Argument definition
++
++    Returns:
++        List of argument names
++    """
++    names = []
++    if arg_def.short_name:
++        names.append(arg_def.short_name)
++    if arg_def.long_name:
++        names.append(arg_def.long_name)
++    return names

src/sultree/constants.pyadded

++"""
++Constants and configuration values for sultree.
++
++This module centralizes all magic numbers and configuration values,
++making them data-driven and easier to maintain.
++"""
++
++from typing import Dict, Any
++import dataclasses
++
++
++@dataclasses.dataclass(frozen=True)
++class Limits:
++    """Resource and validation limits."""
++
++    # Input validation limits
++    MAX_DEPTH: int = 1000
++    MAX_FILE_LIMIT: int = 100000
++    MAX_PATTERN_LENGTH: int = 1000
++    MAX_SELINUX_PATTERN_LENGTH: int = 500
++    MAX_PATH_LENGTH: int = 4096
++
++    # Performance tuning
++    SELINUX_QUERY_TIMEOUT: int = 5
++    MAX_LINE_LENGTH: int = 2000
++    MAX_FILE_READ_LINES: int = 2000
++
++    # SELinux context fields (allows up to 6 for complex MLS levels)
++    MAX_SELINUX_FIELDS: int = 6
++
++
++@dataclasses.dataclass(frozen=True)
++class TreeChars:
++    """Tree drawing characters for different terminal types."""
++
++    # Unicode tree characters (default)
++    UNICODE: Dict[str, str] = dataclasses.field(default_factory=lambda: {
++        'vertical': '│',
++        'branch': '├──',
++        'last': '└──',
++        'space': '    ',
++        'continuation': '│   '
++    })
++
++    # ASCII fallback characters
++    ASCII: Dict[str, str] = dataclasses.field(default_factory=lambda: {
++        'vertical': '|',
++        'branch': '|--',
++        'last': '`--',
++        'space': '    ',
++        'continuation': '|   '
++    })
++
++
++@dataclasses.dataclass(frozen=True)
++class Security:
++    """Security-related constants."""
++
++    # Dangerous characters to remove from patterns
++    DANGEROUS_CHARS: tuple = (';', '&', '|', '`', '$', '(', ')', '<', '>', '\n', '\r')
++
++    # Dangerous regex patterns
++    DANGEROUS_REGEX_PATTERNS: tuple = (
++        r'\(\?\(\?\!',  # Catastrophic backtracking
++        r'\(\?\(\?\=',  # Catastrophic backtracking
++        r'\*\*\*+',     # Excessive repetition
++    )
++
++    # SELinux extended attribute name
++    SELINUX_XATTR: str = 'security.selinux'
++
++
++@dataclasses.dataclass(frozen=True)
++class ExitCodes:
++    """Standard exit codes."""
++
++    SUCCESS: int = 0
++    GENERAL_ERROR: int = 1
++    INVALID_ARGS: int = 2
++    PERMISSION_ERROR: int = 3
++    PARTIAL_SUCCESS: int = 4  # Some directories processed successfully
++    INTERRUPTED: int = 130  # Ctrl+C
++
++
++@dataclasses.dataclass(frozen=True)
++class Config:
++    """Main configuration object combining all constants."""
++
++    limits: Limits = dataclasses.field(default_factory=Limits)
++    tree_chars: TreeChars = dataclasses.field(default_factory=TreeChars)
++    security: Security = dataclasses.field(default_factory=Security)
++    exit_codes: ExitCodes = dataclasses.field(default_factory=ExitCodes)
++
++
++# Global configuration instance
++CONFIG = Config()
++
++
++def get_config() -> Config:
++    """
++    Get the global configuration instance.
++
++    Returns:
++        Configuration object with all constants
++    """
++    return CONFIG

src/sultree/tree_renderer.pyadded

++"""
++Proper tree rendering module for sultree.
++
++This module implements the visual tree structure that makes tree commands useful,
++with proper indentation, connectors, and hierarchical display.
++"""
++
++import sys
++from pathlib import Path
++from typing import List, Dict, Optional, TextIO, Tuple
++from dataclasses import dataclass
++
++from .constants import CONFIG
++from .traversal import FileEntry
++from .selinux import get_selinux_context
++
++
++@dataclass
++class TreeNode:
++    """Represents a node in the tree structure."""
++    entry: FileEntry
++    children: List['TreeNode']
++    is_last: bool = False  # Is this the last child of its parent?
++
++    def __post_init__(self):
++        if not hasattr(self, 'children') or self.children is None:
++            self.children = []
++
++
++class TreeRenderer:
++    """
++    Renders directory trees with proper visual structure.
++
++    Handles the tree drawing characters, indentation, and hierarchical display
++    that makes tree commands visually useful.
++    """
++
++    def __init__(self, show_full_path: bool = False,
++                 show_selinux: bool = False,
++                 use_ascii: bool = False,
++                 output_file: Optional[TextIO] = None):
++        """
++        Initialize tree renderer.
++
++        Args:
++            show_full_path: Show full paths instead of just names
++            show_selinux: Include SELinux contexts in output
++            use_ascii: Use ASCII characters instead of Unicode
++            output_file: Output file (default: stdout)
++        """
++        self.show_full_path = show_full_path
++        self.show_selinux = show_selinux
++        self.output_file = output_file or sys.stdout
++
++        # Choose character set based on terminal capabilities
++        if use_ascii or not self._supports_unicode():
++            self.chars = CONFIG.tree_chars.ASCII
++        else:
++            self.chars = CONFIG.tree_chars.UNICODE
++
++        # Statistics tracking
++        self.dir_count = 0
++        self.file_count = 0
++
++    def _supports_unicode(self) -> bool:
++        """
++        Check if terminal supports Unicode characters.
++
++        Returns:
++            True if Unicode is supported
++        """
++        try:
++            # Check encoding
++            encoding = self.output_file.encoding or 'ascii'
++            if 'utf' not in encoding.lower():
++                return False
++
++            # Check if we can write Unicode characters
++            self.output_file.write('')  # Test write access
++            return True
++
++        except (AttributeError, UnicodeError):
++            return False
++
++    def render_tree(self, root_path: Path, root_node: TreeNode, show_report: bool = True) -> None:
++        """
++        Render the complete tree structure.
++
++        Args:
++            root_path: Root directory path
++            root_node: Root tree node
++            show_report: Whether to show file/directory count at end
++        """
++        # Print root directory
++        self._print_root(root_path)
++
++        # Render tree structure
++        self._render_node_children(root_node.children, prefix="", is_root=True)
++
++        # Print summary report
++        if show_report:
++            self._print_report()
++
++    def _render_node_children(self, nodes: List[TreeNode], prefix: str, is_root: bool = False) -> None:
++        """
++        Render a list of child nodes with proper tree structure.
++
++        Args:
++            nodes: List of child nodes to render
++            prefix: Current prefix for indentation
++            is_root: Whether these are direct children of root
++        """
++        for i, node in enumerate(nodes):
++            is_last = (i == len(nodes) - 1)
++            self._render_node(node, prefix, is_last, is_root)
++
++    def _render_node(self, node: TreeNode, prefix: str, is_last: bool, is_root: bool = False) -> None:
++        """
++        Render a single node with proper tree connectors.
++
++        Args:
++            node: Node to render
++            prefix: Current prefix for indentation
++            is_last: Whether this is the last child at this level
++            is_root: Whether this is a direct child of root
++        """
++        # Build the connector
++        if is_root:
++            # Direct children of root
++            connector = self.chars['last'] if is_last else self.chars['branch']
++        else:
++            connector = self.chars['last'] if is_last else self.chars['branch']
++
++        # Get display name
++        display_name = self._get_display_name(node.entry)
++
++        # Add SELinux context if requested
++        selinux_info = ""
++        if self.show_selinux:
++            selinux_info = self._get_selinux_display(node.entry.path)
++
++        # Print the node
++        line = f"{prefix}{connector} {display_name}{selinux_info}"
++        self._safe_print(line)
++
++        # Update statistics
++        if node.entry.is_dir:
++            self.dir_count += 1
++        else:
++            self.file_count += 1
++
++        # Render children if any
++        if node.children:
++            # Build prefix for children
++            if is_last:
++                child_prefix = prefix + self.chars['space']
++            else:
++                child_prefix = prefix + self.chars['continuation']
++
++            self._render_node_children(node.children, child_prefix)
++
++    def _get_display_name(self, entry: FileEntry) -> str:
++        """
++        Get the display name for a file entry.
++
++        Args:
++            entry: FileEntry to get name for
++
++        Returns:
++            Formatted display name
++        """
++        if self.show_full_path:
++            display_name = str(entry.path)
++        else:
++            display_name = entry.name
++
++        # Add symlink target if applicable
++        if entry.is_symlink and entry.symlink_target:
++            safe_target = self._safe_filename(str(entry.symlink_target))
++            display_name += f" -> {safe_target}"
++
++        return self._safe_filename(display_name)
++
++    def _get_selinux_display(self, file_path: Path) -> str:
++        """
++        Get formatted SELinux context for display.
++
++        Args:
++            file_path: Path to get context for
++
++        Returns:
++            Formatted SELinux context string
++        """
++        try:
++            context = get_selinux_context(file_path)
++            if context:
++                return f"  [{context}]"
++        except Exception as e:
++            # Don't let SELinux errors break tree rendering
++            pass
++
++        return ""
++
++    def _safe_filename(self, filename: str) -> str:
++        """
++        Make filename safe for terminal display.
++
++        Args:
++            filename: Raw filename
++
++        Returns:
++            Safely escaped filename
++        """
++        if not filename:
++            return "<empty>"
++
++        # Replace control characters with visible representations
++        safe_chars = []
++        for char in filename:
++            # Replace control characters with visible representations
++            if ord(char) < 32 or ord(char) == 127:  # Control characters
++                safe_chars.append(f"\\x{ord(char):02x}")
++            elif char in ('\n', '\r', '\t'):  # Specific dangerous chars
++                safe_chars.append(repr(char)[1:-1])  # Use repr but remove quotes
++            else:
++                safe_chars.append(char)
++
++        return ''.join(safe_chars)
++
++    def _print_root(self, root_path: Path) -> None:
++        """
++        Print the root directory name.
++
++        Args:
++            root_path: Root directory to display
++        """
++        root_display = str(root_path) if self.show_full_path else root_path.name or str(root_path)
++        safe_display = self._safe_filename(root_display)
++        self._safe_print(safe_display)
++
++    def _safe_print(self, text: str) -> None:
++        """
++        Safely print text to output, handling encoding issues.
++
++        Args:
++            text: Text to print
++        """
++        try:
++            print(text, file=self.output_file)
++        except UnicodeEncodeError:
++            # Fallback for terminals that can't handle the text
++            safe_text = text.encode('ascii', 'replace').decode('ascii')
++            print(safe_text, file=self.output_file)
++
++    def _print_report(self) -> None:
++        """
++        Print summary report of files and directories.
++        """
++        total = self.dir_count + self.file_count
++
++        report_parts = []
++        if self.dir_count > 0:
++            dir_word = "directory" if self.dir_count == 1 else "directories"
++            report_parts.append(f"{self.dir_count} {dir_word}")
++
++        if self.file_count > 0:
++            file_word = "file" if self.file_count == 1 else "files"
++            report_parts.append(f"{self.file_count} {file_word}")
++
++        if report_parts:
++            report = ", ".join(report_parts)
++            self._safe_print(f"\n{report}")
++
++
++def build_tree_structure(entries: List[FileEntry], root_path: Path) -> TreeNode:
++    """
++    Build a proper tree structure from a flat list of entries.
++
++    Args:
++        entries: Flat list of FileEntry objects
++        root_path: The root directory path
++
++    Returns:
++        Root TreeNode with hierarchical structure
++    """
++    # Create a mapping from path to node
++    path_to_node: Dict[Path, TreeNode] = {}
++
++    # Create the root node first
++    root_entry = FileEntry(
++        path=root_path,
++        name=root_path.name or str(root_path),
++        is_dir=True,
++        depth=0
++    )
++    root_node = TreeNode(entry=root_entry, children=[])
++    path_to_node[root_path] = root_node
++
++    # Sort entries by path depth to ensure parents are processed before children
++    sorted_entries = sorted(entries, key=lambda e: len(e.path.parts))
++
++    for entry in sorted_entries:
++        # Create node for this entry
++        node = TreeNode(entry=entry, children=[])
++        path_to_node[entry.path] = node
++
++        # Find parent and add as child
++        parent_path = entry.path.parent
++        if parent_path in path_to_node:
++            parent_node = path_to_node[parent_path]
++            parent_node.children.append(node)
++        else:
++            # Parent not in our tree (might be filtered out or permission denied)
++            # Try to find the closest ancestor that exists
++            current_path = parent_path
++            while current_path and current_path != current_path.parent:
++                if current_path in path_to_node:
++                    path_to_node[current_path].children.append(node)
++                    break
++                current_path = current_path.parent
++            else:
++                # No ancestor found, add to root
++                root_node.children.append(node)
++
++    # Sort children at each level (directories first, then alphabetical)
++    def sort_children(node: TreeNode):
++        node.children.sort(key=lambda n: (not n.entry.is_dir, n.entry.name.lower()))
++        for child in node.children:
++            sort_children(child)
++
++    sort_children(root_node)
++
++    return root_node

src/sultree/validators.pyadded

++"""
++Reusable validation utilities for sultree.
++
++This module consolidates validation logic to eliminate duplication
++and provide consistent error handling.
++"""
++
++import argparse
++import re
++from pathlib import Path
++from typing import Union, List
++
++from .constants import CONFIG
++
++
++class ValidationError(Exception):
++    """Base exception for validation errors."""
++    pass
++
++
++def validate_integer_in_range(
++    value: str,
++    name: str,
++    min_val: int = 0,
++    max_val: Union[int, None] = None
++) -> int:
++    """
++    Generic integer validation with range checking.
++
++    Args:
++        value: String representation of integer
++        name: Human-readable name for error messages
++        min_val: Minimum allowed value (inclusive)
++        max_val: Maximum allowed value (inclusive), None for no limit
++
++    Returns:
++        Validated integer value
++
++    Raises:
++        argparse.ArgumentTypeError: If validation fails
++    """
++    try:
++        int_val = int(value)
++
++        if int_val < min_val:
++            raise argparse.ArgumentTypeError(f"{name} must be >= {min_val}")
++
++        if max_val is not None and int_val > max_val:
++            raise argparse.ArgumentTypeError(f"{name} too large (max {max_val})")
++
++        return int_val
++
++    except ValueError:
++        raise argparse.ArgumentTypeError(f"{name} must be an integer")
++
++
++def validate_string_length(
++    value: str,
++    name: str,
++    max_length: int,
++    allow_empty: bool = False
++) -> str:
++    """
++    Generic string length validation.
++
++    Args:
++        value: String to validate
++        name: Human-readable name for error messages
++        max_length: Maximum allowed length
++        allow_empty: Whether empty strings are allowed
++
++    Returns:
++        Validated string
++
++    Raises:
++        argparse.ArgumentTypeError: If validation fails
++    """
++    if not value and not allow_empty:
++        raise argparse.ArgumentTypeError(f"{name} cannot be empty")
++
++    if len(value) > max_length:
++        raise argparse.ArgumentTypeError(
++            f"{name} too long (max {max_length} characters)"
++        )
++
++    return value
++
++
++def validate_pattern_safety(pattern: str, name: str) -> str:
++    """
++    Validate pattern for potentially dangerous constructs.
++
++    Args:
++        pattern: Pattern to validate
++        name: Human-readable name for error messages
++
++    Returns:
++        Validated pattern
++
++    Raises:
++        argparse.ArgumentTypeError: If pattern contains dangerous constructs
++    """
++    # Check for dangerous regex patterns
++    for dangerous in CONFIG.security.DANGEROUS_REGEX_PATTERNS:
++        if re.search(dangerous, pattern):
++            raise argparse.ArgumentTypeError(
++                f"{name} contains potentially dangerous constructs"
++            )
++
++    return pattern
++
++
++def sanitize_selinux_pattern(pattern: str) -> str:
++    """
++    Sanitize SELinux pattern by removing dangerous characters.
++
++    Args:
++        pattern: Pattern to sanitize
++
++    Returns:
++        Sanitized pattern
++    """
++    # Remove dangerous characters
++    for char in CONFIG.security.DANGEROUS_CHARS:
++        pattern = pattern.replace(char, '')
++
++    return pattern.strip()
++
++
++def validate_selinux_context_format(pattern: str, name: str) -> str:
++    """
++    Validate SELinux context pattern format.
++
++    Args:
++        pattern: SELinux pattern to validate
++        name: Human-readable name for error messages
++
++    Returns:
++        Validated pattern
++
++    Raises:
++        argparse.ArgumentTypeError: If format is invalid
++    """
++    # Basic SELinux context format validation
++    if ':' in pattern:
++        parts = pattern.split(':')
++        if len(parts) > CONFIG.limits.MAX_SELINUX_FIELDS:
++            raise argparse.ArgumentTypeError(
++                f"{name} has too many colon-separated parts"
++            )
++
++    return pattern
++
++
++def validate_path_safety(path_str: str, name: str) -> Path:
++    """
++    Validate path for security issues.
++
++    Args:
++        path_str: Path string to validate
++        name: Human-readable name for error messages
++
++    Returns:
++        Validated Path object
++
++    Raises:
++        argparse.ArgumentTypeError: If path is unsafe
++    """
++    # Check for null bytes (major security issue)
++    if '\x00' in path_str:
++        raise argparse.ArgumentTypeError(f"{name} contains null bytes")
++
++    try:
++        path = Path(path_str)
++        return path
++    except (ValueError, OSError) as e:
++        raise argparse.ArgumentTypeError(f"invalid {name}: {e}")
++
++
++# Specialized validators using the generic functions above
++
++def validate_depth(value: str) -> int:
++    """Validate depth argument."""
++    return validate_integer_in_range(
++        value, "depth", 0, CONFIG.limits.MAX_DEPTH
++    )
++
++
++def validate_file_limit(value: str) -> int:
++    """Validate file limit argument."""
++    return validate_integer_in_range(
++        value, "file limit", 1, CONFIG.limits.MAX_FILE_LIMIT
++    )
++
++
++def validate_pattern(pattern: str) -> str:
++    """Validate and sanitize pattern arguments."""
++    pattern = validate_string_length(
++        pattern, "pattern", CONFIG.limits.MAX_PATTERN_LENGTH
++    )
++    return validate_pattern_safety(pattern, "pattern")
++
++
++def validate_selinux_pattern(pattern: str) -> str:
++    """Validate SELinux pattern for security."""
++    pattern = validate_string_length(
++        pattern, "SELinux pattern", CONFIG.limits.MAX_SELINUX_PATTERN_LENGTH
++    )
++
++    # Check for dangerous characters
++    for char in CONFIG.security.DANGEROUS_CHARS:
++        if char in pattern:
++            raise argparse.ArgumentTypeError(
++                f"SELinux pattern contains invalid character: '{char}'"
++            )
++
++    pattern = validate_selinux_context_format(pattern, "SELinux pattern")
++
++    return pattern
++
++
++def validate_path(path_str: str) -> Path:
++    """Validate and sanitize path arguments."""
++    path_str = validate_string_length(
++        path_str, "path", CONFIG.limits.MAX_PATH_LENGTH
++    )
++
++    return validate_path_safety(path_str, "path")

sultree.specmodified

  %autosetup
  %build
--%py3_build
++export PATH=$PATH:/home/espadon/.local/bin
++%{python3} -m build --wheel --no-isolation
  %install
--%py3_install
++export PATH=$PATH:/home/espadon/.local/bin
++%{python3} -m pip install --root %{buildroot} --no-deps --ignore-installed dist/*.whl
  # Install the standalone script
  install -Dm755 sultree %{buildroot}%{_bindir}/sultree-standalone
  %files
  %doc README.md
  %{python3_sitelib}/%{name}/
--%{python3_sitelib}/%{name}-%{version}*.egg-info/
++%{python3_sitelib}/%{name}-%{version}*.dist-info/
  %{_bindir}/sultree
  %{_bindir}/sultree-standalone