cicwave 0.5.0__py3-none-any.whl

cicwave/__init__.py

@@ -0,0 +1,25 @@
+"""
+cicwave - Advanced waveform viewer with PyQtGraph backend
+
+A standalone waveform viewer extracted from cicsim, focused on providing
+high-performance visualization of simulation data with PyQtGraph and Qt6.
+
+Supports multiple file formats:
+- ngspice .raw files
+- CSV, TSV, Excel 
+- Parquet, HDF5, Feather
+- VCD digital waveforms
+- LitePoint .iqvsa IQ capture files
+
+Features:
+- GPU-accelerated rendering with PyQtGraph
+- Multi-dimensional data pivoting
+- Session save/restore
+- Export to PDF/PNG/SVG
+- Digital waveform support
+- Engineering unit formatting
+"""
+
+__version__ = "1.0.0"
+__author__ = "Carsten Wulff"
+__email__ = "carsten@wulff.no"

cicwave/cli.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+######################################################################
+##        Copyright (c) 2020 Carsten Wulff Software, Norway
+## ###################################################################
+## Created       : wulff at 2020-10-23
+## ###################################################################
+##  The MIT License (MIT)
+##
+##  Permission is hereby granted, free of charge, to any person obtaining a copy
+##  of this software and associated documentation files (the "Software"), to deal
+##  in the Software without restriction, including without limitation the rights
+##  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+##  copies of the Software, and to permit persons to whom the Software is
+##  furnished to do so, subject to the following conditions:
+##
+##  The above copyright notice and this permission notice shall be included in all
+##  copies or substantial portions of the Software.
+##
+##  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+##  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+##  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+##  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+##  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+##  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+##  SOFTWARE.
+##
+######################################################################
+
+import os
+import sys
+import glob as _glob
+import click
+from .command import setup_logging
+
+
+def _resolve_wave_x_from_cli_env(cli_x):
+    """Apply --x, else CICWAVE_X environment variable."""
+    if cli_x:
+        return cli_x
+    v = os.environ.get("CICWAVE_X")
+    if v and str(v).strip():
+        return str(v).strip()
+    return None
+
+
+def _expand_glob_patterns(files, patterns):
+    """Merge positional ``files`` with files matched by --glob ``patterns``.
+
+    Each pattern is expanded with ``glob.glob(..., recursive=True)`` so that
+    ``**`` works. Order: positional first, then each pattern in order. Files
+    are de-duplicated while preserving first-seen order. Patterns that match
+    nothing are reported on stderr but not fatal.
+    """
+    out = []
+    seen = set()
+    for f in files:
+        if f not in seen:
+            seen.add(f)
+            out.append(f)
+    for pat in patterns or ():
+        matches = sorted(_glob.glob(pat, recursive=True))
+        if not matches:
+            print("warning: --glob '%s' matched no files" % pat,
+                  file=sys.stderr)
+            continue
+        for m in matches:
+            if m not in seen:
+                seen.add(m)
+                out.append(m)
+    return tuple(out)
+
+
+def _run_wave_pg(files, x, sheet, pivot_spec=None,
+                 pivot_info_flag=False, session_path=None, export_path=None):
+    """Run the PyQtGraph waveform viewer."""
+    x = _resolve_wave_x_from_cli_env(x)
+    
+    if pivot_spec:
+        from .pivot import load_spec, pivot_info, apply_pivot
+        from .wavefiles import WaveFile
+        spec = load_spec(pivot_spec)
+
+        if pivot_info_flag:
+            for f in files:
+                wf = WaveFile(f, x or "")
+                print("--- %s ---" % f)
+                print(pivot_info(wf.df, spec))
+                print()
+            return
+
+        if not x and spec.get('columns'):
+            x = spec['columns']
+
+    # Import the PyQtGraph backend
+    try:
+        from .wave_pg import CmdWavePg
+    except ImportError as e:
+        print("Error: PyQtGraph backend requires PySide6 and pyqtgraph")
+        print("Install with: pip install PySide6 pyqtgraph")
+        print(f"  ({e})")
+        sys.exit(1)
+    
+    c = CmdWavePg(x)
+
+    if session_path:
+        c.win.applySession(session_path)
+
+    if pivot_spec:
+        for f in files:
+            wf = WaveFile(f, x or "")
+            pivoted = apply_pivot(wf.df, spec)
+            name = "pivot(%s)" % os.path.basename(f)
+            c.openDataFrame(pivoted, name,
+                            pivot_spec_path=os.path.abspath(pivot_spec),
+                            original_path=os.path.abspath(f))
+    else:
+        for f in files:
+            c.openFile(f, sheet_name=sheet)
+
+    if export_path:
+        c.exportAndExit(export_path)
+    else:
+        c.run()
+
+
+@click.command()
+@click.argument("files", nargs=-1)
+@click.option("--glob", "globs", multiple=True,
+              help="Glob pattern (repeatable). Supports ** for recursion. "
+                   "Useful on shells like PowerShell that don't auto-expand.")
+@click.option("--x", default=None,
+              help="X-axis column; else CICWAVE_X; else saved default; else auto")
+@click.option("--sheet", default=None, help="Sheet name for Excel files (default: first sheet)")
+@click.option("--pivot", default=None, help="Pivot spec file (YAML/JSON)")
+@click.option("--pivot-info", is_flag=True, default=False, help="Print pivot dimensions and exit")
+@click.option("--session", default=None, help="Load session file (.cicwave.yaml)")
+@click.option("--export", default=None, help="Export plot to file (PDF/PNG/SVG) and exit")
+@click.option("--color/--no-color", default=True, help="Enable/Disable color output")
+@click.option("--debug", is_flag=True, default=False, help="Enable debug logging")
+def main(files, globs, x, sheet, pivot, pivot_info, session, export, color, debug):
+    """cicwave: Advanced waveform viewer with PyQtGraph backend.
+
+    A high-performance waveform viewer focused on PyQtGraph and Qt6 for
+    advanced visualization of simulation data.
+
+    Supports: .raw, .csv, .tsv, .xlsx, .json, .parquet, .feather, .h5,
+    .pkl, .vcd (digital), .iqvsa (LitePoint), and more.
+
+    \b
+    Pivot:
+      --pivot spec.yaml     Reshape data using pivot spec before viewing
+      --pivot-info          Print unique values per pivot dimension and exit
+
+    \b
+    Session:
+      --session plot.cicwave.yaml         Load saved session
+      --export plot.pdf                   Export to file and exit (no GUI)
+      --session s.yaml --export out.pdf   Restore session and export
+
+    \b
+    Globs:
+      --glob 'data/*.csv'             Repeatable, supports ** for recursion
+      --glob '**/*.raw'               Useful on PowerShell which doesn't
+                                       auto-expand patterns
+    """
+    # Set up logging
+    import logging
+    level = logging.DEBUG if debug else logging.INFO
+    setup_logging(color=color, level=level)
+    
+    files = _expand_glob_patterns(files, globs)
+    _run_wave_pg(files, x, sheet, pivot, pivot_info, session, export)
+
+
+if __name__ == "__main__":
+    main()

