oscura 0.5.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

oscura/{dsl → api/dsl}/commands.py

@@ -3,7 +3,6 @@
 Built-in command implementations for DSL.
 """
 
-import sys
 from pathlib import Path
 from typing import Any
 
@@ -27,33 +26,14 @@ def cmd_load(filename: str) -> Any:
     if not path.exists():
         raise OscuraError(f"File not found: {filename}")
 
-    # Determine loader based on extension
-    ext = path.suffix.lower()
-
+    # Use the unified loader
     try:
-        if ext == ".csv":
-            from oscura.loaders.csv import (  # type: ignore[import-not-found]
-                load_csv,  # type: ignore[import-not-found]
-            )
-
-            return load_csv(str(path))
-        elif ext == ".bin":
-            from oscura.loaders.binary import (  # type: ignore[import-not-found]
-                load_binary,  # type: ignore[import-not-found]
-            )
-
-            return load_binary(str(path))
-        elif ext in (".h5", ".hdf5"):
-            from oscura.loaders.hdf5 import (  # type: ignore[import-not-found]
-                load_hdf5,  # type: ignore[import-not-found]
-            )
-
-            return load_hdf5(str(path))
-        else:
-            raise OscuraError(f"Unsupported file format: {ext}")
+        from oscura.loaders import load
+
+        return load(str(path))
 
     except ImportError as e:
-        raise OscuraError(f"Loader not available for {ext}: {e}")  # noqa: B904
+        raise OscuraError(f"Loader not available: {e}")
 
 
 def cmd_filter(trace: Any, filter_type: str, *args: Any, **kwargs: Any) -> Any:
@@ -72,41 +52,41 @@ def cmd_filter(trace: Any, filter_type: str, *args: Any, **kwargs: Any) -> Any:
         OscuraError: If filter cannot be applied
     """
     try:
-        from oscura.filtering import filters  # type: ignore[attr-defined]
+        from oscura.utils import filtering
 
         if filter_type.lower() == "lowpass":
             if len(args) < 1:
                 raise OscuraError("lowpass filter requires cutoff frequency")
-            return filters.low_pass(trace, cutoff=args[0], **kwargs)
+            return filtering.low_pass(trace, cutoff=args[0], **kwargs)
 
         elif filter_type.lower() == "highpass":
             if len(args) < 1:
                 raise OscuraError("highpass filter requires cutoff frequency")
-            return filters.high_pass(trace, cutoff=args[0], **kwargs)
+            return filtering.high_pass(trace, cutoff=args[0], **kwargs)
 
         elif filter_type.lower() == "bandpass":
             if len(args) < 2:
                 raise OscuraError("bandpass filter requires low and high cutoff frequencies")
-            return filters.band_pass(trace, low=args[0], high=args[1], **kwargs)
+            return filtering.band_pass(trace, low=args[0], high=args[1], **kwargs)
 
         elif filter_type.lower() == "bandstop":
             if len(args) < 2:
                 raise OscuraError("bandstop filter requires low and high cutoff frequencies")
-            return filters.band_stop(trace, low=args[0], high=args[1], **kwargs)
+            return filtering.band_stop(trace, low=args[0], high=args[1], **kwargs)
 
         else:
             raise OscuraError(f"Unknown filter type: {filter_type}")
 
     except ImportError:
-        raise OscuraError("Filtering module not available")  # noqa: B904
+        raise OscuraError("Filtering module not available")
 
 
-def cmd_measure(trace: Any, *measurements: str) -> Any:
+def cmd_measure(trace: Any, *measurement_names: str) -> Any:
     """Measure properties of trace.
 
     Args:
         trace: Input trace
-        *measurements: Measurement names (rise_time, fall_time, etc.)
+        *measurement_names: Measurement names (rise_time, fall_time, etc.)
 
     Returns:
         Measurement results (single value or dict)
@@ -115,38 +95,36 @@ def cmd_measure(trace: Any, *measurements: str) -> Any:
         OscuraError: If measurement cannot be performed
     """
     try:
