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