From f18e017310bc39fb11bb11f734e58897e05f5634 2018-05-01 15:31:40
From: Alexis Jeandet <alexis.jeandet@member.fsf.org>
Date: 2018-05-01 15:31:40
Subject: [PATCH] Some refactoring on PB11 wrappers

Most sciqlop core wrappers are moved into a dedicated python module.

We needs to get rid off sqpapp!

All current sciqlop modules should either be stateless or act as real
singletons they must not need any app to be used.
This will ease testing, wrapping and usage.

Signed-off-by: Alexis Jeandet <alexis.jeandet@member.fsf.org>

---

diff --git a/core/CMakeLists.txt b/core/CMakeLists.txt
index df571fb..3a49e9d 100644
--- a/core/CMakeLists.txt
+++ b/core/CMakeLists.txt
@@ -1,6 +1,84 @@
 FILE (GLOB_RECURSE core_SRCS
-        include/*.h
-        src/*.cpp
+    ./include/DataSource/DataSourceItemMergeHelper.h
+    ./include/DataSource/DataSourceItemAction.h
+    ./include/DataSource/DataSourceItem.h
+    ./include/DataSource/DataSourceController.h
+    ./include/Common/SortUtils.h
+    ./include/Common/spimpl.h
+    ./include/Common/MimeTypesDef.h
+    ./include/Common/MetaTypes.h
+    ./include/Common/StringUtils.h
+    ./include/Common/SignalWaiter.h
+    ./include/Common/DateUtils.h
+    ./include/Plugin/IPlugin.h
+    ./include/Data/ArrayDataIterator.h
+    ./include/Data/VariableRequest.h
+    ./include/Data/VectorSeries.h
+    ./include/Data/SqpRange.h
+    ./include/Data/ScalarSeries.h
+    ./include/Data/DataSeriesMergeHelper.h
+    ./include/Data/DataSeries.h
+    ./include/Data/AcquisitionDataPacket.h
+    ./include/Data/DataSeriesType.h
+    ./include/Data/AcquisitionRequest.h
+    ./include/Data/SqpIterator.h
+    ./include/Data/ArrayData.h
+    ./include/Data/DataSeriesIterator.h
+    ./include/Data/DataSeriesUtils.h
+    ./include/Data/SpectrogramSeries.h
+    ./include/Data/Unit.h
+    ./include/Data/DataProviderParameters.h
+    ./include/Data/OptionalAxis.h
+    ./include/Data/IDataProvider.h
+    ./include/Data/IDataSeries.h
+    ./include/Network/NetworkController.h
+    ./include/Version.h
+    ./include/CoreGlobal.h
+    ./include/Catalogue/CatalogueController.h
+    ./include/Visualization/VisualizationController.h
+    ./include/PluginManager/PluginManager.h
+    ./include/Variable/VariableModel.h
+    ./include/Variable/VariableAcquisitionWorker.h
+    ./include/Variable/VariableCacheStrategy.h
+    ./include/Variable/VariableSynchronizationGroup.h
+    ./include/Variable/VariableSingleThresholdCacheStrategy.h
+    ./include/Variable/VariableCacheStrategyFactory.h
+    ./include/Variable/Variable.h
+    ./include/Variable/VariableCacheController.h
+    ./include/Variable/VariableController.h
+    ./include/Time/TimeController.h
+    ./include/Settings/ISqpSettingsBindable.h
+    ./include/Settings/SqpSettingsDefs.h
+
+    ./src/DataSource/DataSourceItem.cpp
+    ./src/DataSource/DataSourceItemAction.cpp
+    ./src/DataSource/DataSourceItemMergeHelper.cpp
+    ./src/DataSource/DataSourceController.cpp
+    ./src/Common/DateUtils.cpp
+    ./src/Common/MimeTypesDef.cpp
+    ./src/Common/StringUtils.cpp
+    ./src/Common/SignalWaiter.cpp
+    ./src/Data/ScalarSeries.cpp
+    ./src/Data/DataSeriesIterator.cpp
+    ./src/Data/OptionalAxis.cpp
+    ./src/Data/ArrayDataIterator.cpp
+    ./src/Data/SpectrogramSeries.cpp
+    ./src/Data/DataSeriesUtils.cpp
+    ./src/Data/VectorSeries.cpp
+    ./src/Network/NetworkController.cpp
+    ./src/Catalogue/CatalogueController.cpp
+    ./src/Visualization/VisualizationController.cpp
+    ./src/PluginManager/PluginManager.cpp
+    ./src/Variable/VariableController.cpp
+    ./src/Variable/VariableModel.cpp
+    ./src/Variable/VariableCacheController.cpp
+    ./src/Variable/VariableSynchronizationGroup.cpp
+    ./src/Variable/Variable.cpp
+    ./src/Variable/VariableAcquisitionWorker.cpp
+    ./src/Version.cpp
+    ./src/Time/TimeController.cpp
+    ./src/Settings/SqpSettingsDefs.cpp
+
         )
 
 add_definitions(-DCORE_STATIC)
@@ -19,6 +97,23 @@ target_link_libraries(sciqlopcore PUBLIC
   catalogs
 )
 
+
+pybind11_add_module(sciqlopqt src/pybind11_wrappers/QtWrappers.cpp)
+target_link_libraries(sciqlopqt PUBLIC Qt5::Core)
+
+pybind11_add_module(pysciqlopcore src/pybind11_wrappers/CoreWrappers.cpp)
+target_link_libraries(pysciqlopcore PUBLIC sciqlopcore)
+
+add_library(pysciqlop src/pybind11_wrappers/pywrappers_common.h)
+target_link_libraries(pysciqlop PUBLIC Qt5::Core)
+target_include_directories(pysciqlop PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src/pybind11_wrappers/>
+    $<INSTALL_INTERFACE:include/SciQLOP/py_wrappers>
+)
+
+SET_PROPERTY(GLOBAL PROPERTY CORE_PYTHON_PATH  ${CMAKE_CURRENT_BINARY_DIR})
+
+
 install(TARGETS sciqlopcore EXPORT SciQLOPCoreConfig
     ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
     LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
diff --git a/core/src/pybind11_wrappers/CoreWrappers.cpp b/core/src/pybind11_wrappers/CoreWrappers.cpp
new file mode 100644
index 0000000..01b683f
--- /dev/null
+++ b/core/src/pybind11_wrappers/CoreWrappers.cpp
@@ -0,0 +1,115 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/operators.h>
+#include <pybind11/embed.h>
+#include <pybind11/numpy.h>
+#include <pybind11/chrono.h>
+
+#include <string>
+#include <sstream>
+
+#include "pywrappers_common.h"
+#include "CoreWrappers.h"
+
+#include <Data/DataSeriesType.h>
+#include <Data/ScalarSeries.h>
+#include <Data/VectorSeries.h>
+#include <Data/Unit.h>
+#include <Data/IDataProvider.h>
+
+#include <Variable/VariableController.h>
+
+#include <Time/TimeController.h>
+
+
+
+namespace py = pybind11;
+using namespace std::chrono;
+
+PYBIND11_MODULE(pysciqlopcore,m){
+
+    py::enum_<DataSeriesType>(m, "DataSeriesType")
+            .value("SCALAR", DataSeriesType::SCALAR)
+            .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
+            .value("UNKNOWN", DataSeriesType::UNKNOWN)
+            .export_values();
+
+    py::class_<Unit>(m, "Unit")
+            .def_readwrite("name", &Unit::m_Name)
+            .def_readwrite("time_unit", &Unit::m_TimeUnit)
+            .def(py::self == py::self)
+            .def(py::self != py::self)
+            .def("__repr__",__repr__<Unit>);
+
+    py::class_<DataSeriesIteratorValue>(m,"DataSeriesIteratorValue")
+            .def_property_readonly("x", &DataSeriesIteratorValue::x)
+            .def("value", py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
+            .def("value", py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_));
+
+    py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
+            .def("nbPoints", &IDataSeries::nbPoints)
+            .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
+            .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
+            .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
+            .def("__getitem__", [](IDataSeries& serie, int key) {
+        return *(serie.begin()+key);
+    }, py::is_operator())
+            .def("__len__", &IDataSeries::nbPoints)
+            .def("__iter__", [](IDataSeries& serie) {
+        return py::make_iterator(serie.begin(), serie.end());
+    }, py::keep_alive<0, 1>())
+            .def("__repr__",__repr__<IDataSeries>);
+
+    py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(m, "ScalarSeries")
+            .def("nbPoints", &ScalarSeries::nbPoints);
+
+    py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(m, "VectorSeries")
+            .def("nbPoints", &VectorSeries::nbPoints);
+
+
+    py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
+
+
+    py::class_<Variable,std::shared_ptr<Variable>>(m, "Variable")
+            .def(py::init<const QString&>())
+            .def_property("name", &Variable::name, &Variable::setName)
+            .def_property("range", &Variable::range, &Variable::setRange)
+            .def_property("cacheRange", &Variable::cacheRange, &Variable::setCacheRange)
+            .def_property_readonly("nbPoints", &Variable::nbPoints)
+            .def_property_readonly("dataSeries", &Variable::dataSeries)
+            .def("__len__", [](Variable& variable) {
+        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
+        return std::distance(rng.first,rng.second);
+    })
+            .def("__iter__", [](Variable& variable) {
+        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
+        return py::make_iterator(rng.first, rng.second);
+    }, py::keep_alive<0, 1>())
+            .def("__getitem__", [](Variable& variable, int key) {
+        //insane and slow!
+        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
+        if(key<0)
+            return *(rng.second+key);
+        else
+            return *(rng.first+key);
+    })
+            .def("__repr__",__repr__<Variable>);
+
+
+    py::class_<SqpRange>(m,"SqpRange")
+            .def("fromDateTime", &SqpRange::fromDateTime, py::return_value_policy::move)
+            .def(py::init([](double start, double stop){return SqpRange{start, stop};}))
+            .def(py::init([](system_clock::time_point start, system_clock::time_point stop)
+    {
+                     double start_ = 0.001 * duration_cast<milliseconds>(start.time_since_epoch()).count();
+                     double stop_ = 0.001 * duration_cast<milliseconds>(stop.time_since_epoch()).count();
+                     return SqpRange{start_, stop_};
+                 }))
+            .def_property_readonly("start", [](const SqpRange& range){
+        return  system_clock::from_time_t(range.m_TStart);
+    })
+            .def_property_readonly("stop", [](const SqpRange& range){
+        return  system_clock::from_time_t(range.m_TEnd);
+    })
+            .def("__repr__", __repr__<SqpRange>);
+
+}
diff --git a/core/src/pybind11_wrappers/CoreWrappers.h b/core/src/pybind11_wrappers/CoreWrappers.h
new file mode 100644
index 0000000..d741d65
--- /dev/null
+++ b/core/src/pybind11_wrappers/CoreWrappers.h
@@ -0,0 +1,54 @@
+#pragma once
+#include <pybind11/pybind11.h>
+#include <pybind11/operators.h>
+
+#include <string>
+#include <sstream>
+#include "pywrappers_common.h"
+#include "QtWrappers.h"
+#include <Data/DataSeriesType.h>
+#include <Data/Unit.h>
+#include <Data/IDataSeries.h>
+#include <Variable/Variable.h>
+#include <Data/SqpRange.h>
+
+
+std::ostream &operator <<(std::ostream& os, const Unit& u)
+{
+    os << "=========================" << std::endl
+       << "Unit:" << std::endl
+       << " Name: " << u.m_Name << std::endl
+       << " Is_TimeUnit: " << u.m_TimeUnit << std::endl;
+    return os;
+}
+
+
+std::ostream &operator <<(std::ostream& os, const IDataSeries& ds)
+{
+    os << "=========================" << std::endl
+       << "DataSerie:" << std::endl
+       << " Number of points:" << ds.nbPoints() << std::endl
+       << " X Axis Unit:" << std::endl << ds.xAxisUnit() << std::endl
+       << " Y Axis Unit:" << std::endl << ds.yAxisUnit()<< std::endl
+       << " Values Axis Unit:" << std::endl << ds.valuesUnit()<< std::endl;
+    return os;
+}
+
+std::ostream &operator <<(std::ostream& os, const SqpRange& range)
+{
+    os << "=========================" << std::endl
+       << "SqpRange:" << std::endl
+       << " Start date: " << DateUtils::dateTime(range.m_TStart).toString() << std::endl
+       << " Stop date: "  << DateUtils::dateTime(range.m_TEnd).toString() << std::endl;
+    return os;
+}
+
+std::ostream &operator <<(std::ostream& os, const Variable& variable)
+{
+    os << "=========================" << std::endl
+       << "Variable:" << std::endl
+       << " Name: " << variable.name() << std::endl
+       << " range: " << std::endl << variable.range() << std::endl
+       << " cache range: " << std::endl << variable.cacheRange() << std::endl;
+    return os;
+}
diff --git a/core/src/pybind11_wrappers/QtWrappers.cpp b/core/src/pybind11_wrappers/QtWrappers.cpp
new file mode 100644
index 0000000..c979bf2
--- /dev/null
+++ b/core/src/pybind11_wrappers/QtWrappers.cpp
@@ -0,0 +1,33 @@
+#include <QString>
+#include <QUuid>
+#include <QDate>
+#include <QTime>
+#include <string>
+#include <sstream>
+#include "pywrappers_common.h"
+#include <pybind11/pybind11.h>
+#include "QtWrappers.h"
+
+namespace py = pybind11;
+
+
+
+PYBIND11_MODULE(sciqlopqt,m){
+    py::class_<QString>(m, "QString")
+            .def(py::init([](const std::string& value){return QString::fromStdString(value);}))
+            .def("__repr__", __repr__<QString>);
+
+    py::class_<QUuid>(m,"QUuid")
+            .def(py::init([](){return QUuid::createUuid();}))
+            .def("__repr__",__repr__<QUuid>);
+
+    py::class_<QDate>(m,"QDate")
+            .def(py::init<int,int,int>());
+
+    py::class_<QTime>(m,"QTime")
+            .def(py::init<int,int,int>());
+
+
+    py::implicitly_convertible<std::string, QString>();
+}
+
diff --git a/core/src/pybind11_wrappers/QtWrappers.h b/core/src/pybind11_wrappers/QtWrappers.h
new file mode 100644
index 0000000..2bf2c2a
--- /dev/null
+++ b/core/src/pybind11_wrappers/QtWrappers.h
@@ -0,0 +1,19 @@
+#pragma once
+#include <QString>
+#include <QUuid>
+#include <QDate>
+#include <QTime>
+#include <string>
+#include <sstream>
+
+std::ostream &operator <<(std::ostream& os, const QString& qstr)
+{
+    os << qstr.toStdString();
+    return os;
+}
+
+std::ostream &operator <<(std::ostream& os, const QUuid& uuid)
+{
+    os << "QUuid:" << uuid.toString() << std::endl;
+    return os;
+}
diff --git a/core/src/pybind11_wrappers/pywrappers_common.h b/core/src/pybind11_wrappers/pywrappers_common.h
new file mode 100644
index 0000000..bef170e
--- /dev/null
+++ b/core/src/pybind11_wrappers/pywrappers_common.h
@@ -0,0 +1,18 @@
+#ifndef PYWRAPPERS_COMMON_H
+#define PYWRAPPERS_COMMON_H
+#include <QString>
+#include <string>
+#include <sstream>
+#include <QUuid>
+#include <pybind11/pybind11.h>
+
+
+template <typename T>
+std::string __repr__(const T& obj)
+{
+    std::stringstream sstr;
+    sstr << obj;
+    return sstr.str();
+}
+
+#endif //PYWRAPPERS_COMMON_H
diff --git a/plugins/amda/CMakeLists.txt b/plugins/amda/CMakeLists.txt
index 0df99ec..8bd117c 100644
--- a/plugins/amda/CMakeLists.txt
+++ b/plugins/amda/CMakeLists.txt
@@ -41,18 +41,31 @@ declare_test(TestAmdaFuzzing TestAmdaFuzzing "tests/TestAmdaFuzzing.cpp;tests/Fu
 
 pybind11_add_module(pytestamda tests/PyTestAmdaWrapper.cpp)
 target_link_libraries(pytestamda PUBLIC amdaplugin)
+target_link_libraries(pytestamda PUBLIC pysciqlop)
+
 
 #pybind11_add_module(pytestamdalib SHARED tests/PyTestAmdaWrapper.cpp)
 add_library(pytestamdalib tests/PyTestAmdaWrapper.cpp)
 target_link_libraries(pytestamdalib PUBLIC pybind11::module)
 target_link_libraries(pytestamdalib PUBLIC pybind11::embed)
 target_link_libraries(pytestamdalib PUBLIC amdaplugin)
+target_link_libraries(pytestamdalib PUBLIC pysciqlop)
+
+GET_PROPERTY(CORE_PYTHON_PATH GLOBAL PROPERTY CORE_PYTHON_PATH)
 
 declare_test(TestAmdaFileParserEmbed TestAmdaFileParserEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
 target_compile_definitions(TestAmdaFileParserEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaFileParser.py")
+set_tests_properties(TestAmdaFileParserEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
+
 
 declare_test(TestAmdaDownloadEmbed TestAmdaDownloadEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
 target_compile_definitions(TestAmdaDownloadEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaDownload.py")
+set_tests_properties(TestAmdaDownloadEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
+
+
+declare_test(TestAmdaMiniFuzzEmbed TestAmdaMiniFuzzEmbed "tests/PyTestAmdaWrapperExe.cpp" "amdaplugin;pytestamdalib")
+target_compile_definitions(TestAmdaMiniFuzzEmbed PRIVATE -DPYTESTAMDA_SCRIPT="${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaMiniFuzz.py")
+set_tests_properties(TestAmdaMiniFuzzEmbed  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
 
 
 find_package(PythonInterp 3 REQUIRED)
@@ -61,13 +74,11 @@ add_test(NAME TestAmdaFileParser
   COMMAND ${PYTHON_EXECUTABLE}
     ${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaFileParser.py
     TestAmdaFileParser)
-set_tests_properties(TestAmdaFileParser  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR})
+set_tests_properties(TestAmdaFileParser  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
 
 
 add_test(NAME TestAmdaDownload
   COMMAND ${PYTHON_EXECUTABLE}
     ${CMAKE_CURRENT_LIST_DIR}/tests/TestAmdaDownload.py
     TestAmdaDownload)
-set_tests_properties(TestAmdaDownload  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR})
-
-
+set_tests_properties(TestAmdaDownload  PROPERTIES ENVIRONMENT PYTHONPATH=${CMAKE_CURRENT_BINARY_DIR}:${CORE_PYTHON_PATH})
diff --git a/plugins/amda/tests/PyTestAmdaWrapper.cpp b/plugins/amda/tests/PyTestAmdaWrapper.cpp
index ecda73e..8ccce66 100644
--- a/plugins/amda/tests/PyTestAmdaWrapper.cpp
+++ b/plugins/amda/tests/PyTestAmdaWrapper.cpp
@@ -42,66 +42,24 @@
 #include <AmdaProvider.h>
 #include <AmdaResultParser.h>
 
-#include <QDate>
-#include <QTime>
-#include <QUuid>
-#include <QString>
+//#include <QDate>
+//#include <QTime>
+//#include <QUuid>
+//#include <QString>
 #include <QFile>
 
-using namespace std::chrono;
-namespace py = pybind11;
-
-std::ostream &operator <<(std::ostream& os, const Unit& u)
-{
-    os << "=========================" << std::endl
-       << "Unit:" << std::endl
-       << " Name: " << u.m_Name.toStdString() << std::endl
-       << " Is_TimeUnit: " << u.m_TimeUnit << std::endl;
-    return os;
-}
-
-std::ostream &operator <<(std::ostream& os, const IDataSeries& ds)
-{
-    os << "=========================" << std::endl
-       << "DataSerie:" << std::endl
-       << " Number of points:" << ds.nbPoints() << std::endl
-       << " X Axis Unit:" << std::endl << ds.xAxisUnit() << std::endl
-       << " Y Axis Unit:" << std::endl << ds.yAxisUnit()<< std::endl
-       << " Values Axis Unit:" << std::endl << ds.valuesUnit()<< std::endl;
-    return os;
-}
-
-std::ostream &operator <<(std::ostream& os, const SqpRange& range)
-{
-    os << "=========================" << std::endl
-       << "SqpRange:" << std::endl
-       << " Start date: " << DateUtils::dateTime(range.m_TStart).toString().toStdString() << std::endl
-       << " Stop date: "  << DateUtils::dateTime(range.m_TEnd).toString().toStdString() << std::endl;
-    return os;
-}
+#include <pywrappers_common.h>
+#include <CoreWrappers.h>
 
-std::ostream &operator <<(std::ostream& os, const Variable& variable)
-{
-    os << "=========================" << std::endl
-       << "Variable:" << std::endl
-       << " Name: " << variable.name().toStdString() << std::endl
-       << " range: " << std::endl << variable.range() << std::endl
-       << " cache range: " << std::endl << variable.cacheRange() << std::endl;
-    return os;
-}
 
-template <typename T>
-std::string __repr__(const T& obj)
-{
-    std::stringstream sstr;
-    sstr << obj;
-    return sstr.str();
-}
+using namespace std::chrono;
+namespace py = pybind11;
 
 
 
 
 PYBIND11_MODULE(pytestamda, m){
+
     int argc = 0;
     char ** argv=nullptr;
     SqpApplication::setOrganizationName("LPP");
@@ -109,52 +67,10 @@ PYBIND11_MODULE(pytestamda, m){
     SqpApplication::setApplicationName("SciQLop");
     static SqpApplication app(argc, argv);
 
-    m.doc() = "hello";
+    auto qtmod = py::module::import("sciqlopqt");
+    auto sciqlopmod = py::module::import("pysciqlopcore");
 
-    auto amda_provider = std::make_shared<AmdaProvider>();
-    m.def("amda_provider",[amda_provider](){return amda_provider;}, py::return_value_policy::copy);
-
-    py::enum_<DataSeriesType>(m, "DataSeriesType")
-            .value("SCALAR", DataSeriesType::SCALAR)
-            .value("SPECTROGRAM", DataSeriesType::SPECTROGRAM)
-            .value("UNKNOWN", DataSeriesType::UNKNOWN)
-            .export_values();
-
-    py::class_<Unit>(m, "Unit")
-            .def_readwrite("name", &Unit::m_Name)
-            .def_readwrite("time_unit", &Unit::m_TimeUnit)
-            .def(py::self == py::self)
-            .def(py::self != py::self)
-            .def("__repr__",__repr__<Unit>);
-
-    py::class_<DataSeriesIteratorValue>(m,"DataSeriesIteratorValue")
-            .def_property_readonly("x", &DataSeriesIteratorValue::x)
-            .def("value", py::overload_cast<>(&DataSeriesIteratorValue::value, py::const_))
-            .def("value", py::overload_cast<int>(&DataSeriesIteratorValue::value, py::const_));
-
-    py::class_<IDataSeries, std::shared_ptr<IDataSeries>>(m, "IDataSeries")
-            .def("nbPoints", &IDataSeries::nbPoints)
-            .def_property_readonly("xAxisUnit", &IDataSeries::xAxisUnit)
-            .def_property_readonly("yAxisUnit", &IDataSeries::yAxisUnit)
-            .def_property_readonly("valuesUnit", &IDataSeries::valuesUnit)
-            .def("__getitem__", [](IDataSeries& serie, int key) {
-        return *(serie.begin()+key);
-    }, py::is_operator())
-            .def("__len__", &IDataSeries::nbPoints)
-            .def("__iter__", [](IDataSeries& serie) {
-        return py::make_iterator(serie.begin(), serie.end());
-    }, py::keep_alive<0, 1>())
-            .def("__repr__",__repr__<IDataSeries>);
-
-    py::class_<ScalarSeries, std::shared_ptr<ScalarSeries>, IDataSeries>(m, "ScalarSeries")
-            .def("nbPoints", &ScalarSeries::nbPoints);
-
-    py::class_<VectorSeries, std::shared_ptr<VectorSeries>, IDataSeries>(m, "VectorSeries")
-            .def("nbPoints", &VectorSeries::nbPoints);
-
-    py::class_<QString>(m, "QString")
-            .def(py::init([](const std::string& value){return QString::fromStdString(value);}))
-            .def("__repr__", &QString::toStdString);
+    m.doc() = "hello";
 
     py::class_<VariableController>(m, "VariableController")
             .def_static("createVariable",[](const QString &name,
@@ -163,12 +79,38 @@ PYBIND11_MODULE(pytestamda, m){
     })
             .def_static("hasPendingDownloads",
                         [](){return sqpApp->variableController().hasPendingDownloads();}
-                        );
+                        )
+            .def_static("addSynchronizationGroup",
+                        [](QUuid uuid){sqpApp->variableController().onAddSynchronizationGroupId(uuid);}
+                        )
+            .def_static("removeSynchronizationGroup",
+                [](QUuid uuid){sqpApp->variableController().onRemoveSynchronizationGroupId(uuid);}
+                )
+            .def_static("synchronizeVar",
+                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().onAddSynchronized(variable, uuid);}
+                )
+            .def_static("deSynchronizeVar",
+                [](std::shared_ptr<Variable> variable, QUuid uuid){sqpApp->variableController().desynchronize(variable, uuid);}
+                )
+            .def_static("deleteVariable",
+                        [](std::shared_ptr<Variable> variable){
+        sqpApp->variableController().deleteVariable(variable);}
+                        )
+            .def_static("update_range",[](std::shared_ptr<Variable> variable, const SqpRange &range, bool synchronise){
+        sqpApp->variableController().onRequestDataLoading({variable}, range, synchronise);
+    })
+            .def_static("wait_for_downloads",[](){
+        while (sqpApp->variableController().hasPendingDownloads()) {
+            usleep(100);
+        }
+    });
 
     py::class_<TimeController>(m,"TimeController")
             .def_static("setTime", [](SqpRange range){sqpApp->timeController().onTimeToUpdate(range);});
 
-    py::class_<IDataProvider, std::shared_ptr<IDataProvider>>(m, "IDataProvider");
+
+    auto amda_provider = std::make_shared<AmdaProvider>();
+    m.def("amda_provider",[amda_provider](){return amda_provider;}, py::return_value_policy::copy);
 
     py::class_<AmdaProvider, std::shared_ptr<AmdaProvider>, IDataProvider>(m, "AmdaProvider");
 
@@ -178,58 +120,6 @@ PYBIND11_MODULE(pytestamda, m){
         return std::dynamic_pointer_cast<ScalarSeries>(AmdaResultParser::readTxt(path, DataSeriesType::SCALAR));
     }, py::return_value_policy::copy);
 
-    py::class_<Variable,std::shared_ptr<Variable>>(m, "Variable")
-            .def(py::init<const QString&>())
-            .def_property("name", &Variable::name, &Variable::setName)
-            .def_property("range", &Variable::range, &Variable::setRange)
-            .def_property("cacheRange", &Variable::cacheRange, &Variable::setCacheRange)
-            .def_property_readonly("nbPoints", &Variable::nbPoints)
-            .def_property_readonly("dataSeries", &Variable::dataSeries)
-            .def("__len__", [](Variable& variable) {
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        return std::distance(rng.first,rng.second);
-    })
-            .def("__iter__", [](Variable& variable) {
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        return py::make_iterator(rng.first, rng.second);
-    }, py::keep_alive<0, 1>())
-            .def("__getitem__", [](Variable& variable, int key) {
-        //insane and slow!
-        auto rng = variable.dataSeries()->xAxisRange(variable.range().m_TStart,variable.range().m_TEnd);
-        if(key<0)
-            return *(rng.second+key);
-        else
-            return *(rng.first+key);
-    })
-            .def("__repr__",__repr__<Variable>);
-
-    py::implicitly_convertible<std::string, QString>();
-
-
-    py::class_<SqpRange>(m,"SqpRange")
-            .def("fromDateTime", &SqpRange::fromDateTime, py::return_value_policy::move)
-            .def(py::init([](double start, double stop){return SqpRange{start, stop};}))
-            .def(py::init([](system_clock::time_point start, system_clock::time_point stop)
-    {
-                     double start_ = 0.001 * duration_cast<milliseconds>(start.time_since_epoch()).count();
-                     double stop_ = 0.001 * duration_cast<milliseconds>(stop.time_since_epoch()).count();
-                     return SqpRange{start_, stop_};
-                 }))
-            .def_property_readonly("start", [](const SqpRange& range){
-        return  system_clock::from_time_t(range.m_TStart);
-    })
-            .def_property_readonly("stop", [](const SqpRange& range){
-        return  system_clock::from_time_t(range.m_TEnd);
-    })
-            .def("__repr__", __repr__<SqpRange>);
-
-    py::class_<QUuid>(m,"QUuid");
-
-    py::class_<QDate>(m,"QDate")
-            .def(py::init<int,int,int>());
-
-    py::class_<QTime>(m,"QTime")
-            .def(py::init<int,int,int>());
 
 }
 
@@ -242,3 +132,4 @@ int pytestamda_test(const char* testScriptPath )
     return 0;
 }
 
+
diff --git a/plugins/amda/tests/TestAmdaDownload.py b/plugins/amda/tests/TestAmdaDownload.py
index c944f2a..294a988 100644
--- a/plugins/amda/tests/TestAmdaDownload.py
+++ b/plugins/amda/tests/TestAmdaDownload.py
@@ -4,8 +4,9 @@ if not hasattr(sys, 'argv'):
     sys.argv  = ['']
 current_script_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.append(current_script_path)
-import amda
 import pytestamda
+import pysciqlopcore
+import amda
 
 import numpy as np
 import datetime
@@ -13,23 +14,6 @@ import time
 import unittest
 import ddt
 
-def wait_for_downloads():
-    while pytestamda.VariableController.hasPendingDownloads():
-        time.sleep(0.1)
-
-def extract_vector(variable):
-    return zip(*[(pt.x, pt.value(0), pt.value(1), pt.value(2)) for pt in variable])
-
-def compare_with_ref(var, ref):
-    t_ref, x_ref, y_ref, z_ref = ref
-    t,x,y,z = extract_vector(var)
-    return all([
-             all([t_ref[i].astype(float)/1000000 == t[i] for i in range(len(t))]),
-             all([x_ref[i] == x[i] for i in range(len(x))]),
-             all([y_ref[i] == y[i] for i in range(len(y))]),
-             all([z_ref[i] == z[i] for i in range(len(z))])
-             ])
-
 @ddt.ddt
 class FunctionalTests(unittest.TestCase):
     def setUp(self):
@@ -43,11 +27,11 @@ class FunctionalTests(unittest.TestCase):
     def test_simple_download(self, case):
         tstart = case[0]
         tstop = case[1]
-        pytestamda.TimeController.setTime(pytestamda.SqpRange(tstart, tstop))
+        pytestamda.TimeController.setTime(pysciqlopcore.SqpRange(tstart, tstop))
         variable = pytestamda.VariableController.createVariable("bx_gse",pytestamda.amda_provider())
-        wait_for_downloads()
+        pytestamda.VariableController.wait_for_downloads()
         t_ref, x_ref, y_ref, z_ref = amda.generate_data(np.datetime64(tstart), np.datetime64(tstop), 4)
-        self.assertTrue( compare_with_ref(variable,(t_ref, x_ref, y_ref, z_ref) ) )
+        self.assertTrue( amda.compare_with_ref(variable,(t_ref, x_ref, y_ref, z_ref) ) )
 
 
 if __name__ == '__main__':
diff --git a/plugins/amda/tests/TestAmdaMiniFuzz.py b/plugins/amda/tests/TestAmdaMiniFuzz.py
new file mode 100644
index 0000000..eb5840a
--- /dev/null
+++ b/plugins/amda/tests/TestAmdaMiniFuzz.py
@@ -0,0 +1,284 @@
+import sys
+import os
+import copy
+
+if not hasattr(sys, 'argv'):
+    sys.argv = ['']
+current_script_path = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(current_script_path)
+import amda
+import pytestamda
+import pysciqlopcore
+import sciqlopqt
+
+import datetime
+import random
+import string
+import jsonpickle
+import argparse
+
+class Variable:
+    class Range:
+        def __init__(self, start, stop):
+            self.start = start
+            self.stop = stop
+
+    def __init__(self, name, t_start, t_stop):
+        self.name = name
+        self.range = Variable.Range(t_start, t_stop)
+
+
+class OperationCtx:
+    def __init__(self, prev_ctx=None):
+        if prev_ctx is None:
+            self.t_start = datetime.datetime(2012, 10, 20, 8, 10, 00)
+            self.t_stop = datetime.datetime(2012, 10, 20, 12, 0, 0)
+            self.variables = dict()
+            self.sync_group = set()
+        else:
+            self.t_start = copy.deepcopy(prev_ctx.t_start)
+            self.t_stop = copy.deepcopy(prev_ctx.t_stop)
+            self.variables = copy.deepcopy(prev_ctx.variables)
+            self.sync_group = copy.deepcopy(prev_ctx.sync_group)
+
+
+__variables__ = dict()
+
+__variables_in_sync__ = set()
+
+__OPS__ = {}
+__WEIGHTS__ = {}
+
+sync_group = sciqlopqt.QUuid()
+pytestamda.VariableController.addSynchronizationGroup(sync_group)
+
+
+def register(weight):
+    def register_(cls):
+        __OPS__[cls.__name__] = cls()
+        __WEIGHTS__[cls.__name__] = weight
+        return cls
+
+    return register_
+
+
+def random_var(ctx):
+    if len(ctx.variables):
+        return random.choice(list(ctx.variables.keys()))
+    else:
+        return None
+
+
+@register(2)
+class CreateVar:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        new_random_name = ''.join(random.choices(string.ascii_letters + string.digits, k=random.randint(1, 40)))
+        ctx.variables[new_random_name] = Variable(new_random_name, ctx.t_start, ctx.t_stop)
+        return {"var_name": new_random_name}
+
+    @staticmethod
+    def do(var_name, *args, **kwargs):
+        __variables__[var_name] = pytestamda.VariableController.createVariable(var_name,
+                                                                               pytestamda.amda_provider())
+
+
+@register(1)
+class DeleteVar:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        var_name = random_var(ctx)
+        if var_name:
+            ctx.variables.pop(var_name)
+            ctx.sync_group.discard(var_name)
+        return {"var_name": var_name}
+
+    @staticmethod
+    def do(var_name, *args, **kwargs):
+        if var_name:
+            variable = __variables__.pop(var_name)
+            pytestamda.VariableController.deleteVariable(variable)
+
+
+class Zoom:
+    @staticmethod
+    def _compute_zoom_ranges(factor, variable):
+        delta = variable.range.stop - variable.range.start
+        center = variable.range.start + (delta / 2)
+        new_delta = delta * factor
+        t_start = center - new_delta / 2
+        t_stop = center + new_delta / 2
+        return t_start, t_stop
+
+    @staticmethod
+    def _zoom(factor, var_name, ctx):
+        var_list = ctx.sync_group if var_name in ctx.sync_group else [var_name]
+        for var_name in var_list:
+            variable = ctx.variables[var_name]
+            t_start, t_stop = Zoom._compute_zoom_ranges(variable=variable, factor=factor)
+            ctx.variables[var_name].range.start = t_start
+            ctx.variables[var_name].range.stop = t_stop
+
+    @staticmethod
+    def prepare(ctx, min, max):
+        var_name = random_var(ctx)
+        factor = random.uniform(min, max)
+        if var_name:
+            Zoom._zoom(factor, var_name, ctx)
+        return {"var_name": var_name, "factor": factor}
+
+    @staticmethod
+    def do(var_name, factor):
+        variable = __variables__[var_name]
+        t_start, t_stop = Zoom._compute_zoom_ranges(variable = variable, factor = factor)
+        sync = True if var_name in __variables_in_sync__ else False
+        pytestamda.VariableController.update_range(variable, pytestamda.SqpRange(t_start, t_stop), sync)
+
+
+@register(10)
+class ZoomIn:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        return Zoom.prepare(ctx, min=1, max=2)
+
+    @staticmethod
+    def do(var_name, factor, *args, **kwargs):
+        if var_name:
+            Zoom.do(var_name, factor)
+
+
+@register(10)
+class ZoomOut:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        return Zoom.prepare(ctx, min=.1, max=1)
+
+    @staticmethod
+    def do(var_name, factor, *args, **kwargs):
+        if var_name:
+            Zoom.do(var_name, factor)
+
+
+@register(10)
+class Shift:
+    @staticmethod
+    def _compute_range(variable, direction, factor):
+        delta = variable.range.stop - variable.range.start
+        offset = delta * factor * direction
+        return variable.range.start + offset, variable.range.stop + offset
+
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        var_name = random_var(ctx)
+        direction = random.choice([1, -1])
+        factor = random.random()
+        if var_name:
+            var_list = ctx.sync_group if var_name in ctx.sync_group else [var_name]
+            for var_name in var_list:
+                variable = ctx.variables[var_name]
+                delta = variable.range.stop - variable.range.start
+                offset = delta * factor * direction
+                variable.range.start , variable.range.stop = Shift._compute_range(variable, direction, factor)
+        return {"var_name": var_name, "direction": direction, "factor": factor}
+
+    @staticmethod
+    def do(var_name, direction, factor, *args, **kwargs):
+        if var_name:
+            variable = __variables__[var_name]
+            t_start, t_stop = Shift._compute_range(variable, direction, factor)
+            sync = True if var_name in __variables_in_sync__ else False
+            pytestamda.VariableController.update_range(variable, pytestamda.SqpRange(t_start, t_stop), sync)
+
+
+@register(3)
+class WaitForDl:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        return {}
+
+    @staticmethod
+    def do(*args, **kwargs):
+        pytestamda.VariableController.wait_for_downloads()
+
+
+@register(2)
+class SyncVar:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        var_name = random_var(ctx)
+        if var_name:
+            ctx.sync_group.add(var_name)
+        return {"var_name": var_name}
+
+    @staticmethod
+    def do(var_name, *args, **kwargs):
+        if var_name:
+            pytestamda.VariableController.synchronizeVar(__variables__[var_name], sync_group)
+            __variables_in_sync__.add(var_name)
+
+
+@register(2)
+class DeSyncVar:
+    @staticmethod
+    def prepare(ctx, *args, **kwargs):
+        var_name = random_var(ctx)
+        if var_name:
+            ctx.sync_group.discard(var_name)
+        return {"var_name": var_name}
+
+    @staticmethod
+    def do(var_name, *args, **kwargs):
+        if var_name:
+            pytestamda.VariableController.deSynchronizeVar(__variables__[var_name], sync_group)
+            __variables_in_sync__.discard(var_name)
+
+
+#parser = argparse.ArgumentParser()
+#parser.add_argument("-r", "--reload", help="reload")
+#cli_args = parser.parse_args()
+
+
+def run_scenario(args,ops):
+    t_start, t_stop = datetime.datetime(2012, 10, 20, 8, 10, 00), datetime.datetime(2012, 10, 20, 12, 0, 0)
+    pytestamda.TimeController.setTime(pytestamda.SqpRange(t_start, t_stop))
+
+    for op_name,arg in zip(ops,args):
+        operation = __OPS__[op_name]
+        operation.do(**arg)
+
+
+def build_scenario(name, steps=100):
+    context_stack = [OperationCtx()]
+    ops = [CreateVar.__name__]  # start with one variable minimum
+    ops += random.choices(list(__OPS__.keys()), weights=list(__WEIGHTS__.values()), k=steps)
+    ops.append(SyncVar.__name__)
+    for op_name in ops:
+        ctx = OperationCtx(context_stack[-1])
+        operation = __OPS__[op_name]
+        args.append(operation.prepare(ctx))
+        context_stack.append(ctx)
+    os.makedirs(name)
+    js = jsonpickle.encode({"args": args, "context_stack": context_stack, "operations": ops})
+    with open(name+"/input.json", "w") as file:
+        file.write(js)
+    return ops, args, context_stack
+
+
+def load_scenario(name):
+    with open(name+"/input.json", "r") as file:
+        js = file.read()
+    data = jsonpickle.decode(js)
+    return data["operations"], data["args"], data["context_stack"]
+
+
+if __name__ == '__main__':
+    scenario = ''.join(random.choices(string.ascii_letters + string.digits, k=32))
+    #ops,args, context_stack = build_scenario(scenario, 300)
+    #print("Generated scenario {}".format(scenario))
+    name = "EuI9qFMLZJ4k7vf8seTww8Z4wGBpspd8"
+    ops, args, context_stack = load_scenario(name)
+    syncs = [WaitForDl.__name__]*len(ops)
+    syncs_args = [{}]*len(ops)
+    ops2 = [op for pair in zip(ops,syncs) for op in pair]
+    args2 = [arg for pair in zip(args,syncs_args) for arg in pair]
+    run_scenario(args=args2, ops=ops2)
diff --git a/plugins/amda/tests/amda.py b/plugins/amda/tests/amda.py
index a138944..c08f127 100644
--- a/plugins/amda/tests/amda.py
+++ b/plugins/amda/tests/amda.py
@@ -15,6 +15,10 @@ def load_scalar(fname):
             float(line.split()[1])]
             for line in f if "#" not in line]
 
+def extract_vector(variable):
+    return zip(*[(pt.x, pt.value(0), pt.value(1), pt.value(2)) for pt in variable])
+
+
 """
 Copied from myAMDA should be factored in somehow
 """
@@ -27,3 +31,13 @@ def generate_data(tstart, tstop, dt):
     y = [(x0 + (i+1) * delta).astype('float')/1000000 for i in range(vector_size)]
     z = [(x0 + (i+2) * delta).astype('float')/1000000 for i in range(vector_size)]
     return t,x,y,z
+
+def compare_with_ref(var, ref):
+    t_ref, x_ref, y_ref, z_ref = ref
+    t,x,y,z = extract_vector(var)
+    return all([
+             all([t_ref[i].astype(float)/1000000 == t[i] for i in range(len(t))]),
+             all([x_ref[i] == x[i] for i in range(len(x))]),
+             all([y_ref[i] == y[i] for i in range(len(y))]),
+             all([z_ref[i] == z[i] for i in range(len(z))])
+             ])
diff --git a/subprojects/pybind11.wrap b/subprojects/pybind11.wrap
new file mode 100644
index 0000000..487bae3
--- /dev/null
+++ b/subprojects/pybind11.wrap
@@ -0,0 +1,10 @@
+[wrap-file]
+directory = pybind11-2.2.2
+
+source_url = https://github.com/pybind/pybind11/archive/v2.2.2.zip
+source_filename = pybind11-2.2.2.zip
+source_hash = 20314968531faa4c8579da2c46c2ce13aecd68ae79b6dd8cf9b99698b2304348
+
+patch_url = https://wrapdb.mesonbuild.com/v1/projects/pybind11/2.2.2/1/get_zip
+patch_filename = pybind11-2.2.2-1-wrap.zip
+patch_hash = 18a273260a59368b59ae754838d76a606ea6be6126e40c59fff5214252b1e26d