crackerjack 0.37.9__py3-none-any.whl → 0.45.2__py3-none-any.whl

crackerjack/services/patterns/utils.py

@@ -0,0 +1,339 @@
+"""Utility functions for regex pattern operations."""
+
+import re
+
+# Import for type checking - circular import avoided
+from typing import TYPE_CHECKING
+
+from .core import MAX_ITERATIONS, CompiledPatternCache, ValidatedPattern
+
+if TYPE_CHECKING:
+    pass  # SAFE_PATTERNS imported at runtime to avoid circular imports
+
+
+def validate_all_patterns() -> dict[str, bool]:
+    """Validate all patterns in the registry."""
+    from . import SAFE_PATTERNS
+
+    results: dict[str, bool] = {}
+    for name, pattern in SAFE_PATTERNS.items():
+        try:
+            pattern._validate()
+            results[name] = True
+        except ValueError as e:
+            results[name] = False
+            print(f"Pattern '{name}' failed validation: {e}")
+    return results
+
+
+def find_pattern_for_text(text: str) -> list[str]:
+    """Find all patterns that match the given text."""
+    from . import SAFE_PATTERNS
+
+    return [name for name, pattern in SAFE_PATTERNS.items() if pattern.test(text)]
+
+
+def apply_safe_replacement(text: str, pattern_name: str) -> str:
+    """Apply a named pattern to text."""
+    from . import SAFE_PATTERNS
+
+    if pattern_name not in SAFE_PATTERNS:
+        raise ValueError(f"Unknown pattern: {pattern_name}")
+
+    return SAFE_PATTERNS[pattern_name].apply(text)
+
+
+def get_pattern_description(pattern_name: str) -> str:
+    """Get description for a named pattern."""
+    from . import SAFE_PATTERNS
+
+    if pattern_name not in SAFE_PATTERNS:
+        return "Unknown pattern"
+
+    return SAFE_PATTERNS[pattern_name].description
+
+
+def fix_multi_word_hyphenation(text: str) -> str:
+    """Fix multi-word hyphenation iteratively."""
+    from . import SAFE_PATTERNS
+
+    return SAFE_PATTERNS["fix_spaced_hyphens"].apply_iteratively(text)
+
+
+def update_pyproject_version(content: str, new_version: str) -> str:
+    """Update version in pyproject.toml content."""
+    from . import SAFE_PATTERNS
+
+    pattern_obj = SAFE_PATTERNS["update_pyproject_version"]
+
+    temp_pattern = ValidatedPattern(
+        name="temp_version_update",
+        pattern=pattern_obj.pattern,
+        replacement=f"\\g<1>{new_version}\\g<3>",
+        description=f"Update version to {new_version}",
+        test_cases=[
+            ('version = "1.2.3"', f'version = "{new_version}"'),
+        ],
+    )
+
+    return re.compile(pattern_obj.pattern, re.MULTILINE).sub(
+        temp_pattern.replacement, content
+    )
+
+
+def apply_formatting_fixes(content: str) -> str:
+    """Apply common formatting fixes to content."""
+    from . import SAFE_PATTERNS
+
+    pattern = SAFE_PATTERNS["remove_trailing_whitespace"]
+    content = re.compile(pattern.pattern, re.MULTILINE).sub(
+        pattern.replacement, content
+    )
+
+    content = SAFE_PATTERNS["normalize_multiple_newlines"].apply(content)
+
+    return content
+
+
+def apply_security_fixes(content: str) -> str:
+    """Apply common security fixes to content."""
+    from . import SAFE_PATTERNS
+
+    content = SAFE_PATTERNS["fix_subprocess_run_shell"].apply(content)
+    content = SAFE_PATTERNS["fix_subprocess_call_shell"].apply(content)
+    content = SAFE_PATTERNS["fix_subprocess_popen_shell"].apply(content)
+
+    content = SAFE_PATTERNS["fix_unsafe_yaml_load"].apply(content)
+    content = SAFE_PATTERNS["fix_weak_md5_hash"].apply(content)
+    content = SAFE_PATTERNS["fix_weak_sha1_hash"].apply(content)
+    content = SAFE_PATTERNS["fix_insecure_random_choice"].apply(content)
+
+    content = SAFE_PATTERNS["remove_debug_prints_with_secrets"].apply(content)
+
+    return content
+
+
+def apply_test_fixes(content: str) -> str:
+    """Apply common test-related fixes to content."""
+    from . import SAFE_PATTERNS
+
+    return SAFE_PATTERNS["normalize_assert_statements"].apply(content)
+
+
+def is_valid_job_id(job_id: str) -> bool:
+    """Check if a job ID is valid."""
+    from . import SAFE_PATTERNS
+
+    return SAFE_PATTERNS["validate_job_id_alphanumeric"].test(job_id)
+
+
+def remove_coverage_fail_under(addopts: str) -> str:
+    """Remove --cov-fail-under from pytest addopts."""
+    from . import SAFE_PATTERNS
+
+    return SAFE_PATTERNS["remove_coverage_fail_under"].apply(addopts)
+
+
+def update_coverage_requirement(content: str, new_coverage: float) -> str:
+    """Update coverage requirement to a new value."""
+    from . import SAFE_PATTERNS
+
+    pattern_obj = SAFE_PATTERNS["update_coverage_requirement"]
+
+    temp_pattern = ValidatedPattern(
+        name="temp_coverage_update",
+        pattern=pattern_obj.pattern,
+        replacement=f"\\1{new_coverage: .0f}",
+        description=f"Update coverage to {new_coverage}",
+        test_cases=[
+            ("--cov-fail-under=85", f"--cov-fail-under={new_coverage: .0f}"),
+        ],
+    )
+
+    return re.compile(pattern_obj.pattern).sub(temp_pattern.replacement, content)
+
+
+def update_repo_revision(content: str, repo_url: str, new_revision: str) -> str:
+    """Update repository revision in content."""
+    escaped_url = re.escape(repo_url)
+    pattern = rf'("repo": "{escaped_url}".*?"rev": )"([^"]+)"'
+    replacement = rf'\1"{new_revision}"'
+
+    return re.compile(pattern, re.DOTALL).sub(replacement, content)
+
+
+def sanitize_internal_urls(text: str) -> str:
+    """Sanitize all internal URLs in text."""
+    from . import SAFE_PATTERNS
+
+    url_patterns = [
+        "sanitize_localhost_urls",
+        "sanitize_127_urls",
+        "sanitize_any_localhost_urls",
+        "sanitize_ws_localhost_urls",
+        "sanitize_ws_127_urls",
+        "sanitize_simple_localhost_urls",
+        "sanitize_simple_ws_localhost_urls",
+    ]
+
+    result = text
+    for pattern_name in url_patterns:
+        result = SAFE_PATTERNS[pattern_name].apply(result)
+
+    return result
+
+
+def apply_pattern_iteratively(
+    text: str, pattern_name: str, max_iterations: int = MAX_ITERATIONS
+) -> str:
+    """Apply a pattern iteratively until no more changes."""
+    from . import SAFE_PATTERNS
+
+    if pattern_name not in SAFE_PATTERNS:
+        raise ValueError(f"Unknown pattern: {pattern_name}")
+
+    return SAFE_PATTERNS[pattern_name].apply_iteratively(text, max_iterations)
+
+
+def get_all_pattern_stats() -> dict[str, dict[str, float] | dict[str, str]]:
+    """Get performance statistics for all patterns."""
+    from . import SAFE_PATTERNS
+
+    test_text = "python - m crackerjack - t with pytest - hypothesis - specialist"
+    stats: dict[str, dict[str, float] | dict[str, str]] = {}
+
+    for name, pattern in SAFE_PATTERNS.items():
+        try:
+            pattern_stats = pattern.get_performance_stats(test_text, iterations=10)
+            stats[name] = pattern_stats
+        except Exception as e:
+            stats[name] = {"error": str(e)}
+
+    return stats
+
+
+def clear_all_caches() -> None:
+    """Clear all pattern caches."""
+    CompiledPatternCache.clear_cache()
+
+
+def get_cache_info() -> dict[str, int | list[str]]:
+    """Get cache statistics."""
+    return CompiledPatternCache.get_cache_stats()
+
+
+def detect_path_traversal_patterns(path_str: str) -> list[str]:
+    """Detect path traversal patterns in a path string."""
+    from . import SAFE_PATTERNS
+
+    detected = []
+    traversal_patterns = [
+        "detect_directory_traversal_basic",
+        "detect_directory_traversal_backslash",
+        "detect_url_encoded_traversal",
+        "detect_double_url_encoded_traversal",
+    ]
+
+    for pattern_name in traversal_patterns:
+        pattern = SAFE_PATTERNS[pattern_name]
+        if pattern.test(path_str):
+            detected.append(pattern_name)
+
+    return detected
+
+
+def detect_null_byte_patterns(path_str: str) -> list[str]:
+    """Detect null byte patterns in a path string."""
+    from . import SAFE_PATTERNS
+
+    detected = []
+    null_patterns = [
+        "detect_null_bytes_url",
+        "detect_null_bytes_literal",
+        "detect_utf8_overlong_null",
+    ]
+
+    for pattern_name in null_patterns:
+        pattern = SAFE_PATTERNS[pattern_name]
+        if pattern.test(path_str):
+            detected.append(pattern_name)
+
+    return detected
+
+
+def detect_dangerous_directory_patterns(path_str: str) -> list[str]:
+    """Detect dangerous directory access patterns in a path string."""
+    from . import SAFE_PATTERNS
+
+    detected = []
+    dangerous_patterns = [
+        "detect_sys_directory_pattern",
+        "detect_proc_directory_pattern",
+        "detect_etc_directory_pattern",
+        "detect_boot_directory_pattern",
+        "detect_dev_directory_pattern",
+        "detect_root_directory_pattern",
+        "detect_var_log_directory_pattern",
+        "detect_bin_directory_pattern",
+        "detect_sbin_directory_pattern",
+    ]
+
+    for pattern_name in dangerous_patterns:
+        pattern = SAFE_PATTERNS[pattern_name]
+        if pattern.test(path_str):
+            detected.append(pattern_name)
+
+    return detected
+
+
+def detect_suspicious_path_patterns(path_str: str) -> list[str]:
+    """Detect suspicious path patterns in a path string."""
+    from . import SAFE_PATTERNS
+
+    detected = []
+    suspicious_patterns = [
+        "detect_parent_directory_in_path",
+        "detect_suspicious_temp_traversal",
+        "detect_suspicious_var_traversal",
+    ]
+
+    for pattern_name in suspicious_patterns:
+        pattern = SAFE_PATTERNS[pattern_name]
+        if pattern.test(path_str):
+            detected.append(pattern_name)
+
+    return detected
+
+
+def validate_path_security(path_str: str) -> dict[str, list[str]]:
+    """Validate path security by checking for various attack patterns."""
+    return {
+        "traversal_patterns": detect_path_traversal_patterns(path_str),
+        "null_bytes": detect_null_byte_patterns(path_str),
+        "dangerous_directories": detect_dangerous_directory_patterns(path_str),
+        "suspicious_patterns": detect_suspicious_path_patterns(path_str),
+    }
+
+
+class RegexPatternsService:
+    """Service class that implements RegexPatternsProtocol.
+
+    Wraps module-level regex pattern functions to provide a protocol-compliant interface.
+    """
+
+    def update_pyproject_version(self, content: str, new_version: str) -> str:
+        """Update version in pyproject.toml content."""
+        return update_pyproject_version(content, new_version)
+
+    def remove_coverage_fail_under(self, content: str) -> str:
+        """Remove --cov-fail-under from pytest addopts."""
+        return remove_coverage_fail_under(content)
+
+    def update_version_in_changelog(self, content: str, new_version: str) -> str:
+        """Update version in changelog content."""
+        # Placeholder implementation - can be enhanced later
+        return content
+
+    def mask_tokens_in_text(self, text: str) -> str:
+        """Mask sensitive tokens in text."""
+        return sanitize_internal_urls(text)

