spiceybun 0.1.0__tar.gz

spiceybun-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Filip Hormot
+
+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.

spiceybun-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: spiceybun
+Version: 0.1.0
+Summary: A python verification wrapper for SPICE.
+Author: Filip Hormot
+Author-email: Filip Hormot <f.hormot@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.5
+Requires-Dist: pandas>=3.0.3
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/fhormot/spiceybun
+Project-URL: Issues, https://github.com/fhormot/spiceybun/issues
+Description-Content-Type: text/markdown
+
+# SPICEybun
+
+An NGSPICE wrapper for simplified verification.
+
+# Usage
+
+```Python
+import spiceybun
+
+simulator = spiceybun.ngspice('./netlist.spice')
+
+simulator.add_transient(1e-6)
+
+simulator.save_signal('V(v_out)')
+simulator.save_signal('V(v_in)')
+
+simulator.run()
+
+```
+
+# Documentation
+TBD
+
+# Long term roadmap
+
+- [ ] Enabling basic functionality:
+    - [ ] All analysis statements
+    - [ ] Variables
+        - [x] Simple variables
+        - [ ] Equations
+        - [ ] Advanced variable features (distribution, limits, etc.)
+    - [ ] Measurements
+        - [x] Explicit spice input
+- [x] Sweeps
+- [x] Monte Carlo
+- [ ] Advanced features
+    - [ ] Netlist from XSchem
+    - [ ] Simulator options
+    - [ ] Report generation

spiceybun-0.1.0/README.md

@@ -0,0 +1,39 @@
+# SPICEybun
+
+An NGSPICE wrapper for simplified verification.
+
+# Usage
+
+```Python
+import spiceybun
+
+simulator = spiceybun.ngspice('./netlist.spice')
+
+simulator.add_transient(1e-6)
+
+simulator.save_signal('V(v_out)')
+simulator.save_signal('V(v_in)')
+
+simulator.run()
+
+```
+
+# Documentation
+TBD
+
+# Long term roadmap
+
+- [ ] Enabling basic functionality:
+    - [ ] All analysis statements
+    - [ ] Variables
+        - [x] Simple variables
+        - [ ] Equations
+        - [ ] Advanced variable features (distribution, limits, etc.)
+    - [ ] Measurements
+        - [x] Explicit spice input
+- [x] Sweeps
+- [x] Monte Carlo
+- [ ] Advanced features
+    - [ ] Netlist from XSchem
+    - [ ] Simulator options
+    - [ ] Report generation

spiceybun-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "spiceybun"
+version = "0.1.0"
+authors = [
+    { name="Filip Hormot", email="f.hormot@gmail.com" },
+]
+description = "A python verification wrapper for SPICE."
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "numpy>=2.4.5",
+    "pandas>=3.0.3",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[build-system]
+requires = ["uv_build>=0.11.14,<0.12"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.3",
+]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+
+[project.urls]
+Homepage = "https://github.com/fhormot/spiceybun"
+Issues = "https://github.com/fhormot/spiceybun/issues"

spiceybun-0.1.0/src/spiceybun/measure_ngspice.py

@@ -0,0 +1,38 @@
+import pandas as pd
+
+class Measure_ngspice():
+        def __init__(self):
+                self._measure = []
+
+        def get_all(self) -> list:
+                return self._measure
+        
+        def explicit(self, measure) -> str:
+                arguments = measure.split()
+
+                self._measure.append({
+                        "name": arguments[2],
+                        "analysis": arguments[1],
+                        "measure": measure
+                        })
+                
+                return measure
+        
+        def process_measure(self, path) -> object:
+                with open(path, 'r') as f:
+                        header = f.readline().strip().split()
+                        values = f.readline().strip().split()
+
+                # df = pd.read_csv(
+                #     path,    
+                #     delimiter=' ',
+                #     nrows=1,
+                #     skipinitialspace=True 
+                # )
+
+                # Extract header and first row
+                output = pd.DataFrame([values], columns=header)
+
+                output.to_csv(path, index=False, header=True)
+
+                return output

spiceybun-0.1.0/src/spiceybun/ngspice.py

