Update binidngs for new eisgenerator, add __repr__ methods

CMakeLists.txt

-cmake_minimum_required(VERSION 3.15...3.22)
+cmake_minimum_required(VERSION 3.22)
 
-project(eisgeneratorpy VERSION "1.0")
+project(eisgenerator VERSION "1.0")
 
 if(SKBUILD)
   # Scikit-Build does not add your site-packages to the search path

example/example.py

 #!/bin/python
 
-import eisgeneratorpy as eis
+import eisgenerator as eis
 
-def printData(data):
-	print('Omega, Re, Im')
-	for i in data:
-		print(f'{i.omega},{i.im.real},{i.im.imag}')
+model = eis.Model("c{1e-6}r{1e3}")
+print(f"model: {model}")
 
-model = eis.Model("C{1e-6}R{1e3}")
-
-eis.Log.level = eis.Log.level.DEBUG
+eis.Log.level = eis.Log.level.WARN
 print(f'set log level: {eis.Log.level}')
 
 with eis.ostream_redirect(stdout=True, stderr=True):
 	data = model.execute(1e6)
-print(data.im)
+print(f"data for omega={data.omega}: {data}")
 
-ranges = list([])
-neededParameters = model.getFlatParametersCount()
-for i in range(neededParameters):
-	ranges.append(eis.Range(1, 1000, 1000, True))
+model = eis.Model("c{1e-6~1e-5}r{1e3~1e4}")
 
 omegaRange = eis.Range(1, 1000, 25, True)
 
-print('Ranges:')
-for eisRange in ranges:
-	print(f'{eisRange.start} {eisRange.end} {eisRange.count}')
-
-neededIterations = model.getRequiredStepsForSweeps(list(ranges))
+neededIterations = model.getRequiredStepsForSweeps()
 print(f'will need {neededIterations} iterations')
-for i in range(neededIterations):
-	#print(f'Spectra {i}:')
-	sweep = model.executeParamByIndex(ranges, omegaRange, i)
-	#printData(sweep)
+sweeps = model.executeAllSweeps(omegaRange)
+
+spectra = eis.EisSpectra()
+spectra.data = sweeps[200]
+spectra.model = model.getModelStrWithParam(200)
+
+print(spectra)

setup.py

@@ -13,14 +13,14 @@ except ImportError:
 from setuptools import find_packages
 
 setup(
-    name="eisgeneratorpy",
-    version="0.0.1",
-    description="a minimal example package (with pybind11)",
-    author="Henry Schreiner",
-    license="MIT",
+    name="eisgenerator",
+    version="1.0.0",
+    description="",
+    author="Carl Philipp Klemm",
+    license="LGPL-3.0",
     packages=find_packages(where="src"),
     package_dir={"": "src"},
-    cmake_install_dir="src/eisgeneratorpy",
+    cmake_install_dir="src/eisgenerator",
     include_package_data=True,
-    python_requires=">=3.6",
+    python_requires=">=3.8",
 )

src/eisgeneratorpy/__init__.py → src/eisgenerator/__init__.py

-from ._core import __doc__, __version__, Model, DataPoint, Range, Log, ostream_redirect
+from ._core import __doc__, __version__, Model, DataPoint, Range, Log, ParseError, FileError, eisDistance, EisSpectra, eisNyquistDistance, ostream_redirect

src/main.cpp

@@ -8,23 +8,58 @@
 #include <eisgenerator/eistype.h>
 #include <eisgenerator/log.h>
 #include <vector>
+#include <sstream>
 
 namespace py = pybind11;
 
 using namespace eis;
 