crackerjack/services/patterns/validation.py

@@ -0,0 +1,46 @@
+"""Input validation patterns."""
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "validate_env_var_name_format": ValidatedPattern(
+        name="validate_env_var_name_format",
+        pattern=r"^[A-Z_][A-Z0-9_]*$",
+        replacement="VALID_ENV_VAR_NAME",
+        description="Validate environment variable name format - uppercase letters, "
+        " numbers, underscores only, must start with letter or underscore",
+        test_cases=[
+            ("VALID_VAR", "VALID_ENV_VAR_NAME"),
+            ("_VALID_VAR", "VALID_ENV_VAR_NAME"),
+            ("API_KEY_123", "VALID_ENV_VAR_NAME"),
+            ("DATABASE_URL", "VALID_ENV_VAR_NAME"),
+            ("_PRIVATE_VAR", "VALID_ENV_VAR_NAME"),
+        ],
+    ),
+    "validate_job_id_alphanumeric": ValidatedPattern(
+        name="validate_job_id_alphanumeric",
+        pattern=r"^[a-zA-Z0-9_-]+$",
+        replacement="VALID",
+        description="Validate job ID contains only alphanumeric characters, "
+        "underscores, and hyphens",
+        test_cases=[
+            ("valid_job-123", "VALID"),
+            ("another_valid-job_456", "VALID"),
+            ("job_123", "VALID"),
+        ],
+    ),
+    "validate_job_id_format": ValidatedPattern(
+        name="validate_job_id_format",
+        pattern=r"^[a-zA-Z0-9\-_]+$",
+        replacement="VALID_JOB_ID",
+        description="Validate job ID format - alphanumeric with hyphens and"
+        " underscores only",
+        test_cases=[
+            ("valid_job-123", "VALID_JOB_ID"),
+            ("another-valid_job_456", "VALID_JOB_ID"),
+            ("job_123", "VALID_JOB_ID"),
+            ("UPPERCASE_JOB-ID", "VALID_JOB_ID"),
+            ("hyphen-underscore_combo", "VALID_JOB_ID"),
+        ],
+    ),
+}

