oscura 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

oscura/dsl/repl.py

@@ -0,0 +1,172 @@
+"""TraceKit DSL REPL (Read-Eval-Print Loop).
+
+Interactive shell for TraceKit DSL.
+"""
+
+import sys
+
+from oscura.dsl.interpreter import Interpreter, InterpreterError
+from oscura.dsl.parser import parse_dsl
+
+
+class REPL:
+    """Interactive DSL shell."""
+
+    def __init__(self) -> None:
+        """Initialize REPL with new interpreter."""
+        self.interpreter = Interpreter()
+        self.running = True
+
+    def print_banner(self) -> None:
+        """Print welcome banner."""
+        print("TraceKit DSL REPL v0.1.0")
+        print("Type 'exit' or 'quit' to exit, 'help' for help")
+        print()
+
+    def print_help(self) -> None:
+        """Print help message."""
+        print("TraceKit DSL Commands:")
+        print("  load <filename>                  - Load a trace file")
+        print("  filter <type> <params>           - Apply filter (lowpass, highpass, etc.)")
+        print("  measure <name>                   - Measure property (rise_time, etc.)")
+        print("  plot                             - Plot trace")
+        print("  export <format>                  - Export data (json, csv, hdf5)")
+        print("  glob(<pattern>)                  - Match files")
+        print()
+        print("Variables:")
+        print("  $name = expression               - Assign variable")
+        print("  $name                            - Reference variable")
+        print()
+        print("Pipelines:")
+        print("  expr | command | command         - Chain operations")
+        print()
+        print("Loops:")
+        print("  for $var in expr: statement      - Iterate")
+        print()
+        print("Special commands:")
+        print("  help                             - Show this help")
+        print("  vars                             - List variables")
+        print("  exit, quit                       - Exit REPL")
+        print()
+
+    def print_variables(self) -> None:
+        """Print current variables."""
+        if not self.interpreter.variables:
+            print("No variables defined")
+            return
+
+        print("Variables:")
+        for name, value in self.interpreter.variables.items():
+            # Truncate long values
+            str_value = str(value)
+            if len(str_value) > 60:
+                str_value = str_value[:57] + "..."
+            print(f"  {name} = {str_value}")
+
+    def read_input(self) -> str | None:
+        """Read input line from user.
+
+        Returns:
+            Input line or None on EOF
+        """
+        try:
+            return input("tk> ")
+        except EOFError:
+            return None
+
+    def eval_special_command(self, line: str) -> bool:
+        """Evaluate special REPL commands.
+
+        Args:
+            line: Input line
+
+        Returns:
+            True if special command was handled, False otherwise
+        """
+        line = line.strip()
+
+        if line in ("exit", "quit"):
+            self.running = False
+            return True
+
+        if line == "help":
+            self.print_help()
+            return True
+
+        if line == "vars":
+            self.print_variables()
+            return True
+
+        return False
+
+    def eval_line(self, line: str) -> None:
+        """Evaluate a single line of input.
+
+        Args:
+            line: Input line
+        """
+        line = line.strip()
+
+        # Skip empty lines
+        if not line:
+            return
+
+        # Skip comments
+        if line.startswith("#"):
+            return
+
+        # Check for special commands
+        if self.eval_special_command(line):
+            return
+
+        # Parse and execute
+        try:
+            ast = parse_dsl(line)
+            self.interpreter.execute(ast)
+
+            # Print result if expression statement (not assignment)
+            if ast and hasattr(ast[-1], "expression"):
+                # Assignment - don't print
+                pass
+            else:
+                # Expression - could print result
+                # For now, commands handle their own output
+                pass
+
+        except SyntaxError as e:
+            print(f"Syntax error: {e}", file=sys.stderr)
+
+        except InterpreterError as e:
+            print(f"Error: {e}", file=sys.stderr)
+
+        except Exception as e:
+            print(f"Unexpected error: {e}", file=sys.stderr)
+
+    def run(self) -> None:
+        """Run REPL loop."""
+        self.print_banner()
+
+        while self.running:
+            line = self.read_input()
+
+            if line is None:
+                # EOF
+                print()
+                break
+
+            self.eval_line(line)
+
+        print("Goodbye!")
+
+
+def start_repl() -> None:
+    """Start interactive REPL.
+
+    This is the main entry point for the DSL REPL.
+    """
+    repl = REPL()
+    repl.run()
+
+
+if __name__ == "__main__":
+    start_repl()

oscura/exceptions.py