cicwave/command.py

@@ -0,0 +1,71 @@
+######################################################################
+##        Copyright (c) 2020 Carsten Wulff Software, Norway
+## ###################################################################
+## Created       : wulff at 2020-10-24
+## ###################################################################
+##  The MIT License (MIT)
+##
+##  Permission is hereby granted, free of charge, to any person obtaining a copy
+##  of this software and associated documentation files (the "Software"), to deal
+##  in the Software without restriction, including without limitation the rights
+##  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+##  copies of the Software, and to permit persons to whom the Software is
+##  furnished to do so, subject to the following conditions:
+##
+##  The above copyright notice and this permission notice shall be included in all
+##  copies or substantial portions of the Software.
+##
+##  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+##  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+##  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+##  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+##  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+##  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+##  SOFTWARE.
+##
+######################################################################
+
+import logging
+
+logger = logging.getLogger("cicwave")
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        logging.DEBUG: '\033[36m',
+        logging.INFO: '\033[32m',
+        logging.WARNING: '\033[93m',
+        logging.ERROR: '\033[31m',
+        logging.CRITICAL: '\033[31m',
+    }
+    RESET = '\033[0m'
+
+    def format(self, record):
+        msg = super().format(record)
+        color = self.COLORS.get(record.levelno, '')
+        return f"{color}{msg}{self.RESET}"
+
+
+def setup_logging(color=True, level=logging.INFO):
+    """Configure the cicwave logger with optional colored output."""
+    log = logging.getLogger("cicwave")
+    log.setLevel(level)
+    log.handlers.clear()
+
+    handler = logging.StreamHandler()
+    handler.setLevel(level)
+
+    if color:
+        formatter = ColoredFormatter("%(message)s")
+    else:
+        formatter = logging.Formatter("%(levelname)-7s | %(message)s")
+
+    handler.setFormatter(formatter)
+    log.addHandler(handler)
+
+
+class Command:
+    """Minimal base command class for cicwave."""
+    
+    def __init__(self):
+        pass