crackerjack/services/patterns/versioning.py

@@ -0,0 +1,62 @@
+"""Version number extraction and update patterns."""
+
+import re
+
+from .core import ValidatedPattern
+
+PATTERNS: dict[str, ValidatedPattern] = {
+    "extract_version_numbers": ValidatedPattern(
+        name="extract_version_numbers",
+        pattern=r"version\s+(\d+\.\d+\.\d+)",
+        replacement=r"\1",
+        description="Extract semantic version numbers from 'version X.Y.Z' patterns",
+        flags=re.IGNORECASE,
+        test_cases=[
+            ("version 1.2.3", "1.2.3"),
+            ("Version 10.0.1", "10.0.1"),
+            ("current version 0.5.0", "current 0.5.0"),
+            ("VERSION 2.11.4", "2.11.4"),
+        ],
+    ),
+    "update_pyproject_version": ValidatedPattern(
+        name="update_pyproject_version",
+        pattern=r'^(version\s*=\s*["\'])([^"\']+)(["\'])$',
+        replacement=r"\g<1>NEW_VERSION\g<3>",
+        description="Update version in pyproject.toml files (NEW_VERSION placeholder"
+        " replaced dynamically)",
+        test_cases=[
+            ('version = "1.2.3"', 'version = "NEW_VERSION"'),
+            ("version='0.1.0'", "version='NEW_VERSION'"),
+            ('version="1.0.0-beta"', 'version="NEW_VERSION"'),
+            ("version = '2.1.0'", "version = 'NEW_VERSION'"),
+            ("version='10.20.30'", "version='NEW_VERSION'"),
+            ('name = "my-package"', 'name = "my-package"'),
+        ],
+    ),
+    "update_repo_revision": ValidatedPattern(
+        name="update_repo_revision",
+        pattern=r'("repo": "[^"]+?".*?"rev": )"([^"]+)"',
+        replacement=r'\1"NEW_REVISION"',
+        description="Update repository revision in config files (NEW_REVISION"
+        " placeholder replaced dynamically)",
+        flags=re.DOTALL,
+        test_cases=[
+            (
+                '"repo": "https: //github.com/user/repo".*"rev": "old_rev"',
+                '"repo": "https: //github.com/user/repo".*"rev": "NEW_REVISION"',
+            ),
+            (
+                '"repo": "git@github.com: user/repo.git", "branch": "main", "rev": '
+                '"abc123"',
+                '"repo": "git@github.com: user/repo.git", "branch": "main", "rev": '
+                '"NEW_REVISION"',
+            ),
+            (
+                '{"repo": "https: //example.com/repo", "description": "test", "rev": '
+                '"456def"}',
+                '{"repo": "https: //example.com/repo", "description": "test", "rev": '
+                '"NEW_REVISION"}',
+            ),
+        ],
+    ),
+}