+std::string reprEisSpectra(const EisSpectra& spectra)
+{
+	std::stringstream ss;
+	spectra.saveToStream(ss);
+	return ss.str();
+}
+
+std::string reprDataPoint(const DataPoint& dp)
+{
+	std::stringstream ss;
+	ss<<std::scientific;
+	ss<<'('<<dp.im.real()<<'+'<<dp.im.imag()<<"j)";
+	return ss.str();
+}
+
 PYBIND11_MODULE(_core, m)
 {
 	py::class_<Model>(m, "Model")
-		.def(py::init<const std::string&>())
-		.def("execute", &Model::execute)
-		.def("executeSweep", &Model::executeSweep)
-		.def("executeParamByIndex", &Model::executeParamByIndex)
-		.def_static("getRequiredStepsForSweeps", &Model::getRequiredStepsForSweeps)
-		.def("getFlatParametersCount", &Model::getFlatParametersCount);
+		.def(py::init<const std::string&, size_t, bool>(),
+			 py::arg("str"), py::arg("paramSweepCount") = 100, py::arg("defaultToRange") = false)
+		.def("execute", &Model::execute, py::arg("omaga"), py::arg("omaga") = 0)
+		.def("executeSweep", static_cast<std::vector<DataPoint> (Model::*)(const std::vector<fvalue>&, size_t)>(&Model::executeSweep),
+			 py::arg("omega"), py::arg("index") = 0)
+		.def("executeAllSweeps", &Model::executeAllSweeps)
+		.def("getModelStr", &Model::getModelStr)
+		.def("getModelStrWithParam", static_cast<std::string (Model::*)(size_t)>(&Model::getModelStrWithParam),
+			 py::arg("index") = 0)
+		.def("getUuid", &Model::getUuid)
+		.def("compile", &Model::compile)
+		.def("isReady", &Model::isReady)
+		.def("resolveSteps", &Model::resolveSteps)
+		.def("getRequiredStepsForSweeps", &Model::getRequiredStepsForSweeps)
+		.def("getCppCode", &Model::getCode)
+		.def("getTorchScript", &Model::getTorchScript)
+		.def("getCompiledFunctionName", &Model::getCompiledFunctionName)
+		.def("__repr__", &Model::getModelStr);
 	py::class_<DataPoint>(m, "DataPoint")
+		.def(py::init<std::complex<fvalue>, fvalue>(), py::arg("im") = std::complex<fvalue>(0, 0), py::arg("omega") = 100)
 		.def_readwrite("omega", &DataPoint::omega)
-		.def_readwrite("im", &DataPoint::im);
+		.def_readwrite("im", &DataPoint::im)
+		.def("__gt__", &DataPoint::operator>)
+		.def("__lt__", &DataPoint::operator<)
+		.def("__eq__", &DataPoint::operator==)
+		.def("__add__", &DataPoint::operator+)
+		.def("complexVectorLength", &DataPoint::complexVectorLength)
+		.def("__repr__", &reprDataPoint);
 	py::class_<Range>(m, "Range")
 		.def(py::init<fvalue, fvalue, size_t, bool>(),
 			py::arg("startI"),
@@ -34,7 +69,31 @@ PYBIND11_MODULE(_core, m)
 		.def_readwrite("start", &Range::start)
 		.def_readwrite("end", &Range::end)
 		.def_readwrite("count", &Range::count)
-		.def_readwrite("log", &Range::log);
+		.def_readwrite("log", &Range::log)
+		.def("stepSize", &Range::stepSize)
+		.def("stepValue", &Range::stepValue)
+		.def("center", &Range::center)
+		.def("at", &Range::at)
+		.def("__getitem__", &Range::at)
+		.def("getString", &Range::getString)
+		.def("getRangeVector", &Range::getRangeVector)
+		.def("fromString", &Range::fromString)
+		.def_static("rangesFromParamString", &Range::rangesFromParamString);
+	py::class_<EisSpectra>(m, "EisSpectra")
+		.def(py::init<>())
+		.def_readwrite("data", &EisSpectra::data)
+		.def_readwrite("model", &EisSpectra::model)
+		.def_readwrite("header", &EisSpectra::header)
+		.def_readwrite("labels", &EisSpectra::labels)
+		.def_readwrite("labelNames", &EisSpectra::labelNames)
+		.def_static("loadFromDisk", &EisSpectra::loadFromDisk)
+		.def("setLabel", &EisSpectra::setLabel)
+		.def("setSzLabels", &EisSpectra::setSzLabels)
+		.def("setLabels", static_cast<void (EisSpectra::*)(const std::vector<double>&)>(&EisSpectra::setLabels))
+		.def("getSzLabels", &EisSpectra::getSzLabels)
+		.def("getFvalueLabels", &EisSpectra::getFvalueLabels)
+		.def("saveToDisk", &EisSpectra::saveToDisk)
+		.def("__repr__", &reprEisSpectra);
 	py::class_<Log>(m, "Log")
 		.def_readwrite_static("level", &Log::level);
 	py::enum_<Log::Level>(m, "Level")
@@ -42,6 +101,10 @@ PYBIND11_MODULE(_core, m)
 		.value("INFO", Log::INFO)
 		.value("WARN", Log::WARN)
 		.value("ERROR", Log::ERROR);
+	py::register_exception<parse_errror>(m, "ParseError");
+	py::register_exception<file_error>(m, "FileError");
 	py::add_ostream_redirect(m, "ostream_redirect");
+	m.def("eisDistance", &eisDistance);
+	m.def("eisNyquistDistance", &eisNyquistDistance);
 	m.attr("__version__") = "1.0";
 }