@@ -0,0 +1,340 @@
+import enum
+import subprocess
+import os
+import re
+import pandas as pd
+from pathlib import Path
+
+from itertools import product
+
+from spiceybun.measure_ngspice import Measure_ngspice
+from spiceybun.variable import Variable
+
+class Ngspice:
+        def __init__(self, path_netlist, **kwargs):
+                self._netlist           = []
+
+                self._analysis          = []
+                self._variables         = []
+                self._plots             = []
+
+                # Control statements
+                self._plot_all          = False
+
+                self._path_netlist      = path_netlist
+
+                self._output_path       = Path(__file__).parent
+
+                self.measure            = Measure_ngspice()
+
+                # Preparation during init
+                self._read_dut_nelist()
+
+        def _read_dut_variables(self) -> None:
+                variables = []
+
+                for line in self._netlist_dut:
+                        result = re.findall(r'\{\w+\}', line)
+
+                        if len(result) > 0:
+                                variables.extend(result)
+
+                variables = list(set(variables))
+
+                for variable in variables:
+                        name = variable.strip('{}')
+                        self._variables.append(Variable(name))
+
+        def get_variables(self) -> list:
+                return self._variables
+
+        def set_variable(self, name, value) -> Variable | None:
+                for variable in self._variables:
+                        if variable.get_name() == name:
+                                variable.set_value(value)
+                                return variable
+
+                return None
+
+        def _read_dut_nelist(self) -> None:
+                with open(self._path_netlist, 'r') as f:
+                        self._netlist_dut = f.readlines()
+
+                # TODO: Strip existing control statements
+
+                # Extract variables
+                self._read_dut_variables()
+
+        def _include(self, path, **kwargs) -> str:
+                # str = f'.include "{path}"'
+                str = f'.include {path}'
+
+                if 'section' in kwargs:
+                        str = str + ' ' + kwargs['section']
+
+                self._netlist.append(str)
+
+                return str
+
+        def _write_netlist_dut(self, **kwargs) -> str:
+                subfolder = kwargs.get('id', '')
+
+                output_path = os.path.join(self._output_path, subfolder)
+                output_netlist = os.path.join(output_path, 'netlist.spice')
+
+                with open(output_netlist, 'w') as f:
+                        f.writelines(self._netlist_dut)
+                os.chmod(output_netlist, 0o755)
+
+                return output_netlist
+
+        def _write_netlist(self, **kwargs) -> str:
+                subfolder = kwargs.get('id', '')
+
+                self._add_control(**kwargs)
+
+                self._netlist.append('.end')
+
+                output_path = os.path.join(self._output_path, subfolder)
+                output_netlist = os.path.join(output_path, 'tb_test.spice')
+
+                with open(output_netlist, 'w') as f:
+                        f.write('\n'.join(self._netlist))
+                os.chmod(output_netlist, 0o755)
+
+                self._netlist_output = output_netlist
+
+                return output_netlist
+
+        def _write_run_command(self, **kwargs) -> str:
+                subfolder = kwargs.get('id', '')
+
+                folder_path = os.path.join(self._output_path, subfolder)
+
+                path_output_netlist = self._netlist_output
+
+                command_format = "#!/bin/bash\nngspice -i -o {output_path} {input_path} -a || sh"
+
+                command_path = os.path.join(folder_path, 'run_command')
+                output_path = os.path.join(folder_path, 'output.log')
+                input_path = path_output_netlist
+
+                netlist_command = command_format.format(
+                        output_path=output_path, 
+                        input_path=input_path
+                        )
+                
+                with open(command_path, 'w') as f:
+                        f.write(netlist_command)
+                os.chmod(command_path, 0o755)
+
+                return command_path
+
+        def _add_control(self, **kwargs) -> list:
+                # Kwargs
+                mc = kwargs.get('mc', False)
+
+                control_statement = []
+                control_statement.append('\n* Control statements added by the tool')
+
+                # Parameter definitions
+                variables = kwargs.get('variables', self._variables)
+                for variable in variables:
+                        control_statement.append(variable.get_value_definition())
+
+                if mc:
+                        seed = kwargs.get('seed', 1)
+                        mc_runs = kwargs.get('mc_runs', 350)
+
+                # Start of control statements
+                control_statement.append('\n.control')
+
+                # Section
+                # Measurement file preparation
+                control_statement.extend(self._netlist_define_measurement_setup())
+
+                # Section Monte Carlo
+                if mc:
+                        control_statement.append('\n\t* Monte Carlo analysis')
+                        control_statement.append(f'\tsetseed {seed}')
+                        control_statement.append(f'\tlet mc_runs={mc_runs}')
+                        control_statement.append('\tlet mc_index=0')
+
+                        control_statement.append('\n\twhile mc_index < mc_runs')
+
+                # Section
+                # Append analysis
+                for element in self._analysis:
+                        control_statement.append(f'\t\t{element}')
+
+                        suffix = element.split()[0]
+
+                # Section
+                # Save statements
+                # TODO: Wrap measurements and save statments with their respective analysis
+                control_statement.extend(self._netlist_define_plot(**kwargs))
+
+                # Measureement definition and write to file
+                control_statement.extend(self._netlist_define_measurement_write())
+
+                if mc:
+                        control_statement.append('\n\t\tlet mc_index = mc_index + 1')
+                        control_statement.append('\t\treset')
+
+                        control_statement.append('\n\t* End of Monte Carlo iteration')
+                        control_statement.append('\tend')
+
+                control_statement.append('\n\texit')
+                control_statement.append('.endc\n')
+
+                self._netlist.extend(control_statement)
+                return control_statement
+
+        def _netlist_define_plot(self, **kwargs) -> list:
+                control_statement = []
+
+                subfolder = kwargs.get('id', '')
+                output_path = os.path.join(self._output_path, subfolder, 'output.raw')
+
+                # Keep vector names in the header
+                control_statement.append('\n\t\tset wr_vecnames')
+                
+                # Use a single scale (column) for all signals
+                control_statement.append('\t\tset wr_singlescale')
+
+                if not self._plot_all:
+                        control_statement.append(f'\t\twrdata {output_path} {' '.join(self._plots)}')
+                else:
+                        control_statement.append('\t\tsave all')
+                        control_statement.append(f'\t\twrdata {output_path} all')
+
+                return control_statement
+
+        def _netlist_define_measurement_setup(self) -> list:
+                control_statement = []
+
+                measurements = self.measure.get_all()
+                if len(measurements)>0:
+                        control_statement.append('\t*Prepare measurement output file with a header')
+                        measurement_list = ' '.join([measure['name'] for measure in measurements])
+                        control_statement.append(f'\techo "{measurement_list}" > {os.path.join(self._output_path, "results", "measurements.raw\n")}')
+
+                return control_statement
+
+        def _netlist_define_measurement_write(self) -> list:
+                control_statement = []
+
+                control_statement.append('\n\t\t* Measurements')
+
+                measurements = self.measure.get_all()
+                for measure in measurements:
+                        control_statement.append(f'\t\t{measure["measure"]}')
+
+                if len(measurements) > 0:
+                        # control_statement.append('\n\t\tset filetype=ascii')
+                        # control_statement.append('\t\tset nopadding')
+
+                        # meas_string_list = ' '.join([measure['name'] for measure in measurements])
+                        # control_statement.append(f'\twrdata {os.path.join(self._output_path, "measurement.raw")} {meas_string_list}')
+
+                        control_statement.append('\n\t\t* Measurement output in separate files')
+                        measurement_list = ' '.join([f'$&{measure['name']}' for measure in measurements])
+                        control_statement.append(f'\t\techo "{measurement_list}" >> {os.path.join(self._output_path, "results", "measurements.raw")}')
+
+                return control_statement
+
+        def _run_single_run(self, **kwargs) -> str:
+                subfolder = kwargs.get('id', '')
+
+                output_path = os.path.join(self._output_path, subfolder)
+
+                # Verify the output folder exists
+                if not os.path.exists(output_path):
+                        os.makedirs(output_path)
+
+                # Verify that the results folder is available
+                if not os.path.exists(os.path.join(output_path, "results")):
+                        os.makedirs(os.path.join(output_path, "results"))
+
+                path_input_netlist = self._write_netlist_dut(**kwargs)
+
+                self._include(path_input_netlist)
+                path_output_netlist = self._write_netlist(**kwargs)
+
+                command_path = self._write_run_command(**kwargs)
+
+                output = subprocess.run(
+                        command_path, 
+                        # env=self.env, 
+                        shell=True, 
+                        capture_output=True, 
+                        text=True
+                )
+
+                run_path = os.path.join(output_path, 'run.log')
+
+                with open(run_path, 'w') as f:
+                        f.write(output.stdout)
+                os.chmod(command_path, 0o755)
+
+                # self.measure.process_measure(os.path.join(self._output_path, 'measurement.raw'))
+
+                return output.stdout
+
+        def _run_sweep(self, sweep_list, **kwargs) -> list:
+                results = []
+
+                for idx, run in enumerate(sweep_list):
+                        self._netlist = []
+                        results.append(self._run_single_run(variables=run, id=f'{idx}', **kwargs))
+
+                return results
+
+        def add_transient(self, t_stop, **kwargs) -> str:
+                # Overwrite previous transient statement if it exists
+                self._analysis = [x for x in self._analysis if not x.startswith("tran")]
+
+                # TODO: Calculate suggested/maximum steps
+                # Step 1: calculate based on stop time --> Bad for long sims with sharp transients
+                # Step 2: Find/assume fastest signal in netlist and adjust t_step accordingly
+                # --> Not accounting for fast digital signals 
+                # TODO: Define transient statement using variables
+                t_step = kwargs.get('t_step', 1e-9)
+                t_start = kwargs.get('t_start', '0')
+                t_max = kwargs.get('t_max', t_step*10)
+
+                transient_statement = f'tran {t_step} {t_stop} {t_start} {t_max}'
+
+                self._analysis.append(transient_statement)
+
+                return transient_statement
+
+        def save_signal(self, signals) -> list:
+                #TODO: Check if valid net/port
+                if type(signals) is list:
+                        self._plots.extend(signals)
+                else:
+                        self._plots.append(signals)
+
+                return self._plots
+
+        def save_signal_all(self, flag) -> bool:
+                self._plot_all = flag
+
+                return self._plot_all
+
+        def set_output_path(self, path) -> None:
+                self._output_path = path
+
+        def run(self, **kwargs) -> str | list:
+                if len(self._variables) == 0:
+                        return self._run_single_run(**kwargs)
+                
+                #Create all variation combinations
+                permutation_pre_list = [variable.get_split() for variable in self._variables]
+                permutations = list(product(*permutation_pre_list))
+
+                if len(permutations) == 1:
+                        return self._run_single_run(**kwargs)
+
+                return self._run_sweep(permutations, **kwargs)