-        from oscura.analyzers import (  # type: ignore[attr-defined]
-            measurements as meas,  # type: ignore[attr-defined]
-        )
+        from oscura.analyzers import measurements
 
-        if len(measurements) == 0:
+        if len(measurement_names) == 0:
             raise OscuraError("measure command requires at least one measurement name")
 
         results = {}
 
-        for measurement in measurements:
-            meas_name = measurement.lower()
+        for measurement_name in measurement_names:
+            meas_name = measurement_name.lower()
 
             if meas_name == "rise_time":
-                results["rise_time"] = meas.rise_time(trace)
+                results["rise_time"] = measurements.rise_time(trace)
             elif meas_name == "fall_time":
-                results["fall_time"] = meas.fall_time(trace)
+                results["fall_time"] = measurements.fall_time(trace)
             elif meas_name == "period":
-                results["period"] = meas.period(trace)
+                results["period"] = measurements.period(trace)
             elif meas_name == "frequency":
-                results["frequency"] = meas.frequency(trace)
+                results["frequency"] = measurements.frequency(trace)
             elif meas_name == "amplitude":
-                results["amplitude"] = meas.amplitude(trace)
+                results["amplitude"] = measurements.amplitude(trace)
             elif meas_name == "mean":
-                results["mean"] = meas.mean(trace)
+                results["mean"] = measurements.mean(trace)
             elif meas_name == "rms":
-                results["rms"] = meas.rms(trace)
+                results["rms"] = measurements.rms(trace)
             elif meas_name == "all":
                 # Measure all available measurements
-                results = meas.measure_all(trace)
+                results = measurements.measure(trace, parameters=None)
                 break
             else:
-                raise OscuraError(f"Unknown measurement: {measurement}")
+                raise OscuraError(f"Unknown measurement: {measurement_name}")
 
         # Return single value if only one measurement
         if len(results) == 1:
@@ -155,7 +133,7 @@ def cmd_measure(trace: Any, *measurements: str) -> Any:
         return results
 
     except ImportError:
-        raise OscuraError("Measurements module not available")  # noqa: B904
+        raise OscuraError("Measurements module not available")
 
 
 def cmd_plot(trace: Any, **options: Any) -> None:
@@ -169,22 +147,23 @@ def cmd_plot(trace: Any, **options: Any) -> None:
         OscuraError: If plotting fails
     """
     try:
-        from oscura.visualization import (  # type: ignore[attr-defined]
-            plot as plot_module,  # type: ignore[attr-defined]
-        )
+        from oscura.visualization import plot
 
         title = options.get("title", "Trace Plot")
         annotate = options.get("annotate")
 
-        plot_module.plot_trace(trace, title=title)
+        plot.plot_trace(trace, title=title)
 
         if annotate:
-            plot_module.add_annotation(annotate)
+            plot.add_annotation(annotate)
+
+        # Import matplotlib.pyplot for show()
+        import matplotlib.pyplot as plt
 
-        plot_module.show()
+        plt.show()
 
     except ImportError:
-        raise OscuraError("Visualization module not available")  # noqa: B904
+        raise OscuraError("Visualization module not available")
 
 
 def cmd_export(data: Any, format_type: str, filename: str | None = None) -> None:
@@ -199,26 +178,14 @@ def cmd_export(data: Any, format_type: str, filename: str | None = None) -> None
         OscuraError: If export fails
     """
     try:
-        from oscura.exporters import exporters  # type: ignore[attr-defined]
-
-        if filename is None:
-            filename = f"export.{format_type}"
-
-        fmt = format_type.lower()
-
-        if fmt == "json":
-            exporters.json(data, filename)
-        elif fmt == "csv":
-            exporters.csv(data, filename)
-        elif fmt in ("h5", "hdf5"):
-            exporters.hdf5(data, filename)
-        else:
-            raise OscuraError(f"Unknown export format: {format_type}")
-
-        print(f"Exported to {filename}", file=sys.stderr)
-
+        # Export functionality has been redesigned
+        # Use oscura.export.* modules for protocol export
+        raise NotImplementedError(
+            "Data export has been redesigned. Use oscura.export.wireshark, "
+            "oscura.export.kaitai_struct, or oscura.export.scapy_layer for protocol exports."
+        )
     except ImportError:
-        raise OscuraError("Export module not available")  # noqa: B904
+        raise OscuraError("Export module not available")
 
 
 def cmd_glob(pattern: str) -> list[str]:
@@ -232,7 +199,7 @@ def cmd_glob(pattern: str) -> list[str]:
     """
     from glob import glob as glob_func
 
-    return list(glob_func(pattern))  # noqa: PTH207
+    return list(glob_func(pattern))
 
 
 # Command registry

oscura/{dsl → api/dsl}/interpreter.py

@@ -9,7 +9,7 @@ from collections.abc import Callable
 from pathlib import Path
 from typing import Any
 
-from oscura.dsl.parser import (
+from oscura.api.dsl.parser import (
     Assignment,
     Command,
     Expression,
@@ -75,9 +75,9 @@ class Interpreter:
             return load(str(path))
 
         except ImportError as e:
-            raise InterpreterError(f"oscura.loaders not available: {e}")  # noqa: B904
+            raise InterpreterError(f"oscura.loaders not available: {e}")
         except Exception as e:
-            raise InterpreterError(f"Failed to load {filename}: {e}")  # noqa: B904
+            raise InterpreterError(f"Failed to load {filename}: {e}")
 
     def _cmd_filter(self, trace: Any, *args: Any) -> Any:
         """Filter command: filter lowpass 1000."""
@@ -90,7 +90,7 @@ class Interpreter:
 
         # Import filter functions
         try:
-            from oscura import filtering
+            from oscura.utils import filtering
 
             # Note: bandpass and bandstop have different signatures (low, high)
             # but we treat them as Any -> Any for DSL simplicity
@@ -119,9 +119,9 @@ class Interpreter:
             return filter_func(trace, cutoff)
 
         except ImportError as e:
-            raise InterpreterError(f"oscura.filtering not available: {e}")  # noqa: B904
+            raise InterpreterError(f"oscura.filtering not available: {e}")
         except Exception as e:
-            raise InterpreterError(f"Filter failed: {e}")  # noqa: B904
+            raise InterpreterError(f"Filter failed: {e}")
 
     def _cmd_measure(self, trace: Any, *args: Any) -> Any:
         """Measure command: measure rise_time."""
@@ -161,11 +161,11 @@ class Interpreter:
             return measure_func(trace)
 
         except ImportError as e:
-            raise InterpreterError(f"oscura measurements not available: {e}")  # noqa: B904
+            raise InterpreterError(f"oscura measurements not available: {e}")
         except AttributeError as e:
-            raise InterpreterError(f"Measurement function not found: {e}")  # noqa: B904
+            raise InterpreterError(f"Measurement function not found: {e}")
         except Exception as e:
-            raise InterpreterError(f"Measurement failed: {e}")  # noqa: B904
+            raise InterpreterError(f"Measurement failed: {e}")
 
     def _cmd_plot(self, trace: Any, *args: Any) -> Any:
         """Plot command: plot."""
@@ -191,9 +191,9 @@ class Interpreter:
                 raise InterpreterError(f"Unknown plot type: {plot_type}. Available: waveform")
 
         except ImportError as e:
-            raise InterpreterError(f"oscura.visualization not available: {e}")  # noqa: B904
+            raise InterpreterError(f"oscura.visualization not available: {e}")
         except Exception as e:
-            raise InterpreterError(f"Plot failed: {e}")  # noqa: B904
+            raise InterpreterError(f"Plot failed: {e}")
 
     def _cmd_export(self, data: Any, *args: Any) -> Any:
         """Export command: export json "output.json"."""
@@ -211,37 +211,11 @@ class Interpreter:
             if not isinstance(filename, str):
                 raise InterpreterError("export filename must be a string")
 
-        # Import export functions
-        try:
-            from oscura.exporters import csv as csv_exporter
-            from oscura.exporters import json_export
-
-            export_map: dict[str, Any] = {
-                "csv": csv_exporter.export_csv,
-                "json": json_export.export_json,
-            }
-
-            if format_type not in export_map:
-                raise InterpreterError(
-                    f"Unknown export format: {format_type}. "
-                    f"Available: {', '.join(export_map.keys())}"
-                )
-
-            # Export data
-            export_func = export_map[format_type]
-            if filename:
-                export_func(data, filename)
-                return filename
-            else:
-                # Generate default filename
-                default_name = f"export.{format_type}"
-                export_func(data, default_name)
-                return default_name
-
-        except ImportError as e:
-            raise InterpreterError(f"oscura.export not available: {e}")  # noqa: B904
-        except Exception as e:
-            raise InterpreterError(f"Export failed: {e}")  # noqa: B904
+        # Export functionality has been redesigned
+        raise InterpreterError(
+            "Data export has been redesigned. Use oscura.export.wireshark, "
+            "oscura.export.kaitai_struct, or oscura.export.scapy_layer for protocol exports."
+        )
 
     def _cmd_glob(self, pattern: str) -> list[str]:
         """Glob command: glob("*.csv")."""
@@ -250,7 +224,7 @@ class Interpreter:
 
         from glob import glob as glob_func
 
-        return list(glob_func(pattern))  # noqa: PTH207
+        return list(glob_func(pattern))
 
     def eval_expression(self, expr: Expression) -> Any:
         """Evaluate an expression.