@@ -0,0 +1,59 @@
+"""TraceKit exception hierarchy - DEPRECATED compatibility module.
+
+.. deprecated:: 1.0.0
+    This module is deprecated for backward compatibility only.
+    New code MUST import from `oscura.core.exceptions` directly.
+    This module will be removed in a future major version.
+
+This module re-exports exceptions from oscura.core.exceptions.
+The canonical location for all exception classes is `oscura.core.exceptions`.
+
+Why two files exist:
+    - `oscura/core/exceptions.py`: Canonical implementation of all exception classes
+    - `oscura/exceptions.py` (this file): Deprecated re-export for backward compatibility
+
+Migration guide:
+    Old (deprecated):
+        from oscura.exceptions import LoaderError
+
+    New (preferred):
+        from oscura.core.exceptions import LoaderError
+"""
+
+import warnings
+
+# Issue deprecation warning on import
+warnings.warn(
+    "oscura.exceptions is deprecated. "
+    "Import from oscura.core.exceptions instead. "
+    "This module will be removed in a future major version.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+# Re-export all exceptions from core.exceptions
+from oscura.core.exceptions import (  # noqa: E402
+    AnalysisError,
+    ConfigurationError,
+    ExportError,
+    FormatError,
+    InsufficientDataError,
+    LoaderError,
+    SampleRateError,
+    TraceKitError,
+    UnsupportedFormatError,
+    ValidationError,
+)
+
+__all__ = [
+    "AnalysisError",
+    "ConfigurationError",
+    "ExportError",
+    "FormatError",
+    "InsufficientDataError",
+    "LoaderError",
+    "SampleRateError",
+    "TraceKitError",
+    "UnsupportedFormatError",
+    "ValidationError",
+]

oscura/exploratory/__init__.py

@@ -0,0 +1,111 @@
+"""Exploratory analysis for unknown and legacy signals.
+
+This package provides tools for analyzing signals from unknown systems,
+legacy hardware, and corrupted or noisy data.
+
+- UNKNOWN-001: Binary Field Detection
+- UNKNOWN-002: Protocol Auto-Detection with Fuzzy Matching
+- UNKNOWN-003: Unknown Signal Characterization
+- UNKNOWN-004: Pattern Frequency Analysis
+- UNKNOWN-005: Reverse Engineering Workflow
+"""
+
+from oscura.exploratory.error_recovery import (
+    ErrorContext,
+    partial_decode,
+    recover_corrupted_data,
+    retry_with_adjustment,
+)
+from oscura.exploratory.fuzzy import (
+    fuzzy_pattern_match,
+    fuzzy_protocol_detect,
+    fuzzy_timing_match,
+)
+from oscura.exploratory.fuzzy_advanced import (
+    AlignmentResult,
+    PositionAnalysis,
+    VariantCharacterization,
+    align_sequences,
+    align_two_sequences,
+    characterize_variants,
+    compute_conservation_scores,
+)
+from oscura.exploratory.legacy import (
+    assess_signal_quality,
+    characterize_test_points,
+    cross_correlate_multi_reference,
+    detect_logic_families_multi_channel,
+)
+from oscura.exploratory.parse import (
+    DecodedFrame,
+    ErrorTolerance,
+    TimestampCorrection,
+    correct_timestamp_jitter,
+    decode_with_error_tolerance,
+)
+from oscura.exploratory.recovery import (
+    ErrorAnalysis,
+    ErrorPattern,
+    analyze_bit_errors,
+    generate_error_visualization_data,
+)
+from oscura.exploratory.sync import (
+    PacketParseResult,
+    RecoveryStrategy,
+    SyncMatch,
+    fuzzy_sync_search,
+    parse_variable_length_packets,
+)
+from oscura.exploratory.unknown import (
+    analyze_pattern_frequency,
+    characterize_unknown_signal,
+    detect_binary_fields,
+    reverse_engineer_protocol,
+)
+
+__all__ = [
+    # Advanced fuzzy (FUZZY-004, FUZZY-005)
+    "AlignmentResult",
+    "DecodedFrame",
+    "ErrorAnalysis",
+    # Error recovery
+    "ErrorContext",
+    # DAQ - Bit error analysis (DAQ-005)
+    "ErrorPattern",
+    # DAQ - Error-tolerant parsing (DAQ-003, DAQ-004)
+    "ErrorTolerance",
+    "PacketParseResult",
+    "PositionAnalysis",
+    "RecoveryStrategy",
+    # DAQ - Fuzzy sync search (DAQ-001, DAQ-002)
+    "SyncMatch",
+    "TimestampCorrection",
+    "VariantCharacterization",
+    "align_sequences",
+    "align_two_sequences",
+    "analyze_bit_errors",
+    # Unknown signal analysis
+    "analyze_pattern_frequency",
+    # Legacy analysis
+    "assess_signal_quality",
+    "characterize_test_points",
+    "characterize_unknown_signal",
+    "characterize_variants",
+    "compute_conservation_scores",
+    "correct_timestamp_jitter",
+    "cross_correlate_multi_reference",
+    "decode_with_error_tolerance",
+    "detect_binary_fields",
+    "detect_logic_families_multi_channel",
+    # Fuzzy matching
+    "fuzzy_pattern_match",
+    "fuzzy_protocol_detect",
+    "fuzzy_sync_search",
+    "fuzzy_timing_match",
+    "generate_error_visualization_data",
+    "parse_variable_length_packets",
+    "partial_decode",
+    "recover_corrupted_data",
+    "retry_with_adjustment",
+    "reverse_engineer_protocol",
+]