spiceybun-0.1.0/src/spiceybun/tb_test.spice

@@ -0,0 +1,19 @@
+
+* Control statements added by the tool
+.param t_edge=
+.param c_load=
+.param v_vdd=
+
+.control
+		tran 1e-11  500e-9 0 100e-12
+
+		set wr_vecnames
+		set wr_singlescale
+		wrdata /home/fhormot/wk/xschem/spipy/src/spipy/output.raw 
+
+		* Measurements
+
+	exit
+.endc
+
+.end

spiceybun-0.1.0/src/spiceybun/variable.py

@@ -0,0 +1,32 @@
+import copy
+
+class Variable:
+        def __init__(self, name: str):
+                self._name = name
+                self._value = ''
+
+        def get_name(self) -> str:
+                return self._name
+        
+        def get_value(self) -> str:
+                return self._value
+        
+        def get_value_definition(self) -> str:
+                return f'.param {self._name}={self._value}'
+        
+        def set_value(self, value: str) -> None:
+                self._value = value
+
+        def get_split(self) -> list:
+                if not isinstance(self._value, list):
+                        return [self]
+
+                return_list = []
+
+                for idx, variable in enumerate(self.get_value()):
+                        object_copy = copy.deepcopy(self)
+
+                        object_copy.set_value(variable)
+                        return_list.append(object_copy)
+
+                return return_list