@@ -356,12 +330,15 @@ class Interpreter:
 
         return result
 
-    def eval_statement(self, stmt: Statement) -> None:
+    def eval_statement(self, stmt: Statement) -> Any:
         """Execute a statement.
 
         Args:
             stmt: Statement AST node
 
+        Returns:
+            Result of statement execution (None for Assignment and ForLoop, value for expressions)
+
         Raises:
             InterpreterError: On execution errors
         """
@@ -369,26 +346,24 @@ class Interpreter:
         if isinstance(stmt, Assignment):
             value = self.eval_expression(stmt.expression)
             self.variables[stmt.variable] = value
-            return
+            return None
 
         # For loop
         if isinstance(stmt, ForLoop):
             self.eval_for_loop(stmt)
-            return
+            return None
 
         # Expression statement (pipeline)
         if isinstance(stmt, Pipeline):
-            self.eval_pipeline(stmt)
-            return
+            return self.eval_pipeline(stmt)
 
         # Function call as statement (e.g., in for loop body: process($f))
         if isinstance(stmt, FunctionCall):
-            self.eval_function_call(stmt)
-            return
+            return self.eval_function_call(stmt)
 
         # All Statement types covered above (Assignment, ForLoop, Pipeline, FunctionCall)
         # This line is unreachable if type system is correct, but kept for runtime safety
-        raise InterpreterError(f"Unknown statement type: {type(stmt).__name__}")  # type: ignore[unreachable]
+        raise InterpreterError(f"Unknown statement type: {type(stmt).__name__}")
 
     def eval_for_loop(self, loop: ForLoop) -> None:
         """Execute for loop.

oscura/{dsl → api/dsl}/parser.py

@@ -61,7 +61,7 @@ class Lexer:
     Supports indentation-based block structure (Python-style).
     """
 
