janito 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

janito/search_replace/README.md

@@ -1,192 +0,0 @@
-# Search/Replace Module
-
-A smart search and replace module that handles code indentation and provides debugging capabilities for failed searches.
-
-## Usage
-
-### As a Module
-
-```python
-from janito.search_replace import SearchReplacer
-
-# Basic search/replace
-source_code = """
-def hello():
-    print("Hello")
-    print("World")
-"""
-
-search = """    print("Hello")
-    print("World")"""
-
-replacement = """    print("Hi")
-    print("Universe")"""
-
-replacer = SearchReplacer(source_code, search, replacement)
-modified = replacer.replace()
-```
-
-### Command Line Debugging
-
-When a search fails, a debug file is automatically created in `.janito/change_history/`. You can debug these files using:
-
-```bash
-python -m janito.search_replace <debug_file>
-```
-
-Example debug file format:
-```
-Test: Failed search in example.py
-========================================
-Original:
-def hello():
-    print("Hello")
-    print("World")
-========================================
-Search pattern:
-    print("Hi")
-    print("World")
-========================================
-```
-
-## Features
-
-- Indentation-aware searching
-- Multiple search strategies:
-  - ExactMatch: Matches content with exact indentation
-  - ExactContent: Matches content ignoring indentation
-  - IndentAware: Matches preserving relative indentation
-- Debug mode with detailed indentation analysis
-- File extension specific behavior
-- Automatic debug file generation for failed searches
-
-## Search Strategies
-
-The module employs multiple search strategies in a fallback chain to find the best match. Each strategy has specific behaviors and use cases:
-
-### ExactMatch Strategy
-- Matches content exactly, including all whitespace and indentation
-- Strictest matching strategy
-- Best for precise replacements where indentation matters
-- Example:
-  ```python
-  # Pattern:
-      def hello():
-          print("Hi")
-
-  # Will only match exact indentation:
-      def hello():
-          print("Hi")
-
-  # Won't match different indentation:
-  def hello():
-      print("Hi")
-  ```
-
-### IndentAware Strategy
-- Preserves relative indentation between lines
-- Allows different base indentation levels
-- Ideal for matching code blocks inside functions/classes
-- Example:
-  ```python
-  # Pattern:
-      print("Hello")
-      print("World")
-
-  # Matches with different base indentation:
-  def test():
-      print("Hello")
-      print("World")
-
-  def other():
-          print("Hello")
-          print("World")
-
-  # Won't match if relative indentation differs:
-  def wrong():
-      print("Hello")
-          print("World")
-  ```
-
-### ExactContent Strategy
-- Ignores all indentation
-- Matches content after stripping whitespace
-- Useful for matching code regardless of formatting
-- Example:
-  ```python
-  # Pattern:
-  print("Hello")
-      print("World")
-
-  # Matches any indentation:
-        print("Hello")
-    print("World")
-
-  # Also matches:
-  print("Hello")
-print("World")
-  ```
-
-### ExactContentNoComments Strategy
-- Ignores indentation, comments, and empty lines
-- Most flexible strategy
-- Perfect for matching code with varying comments/formatting
-- Example:
-  ```python
-  # Pattern:
-  print("Hello")  # greeting
-
-  print("World")  # message
-
-  # Matches all these variations:
-  def test():
-        print("Hello")   # different comment
-        # some comment
-        print("World")
-
-  # Or:
-  print("Hello")  # no comment
-  print("World")  # different note
-  ```
-
-### ExactContentNoCommentsFirstLinePartial Strategy
-- Matches first line partially, ignoring comments
-- Useful for finding code fragments or partial matches
-- Example:
-  ```python
-  # Pattern:
-  print("Hello")
-
-  # Matches partial content:
-  message = print("Hello") + "extra"
-  result = print("Hello, World")
-  ```
-
-### Strategy Selection and File Types
-
-Strategies are tried in the following order:
-1. ExactMatch
-2. IndentAware
-3. ExactContent
-4. ExactContentNoComments
-5. ExactContentNoCommentsFirstLinePartial
-
-File extension specific behavior:
-
-| File Type | Available Strategies |
-|-----------|---------------------|
-| Python (.py) | All strategies |
-| Java (.java) | All strategies |
-| JavaScript (.js) | All strategies |
-| TypeScript (.ts) | All strategies |
-| Other files | ExactMatch, ExactContent, ExactContentNoComments, ExactContentNoCommentsFirstLinePartial |
-
-The module automatically selects the appropriate strategies based on the file type and tries them in order until a match is found.
-
-## Debug Output
-
-When debugging failed searches, the module provides:
-- Visual whitespace markers (· for spaces, → for tabs)
-- Indentation analysis
-- Line-by-line matching attempts
-- Strategy selection information

