`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