cicwave/ngraw.py

@@ -0,0 +1,105 @@
+# MIT license: https://opensource.org/licenses/MIT
+# See https://github.com/Isotel/mixedsim/blob/master/python/ngspice_read.py
+# for a more complete library. Isotel's version is GPL licensed
+from __future__ import division
+#import division
+import numpy as np
+import pandas as pd
+BSIZE_SP = 512 # Max size of a line of data; we don't want to read the
+               # whole file to find a line, in case file does not have
+               # expected structure.
+MDATA_LIST = [b'title', b'date', b'plotname', b'flags', b'no. variables',
+              b'no. points', b'dimensions', b'command', b'option']
+def ngRawRead(fname: str):
+    """Read ngspice binary raw files. Return tuple of the data, and the
+    plot metadata. The dtype of the data contains field names. This is
+    not very robust yet, and only supports ngspice.
+    >>> darr, mdata = rawread('test.py')
+    >>> darr.dtype.names
+    >>> plot(np.real(darr['frequency']), np.abs(darr['v(out)']))
+    """
+    # Example header of raw file
+    # Title: rc band pass example circuit
+    # Date: Sun Feb 21 11:29:14  2016
+    # Plotname: AC Analysis
+    # Flags: complex
+    # No. Variables: 3
+    # No. Points: 41
+    # Variables:
+    #         0       frequency       frequency       grid=3
+    #         1       v(out)  voltage
+    #         2       v(in)   voltage
+    # Binary:
+    with open(fname, 'rb') as fp:
+        plot = {}
+        arrs = []
+        plots = []
+        names = dict()
+        ind = 0
+        while (True):
+            mdata = fp.readline(BSIZE_SP).split(b':', maxsplit=1)
+            if len(mdata) == 2:
+                if mdata[0].lower() in MDATA_LIST:
+                    plot[mdata[0].lower()] = mdata[1].strip()
+                if mdata[0].lower() == b'variables':
+                    nvars = int(plot[b'no. variables'])
+                    npoints = int(plot[b'no. points'])
+                    plot['varnames'] = []
+                    plot['varunits'] = []
+                    for varn in range(nvars):
+
+                        varspec = (fp.readline(BSIZE_SP).strip()
+                                   .decode('ascii').split())
+                        if varn != int(varspec[0]):
+                            raise ValueError(f"Variable index mismatch in {fname}: expected {varn}, got {varspec[0]}")
+
+                        #- Skip duplicated variables
+                        if(varspec[1] not in names):
+                            names[varspec[1]] = 1
+                        else:
+                            varspec[1] += str(ind)
+                            ind +=1
+                        plot['varnames'].append(varspec[1])
+                        plot['varunits'].append(varspec[2])
+                if mdata[0].lower() == b'binary':
+                    rowdtype = np.dtype({'names': plot['varnames'],
+                                         'formats': [np.complex128 if b'complex'
+                                                     in plot[b'flags']
+                                                     else np.float64]*nvars})
+                    arrs.append(np.fromfile(fp, dtype=rowdtype, count=npoints))
+                    plots.append(plot)
+                    fp.readline()
+            else:
+                break
+
+    return (arrs, plots)
+
+def toDataFrames(ngarr):
+    (arrs,plots) = ngarr
+
+    dfs = list()
+    for i in range(0,len(plots)):
+        df = pd.DataFrame(data=arrs[i],columns=plots[i]['varnames'])
+        dfs.append(df)
+    return dfs
+
+def toDataFrame(fraw):
+    (arrs,plots) = ngRawRead(fraw)
+
+    dfs = list()
+    for i in range(0,len(plots)):
+        df = pd.DataFrame(data=arrs[i],columns=plots[i]['varnames'])
+        dfs.append(df)
+
+    if(len(dfs)> 0):
+        return dfs[0]
+    else:
+        return None
+
+
+
+
+
+if __name__ == '__main__':
+    arrs, plots = ngRawRead('test.raw')
+    print(arrs)