janito/search_replace/__init__.py

@@ -1,7 +0,0 @@
-from .core import SearchReplacer, PatternNotFoundException
-from .searcher import Searcher
-from .replacer import Replacer
-from .parser import parse_test_file
-from .strategy_result import StrategyResult
-
-__all__ = ['SearchReplacer', 'PatternNotFoundException', 'Searcher', 'Replacer', 'parse_test_file', 'StrategyResult']

janito/search_replace/__main__.py

@@ -1,21 +0,0 @@
-"""Main entry point for search/replace module."""
-
-from pathlib import Path
-import sys
-import argparse
-from .play import play_file
-
-def main():
-    parser = argparse.ArgumentParser(description="Debug search/replace patterns")
-    parser.add_argument('file', type=Path, help='Test file to analyze')
-    
-    args = parser.parse_args()
-    
-    if not args.file.exists():
-        print(f"Error: Test file not found: {args.file}")
-        sys.exit(1)
-        
-    play_file(args.file)
-
-if __name__ == "__main__":
-    main()

janito/search_replace/core.py

@@ -1,120 +0,0 @@
-from typing import Optional, List
-from pathlib import Path
-import os
-from datetime import datetime
-from .logger import log_match, log_failure
-from .searcher import Searcher
-from .replacer import Replacer
-
-class PatternNotFoundException(Exception):
-    """Raised when the search pattern is not found in the source code."""
-    pass
-
-class SearchReplacer:
-    """Handles indentation-aware search and replace operations on Python source code."""
-
-    def __init__(self, source_code: str, search_pattern: str, replacement: Optional[str] = None, 
-                 file_ext: Optional[str] = None, debug: bool = False):
-        """Initialize with source code and patterns."""
-        self.source_code = source_code.rstrip()
-        self.search_pattern = search_pattern.rstrip()
-        self.replacement = replacement.rstrip() if replacement else None
-        self.file_ext = file_ext.lower() if file_ext else None
-        self.pattern_found = False
-        self.searcher = Searcher(debug=debug)
-        self.replacer = Replacer(debug=debug)
-
-        # Initialize pattern base indent
-        first_line, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-        self.pattern_base_indent = len(self.searcher.get_indentation(first_line)) if first_line else 0
-
-    def find_pattern(self) -> bool:
-        """Search for pattern with indentation awareness."""
-        try:
-            source_lines = self.source_code.splitlines()
-            search_first, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-            search_indent = self.searcher.get_indentation(search_first)
-            normalized_pattern = self.searcher.normalize_pattern(self.search_pattern, search_indent)
-            matches = self._find_matches(source_lines, normalized_pattern)
-            return bool(self.searcher._find_best_match_position(matches, source_lines, self.pattern_base_indent))
-        except Exception:
-            return False
-
-    def replace(self) -> str:
-        """Perform the search and replace operation."""
-        if self.replacement is None:
-            if not self.find_pattern():
-                raise PatternNotFoundException("Pattern not found")
-            return self.source_code
-
-        source_lines = self.source_code.splitlines()
-        search_first, _ = self.searcher.get_first_non_empty_line(self.search_pattern)
-        search_indent = self.searcher.get_indentation(search_first)
-        normalized_pattern = self.searcher.normalize_pattern(self.search_pattern, search_indent)
-
-        matches = self._find_matches(source_lines, normalized_pattern)
-        best_pos = self.searcher._find_best_match_position(matches, source_lines, self.pattern_base_indent)
-
-        if best_pos is None:
-            # Log failed match if not in debug mode
-            if not self.searcher.debug_mode:
-                log_failure(self.file_ext)
-            raise PatternNotFoundException("Pattern not found")
-
-        if self.searcher.debug_mode:
-            pattern_lines = len(normalized_pattern.splitlines())
-            replacement_lines = len(self.replacement.splitlines()) if self.replacement else 0
-            print(f"\n[DEBUG] Replacing {pattern_lines} lines with {replacement_lines} lines")
-            context_start = max(0, best_pos - 2)
-            context_end = min(len(source_lines), best_pos + len(normalized_pattern.splitlines()) + 2)
-            print("\n[DEBUG] Context before replacement:")
-            for i in range(context_start, context_end):
-                prefix = ">>> " if context_start <= i < best_pos + len(normalized_pattern.splitlines()) else "    "
-                print(f"[DEBUG] {prefix}Line {i + 1}: {source_lines[i]}")
-
-        result = self._apply_replacement(source_lines, best_pos, normalized_pattern)
-
-        if self.searcher.debug_mode:
-            print("\n[DEBUG] Context after replacement:")
-            result_lines = result.splitlines()
-            for i in range(context_start, context_end):
-                prefix = ">>> " if context_start <= i < best_pos + len(self.replacement.splitlines()) else "    "
-                print(f"[DEBUG] {prefix}Line {i + 1}: {result_lines[i]}")
-
-        return result
-
-    def _find_matches(self, source_lines, normalized_pattern):
-        """Find all possible matches in source."""
-        pattern_lines = normalized_pattern.splitlines()
-        return self.searcher._find_matches(source_lines, pattern_lines, self.file_ext)
-
-    def _apply_replacement(self, source_lines, match_pos, normalized_pattern):
-        """Apply replacement at the matched position."""
-        result_lines = []
-        i = 0
-        while i < len(source_lines):
-            if i == match_pos:
-                self.pattern_found = True
-                # Log successful match if not in debug mode
-                # get the 
-                if not self.searcher.debug_mode:
-                    log_match("Strategy", self.file_ext)
-                match_indent = self.searcher.get_indentation(source_lines[i])
-                replacement_lines = self.replacer.create_indented_replacement(
-                    match_indent, self.search_pattern, self.replacement
-                )
-                result_lines.extend(replacement_lines)
-                i += len(normalized_pattern.splitlines())
-            else:
-                result_lines.append(source_lines[i])
-                i += 1
-        return '\n'.join(result_lines)
-
-    def _try_match_at_position(self, pos, source_lines, normalized_pattern):
-        """Check if pattern matches at given position."""
-        pattern_lines = normalized_pattern.splitlines()
-        strategies = self.searcher.get_strategies(self.file_ext)
-        result = self.searcher.try_match_with_strategies(source_lines, pattern_lines, pos, strategies)
-        if result.success and not self.searcher.debug_mode:
-            log_match(result.strategy_name, self.file_ext)
-        return result.success