crackerjack/services/predictive_analytics.py

@@ -8,9 +8,18 @@ from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
 
+if t.TYPE_CHECKING:
+    pass
+
 logger = logging.getLogger(__name__)
 
 
+if t.TYPE_CHECKING:
+
+    class PredictorProtocol(t.Protocol):
+        def predict(self, values: list[float], periods: int = 1) -> list[float]: ...
+
+
 @dataclass
 class TrendAnalysis:
     """Trend analysis result for a metric."""
@@ -141,7 +150,7 @@ class PredictiveAnalyticsEngine:
         )
 
         # Predictors
-        self.predictors = {
+        self.predictors: dict[str, t.Any] = {  # type: ignore[var-annotated]
             "moving_average": MovingAveragePredictor(window_size=10),
             "linear_trend": LinearTrendPredictor(),
             "seasonal": SeasonalPredictor(season_length=24),
@@ -205,9 +214,11 @@ class PredictiveAnalyticsEngine:
         # Generate predictions
         config = self.metric_configs.get(metric_type, {})
         predictor_name = config.get("predictor", "moving_average")
-        predictor = self.predictors[predictor_name]
+        predictor = self.predictors[t.cast(str, predictor_name)]  # type: ignore[index]
 
-        predicted_values = predictor.predict(values, periods=24)  # 24 periods ahead
+        predicted_values = t.cast(t.Any, predictor).predict(
+            values, periods=24
+        )  # 24 periods ahead  # type: ignore[union-attr]
         confidence_intervals = self._calculate_confidence_intervals(
             values, predicted_values
         )
@@ -304,10 +315,10 @@ class PredictiveAnalyticsEngine:
         # Select predictor
         if predictor_name is None:
             config = self.metric_configs.get(metric_type, {})
-            predictor_name = t.cast(str, config.get("predictor", "moving_average"))
+            predictor_name = t.cast(str, config.get("predictor", "moving_average"))  # type: ignore[redundant-cast]
 
-        predictor = self.predictors[predictor_name]
-        predicted_values = predictor.predict(values, periods_ahead)
+        predictor = self.predictors[t.cast(str, predictor_name)]  # type: ignore[index]
+        predicted_values = t.cast(t.Any, predictor).predict(values, periods_ahead)  # type: ignore[union-attr]
 
         # Calculate confidence intervals
         confidence_intervals = self._calculate_confidence_intervals(
@@ -357,8 +368,10 @@ class PredictiveAnalyticsEngine:
             return 0.5
 
         # Generate predictions for validation period
-        predictor = self.predictors[predictor_name]
-        predictions = predictor.predict(train_data, periods=len(validation_data))
+        predictor = self.predictors[t.cast(str, predictor_name)]  # type: ignore[index]
+        predictions = t.cast(t.Any, predictor).predict(
+            train_data, periods=len(validation_data)
+        )  # type: ignore[union-attr]
 
         # Calculate accuracy (inverse of mean absolute error)
         mae = statistics.mean(