-    KEYWORDS = {  # noqa: RUF012
+    KEYWORDS = {
         "load": TokenType.LOAD,
         "filter": TokenType.FILTER,
         "measure": TokenType.MEASURE,
@@ -198,10 +198,12 @@ class Lexer:
     def read_identifier(self) -> str:
         """Read identifier or keyword."""
         chars = []
-        while self.current_char() and (self.current_char().isalnum() or self.current_char() in "_"):  # type: ignore[union-attr, operator, syntax, operator]
-            chars.append(self.current_char())
+        current = self.current_char()
+        while current and (current.isalnum() or current in "_"):
+            chars.append(current)
             self.advance()
-        return "".join(chars)  # type: ignore[arg-type]
+            current = self.current_char()
+        return "".join(chars)
 
     def read_variable(self) -> str:
         """Read variable name ($varname)."""
@@ -246,22 +248,8 @@ class Lexer:
             SyntaxError: On lexical errors
         """
         while self.pos < len(self.text):
-            # Handle indentation at line start
-            if self.at_line_start:
-                self.at_line_start = False
-                indent = self.measure_indent()
-
-                # Skip blank/comment lines
-                if indent == -1:
-                    self.skip_whitespace()
-                    self.skip_comment()
-                    if self.current_char() == "\n":
-                        self.advance()
-                        continue
-                    elif self.current_char() is None:
-                        break
-                else:
-                    self.emit_indent_tokens(indent)
+            if not self._process_line_start():
+                break
 
             self.skip_whitespace()
             self.skip_comment()
@@ -269,76 +257,118 @@ class Lexer:
             if not self.current_char():
                 break
 
-            line, col = self.line, self.column
-            char = self.current_char()
-
-            # Newline
-            if char == "\n":
-                self.tokens.append(Token(TokenType.NEWLINE, "\n", line, col))
-                self.advance()
-
-            # String
-            elif char in "\"'":  # type: ignore[operator]
-                value = self.read_string()
-                self.tokens.append(Token(TokenType.STRING, value, line, col))
+            self._process_token()
 
-            # Number
-            elif char.isdigit() or (  # type: ignore[union-attr]
-                char == "." and self.peek_char() and self.peek_char().isdigit()  # type: ignore[union-attr]
-            ):
-                value = self.read_number()  # type: ignore[assignment]
-                self.tokens.append(Token(TokenType.NUMBER, value, line, col))
-
-            # Variable
-            elif char == "$":
-                value = self.read_variable()
-                self.tokens.append(Token(TokenType.VARIABLE, value, line, col))
+        self._finalize_tokens()
+        return self.tokens
 
-            # Pipe
-            elif char == "|":
-                self.tokens.append(Token(TokenType.PIPE, "|", line, col))
-                self.advance()
+    def _process_line_start(self) -> bool:
+        """Process indentation at line start.
 
-            # Assignment
-            elif char == "=":
-                self.tokens.append(Token(TokenType.ASSIGN, "=", line, col))
-                self.advance()
+        Returns:
+            False if EOF reached, True otherwise.
+        """
+        if self.at_line_start:
+            self.at_line_start = False
+            indent = self.measure_indent()
 
-            # Comma
-            elif char == ",":
-                self.tokens.append(Token(TokenType.COMMA, ",", line, col))
-                self.advance()
+            if indent == -1:
+                return self._skip_blank_line()
+            else:
+                self.emit_indent_tokens(indent)
+        return True
 
-            # Colon
-            elif char == ":":
-                self.tokens.append(Token(TokenType.COLON, ":", line, col))
-                self.advance()
+    def _skip_blank_line(self) -> bool:
+        """Skip blank or comment-only line.
 
-            # Parentheses
-            elif char == "(":
-                self.tokens.append(Token(TokenType.LPAREN, "(", line, col))
-                self.advance()
-            elif char == ")":
-                self.tokens.append(Token(TokenType.RPAREN, ")", line, col))
-                self.advance()
+        Returns:
+            False if EOF, True otherwise.
+        """
+        self.skip_whitespace()
+        self.skip_comment()
+        if self.current_char() == "\n":
+            self.advance()
+            return True
+        return self.current_char() is not None
+
+    def _process_token(self) -> None:
+        """Process and emit next token."""
+        line, col = self.line, self.column
+        char = self.current_char()
+
+        if char == "\n":
+            self._emit_newline(line, col)
+        elif char in "\"'":  # type: ignore[operator]
+            self._emit_string(line, col)
+        elif self._is_number_start(char):
+            self._emit_number(line, col)
+        elif char == "$":
+            self._emit_variable(line, col)
+        elif self._is_single_char_token(char):
+            self._emit_single_char(char, line, col)
+        elif char.isalpha() or char == "_":  # type: ignore[union-attr]
+            self._emit_identifier(line, col)
+        else:
+            raise SyntaxError(f"Unexpected character '{char}' at line {line}, column {col}")
+
+    def _is_number_start(self, char: str | None) -> bool:
+        """Check if character starts a number."""
+        if not char:
+            return False
+        next_char = self.peek_char()
+        return char.isdigit() or (char == "." and next_char is not None and next_char.isdigit())
+
+    def _is_single_char_token(self, char: str | None) -> bool:
+        """Check if character is a single-character token."""
+        if char is None:
+            return False
+        return char in "|=,:()"
+
+    def _emit_newline(self, line: int, col: int) -> None:
+        """Emit newline token."""
+        self.tokens.append(Token(TokenType.NEWLINE, "\n", line, col))
+        self.advance()
 
-            # Identifier or keyword
-            elif char.isalpha() or char == "_":  # type: ignore[union-attr]
-                ident = self.read_identifier()
-                token_type = self.KEYWORDS.get(ident.lower(), TokenType.IDENTIFIER)
-                self.tokens.append(Token(token_type, ident, line, col))
+    def _emit_string(self, line: int, col: int) -> None:
+        """Emit string token."""
+        value = self.read_string()
+        self.tokens.append(Token(TokenType.STRING, value, line, col))
+
+    def _emit_number(self, line: int, col: int) -> None:
+        """Emit number token."""
+        value = self.read_number()
+        self.tokens.append(Token(TokenType.NUMBER, value, line, col))
+
+    def _emit_variable(self, line: int, col: int) -> None:
+        """Emit variable token."""
+        value = self.read_variable()
+        self.tokens.append(Token(TokenType.VARIABLE, value, line, col))
+
+    def _emit_single_char(self, char: str | None, line: int, col: int) -> None:
+        """Emit single-character token."""
+        token_map = {
+            "|": TokenType.PIPE,
+            "=": TokenType.ASSIGN,
+            ",": TokenType.COMMA,
+            ":": TokenType.COLON,
+            "(": TokenType.LPAREN,
+            ")": TokenType.RPAREN,
+        }
+        self.tokens.append(Token(token_map[char], char, line, col))  # type: ignore[index]
+        self.advance()
 
-            else:
-                raise SyntaxError(f"Unexpected character '{char}' at line {line}, column {col}")
+    def _emit_identifier(self, line: int, col: int) -> None:
+        """Emit identifier or keyword token."""
+        ident = self.read_identifier()
+        token_type = self.KEYWORDS.get(ident.lower(), TokenType.IDENTIFIER)
+        self.tokens.append(Token(token_type, ident, line, col))
 
-        # Emit remaining DEDENTs at end of file
+    def _finalize_tokens(self) -> None:
+        """Emit remaining DEDENT and EOF tokens."""
         while len(self.indent_stack) > 1:
             self.indent_stack.pop()
             self.tokens.append(Token(TokenType.DEDENT, 0, self.line, self.column))
-
-        # Add EOF token
         self.tokens.append(Token(TokenType.EOF, None, self.line, self.column))
-        return self.tokens
 
 
 @dataclass

oscura/{dsl → api/dsl}/repl.py

@@ -5,8 +5,8 @@ Interactive shell for Oscura DSL.
 
 import sys
 
-from oscura.dsl.interpreter import Interpreter, InterpreterError
-from oscura.dsl.parser import parse_dsl
+from oscura.api.dsl.interpreter import Interpreter, InterpreterError
+from oscura.api.dsl.parser import parse_dsl
 
 
 class REPL:

oscura/api/dsl.py

@@ -78,7 +78,7 @@ class DSLParser:
         API-010: Domain-Specific Language (DSL)
     """
 
-    OPERATIONS = {  # noqa: RUF012
+    OPERATIONS = {
         "load",
         "save",
         "export",

oscura/{integrations → api/integrations}/__init__.py

@@ -3,7 +3,7 @@
 Third-party and external system integrations.
 """
 
-from oscura.integrations.llm import (
+from oscura.api.integrations.llm import (
     AnalysisHook,
     CostTracker,
     FailoverLLMClient,