janito/search_replace/logger.py

@@ -1,35 +0,0 @@
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-# Configure logging
-logger = logging.getLogger("janito.search_replace")
-logger.setLevel(logging.INFO)
-
-# Create formatter
-formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
-
-# Create file handler
-def setup_file_handler():
-    """Setup file handler for logging if .janito directory exists"""
-    if Path(".janito").exists():
-        fh = logging.FileHandler(".janito/search_logs.txt")
-        fh.setFormatter(formatter)
-        logger.addHandler(fh)
-
-setup_file_handler()
-
-def log_match(strategy_name: str, file_type: Optional[str] = None):
-    """Log successful match with strategy info"""
-    msg = f"Match found using {strategy_name}"
-    if file_type:
-        msg += f" for file type {file_type}"
-    logger.info(msg)
-
-def log_failure(file_type: Optional[str] = None):
-    """Log failed match attempt"""
-    msg = "Failed to match pattern"
-    if file_type:
-        msg += f" for file type {file_type}"
-    logger.warning(msg)

janito/search_replace/parser.py

@@ -1,52 +0,0 @@
-from pathlib import Path
-from typing import List, Dict
-
-def parse_test_file(filepath: Path) -> List[Dict]:
-    """Parse a test file containing test cases. Replacement section is optional."""
-    test_cases = []
-    current_test = {}
-    current_section = None
-    current_content = []
-
-    try:
-        content = filepath.read_text()
-        lines = content.splitlines()
-
-        for line in lines:
-            if line.startswith("Test: "):
-                if current_test:
-                    if current_section and current_content:
-                        current_test[current_section] = "\n".join(current_content)
-                    test_cases.append(current_test)
-                current_test = {"name": line[6:].strip(), "expect_success": True}
-                current_section = None
-                current_content = []
-            elif line.startswith("Original:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "source"
-                current_content = []
-            elif line.startswith("Search pattern:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "search"
-                current_content = []
-            elif line.startswith("Replacement:"):
-                if current_section and current_content:
-                    current_test[current_section] = "\n".join(current_content)
-                current_section = "replacement"
-                current_content = []
-            elif not line.startswith("="):  # Skip separator lines
-                if current_section:
-                    current_content.append(line)
-
-        # Add last test case
-        if current_test:
-            if current_section and current_content:
-                current_test[current_section] = "\n".join(current_content)
-            test_cases.append(current_test)
-
-        return test_cases
-    except Exception as e:
-        print(f"Error parsing test file: {e}")
-        return []

janito/search_replace/play.py

@@ -1,61 +0,0 @@
-from pathlib import Path
-from typing import Optional
-from .parser import parse_test_file
-from .core import SearchReplacer
-import re
-
-def _extract_file_ext(test_info: str) -> Optional[str]:
-    """Extract file extension from test description."""
-    # Try to find filename or extension in the test info
-    ext_match = re.search(r'\.([a-zA-Z0-9]+)\b', test_info)
-    if (ext_match):
-        return f".{ext_match.group(1).lower()}"
-    
-    # Look for language mentions
-    lang_map = {
-        'python': '.py',
-        'javascript': '.js',
-        'typescript': '.ts',
-        'java': '.java'
-    }
-    
-    for lang, ext in lang_map.items():
-        if lang.lower() in test_info.lower():
-            return ext
-            
-    return None
-
-def play_file(filepath: Path):
-    """Play back a test file and show detailed debugging info."""
-    test_cases = parse_test_file(filepath)
-    
-    for test in test_cases:
-        print(f"\nTest: {test['name']}")
-        print("=" * 50)
-        
-        if 'source' not in test or 'search' not in test:
-            print("Invalid test case - missing source or search pattern")
-            continue
-            
-        file_ext = _extract_file_ext(test['name'])
-        print(f"\nFile type: {file_ext or 'unknown'}")
-        
-        replacer = SearchReplacer(
-            source_code=test['source'],
-            search_pattern=test['search'],
-            replacement=test.get('replacement'),
-            file_ext=file_ext,
-            debug=True
-        )
-        
-        try:
-            print("\nAttempting search/replace...")
-            result = replacer.replace()
-            print("\nResult:")
-            print("-" * 50)
-            print(result)
-            
-        except Exception as e:
-            print(f"\nError: {str(e)}")
-        
-        print("\n" + "="*50)

janito/search_replace/replacer.py

@@ -1,36 +0,0 @@
-from typing import List
-from .searcher import Searcher
-
-class Replacer:
-    """Handles replacement operations with proper indentation."""
-
-    def __init__(self, debug: bool = False):
-        """Initialize replacer with debug mode."""
-        self.searcher = Searcher(debug=debug)
-        self.debug_mode = debug
-
-    def create_indented_replacement(self, match_indent: str, search_pattern: str, replacement: str) -> List[str]:
-        """Create properly indented replacement lines."""
-        search_first, search_start_idx = self.searcher.get_first_non_empty_line(search_pattern)
-        replace_first, replace_start_idx = self.searcher.get_first_non_empty_line(replacement)
-
-        search_indent = self.searcher.get_indentation(search_first)
-        replace_indent = self.searcher.get_indentation(replace_first)
-
-        replace_lines = replacement.splitlines()
-        indented_replacement = []
-
-        # Calculate indentation shifts
-        context_shift = len(match_indent) - len(search_indent)
-        pattern_shift = len(replace_indent) - len(search_indent)
-
-        for i, line in enumerate(replace_lines):
-            if i < replace_start_idx or not line.strip():
-                indented_replacement.append('')
-            else:
-                line_indent = self.searcher.get_indentation(line)
-                rel_indent = len(line_indent) - len(replace_indent)
-                final_indent = ' ' * (len(match_indent) + rel_indent)
-                indented_replacement.append(final_indent + line.lstrip())
-
-        return indented_replacement