oscura 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

oscura/exporters/spice_export.py

@@ -1,210 +0,0 @@
-"""SPICE PWL export functionality for Oscura.
-
-This module provides export to SPICE Piece-Wise Linear (PWL) format for
-use in circuit simulation tools like LTspice, ngspice, Cadence, etc.
-
-
-Example:
-    >>> from oscura.exporters.spice_export import export_pwl
-    >>> export_pwl(trace, "stimulus.pwl")
-    >>> # Use in SPICE: V1 in 0 PWL file=stimulus.pwl
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-import numpy as np
-
-from oscura.core.types import DigitalTrace, WaveformTrace
-
-if TYPE_CHECKING:
-    from numpy.typing import NDArray
-
-
-def export_pwl(
-    data: WaveformTrace | DigitalTrace | NDArray[Any] | tuple[NDArray[Any], NDArray[Any]],
-    path: str | Path,
-    *,
-    time_scale: float = 1.0,
-    amplitude_scale: float = 1.0,
-    time_offset: float = 0.0,
-    amplitude_offset: float = 0.0,
-    precision: int = 12,
-    comment: str | None = None,
-    downsample: int = 1,
-    format_style: str = "ltspice",
-) -> None:
-    """Export data to SPICE PWL (Piece-Wise Linear) format.
-
-    Creates a PWL file that can be used as a stimulus source in SPICE
-    circuit simulators. The format consists of time-value pairs.
-
-    Args:
-        data: Data to export. Can be:
-            - WaveformTrace or DigitalTrace
-            - NumPy array (uses trace.time_vector or generates index-based time)
-            - Tuple of (time_array, value_array)
-        path: Output file path.
-        time_scale: Scaling factor for time values (e.g., 1e-9 for ns).
-        amplitude_scale: Scaling factor for amplitude values.
-        time_offset: Offset to add to all time values.
-        amplitude_offset: Offset to add to all amplitude values.
-        precision: Decimal precision for output values.
-        comment: Optional comment to include at top of file.
-        downsample: Downsample factor to reduce file size (1 = no downsampling).
-        format_style: Output format style:
-            - "ltspice": LTspice compatible (time value pairs)
-            - "ngspice": ngspice compatible (same as ltspice)
-            - "hspice": HSPICE compatible (with header)
-
-    Raises:
-        TypeError: If data type is not supported.
-
-    Example:
-        >>> # Export as stimulus for simulation
-        >>> export_pwl(trace, "input.pwl")
-        >>> # In LTspice: V1 in 0 PWL file=input.pwl
-
-        >>> # Scale time to nanoseconds for display
-        >>> export_pwl(trace, "input.pwl", time_scale=1e9)
-
-    References:
-        EXP-005
-    """
-    path = Path(path)
-
-    # Extract time and value arrays
-    if isinstance(data, WaveformTrace | DigitalTrace):
-        time = data.time_vector
-        values = data.data
-    elif isinstance(data, tuple) and len(data) == 2:
-        time, values = data
-    elif isinstance(data, np.ndarray):
-        # Generate time based on array index (assume 1 unit per sample)
-        time = np.arange(len(data), dtype=np.float64)
-        values = data
-    else:
-        raise TypeError(f"Unsupported data type: {type(data)}")
-
-    # Apply downsampling
-    if downsample > 1:
-        time = time[::downsample]
-        values = values[::downsample]
-
-    # Apply scaling and offset
-    time = time * time_scale + time_offset
-    values = values * amplitude_scale + amplitude_offset
-
-    # Write to file
-    with open(path, "w") as f:
-        # Write comment/header
-        if format_style == "hspice":
-            f.write("* HSPICE PWL Data\n")
-            if comment:
-                f.write(f"* {comment}\n")
-            f.write(f"* Points: {len(time)}\n")
-            f.write("*\n")
-        elif comment:
-            f.write(f"; {comment}\n")
-
-        # Write time-value pairs
-        fmt = f"{{:.{precision}g}} {{:.{precision}g}}\n"
-        f.writelines(fmt.format(t, v) for t, v in zip(time, values, strict=False))
-
-
-def export_pwl_multi(
-    traces: dict[str, WaveformTrace | DigitalTrace | NDArray[Any]],
-    path: str | Path,
-    *,
-    time_scale: float = 1.0,
-    amplitude_scale: float = 1.0,
-    precision: int = 12,
-    downsample: int = 1,
-) -> None:
-    """Export multiple traces to individual PWL files.
-
-    Creates separate PWL files for each trace in the dictionary,
-    with filenames based on the dictionary keys.
-
-    Args:
-        traces: Dictionary mapping signal names to trace data.
-        path: Output directory path.
-        time_scale: Scaling factor for time values.
-        amplitude_scale: Scaling factor for amplitude values.
-        precision: Decimal precision for output values.
-        downsample: Downsample factor to reduce file size.
-
-    Example:
-        >>> traces = {
-        ...     "clk": clock_trace,
-        ...     "data": data_trace,
-        ...     "reset": reset_trace,
-        ... }
-        >>> export_pwl_multi(traces, "stimuli/")
-        >>> # Creates: stimuli/clk.pwl, stimuli/data.pwl, stimuli/reset.pwl
-
-    References:
-        EXP-005
-    """
-    path = Path(path)
-    path.mkdir(parents=True, exist_ok=True)
-
-    for name, data in traces.items():
-        # Sanitize filename
-        safe_name = "".join(c if c.isalnum() or c in "_-" else "_" for c in name)
-        file_path = path / f"{safe_name}.pwl"
-
-        export_pwl(
-            data,
-            file_path,
-            time_scale=time_scale,
-            amplitude_scale=amplitude_scale,
-            precision=precision,
-            downsample=downsample,
-            comment=f"Signal: {name}",
-        )
-
-
-def generate_spice_source(
-    pwl_path: str | Path,
-    node_positive: str = "in",
-    node_negative: str = "0",
-    source_name: str = "V1",
-    source_type: str = "voltage",
-) -> str:
-    """Generate SPICE source definition for a PWL file.
-
-    Args:
-        pwl_path: Path to PWL file.
-        node_positive: Positive node name.
-        node_negative: Negative node name (usually "0" for ground).
-        source_name: Source instance name.
-        source_type: Source type ("voltage" or "current").
-
-    Returns:
-        SPICE source definition string.
-
-    Example:
-        >>> line = generate_spice_source("input.pwl", "in", "0", "V1")
-        >>> print(line)
-        V1 in 0 PWL file=input.pwl
-
-    References:
-        EXP-005
-    """
-    prefix = "V" if source_type == "voltage" else "I"
-
-    # Ensure source name starts with correct prefix
-    if not source_name.upper().startswith(prefix):
-        source_name = f"{prefix}{source_name}"
-
-    return f"{source_name} {node_positive} {node_negative} PWL file={pwl_path}"
-
-
-__all__ = [
-    "export_pwl",
-    "export_pwl_multi",
-    "generate_spice_source",
-]

oscura/exporters/vintage_logic_csv.py

@@ -1,247 +0,0 @@
-"""CSV export functions for vintage logic analysis results.
-
-This module provides specialized CSV exporters for vintage logic analysis data,
-including timing measurements, IC identification, and bill of materials.
-
-Example:
-    >>> from oscura.exporters.vintage_logic_csv import export_bom_csv
-    >>> export_bom_csv(result, "bom.csv")
-"""
-
-from __future__ import annotations
-
-import csv
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from oscura.analyzers.digital.vintage_result import VintageLogicAnalysisResult
-
-
-def export_timing_measurements_csv(
-    result: VintageLogicAnalysisResult,
-    path: str | Path,
-) -> None:
-    """Export timing measurements to CSV.
-
-    Creates a CSV file with columns: parameter, measured_value_ns, measurement_type.
-
-    Args:
-        result: Vintage logic analysis result.
-        path: Output CSV file path.
-
-    Example:
-        >>> export_timing_measurements_csv(result, "timing.csv")
-    """
-    path = Path(path)
-
-    with path.open("w", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-
-        # Write header
-        writer.writerow(["parameter", "measured_value_ns", "measurement_type"])
-
-        # Write timing measurements
-        for param_name, value in result.timing_measurements.items():
-            # Determine measurement type from parameter name
-            if "_t_pd" in param_name:
-                meas_type = "propagation_delay"
-            elif "_t_su" in param_name:
-                meas_type = "setup_time"
-            elif "_t_h" in param_name:
-                meas_type = "hold_time"
-            elif "_t_w" in param_name:
-                meas_type = "pulse_width"
-            else:
-                meas_type = "other"
-
-            writer.writerow([param_name, f"{value * 1e9:.3f}", meas_type])
-
-
-def export_ic_identification_csv(
-    result: VintageLogicAnalysisResult,
-    path: str | Path,
-) -> None:
-    """Export IC identification results to CSV.
-
-    Creates a CSV file with columns: ic_name, confidence, family, timing_params,
-    validation_status.
-
-    Args:
-        result: Vintage logic analysis result.
-        path: Output CSV file path.
-
-    Example:
-        >>> export_ic_identification_csv(result, "ic_identification.csv")
-    """
-    path = Path(path)
-
-    with path.open("w", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-
-        # Write header
-        writer.writerow(
-            [
-                "ic_name",
-                "confidence",
-                "family",
-                "t_pd_ns",
-                "t_su_ns",
-                "t_h_ns",
-                "t_w_ns",
-                "validation_status",
-            ]
-        )
-
-        # Write IC identification results
-        for ic_result in result.identified_ics:
-            # Extract timing parameters
-            t_pd = ic_result.timing_params.get("t_pd", 0) * 1e9
-            t_su = ic_result.timing_params.get("t_su", 0) * 1e9
-            t_h = ic_result.timing_params.get("t_h", 0) * 1e9
-            t_w = ic_result.timing_params.get("t_w", 0) * 1e9
-
-            # Determine validation status
-            validation_failed = any(v.get("passes") is False for v in ic_result.validation.values())
-            validation_status = "FAIL" if validation_failed else "PASS"
-
-            writer.writerow(
-                [
-                    ic_result.ic_name,
-                    f"{ic_result.confidence:.3f}",
-                    ic_result.family,
-                    f"{t_pd:.3f}" if t_pd > 0 else "",
-                    f"{t_su:.3f}" if t_su > 0 else "",
-                    f"{t_h:.3f}" if t_h > 0 else "",
-                    f"{t_w:.3f}" if t_w > 0 else "",
-                    validation_status,
-                ]
-            )
-
-
-def export_bom_csv(
-    result: VintageLogicAnalysisResult,
-    path: str | Path,
-) -> None:
-    """Export bill of materials to CSV.
-
-    Creates a CSV file compatible with spreadsheet programs and procurement systems.
-    Columns: part_number, description, quantity, category, notes.
-
-    Args:
-        result: Vintage logic analysis result.
-        path: Output CSV file path.
-
-    Example:
-        >>> export_bom_csv(result, "bom.csv")
-    """
-    path = Path(path)
-
-    with path.open("w", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-
-        # Write header
-        writer.writerow(["part_number", "description", "quantity", "category", "notes"])
-
-        # Write BOM entries
-        for entry in result.bom:
-            writer.writerow(
-                [
-                    entry.part_number,
-                    entry.description,
-                    entry.quantity,
-                    entry.category,
-                    entry.notes or "",
-                ]
-            )
-
-
-def export_voltage_levels_csv(
-    result: VintageLogicAnalysisResult,
-    path: str | Path,
-) -> None:
-    """Export voltage levels to CSV.
-
-    Creates a CSV file with measured voltage levels for the detected logic family.
-
-    Args:
-        result: Vintage logic analysis result.
-        path: Output CSV file path.
-
-    Example:
-        >>> export_voltage_levels_csv(result, "voltage_levels.csv")
-    """
-    path = Path(path)
-
-    with path.open("w", newline="") as csvfile:
-        writer = csv.writer(csvfile)
-
-        # Write header
-        writer.writerow(["parameter", "voltage_v", "logic_family"])
-
-        # Write voltage levels
-        for param, value in result.voltage_levels.items():
-            writer.writerow([param, f"{value:.3f}", result.detected_family])
-
-
-def export_all_vintage_logic_csv(
-    result: VintageLogicAnalysisResult,
-    output_dir: str | Path,
-    *,
-    prefix: str = "",
-) -> dict[str, Path]:
-    """Export all vintage logic analysis data to CSV files.
-
-    Convenience function that exports all data types to separate CSV files.
-
-    Args:
-        result: Vintage logic analysis result.
-        output_dir: Output directory for CSV files.
-        prefix: Optional prefix for file names.
-
-    Returns:
-        Dictionary mapping data type to output file path.
-
-    Example:
-        >>> paths = export_all_vintage_logic_csv(result, "./output", prefix="analysis_")
-        >>> print(paths["bom"])  # PosixPath('./output/analysis_bom.csv')
-    """
-    output_dir = Path(output_dir)
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    paths: dict[str, Path] = {}
-
-    # Export timing measurements
-    if result.timing_measurements:
-        timing_path = output_dir / f"{prefix}timing_measurements.csv"
-        export_timing_measurements_csv(result, timing_path)
-        paths["timing_measurements"] = timing_path
-
-    # Export IC identification
-    if result.identified_ics:
-        ic_path = output_dir / f"{prefix}ic_identification.csv"
-        export_ic_identification_csv(result, ic_path)
-        paths["ic_identification"] = ic_path
-
-    # Export BOM
-    if result.bom:
-        bom_path = output_dir / f"{prefix}bom.csv"
-        export_bom_csv(result, bom_path)
-        paths["bom"] = bom_path
-
-    # Export voltage levels
-    if result.voltage_levels:
-        voltage_path = output_dir / f"{prefix}voltage_levels.csv"
-        export_voltage_levels_csv(result, voltage_path)
-        paths["voltage_levels"] = voltage_path
-
-    return paths
-
-
-__all__ = [
-    "export_all_vintage_logic_csv",
-    "export_bom_csv",
-    "export_ic_identification_csv",
-    "export_timing_measurements_csv",
-    "export_voltage_levels_csv",
-]