cicwave/pivot.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+
+"""
+Pivot spec loader for cicwave.
+
+A pivot spec (YAML or JSON) defines how to reshape a flat DataFrame
+into a wide format suitable for waveform plotting.
+
+Spec format::
+
+    index: Parameter       # split by — each unique value becomes a wave
+    columns: Frequency     # (optional) x-axis; rows with None/NaN dropped
+    values: Measurement    # y-axis values
+    conditions:            # further split waves by these; each unique combo
+      - Temp               # of (index x conditions) becomes its own wave
+      - Config
+    aliases:               # optional: short names for long condition values
+      Config:
+        c0: "LV"
+
+Use ``--pivot-info`` to discover the cN keys for each condition column.
+"""
+
+import json
+import yaml
+import pandas as pd
+
+
+def load_spec(path):
+    with open(path) as f:
+        if path.endswith('.json'):
+            return json.load(f)
+        return yaml.safe_load(f)
+
+
+def _is_json_kv_array(val):
+    if not isinstance(val, str):
+        return False
+    val = val.strip()
+    if not (val.startswith('[') and val.endswith(']')):
+        return False
+    try:
+        arr = json.loads(val)
+        return (isinstance(arr, list) and len(arr) > 0
+                and all(isinstance(d, dict) and 'value' in d for d in arr))
+    except (json.JSONDecodeError, TypeError):
+        return False
+
+
+def _is_kv_semicolon(val):
+    """Detect 'KEY=VAL;KEY=VAL;...' patterns."""
+    if not isinstance(val, str):
+        return False
+    parts = [p for p in val.strip().split(';') if p]
+    return len(parts) >= 2 and all('=' in p for p in parts)
+
+
+def _is_structured_value(val):
+    s = str(val)
+    return _is_json_kv_array(s) or _is_kv_semicolon(s)
+
+
+def _shorten_value(val):
+    """Auto-shorten a condition value for column names."""
+    try:
+        if isinstance(val, float) and val == int(val):
+            return str(int(val))
+    except (ValueError, OverflowError):
+        pass
+    s = str(val)
+    if _is_json_kv_array(s):
+        arr = json.loads(s)
+        return '_'.join(str(d.get('value', '')) for d in arr)
+    if _is_kv_semicolon(s):
+        parts = [p.split('=', 1)[1] for p in s.strip().split(';') if p and '=' in p]
+        return '_'.join(parts)
+    return s
+
+
+def _condition_prefix(name):
+    return name[0].upper()
+
+
+def _build_alias_map(unique_vals, aliases_section):
+    """Map cN keys to user-defined aliases, falling back to auto-shorten."""
+    indexed = {("c%d" % i): v for i, v in enumerate(unique_vals)}
+    result = {}
+    for ckey, orig_val in indexed.items():
+        if aliases_section and ckey in aliases_section:
+            result[orig_val] = str(aliases_section[ckey])
+        else:
+            result[orig_val] = _shorten_value(orig_val)
+    return result
+
+
+def pivot_info(df, spec):
+    """Return a human-readable summary of pivot dimensions and unique values."""
+    index_col = spec['index']
+    columns_col = spec.get('columns')
+    values_col = spec['values']
+    conditions = spec.get('conditions', [])
+
+    available = set(df.columns)
+    lines = []
+
+    lines.append("available columns: %s" % ', '.join(sorted(available)))
+    lines.append("")
+
+    if index_col in available:
+        lines.append("index: %s (%d unique)" % (index_col, df[index_col].nunique()))
+        for v in sorted(df[index_col].dropna().unique(), key=str):
+            lines.append("  %s" % v)
+    else:
+        lines.append("index: %s  ** NOT FOUND **" % index_col)
+
+    if columns_col:
+        lines.append("")
+        if columns_col in available:
+            lines.append("columns: %s (%d unique)" % (
+                columns_col, df[columns_col].nunique()))
+            for v in sorted(df[columns_col].unique(), key=lambda x: str(x)):
+                lines.append("  %s" % v)
+        else:
+            lines.append("columns: %s  ** NOT FOUND (will be skipped) **" % columns_col)
+
+    lines.append("")
+    if values_col in available:
+        lines.append("values: %s" % values_col)
+    else:
+        lines.append("values: %s  ** NOT FOUND **" % values_col)
+
+    if conditions:
+        lines.append("")
+        lines.append("conditions:")
+        json_cols = []
+        for cond in conditions:
+            unique_vals = sorted(df[cond].dropna().unique(), key=str)
+            lines.append("")
+            lines.append("  %s (%d unique)" % (cond, len(unique_vals)))
+            has_json = any(_is_structured_value(v) for v in unique_vals)
+            for i, v in enumerate(unique_vals):
+                if has_json:
+                    lines.append("    c%d: %s" % (i, _shorten_value(v)))
+                else:
+                    lines.append("    %s" % _shorten_value(v))
+            if has_json:
+                json_cols.append(cond)
+
+        if json_cols:
+            lines.append("")
+            lines.append("Suggested aliases for your pivot spec:")
+            lines.append("aliases:")
+            for cond in json_cols:
+                lines.append("  %s:" % cond)
+                unique_vals = sorted(df[cond].dropna().unique(), key=str)
+                for i, v in enumerate(unique_vals):
+                    short = _shorten_value(v)
+                    lines.append('    c%d: "%s"' % (i, short))
+
+    return "\n".join(lines)
+
+
+def apply_pivot(df, spec):
+    """Reshape *df* according to *spec*, return a wide DataFrame.
+
+    ``index`` values become wave names (one column per unique value).
+    ``columns`` (if present) becomes the x-axis — rows with None/NaN
+    in that column are dropped.  ``conditions`` further split waves so
+    each unique (index × conditions) combo is its own wave.
+    """
+    index_col = spec['index']
+    columns_col = spec.get('columns')
+    values_col = spec['values']
+    conditions = spec.get('conditions', [])
+    aliases = spec.get('aliases', {})
+
+    available = set(df.columns)
+    missing = []
+    if index_col not in available:
+        missing.append("index '%s'" % index_col)
+    if values_col not in available:
+        missing.append("values '%s'" % values_col)
+    for cond in conditions:
+        if cond not in available:
+            missing.append("condition '%s'" % cond)
+    if missing:
+        raise KeyError(
+            "Pivot spec references missing columns: %s\n"
+            "Available columns: %s" % (
+                ', '.join(missing), ', '.join(sorted(available))))
+
+    has_xaxis = columns_col and columns_col in available
+
+    alias_maps = {}
+    for cond in conditions:
+        unique_vals = sorted(df[cond].dropna().unique(), key=str)
+        alias_maps[cond] = _build_alias_map(unique_vals, aliases.get(cond))
+
+    keep = [index_col, values_col] + conditions
+    if has_xaxis:
+        keep.insert(1, columns_col)
+    sub = df[keep].copy()
+
+    if has_xaxis:
+        sub = sub.dropna(subset=[columns_col])
+
+    wave_col = sub[index_col].astype(str)
+    for cond in conditions:
+        amap = alias_maps.get(cond, {})
+        labels = sub[cond].map(
+            lambda v: amap.get(v, _shorten_value(v)))
+        wave_col = wave_col + '_' + _condition_prefix(cond) + labels.astype(str)
+    sub['_wave'] = wave_col
+
+    if has_xaxis:
+        result = sub.pivot_table(
+            index=columns_col,
+            columns='_wave',
+            values=values_col,
+            aggfunc='mean',
+        )
+        result.columns.name = None
+        result = result.reset_index()
+        # Try to make x-axis numeric
+        try:
+            result[columns_col] = pd.to_numeric(result[columns_col])
+            result = result.sort_values(columns_col)
+        except (ValueError, TypeError):
+            pass
+    else:
+        result = sub.pivot_table(
+            index='_wave',
+            columns=index_col,
+            values=values_col,
+            aggfunc='mean',
+        )
+        result.columns.name = None
+        result = result.reset_index().rename(columns={'_wave': 'condition'})
+
+    return result