medpython 1.2.0__cp314-cp314-win_amd64.whl

med/medpython.py

@@ -0,0 +1,3995 @@
+# This file was automatically generated by SWIG (https://www.swig.org).
+# Version 4.4.1
+#
+# Do not make changes to this file unless you know what you are doing - modify
+# the SWIG interface file instead.
+
+"""
+
+    class Dictionary
+        Methods:
+            __init__(PidRepository rep) -> Dictionary
+            get_members_to_all_sets(int section_id, int * members_array) -> IntVecIntMapAdaptor
+            id(string & signame) -> int
+            name(int id) -> string
+            prep_sets_lookup_table(int section_id, StringVector set_names)
+            section_id(string name) -> int
+
+
+    class FeatureAttr
+        Methods:
+            imputed -> bool   (property getter)
+            normalized -> bool   (property getter)
+            imputed <- bool   (property setter)
+            normalized <- bool   (property setter)
+            __init__() -> FeatureAttr
+
+        Data descriptors:
+            imputed -> bool   (property getter)
+            normalized -> bool   (property getter)
+
+
+    class Features
+        Methods:
+            attributes -> StringFeatureAttrMapAdaptor   (property getter)
+            data -> StringVecFloatMapAdaptor   (property getter)
+            pid_pos_len -> IntPairIntIntMapAdaptor   (property getter)
+            samples -> SampleVectorAdaptor   (property getter)
+            tags -> StringUOSetStringMapAdaptor   (property getter)
+            time_unit -> int   (property getter)
+            weights    (property getter)
+            time_unit <- int   (property setter)
+            __init__() -> Features
+            __init__(int _time_unit) -> Features
+            __init__(Features other) -> Features
+            append_samples(IdSamples in_samples)
+            append_samples(Samples in_samples)
+            clear()
+            filter(StringVector selectedFeatures) -> int
+            get_as_matrix(Mat mat)
+            get_as_matrix(Mat mat, vector< string > names)
+            get_as_matrix(Mat mat, vector< string > const names, int * int_in_buf)
+            get_crc() -> unsigned int
+            get_feature_names() -> StringVector
+            get_max_serial_id_cnt() -> int
+            get_pid_len(int pid) -> int
+            get_pid_pos(int pid) -> int
+            get_samples(Samples outSamples)
+            init_all_samples(IdSamplesVectorAdaptor in_samples)
+            init_pid_pos_len()
+            insert_samples(IdSamples in_samples, int index)
+            print_csv()
+            read_from_csv_mat(string const & csv_fname) -> int
+            set_as_matrix(Mat mat)
+            set_time_unit(int _time_unit)
+            version() -> int
+            write_as_csv_mat(string const & csv_fname) -> int
+
+        Static methods:
+        global_serial_id_cnt    (property getter)
+            global_serial_id_cnt -> int   (property getter)
+        MEDPY_SET_global_serial_id_cnt(*args)
+            MEDPY_SET_global_serial_id_cnt(int newval)
+
+        Data descriptors:
+            attributes -> StringFeatureAttrMapAdaptor   (property getter)
+            data -> StringVecFloatMapAdaptor   (property getter)
+        global_serial_id_cnt
+            pid_pos_len -> IntPairIntIntMapAdaptor   (property getter)
+            samples -> SampleVectorAdaptor   (property getter)
+            tags -> StringUOSetStringMapAdaptor   (property getter)
+            time_unit -> int   (property getter)
+            weights    (property getter)
+
+
+    class IdSamples
+        Methods:
+            id -> int   (property getter)
+            samples -> SampleVectorAdaptor   (property getter)
+            split -> int   (property getter)
+            id <- int   (property setter)
+            split <- int   (property setter)
+            __init__(int _id) -> IdSamples
+            __init__() -> IdSamples
+            same_as(IdSamples other, int mode) -> bool
+            set_split(int _split)
+
+        Data descriptors:
+            id -> int   (property getter)
+            samples -> SampleVectorAdaptor   (property getter)
+            split -> int   (property getter)
+
+
+    class Mat
+        Methods:
+            avg    (property getter)
+            missing_value -> float   (property getter)
+            ncols -> int   (property getter)
+            normalized_flag -> int   (property getter)
+            nrows -> int   (property getter)
+            row_ids    (property getter)
+            signals -> StringVector   (property getter)
+            std    (property getter)
+            transposed_flag -> int   (property getter)
+            missing_value <- float   (property setter)
+            normalized_flag <- int   (property setter)
+            row_ids <- int   (property setter)
+            transposed_flag <- int   (property setter)
+            __getitem__(IntVector index) -> float
+            __init__() -> Mat
+            __init__(int n_rows, int n_cols) -> Mat
+            __init__(float * IN_ARRAY2) -> Mat
+            __len__() -> unsigned long long
+            __setitem__(IntVector index, float val)
+            add_cols(Mat m_add)
+            add_cols(float * m_add)
+            add_rows(Mat m_add)
+            add_rows(float * m_add)
+            clear()
+            get_col(int i_col)
+            get_cols_avg_std()
+            get_numpy_copy()
+            get_numpy_view_unsafe()
+            get_row(int i_row)
+            get_sub_mat(vector< int > & rows_to_take, vector< int > & cols_to_take)
+            get_sub_mat_by_flags(vector< int > & rows_to_take_flag, vector< int > & cols_to_take_flag)
+            is_valid(bool output=False) -> bool
+            is_valid() -> bool
+            load(float * IN_ARRAY2)
+            load(Mat x)
+            load_numpy(float * IN_ARRAY2)
+            load_transposed(float * IN_ARRAY2)
+            normalize(int norm_type, float * wgts)
+            normalize(int norm_type=Normalize_Cols)
+            normalize()
+            normalize(float * external_avg, float * external_std, int norm_type=1)
+            normalize(float * external_avg, float * external_std)
+            read_from_bin_file(string const & fname) -> int
+            read_from_csv_file(string const & fname, int titles_line_flag) -> int
+            resize(int n_rows, int n_cols)
+            set_signals(StringVector sigs)
+            set_val(float val)
+            test(int n_rows, int n_cols)
+            transpose()
+            write_to_bin_file(string const & fname) -> int
+            write_to_csv_file(string const & fname) -> int
+            zero()
+
+        Static methods:
+        Normalize_Cols    (property getter)
+            Normalize_Cols -> int   (property getter)
+        Normalize_Rows    (property getter)
+            Normalize_Rows -> int   (property getter)
+
+        Data descriptors:
+        Normalize_Cols
+        Normalize_Rows
+            avg    (property getter)
+            missing_value -> float   (property getter)
+            ncols -> int   (property getter)
+            normalized_flag -> int   (property getter)
+            nrows -> int   (property getter)
+            row_ids    (property getter)
+            signals -> StringVector   (property getter)
+            std    (property getter)
+            transposed_flag -> int   (property getter)
+
+
+    class Model
+        Methods:
+            features -> Features   (property getter)
+            verbosity -> int   (property getter)
+            verbosity <- int   (property setter)
+            __init__() -> Model
+            add_age()
+            add_feature_generator(string & name, string & signal)
+            add_feature_generator_to_set(int i_set, string const & init_string)
+            add_feature_generators(string & name, vector< string > & signals)
+            add_feature_generators(string & name, vector< string > & signals, string init_string)
+            add_feature_generators(string & name, string & signal, string init_string)
+            add_feature_processor_to_set(int i_set, int duplicate, string const & init_string)
+            add_gender()
+            add_imputers()
+            add_imputers(string init_string)
+            add_imputers(vector< string > & features)
+            add_imputers(vector< string > & features, string init_string)
+            add_normalizers()
+            add_normalizers(string init_string)
+            add_normalizers(vector< string > & features)
+            add_normalizers(vector< string > & features, string init_string)
+            add_process_to_set(int i_set, int duplicate, string const & init_string)
+            add_process_to_set(int i_set, string const & init_string)
+            add_rep_processor_to_set(int i_set, string const & init_string)
+            apply(PidRepository rep, Samples samples) -> int
+            apply(PidRepository rep, Samples samples, int start_stage, int end_stage) -> int
+            apply_feature_processors(Features features) -> int
+            clear()
+            collect_and_add_virtual_signals(PidRepository rep) -> int
+            dprint_process(string const & pref, int rp_flag, int fg_flag, int fp_flag)
+            filter_rep_processors()
+            generate_all_features(PidRepository rep, Samples samples, Features features, StringVector req_feature_generators) -> int
+            get_all_features_names(vector< string > & feat_names, int before_process_set)
+            get_required_signal_names() -> StringVector
+            init_from_json_file(std::string const & fname)
+            init_from_json_file_with_alterations(std::string const & fname, StringVector json_alt) -> StringVector
+            learn(PidRepository rep, Samples samples) -> int
+            learn(PidRepository rep, Samples samples, int start_stage, int end_stage) -> int
+            learn_and_apply_feature_processors(Features features) -> int
+            learn_feature_generators(PidRepository rep, Samples learn_samples) -> int
+            learn_feature_processors(Features features) -> int
+            learn_rep_processors(PidRepository rep, Samples samples) -> int
+            quick_learn_rep_processors(PidRepository rep, Samples samples) -> int
+            read_from_file(string const & fname) -> int
+            set_predictor(string name)
+            set_predictor(string name, string init_string)
+            write_feature_matrix(string const mat_fname) -> int
+            write_to_file(std::string const & fname) -> int
+
+        Data descriptors:
+            features -> Features   (property getter)
+            verbosity -> int   (property getter)
+
+
+    class ModelStage
+        Methods:
+            __init__() -> ModelStage
+        Data and other attributes:
+        APPLY_FTR_GENERATORS = 2
+        APPLY_FTR_PROCESSORS = 4
+        APPLY_PREDICTOR = 6
+        END = 8
+        INSERT_PREDS = 7
+        LEARN_FTR_GENERATORS = 1
+        LEARN_FTR_PROCESSORS = 3
+        LEARN_PREDICTOR = 5
+        LEARN_REP_PROCESSORS = 0
+
+
+
+    class PidRepository
+        Methods:
+            pids -> IntVector   (property getter)
+            __init__() -> PidRepository
+            dict_name(int_section_id, int_id) -> string
+              returns name of section + id
+            dict_prep_sets_lookup_table(int_section_id, list_String set_names) -> BoolVector
+              returns a look-up-table for given set names
+            dict_section_id(str_secName) -> int
+              returns section id number for a given section name
+            export_to_numpy(str_signame) -> SigExporter
+              Returns the signal data represented as a list of numpy arrays, one for each field
+        get_sig = __export_to_pandas(self, sig_name_str, translate=True, pids=None)
+            get_sig(signame [, translate=True][, pids=None]) -> Pandas DataFrame
+            translate : If True, will decode categorical fields into a readable representation in Pandas
+            pid : If list is provided, will load only pids from the given list
+                  If 'All' is provided, will use all available pids
+            init(conf_file_name) -> int
+            returns -1 if fails
+            loadsig(str_signame) -> int
+              load a signal
+            read_all(conf_file_fname, [pids_to_take_array], [list_str_signals_to_take]) -> int
+            returns -1 if fails
+            reading a repository for a group of pids and signals.Empty group means all of it.
+            read_all(conf_file_fname, [pids_to_take_array], [list_str_signals_to_take]) -> int
+            returns -1 if fails
+            reading a repository for a group of pids and signals.Empty group means all of it.
+            read_all_i(std::string const & conf_fname, IntVector pids_to_take, IntVector signals_to_take) -> int
+            sig_id(str_signame) -> int
+              returns signal id number for a given signal name
+            sig_type(str_signame) -> int
+              returns signal type id for a given signal name
+            uget(int_pid, int_sid) -> SigVectorAdaptor
+              returns a vector of universal signals
+
+        Data descriptors:
+        dict
+            PidRepository_dict_get() -> Dictionary
+            pids -> IntVector   (property getter)
+
+
+    class Sample
+        Methods:
+            id -> int   (property getter)
+            outcome -> int   (property getter)
+            outcomeTime -> int   (property getter)
+            prediction    (property getter)
+            split -> int   (property getter)
+            time -> int   (property getter)
+            id <- int   (property setter)
+            outcome <- int   (property setter)
+            outcomeTime <- int   (property setter)
+            prediction <- float   (property setter)
+            split <- int   (property setter)
+            time <- int   (property setter)
+            __copy__() -> Sample
+            __init__() -> Sample
+            parse_from_string(string & s, int time_unit) -> int
+            print_(string const prefix)
+            print_()
+            write_to_string(string & s, int time_unit)
+
+        Data descriptors:
+            id -> int   (property getter)
+            outcome -> int   (property getter)
+            outcomeTime -> int   (property getter)
+            prediction    (property getter)
+            split -> int   (property getter)
+            time -> int   (property getter)
+
+
+    class Samples
+        Methods:
+            idSamples -> IdSamplesVectorAdaptor   (property getter)
+            time_unit -> int   (property getter)
+            time_unit <- int   (property setter)
+            from_df(PandasAdaptor pandas_df)
+            to_df() -> PandasAdaptor
+            __init__() -> Samples
+            append(Samples newSamples)
+        as_df = __sample_export_to_pandas(self)
+            clear()
+            dilute(float prob)
+            export_to_pandas_df() -> SampleVecExporter
+            export_to_sample_vec() -> SampleVectorAdaptor
+            get_attributes() -> StringVector
+            get_categs()
+            get_ids()
+            get_predictions_size() -> int
+            get_preds()
+            get_str_attributes() -> StringVector
+            get_y()
+            insertRec(int pid, int time, float outcome, int outcomeTime)
+            insertRec(int pid, int time, float outcome, int outcomeTime, float pred)
+            insertRec(int pid, int time)
+            insert_preds(Features featuresData) -> int
+            nSamples() -> int
+            normalize()
+            read_from_bin_file(string const & file_name) -> int
+            read_from_file(string const & file_name) -> int
+            same_as(Samples other, int mode) -> bool
+            sort_by_id_date()
+            version() -> int
+            write_to_bin_file(string const & file_name) -> int
+            write_to_file(string const & fname) -> int
+
+        Data descriptors:
+            idSamples -> IdSamplesVectorAdaptor   (property getter)
+            time_unit -> int   (property getter)
+
+
+    class Sig
+        Methods:
+            __init__(Sig other) -> Sig
+            date(int chan=0) -> int
+            date() -> int
+            days(int chan=0) -> int
+            days() -> int
+            hours(int chan=0) -> int
+            hours() -> int
+            minutes(int chan=0) -> int
+            minutes() -> int
+            months(int chan=0) -> int
+            months() -> int
+            time(int chan=0) -> int
+            time() -> int
+            timeU(int to_time_unit) -> int
+            val(int chan=0) -> float
+            val() -> float
+            years(int chan=0) -> int
+            years() -> int
+
+
+    class Split
+        Methods:
+            nsplits -> int   (property getter)
+            pid2split -> IntIntMapAdaptor   (property getter)
+            __init__() -> Split
+            clear()
+            read_from_file(string const & fname) -> int
+            write_to_file(string const & fname) -> int
+
+        Data descriptors:
+            nsplits -> int   (property getter)
+            pid2split -> IntIntMapAdaptor   (property getter)
+
+
+    class Time
+        Methods:
+            __init__() -> Time
+        Data and other attributes:
+        Date = 1
+        DateTimeString = 7
+        Days = 4
+        Hours = 5
+        Minutes = 6
+        Months = 3
+        Undefined = 0
+        Years = 2
+
+
+"""
+
+from sys import version_info as _swig_python_version_info
+# Import the low-level C/C++ module
+if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
+    from . import _medpython
+else:
+    import _medpython
+
+try:
+    import builtins as __builtin__
+except ImportError:
+    import __builtin__
+
+def _swig_repr(self):
+    try:
+        strthis = "proxy of " + self.this.__repr__()
+    except __builtin__.Exception:
+        strthis = ""
+    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
+
+def _swig_setattr_nondynamic_instance_variable(set):
+    def set_instance_attr(self, name, value):
+        if name == "this":
+            set(self, name, value)
+        elif name == "thisown":
+            self.this.own(value)
+        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
+            set(self, name, value)
+        else:
+            raise AttributeError("You cannot add instance attributes to %s" % self)
+    return set_instance_attr
+
+
+def _swig_setattr_nondynamic_class_variable(set):
+    def set_class_attr(cls, name, value):
+        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
+            set(cls, name, value)
+        else:
+            raise AttributeError("You cannot add class attributes to %s" % cls)
+    return set_class_attr
+
+
+def _swig_add_metaclass(metaclass):
+    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
+    def wrapper(cls):
+        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
+    return wrapper
+
+
+class _SwigNonDynamicMeta(type):
+    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
+    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
+
+
+class SwigPyIterator(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args, **kwargs):
+        raise AttributeError("No constructor defined - class is abstract")
+    __repr__ = _swig_repr
+    __swig_destroy__ = _medpython.delete_SwigPyIterator
+
+    def value(self):
+        return _medpython.SwigPyIterator_value(self)
+
+    def incr(self, n=1):
+        return _medpython.SwigPyIterator_incr(self, n)
+
+    def decr(self, n=1):
+        return _medpython.SwigPyIterator_decr(self, n)
+
+    def distance(self, x):
+        return _medpython.SwigPyIterator_distance(self, x)
+
+    def equal(self, x):
+        return _medpython.SwigPyIterator_equal(self, x)
+
+    def copy(self):
+        return _medpython.SwigPyIterator_copy(self)
+
+    def next(self):
+        return _medpython.SwigPyIterator_next(self)
+
+    def __next__(self):
+        return _medpython.SwigPyIterator___next__(self)
+
+    def previous(self):
+        return _medpython.SwigPyIterator_previous(self)
+
+    def advance(self, n):
+        return _medpython.SwigPyIterator_advance(self, n)
+
+    def __eq__(self, x):
+        return _medpython.SwigPyIterator___eq__(self, x)
+
+    def __ne__(self, x):
+        return _medpython.SwigPyIterator___ne__(self, x)
+
+    def __iadd__(self, n):
+        return _medpython.SwigPyIterator___iadd__(self, n)
+
+    def __isub__(self, n):
+        return _medpython.SwigPyIterator___isub__(self, n)
+
+    def __add__(self, n):
+        return _medpython.SwigPyIterator___add__(self, n)
+
+    def __sub__(self, *args):
+        return _medpython.SwigPyIterator___sub__(self, *args)
+    def __iter__(self):
+        return self
+
+# Register SwigPyIterator in _medpython:
+_medpython.SwigPyIterator_swigregister(SwigPyIterator)
+class BoolVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.BoolVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.BoolVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.BoolVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.BoolVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.BoolVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.BoolVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.BoolVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.BoolVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.BoolVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.BoolVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.BoolVector_pop(self)
+
+    def append(self, x):
+        return _medpython.BoolVector_append(self, x)
+
+    def empty(self):
+        return _medpython.BoolVector_empty(self)
+
+    def size(self):
+        return _medpython.BoolVector_size(self)
+
+    def swap(self, v):
+        return _medpython.BoolVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.BoolVector_begin(self)
+
+    def end(self):
+        return _medpython.BoolVector_end(self)
+
+    def rbegin(self):
+        return _medpython.BoolVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.BoolVector_rend(self)
+
+    def clear(self):
+        return _medpython.BoolVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.BoolVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.BoolVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.BoolVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.BoolVector_swiginit(self, _medpython.new_BoolVector(*args))
+
+    def push_back(self, x):
+        return _medpython.BoolVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.BoolVector_front(self)
+
+    def back(self):
+        return _medpython.BoolVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.BoolVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.BoolVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.BoolVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.BoolVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.BoolVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_BoolVector
+
+# Register BoolVector in _medpython:
+_medpython.BoolVector_swigregister(BoolVector)
+class IntVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.IntVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.IntVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.IntVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.IntVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.IntVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.IntVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.IntVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.IntVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.IntVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.IntVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.IntVector_pop(self)
+
+    def append(self, x):
+        return _medpython.IntVector_append(self, x)
+
+    def empty(self):
+        return _medpython.IntVector_empty(self)
+
+    def size(self):
+        return _medpython.IntVector_size(self)
+
+    def swap(self, v):
+        return _medpython.IntVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.IntVector_begin(self)
+
+    def end(self):
+        return _medpython.IntVector_end(self)
+
+    def rbegin(self):
+        return _medpython.IntVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.IntVector_rend(self)
+
+    def clear(self):
+        return _medpython.IntVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.IntVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.IntVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.IntVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.IntVector_swiginit(self, _medpython.new_IntVector(*args))
+
+    def push_back(self, x):
+        return _medpython.IntVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.IntVector_front(self)
+
+    def back(self):
+        return _medpython.IntVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.IntVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.IntVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.IntVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.IntVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.IntVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_IntVector
+
+# Register IntVector in _medpython:
+_medpython.IntVector_swigregister(IntVector)
+class CharVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.CharVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.CharVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.CharVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.CharVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.CharVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.CharVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.CharVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.CharVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.CharVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.CharVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.CharVector_pop(self)
+
+    def append(self, x):
+        return _medpython.CharVector_append(self, x)
+
+    def empty(self):
+        return _medpython.CharVector_empty(self)
+
+    def size(self):
+        return _medpython.CharVector_size(self)
+
+    def swap(self, v):
+        return _medpython.CharVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.CharVector_begin(self)
+
+    def end(self):
+        return _medpython.CharVector_end(self)
+
+    def rbegin(self):
+        return _medpython.CharVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.CharVector_rend(self)
+
+    def clear(self):
+        return _medpython.CharVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.CharVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.CharVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.CharVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.CharVector_swiginit(self, _medpython.new_CharVector(*args))
+
+    def push_back(self, x):
+        return _medpython.CharVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.CharVector_front(self)
+
+    def back(self):
+        return _medpython.CharVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.CharVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.CharVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.CharVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.CharVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.CharVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_CharVector
+
+# Register CharVector in _medpython:
+_medpython.CharVector_swigregister(CharVector)
+class DoubleVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.DoubleVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.DoubleVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.DoubleVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.DoubleVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.DoubleVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.DoubleVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.DoubleVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.DoubleVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.DoubleVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.DoubleVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.DoubleVector_pop(self)
+
+    def append(self, x):
+        return _medpython.DoubleVector_append(self, x)
+
+    def empty(self):
+        return _medpython.DoubleVector_empty(self)
+
+    def size(self):
+        return _medpython.DoubleVector_size(self)
+
+    def swap(self, v):
+        return _medpython.DoubleVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.DoubleVector_begin(self)
+
+    def end(self):
+        return _medpython.DoubleVector_end(self)
+
+    def rbegin(self):
+        return _medpython.DoubleVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.DoubleVector_rend(self)
+
+    def clear(self):
+        return _medpython.DoubleVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.DoubleVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.DoubleVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.DoubleVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.DoubleVector_swiginit(self, _medpython.new_DoubleVector(*args))
+
+    def push_back(self, x):
+        return _medpython.DoubleVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.DoubleVector_front(self)
+
+    def back(self):
+        return _medpython.DoubleVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.DoubleVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.DoubleVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.DoubleVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.DoubleVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.DoubleVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_DoubleVector
+
+# Register DoubleVector in _medpython:
+_medpython.DoubleVector_swigregister(DoubleVector)
+class StringVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.StringVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.StringVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.StringVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.StringVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.StringVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.StringVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.StringVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.StringVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.StringVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.StringVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.StringVector_pop(self)
+
+    def append(self, x):
+        return _medpython.StringVector_append(self, x)
+
+    def empty(self):
+        return _medpython.StringVector_empty(self)
+
+    def size(self):
+        return _medpython.StringVector_size(self)
+
+    def swap(self, v):
+        return _medpython.StringVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.StringVector_begin(self)
+
+    def end(self):
+        return _medpython.StringVector_end(self)
+
+    def rbegin(self):
+        return _medpython.StringVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.StringVector_rend(self)
+
+    def clear(self):
+        return _medpython.StringVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.StringVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.StringVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.StringVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.StringVector_swiginit(self, _medpython.new_StringVector(*args))
+
+    def push_back(self, x):
+        return _medpython.StringVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.StringVector_front(self)
+
+    def back(self):
+        return _medpython.StringVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.StringVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.StringVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.StringVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.StringVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.StringVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_StringVector
+
+# Register StringVector in _medpython:
+_medpython.StringVector_swigregister(StringVector)
+class FloatVector(object):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def iterator(self):
+        return _medpython.FloatVector_iterator(self)
+    def __iter__(self):
+        return self.iterator()
+
+    def __nonzero__(self):
+        return _medpython.FloatVector___nonzero__(self)
+
+    def __bool__(self):
+        return _medpython.FloatVector___bool__(self)
+
+    def __len__(self):
+        return _medpython.FloatVector___len__(self)
+
+    def __getslice__(self, i, j):
+        return _medpython.FloatVector___getslice__(self, i, j)
+
+    def __setslice__(self, *args):
+        return _medpython.FloatVector___setslice__(self, *args)
+
+    def __delslice__(self, i, j):
+        return _medpython.FloatVector___delslice__(self, i, j)
+
+    def __delitem__(self, *args):
+        return _medpython.FloatVector___delitem__(self, *args)
+
+    def __getitem__(self, *args):
+        return _medpython.FloatVector___getitem__(self, *args)
+
+    def __setitem__(self, *args):
+        return _medpython.FloatVector___setitem__(self, *args)
+
+    def pop(self):
+        return _medpython.FloatVector_pop(self)
+
+    def append(self, x):
+        return _medpython.FloatVector_append(self, x)
+
+    def empty(self):
+        return _medpython.FloatVector_empty(self)
+
+    def size(self):
+        return _medpython.FloatVector_size(self)
+
+    def swap(self, v):
+        return _medpython.FloatVector_swap(self, v)
+
+    def begin(self):
+        return _medpython.FloatVector_begin(self)
+
+    def end(self):
+        return _medpython.FloatVector_end(self)
+
+    def rbegin(self):
+        return _medpython.FloatVector_rbegin(self)
+
+    def rend(self):
+        return _medpython.FloatVector_rend(self)
+
+    def clear(self):
+        return _medpython.FloatVector_clear(self)
+
+    def get_allocator(self):
+        return _medpython.FloatVector_get_allocator(self)
+
+    def pop_back(self):
+        return _medpython.FloatVector_pop_back(self)
+
+    def erase(self, *args):
+        return _medpython.FloatVector_erase(self, *args)
+
+    def __init__(self, *args):
+        _medpython.FloatVector_swiginit(self, _medpython.new_FloatVector(*args))
+
+    def push_back(self, x):
+        return _medpython.FloatVector_push_back(self, x)
+
+    def front(self):
+        return _medpython.FloatVector_front(self)
+
+    def back(self):
+        return _medpython.FloatVector_back(self)
+
+    def assign(self, n, x):
+        return _medpython.FloatVector_assign(self, n, x)
+
+    def resize(self, *args):
+        return _medpython.FloatVector_resize(self, *args)
+
+    def insert(self, *args):
+        return _medpython.FloatVector_insert(self, *args)
+
+    def reserve(self, n):
+        return _medpython.FloatVector_reserve(self, n)
+
+    def capacity(self):
+        return _medpython.FloatVector_capacity(self)
+    __swig_destroy__ = _medpython.delete_FloatVector
+
+# Register FloatVector in _medpython:
+_medpython.FloatVector_swigregister(FloatVector)
+class StopIterator(object):
+    r"""Proxy of C++ StopIterator class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StopIterator self) -> StopIterator"""
+        _medpython.StopIterator_swiginit(self, _medpython.new_StopIterator())
+    __swig_destroy__ = _medpython.delete_StopIterator
+
+# Register StopIterator in _medpython:
+_medpython.StopIterator_swigregister(StopIterator)
+class IntIntMapAdaptor(object):
+    r"""Proxy of C++ MPIntIntMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(IntIntMapAdaptor self) -> IntIntMapAdaptor"""
+        _medpython.IntIntMapAdaptor_swiginit(self, _medpython.new_IntIntMapAdaptor())
+    __swig_destroy__ = _medpython.delete_IntIntMapAdaptor
+
+    def __len__(self):
+        r"""__len__(IntIntMapAdaptor self) -> int"""
+        return _medpython.IntIntMapAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(IntIntMapAdaptor self, int i) -> int"""
+        return _medpython.IntIntMapAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(IntIntMapAdaptor self, int i, int val)"""
+        return _medpython.IntIntMapAdaptor___setitem__(self, i, val)
+
+    def keys(self):
+        r"""keys(IntIntMapAdaptor self)"""
+        return _medpython.IntIntMapAdaptor_keys(self)
+
+# Register IntIntMapAdaptor in _medpython:
+_medpython.IntIntMapAdaptor_swigregister(IntIntMapAdaptor)
+class StringStringMapAdaptor(object):
+    r"""Proxy of C++ MPStringStringMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringStringMapAdaptor self) -> StringStringMapAdaptor"""
+        _medpython.StringStringMapAdaptor_swiginit(self, _medpython.new_StringStringMapAdaptor())
+    __swig_destroy__ = _medpython.delete_StringStringMapAdaptor
+
+    def __len__(self):
+        r"""__len__(StringStringMapAdaptor self) -> int"""
+        return _medpython.StringStringMapAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(StringStringMapAdaptor self, std::string const & i) -> std::string"""
+        return _medpython.StringStringMapAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(StringStringMapAdaptor self, std::string const & i, std::string const & val)"""
+        return _medpython.StringStringMapAdaptor___setitem__(self, i, val)
+
+    def keys(self):
+        r"""keys(StringStringMapAdaptor self) -> StringVector"""
+        return _medpython.StringStringMapAdaptor_keys(self)
+
+# Register StringStringMapAdaptor in _medpython:
+_medpython.StringStringMapAdaptor_swigregister(StringStringMapAdaptor)
+class StringFloatMapAdaptor(object):
+    r"""Proxy of C++ MPStringFloatMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringFloatMapAdaptor self) -> StringFloatMapAdaptor"""
+        _medpython.StringFloatMapAdaptor_swiginit(self, _medpython.new_StringFloatMapAdaptor())
+    __swig_destroy__ = _medpython.delete_StringFloatMapAdaptor
+
+    def __len__(self):
+        r"""__len__(StringFloatMapAdaptor self) -> int"""
+        return _medpython.StringFloatMapAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(StringFloatMapAdaptor self, std::string const & i) -> float"""
+        return _medpython.StringFloatMapAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(StringFloatMapAdaptor self, std::string const & i, float val)"""
+        return _medpython.StringFloatMapAdaptor___setitem__(self, i, val)
+
+    def keys(self):
+        r"""keys(StringFloatMapAdaptor self) -> StringVector"""
+        return _medpython.StringFloatMapAdaptor_keys(self)
+
+# Register StringFloatMapAdaptor in _medpython:
+_medpython.StringFloatMapAdaptor_swigregister(StringFloatMapAdaptor)
+class StringVecFloatMapAdaptor(object):
+    r"""Proxy of C++ MPStringVecFloatMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringVecFloatMapAdaptor self) -> StringVecFloatMapAdaptor"""
+        _medpython.StringVecFloatMapAdaptor_swiginit(self, _medpython.new_StringVecFloatMapAdaptor())
+    __swig_destroy__ = _medpython.delete_StringVecFloatMapAdaptor
+
+    def __len__(self):
+        r"""__len__(StringVecFloatMapAdaptor self) -> int"""
+        return _medpython.StringVecFloatMapAdaptor___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(StringVecFloatMapAdaptor self, std::string key)"""
+        return _medpython.StringVecFloatMapAdaptor___getitem__(self, key)
+
+    def __setitem__(self, key, float_in_buf):
+        r"""__setitem__(StringVecFloatMapAdaptor self, std::string key, float * float_in_buf)"""
+        return _medpython.StringVecFloatMapAdaptor___setitem__(self, key, float_in_buf)
+
+    def keys(self):
+        r"""keys(StringVecFloatMapAdaptor self) -> StringVector"""
+        return _medpython.StringVecFloatMapAdaptor_keys(self)
+
+# Register StringVecFloatMapAdaptor in _medpython:
+_medpython.StringVecFloatMapAdaptor_swigregister(StringVecFloatMapAdaptor)
+class IntPairIntIntMapAdaptor(object):
+    r"""Proxy of C++ MPIntPairIntIntMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(IntPairIntIntMapAdaptor self) -> IntPairIntIntMapAdaptor"""
+        _medpython.IntPairIntIntMapAdaptor_swiginit(self, _medpython.new_IntPairIntIntMapAdaptor())
+    __swig_destroy__ = _medpython.delete_IntPairIntIntMapAdaptor
+
+    def __len__(self):
+        r"""__len__(IntPairIntIntMapAdaptor self) -> int"""
+        return _medpython.IntPairIntIntMapAdaptor___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(IntPairIntIntMapAdaptor self, int key)"""
+        return _medpython.IntPairIntIntMapAdaptor___getitem__(self, key)
+
+    def __setitem__(self, key, int_in_buf):
+        r"""__setitem__(IntPairIntIntMapAdaptor self, int key, int * int_in_buf)"""
+        return _medpython.IntPairIntIntMapAdaptor___setitem__(self, key, int_in_buf)
+
+    def keys(self):
+        r"""keys(IntPairIntIntMapAdaptor self)"""
+        return _medpython.IntPairIntIntMapAdaptor_keys(self)
+
+# Register IntPairIntIntMapAdaptor in _medpython:
+_medpython.IntPairIntIntMapAdaptor_swigregister(IntPairIntIntMapAdaptor)
+class StringUOSetStringMapAdaptor(object):
+    r"""Proxy of C++ MPStringUOSetStringMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringUOSetStringMapAdaptor self) -> StringUOSetStringMapAdaptor"""
+        _medpython.StringUOSetStringMapAdaptor_swiginit(self, _medpython.new_StringUOSetStringMapAdaptor())
+    __swig_destroy__ = _medpython.delete_StringUOSetStringMapAdaptor
+
+    def __len__(self):
+        r"""__len__(StringUOSetStringMapAdaptor self) -> int"""
+        return _medpython.StringUOSetStringMapAdaptor___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(StringUOSetStringMapAdaptor self, std::string key) -> StringVector"""
+        return _medpython.StringUOSetStringMapAdaptor___getitem__(self, key)
+
+    def __setitem__(self, key, val):
+        r"""__setitem__(StringUOSetStringMapAdaptor self, std::string key, StringVector val)"""
+        return _medpython.StringUOSetStringMapAdaptor___setitem__(self, key, val)
+
+    def keys(self):
+        r"""keys(StringUOSetStringMapAdaptor self) -> StringVector"""
+        return _medpython.StringUOSetStringMapAdaptor_keys(self)
+
+# Register StringUOSetStringMapAdaptor in _medpython:
+_medpython.StringUOSetStringMapAdaptor_swigregister(StringUOSetStringMapAdaptor)
+class IntStringMapAdaptor(object):
+    r"""Proxy of C++ MPIntStringMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(IntStringMapAdaptor self) -> IntStringMapAdaptor"""
+        _medpython.IntStringMapAdaptor_swiginit(self, _medpython.new_IntStringMapAdaptor())
+    __swig_destroy__ = _medpython.delete_IntStringMapAdaptor
+
+    def __len__(self):
+        r"""__len__(IntStringMapAdaptor self) -> int"""
+        return _medpython.IntStringMapAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(IntStringMapAdaptor self, int i) -> std::string"""
+        return _medpython.IntStringMapAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(IntStringMapAdaptor self, int i, string const & val)"""
+        return _medpython.IntStringMapAdaptor___setitem__(self, i, val)
+
+    def keys(self):
+        r"""keys(IntStringMapAdaptor self) -> IntVector"""
+        return _medpython.IntStringMapAdaptor_keys(self)
+
+# Register IntStringMapAdaptor in _medpython:
+_medpython.IntStringMapAdaptor_swigregister(IntStringMapAdaptor)
+class IntVecIntMapAdaptor(object):
+    r"""Proxy of C++ MPIntVecIntMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    o = property(_medpython.IntVecIntMapAdaptor_o_get, _medpython.IntVecIntMapAdaptor_o_set, doc=r"""o : p.std::map<(int,std::vector<(int,std::allocator<(int)>)>)>""")
+
+    def __init__(self):
+        r"""__init__(IntVecIntMapAdaptor self) -> IntVecIntMapAdaptor"""
+        _medpython.IntVecIntMapAdaptor_swiginit(self, _medpython.new_IntVecIntMapAdaptor())
+    __swig_destroy__ = _medpython.delete_IntVecIntMapAdaptor
+
+    def __len__(self):
+        r"""__len__(IntVecIntMapAdaptor self) -> int"""
+        return _medpython.IntVecIntMapAdaptor___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(IntVecIntMapAdaptor self, int key)"""
+        return _medpython.IntVecIntMapAdaptor___getitem__(self, key)
+
+    def __setitem__(self, key, int_in_buf):
+        r"""__setitem__(IntVecIntMapAdaptor self, int key, int * int_in_buf)"""
+        return _medpython.IntVecIntMapAdaptor___setitem__(self, key, int_in_buf)
+
+    def keys(self):
+        r"""keys(IntVecIntMapAdaptor self) -> IntVector"""
+        return _medpython.IntVecIntMapAdaptor_keys(self)
+
+# Register IntVecIntMapAdaptor in _medpython:
+_medpython.IntVecIntMapAdaptor_swigregister(IntVecIntMapAdaptor)
+
+def logger_use_stdout():
+    r"""logger_use_stdout()"""
+    return _medpython.logger_use_stdout()
+class StringBtResultMap(object):
+    r"""Proxy of C++ MPStringBtResultMap class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringBtResultMap self) -> StringBtResultMap"""
+        _medpython.StringBtResultMap_swiginit(self, _medpython.new_StringBtResultMap())
+    __swig_destroy__ = _medpython.delete_StringBtResultMap
+
+    def __len__(self):
+        r"""__len__(StringBtResultMap self) -> int"""
+        return _medpython.StringBtResultMap___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(StringBtResultMap self, std::string const & key) -> StringFloatMapAdaptor"""
+        return _medpython.StringBtResultMap___getitem__(self, key)
+
+    def __setitem__(self, key, val):
+        r"""__setitem__(StringBtResultMap self, std::string const & key, StringFloatMapAdaptor val)"""
+        return _medpython.StringBtResultMap___setitem__(self, key, val)
+
+    def keys(self):
+        r"""keys(StringBtResultMap self) -> StringVector"""
+        return _medpython.StringBtResultMap_keys(self)
+
+    def to_file(self, file_path):
+        r"""to_file(StringBtResultMap self, std::string const & file_path)"""
+        return _medpython.StringBtResultMap_to_file(self, file_path)
+
+# Register StringBtResultMap in _medpython:
+_medpython.StringBtResultMap_swigregister(StringBtResultMap)
+class Bootstrap(object):
+    r"""Proxy of C++ MPBootstrap class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Bootstrap self) -> Bootstrap"""
+        _medpython.Bootstrap_swiginit(self, _medpython.new_Bootstrap())
+    __swig_destroy__ = _medpython.delete_Bootstrap
+
+    def MEDPY_GET_sample_per_pid(self):
+        r"""MEDPY_GET_sample_per_pid(Bootstrap self) -> int"""
+        return _medpython.Bootstrap_MEDPY_GET_sample_per_pid(self)
+
+    def MEDPY_SET_sample_per_pid(self, _sample_per_pid):
+        r"""MEDPY_SET_sample_per_pid(Bootstrap self, int _sample_per_pid)"""
+        return _medpython.Bootstrap_MEDPY_SET_sample_per_pid(self, _sample_per_pid)
+
+    def MEDPY_GET_nbootstrap(self):
+        r"""MEDPY_GET_nbootstrap(Bootstrap self) -> int"""
+        return _medpython.Bootstrap_MEDPY_GET_nbootstrap(self)
+
+    def MEDPY_SET_nbootstrap(self, _nbootstrap):
+        r"""MEDPY_SET_nbootstrap(Bootstrap self, int _nbootstrap)"""
+        return _medpython.Bootstrap_MEDPY_SET_nbootstrap(self, _nbootstrap)
+
+    def MEDPY_GET_ROC_score_min_samples(self):
+        r"""MEDPY_GET_ROC_score_min_samples(Bootstrap self) -> int"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_score_min_samples(self)
+
+    def MEDPY_SET_ROC_score_min_samples(self, _ROC_score_min_samples):
+        r"""MEDPY_SET_ROC_score_min_samples(Bootstrap self, int _ROC_score_min_samples)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_score_min_samples(self, _ROC_score_min_samples)
+
+    def MEDPY_GET_ROC_score_bins(self):
+        r"""MEDPY_GET_ROC_score_bins(Bootstrap self) -> int"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_score_bins(self)
+
+    def MEDPY_SET_ROC_score_bins(self, _ROC_score_bins):
+        r"""MEDPY_SET_ROC_score_bins(Bootstrap self, int _ROC_score_bins)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_score_bins(self, _ROC_score_bins)
+
+    def MEDPY_GET_ROC_max_diff_working_point(self):
+        r"""MEDPY_GET_ROC_max_diff_working_point(Bootstrap self) -> float"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_max_diff_working_point(self)
+
+    def MEDPY_SET_ROC_max_diff_working_point(self, _ROC_max_diff_working_point):
+        r"""MEDPY_SET_ROC_max_diff_working_point(Bootstrap self, float _ROC_max_diff_working_point)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_max_diff_working_point(self, _ROC_max_diff_working_point)
+
+    def MEDPY_GET_ROC_score_resolution(self):
+        r"""MEDPY_GET_ROC_score_resolution(Bootstrap self) -> float"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_score_resolution(self)
+
+    def MEDPY_SET_ROC_score_resolution(self, _ROC_score_resolutiont):
+        r"""MEDPY_SET_ROC_score_resolution(Bootstrap self, float _ROC_score_resolutiont)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_score_resolution(self, _ROC_score_resolutiont)
+
+    def MEDPY_GET_ROC_use_score_working_points(self):
+        r"""MEDPY_GET_ROC_use_score_working_points(Bootstrap self) -> bool"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_use_score_working_points(self)
+
+    def MEDPY_SET_ROC_use_score_working_points(self, _ROC_use_score_working_points):
+        r"""MEDPY_SET_ROC_use_score_working_points(Bootstrap self, bool _ROC_use_score_working_points)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_use_score_working_points(self, _ROC_use_score_working_points)
+
+    def MEDPY_GET_ROC_working_point_FPR(self):
+        r"""MEDPY_GET_ROC_working_point_FPR(Bootstrap self) -> FloatVector"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_working_point_FPR(self)
+
+    def MEDPY_SET_ROC_working_point_FPR(self, _ROC_working_point_FPR):
+        r"""MEDPY_SET_ROC_working_point_FPR(Bootstrap self, FloatVector _ROC_working_point_FPR)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_working_point_FPR(self, _ROC_working_point_FPR)
+
+    def MEDPY_GET_ROC_working_point_PR(self):
+        r"""MEDPY_GET_ROC_working_point_PR(Bootstrap self) -> FloatVector"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_working_point_PR(self)
+
+    def MEDPY_SET_ROC_working_point_PR(self, _ROC_working_point_PR):
+        r"""MEDPY_SET_ROC_working_point_PR(Bootstrap self, FloatVector _ROC_working_point_PR)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_working_point_PR(self, _ROC_working_point_PR)
+
+    def MEDPY_GET_ROC_working_point_SENS(self):
+        r"""MEDPY_GET_ROC_working_point_SENS(Bootstrap self) -> FloatVector"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_working_point_SENS(self)
+
+    def MEDPY_SET_ROC_working_point_SENS(self, _ROC_working_point_SENS):
+        r"""MEDPY_SET_ROC_working_point_SENS(Bootstrap self, FloatVector _ROC_working_point_SENS)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_working_point_SENS(self, _ROC_working_point_SENS)
+
+    def MEDPY_GET_ROC_working_point_Score(self):
+        r"""MEDPY_GET_ROC_working_point_Score(Bootstrap self) -> FloatVector"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_working_point_Score(self)
+
+    def MEDPY_SET_ROC_working_point_Score(self, _ROC_working_point_Score):
+        r"""MEDPY_SET_ROC_working_point_Score(Bootstrap self, FloatVector _ROC_working_point_Score)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_working_point_Score(self, _ROC_working_point_Score)
+
+    def MEDPY_GET_ROC_working_point_TOPN(self):
+        r"""MEDPY_GET_ROC_working_point_TOPN(Bootstrap self) -> IntVector"""
+        return _medpython.Bootstrap_MEDPY_GET_ROC_working_point_TOPN(self)
+
+    def MEDPY_SET_ROC_working_point_TOPN(self, MEDPY_GET_ROC_working_point_TOPN):
+        r"""MEDPY_SET_ROC_working_point_TOPN(Bootstrap self, IntVector MEDPY_GET_ROC_working_point_TOPN)"""
+        return _medpython.Bootstrap_MEDPY_SET_ROC_working_point_TOPN(self, MEDPY_GET_ROC_working_point_TOPN)
+
+    def parse_cohort_line(self, line):
+        r"""parse_cohort_line(Bootstrap self, string const & line)"""
+        return _medpython.Bootstrap_parse_cohort_line(self, line)
+
+    def get_cohort_from_arg(self, single_cohort):
+        r"""get_cohort_from_arg(Bootstrap self, string const & single_cohort)"""
+        return _medpython.Bootstrap_get_cohort_from_arg(self, single_cohort)
+
+    def parse_cohort_file(self, cohorts_path):
+        r"""parse_cohort_file(Bootstrap self, string const & cohorts_path)"""
+        return _medpython.Bootstrap_parse_cohort_file(self, cohorts_path)
+
+    def init_from_str(self, str):
+        r"""init_from_str(Bootstrap self, string const & str)"""
+        return _medpython.Bootstrap_init_from_str(self, str)
+
+    def bootstrap_cohort(self, samples, rep_path, json_model, cohorts_path):
+        r"""bootstrap_cohort(Bootstrap self, Samples samples, string const & rep_path, string const & json_model, string const & cohorts_path) -> StringBtResultMap"""
+        return _medpython.Bootstrap_bootstrap_cohort(self, samples, rep_path, json_model, cohorts_path)
+
+    def _bootstrap(self, preds, labels):
+        r"""_bootstrap(Bootstrap self, FloatVector preds, FloatVector labels) -> StringFloatMapAdaptor"""
+        return _medpython.Bootstrap__bootstrap(self, preds, labels)
+
+    def _bootstrap_pid(self, pids, preds, labels):
+        r"""_bootstrap_pid(Bootstrap self, FloatVector pids, FloatVector preds, FloatVector labels) -> StringFloatMapAdaptor"""
+        return _medpython.Bootstrap__bootstrap_pid(self, pids, preds, labels)
+
+    sample_per_pid = property(MEDPY_GET_sample_per_pid,MEDPY_SET_sample_per_pid)
+    nbootstrap = property(MEDPY_GET_nbootstrap,MEDPY_SET_nbootstrap)
+    ROC_score_min_samples = property(MEDPY_GET_ROC_score_min_samples,MEDPY_SET_ROC_score_min_samples)
+    ROC_score_bins = property(MEDPY_GET_ROC_score_bins,MEDPY_SET_ROC_score_bins)
+    ROC_max_diff_working_point = property(MEDPY_GET_ROC_max_diff_working_point,MEDPY_SET_ROC_max_diff_working_point)
+    ROC_score_resolution = property(MEDPY_GET_ROC_score_resolution,MEDPY_SET_ROC_score_resolution)
+    ROC_use_score_working_points = property(MEDPY_GET_ROC_use_score_working_points,MEDPY_SET_ROC_use_score_working_points)
+    ROC_working_point_FPR = property(MEDPY_GET_ROC_working_point_FPR,MEDPY_SET_ROC_working_point_FPR)
+    ROC_working_point_PR = property(MEDPY_GET_ROC_working_point_PR,MEDPY_SET_ROC_working_point_PR)
+    ROC_working_point_SENS = property(MEDPY_GET_ROC_working_point_SENS,MEDPY_SET_ROC_working_point_SENS)
+    ROC_working_point_Score = property(MEDPY_GET_ROC_working_point_Score,MEDPY_SET_ROC_working_point_Score)
+    ROC_working_point_TOPN = property(MEDPY_GET_ROC_working_point_TOPN,MEDPY_SET_ROC_working_point_TOPN)
+
+
+# Register Bootstrap in _medpython:
+_medpython.Bootstrap_swigregister(Bootstrap)
+class Dictionary(object):
+    r"""Proxy of C++ MPDictionary class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, rep):
+        r"""__init__(Dictionary self, PidRepository rep) -> Dictionary"""
+        _medpython.Dictionary_swiginit(self, _medpython.new_Dictionary(rep))
+
+    def section_id(self, name):
+        r"""section_id(Dictionary self, string name) -> int"""
+        return _medpython.Dictionary_section_id(self, name)
+
+    def id(self, section_id, signame):
+        r"""id(Dictionary self, int section_id, string & signame) -> int"""
+        return _medpython.Dictionary_id(self, section_id, signame)
+
+    def name(self, section_id, id):
+        r"""name(Dictionary self, int section_id, int id) -> string"""
+        return _medpython.Dictionary_name(self, section_id, id)
+
+    def prep_sets_lookup_table(self, section_id, set_names):
+        r"""prep_sets_lookup_table(Dictionary self, int section_id, StringVector set_names)"""
+        return _medpython.Dictionary_prep_sets_lookup_table(self, section_id, set_names)
+
+    def get_members_to_all_sets(self, section_id, members_array):
+        r"""get_members_to_all_sets(Dictionary self, int section_id, int * members_array) -> IntVecIntMapAdaptor"""
+        return _medpython.Dictionary_get_members_to_all_sets(self, section_id, members_array)
+    __swig_destroy__ = _medpython.delete_Dictionary
+
+# Register Dictionary in _medpython:
+_medpython.Dictionary_swigregister(Dictionary)
+class FeatureAttr(object):
+    r"""Proxy of C++ MPFeatureAttr class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(FeatureAttr self) -> FeatureAttr"""
+        _medpython.FeatureAttr_swiginit(self, _medpython.new_FeatureAttr())
+    __swig_destroy__ = _medpython.delete_FeatureAttr
+
+    def MEDPY_SET_normalized(self, _normalized):
+        r"""MEDPY_SET_normalized(FeatureAttr self, bool _normalized)"""
+        return _medpython.FeatureAttr_MEDPY_SET_normalized(self, _normalized)
+
+    def MEDPY_GET_normalized(self):
+        r"""MEDPY_GET_normalized(FeatureAttr self) -> bool"""
+        return _medpython.FeatureAttr_MEDPY_GET_normalized(self)
+
+    def MEDPY_SET_imputed(self, _imputed):
+        r"""MEDPY_SET_imputed(FeatureAttr self, bool _imputed)"""
+        return _medpython.FeatureAttr_MEDPY_SET_imputed(self, _imputed)
+
+    def MEDPY_GET_imputed(self):
+        r"""MEDPY_GET_imputed(FeatureAttr self) -> bool"""
+        return _medpython.FeatureAttr_MEDPY_GET_imputed(self)
+
+    def MEDPY_SET_denorm_mean(self, _denorm_mean):
+        r"""MEDPY_SET_denorm_mean(FeatureAttr self, float _denorm_mean)"""
+        return _medpython.FeatureAttr_MEDPY_SET_denorm_mean(self, _denorm_mean)
+
+    def MEDPY_GET_denorm_mean(self):
+        r"""MEDPY_GET_denorm_mean(FeatureAttr self) -> float"""
+        return _medpython.FeatureAttr_MEDPY_GET_denorm_mean(self)
+
+    def MEDPY_SET_denorm_sdv(self, _denorm_sdv):
+        r"""MEDPY_SET_denorm_sdv(FeatureAttr self, float _denorm_sdv)"""
+        return _medpython.FeatureAttr_MEDPY_SET_denorm_sdv(self, _denorm_sdv)
+
+    def MEDPY_GET_denorm_sdv(self):
+        r"""MEDPY_GET_denorm_sdv(FeatureAttr self) -> float"""
+        return _medpython.FeatureAttr_MEDPY_GET_denorm_sdv(self)
+
+    def asSerializable(self):
+        r"""asSerializable(FeatureAttr self) -> SerializableObject"""
+        return _medpython.FeatureAttr_asSerializable(self)
+
+    normalized = property(MEDPY_GET_normalized,MEDPY_SET_normalized)
+    imputed = property(MEDPY_GET_imputed,MEDPY_SET_imputed)
+    denorm_mean = property(MEDPY_GET_denorm_mean,MEDPY_SET_denorm_mean)
+    denorm_sdv = property(MEDPY_GET_denorm_sdv,MEDPY_SET_denorm_sdv)
+
+
+# Register FeatureAttr in _medpython:
+_medpython.FeatureAttr_swigregister(FeatureAttr)
+class StringFeatureAttrMapAdaptor(object):
+    r"""Proxy of C++ MPStringFeatureAttrMapAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(StringFeatureAttrMapAdaptor self) -> StringFeatureAttrMapAdaptor"""
+        _medpython.StringFeatureAttrMapAdaptor_swiginit(self, _medpython.new_StringFeatureAttrMapAdaptor())
+    __swig_destroy__ = _medpython.delete_StringFeatureAttrMapAdaptor
+
+    def __len__(self):
+        r"""__len__(StringFeatureAttrMapAdaptor self) -> int"""
+        return _medpython.StringFeatureAttrMapAdaptor___len__(self)
+
+    def __getitem__(self, key):
+        r"""__getitem__(StringFeatureAttrMapAdaptor self, std::string key) -> FeatureAttr"""
+        return _medpython.StringFeatureAttrMapAdaptor___getitem__(self, key)
+
+    def __setitem__(self, key, val):
+        r"""__setitem__(StringFeatureAttrMapAdaptor self, std::string key, FeatureAttr val)"""
+        return _medpython.StringFeatureAttrMapAdaptor___setitem__(self, key, val)
+
+    def keys(self):
+        r"""keys(StringFeatureAttrMapAdaptor self) -> StringVector"""
+        return _medpython.StringFeatureAttrMapAdaptor_keys(self)
+
+# Register StringFeatureAttrMapAdaptor in _medpython:
+_medpython.StringFeatureAttrMapAdaptor_swigregister(StringFeatureAttrMapAdaptor)
+class Features(object):
+    r"""Proxy of C++ MPFeatures class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    __swig_destroy__ = _medpython.delete_Features
+
+    def __init__(self, *args):
+        r"""
+        __init__(Features self) -> Features
+        __init__(Features self, int _time_unit) -> Features
+        __init__(Features self, Features other) -> Features
+        """
+        _medpython.Features_swiginit(self, _medpython.new_Features(*args))
+
+    def MEDPY_GET_data(self):
+        r"""MEDPY_GET_data(Features self) -> StringVecFloatMapAdaptor"""
+        return _medpython.Features_MEDPY_GET_data(self)
+
+    def MEDPY_GET_weights(self):
+        r"""MEDPY_GET_weights(Features self)"""
+        return _medpython.Features_MEDPY_GET_weights(self)
+
+    def MEDPY_GET_samples(self):
+        r"""MEDPY_GET_samples(Features self) -> SampleVectorAdaptor"""
+        return _medpython.Features_MEDPY_GET_samples(self)
+
+    def MEDPY_GET_pid_pos_len(self):
+        r"""MEDPY_GET_pid_pos_len(Features self) -> IntPairIntIntMapAdaptor"""
+        return _medpython.Features_MEDPY_GET_pid_pos_len(self)
+
+    def MEDPY_GET_attributes(self):
+        r"""MEDPY_GET_attributes(Features self) -> StringFeatureAttrMapAdaptor"""
+        return _medpython.Features_MEDPY_GET_attributes(self)
+
+    def MEDPY_GET_tags(self):
+        r"""MEDPY_GET_tags(Features self) -> StringUOSetStringMapAdaptor"""
+        return _medpython.Features_MEDPY_GET_tags(self)
+
+    def MEDPY_GET_time_unit(self):
+        r"""MEDPY_GET_time_unit(Features self) -> int"""
+        return _medpython.Features_MEDPY_GET_time_unit(self)
+
+    def MEDPY_SET_time_unit(self, new_time_unit):
+        r"""MEDPY_SET_time_unit(Features self, int new_time_unit)"""
+        return _medpython.Features_MEDPY_SET_time_unit(self, new_time_unit)
+
+    @staticmethod
+    def MEDPY_GET_global_serial_id_cnt():
+        r"""MEDPY_GET_global_serial_id_cnt() -> int"""
+        return _medpython.Features_MEDPY_GET_global_serial_id_cnt()
+
+    @staticmethod
+    def MEDPY_SET_global_serial_id_cnt(newval):
+        r"""MEDPY_SET_global_serial_id_cnt(int newval)"""
+        return _medpython.Features_MEDPY_SET_global_serial_id_cnt(newval)
+
+    def clear(self):
+        r"""clear(Features self)"""
+        return _medpython.Features_clear(self)
+
+    def set_time_unit(self, _time_unit):
+        r"""set_time_unit(Features self, int _time_unit)"""
+        return _medpython.Features_set_time_unit(self, _time_unit)
+
+    def get_feature_names(self):
+        r"""get_feature_names(Features self) -> StringVector"""
+        return _medpython.Features_get_feature_names(self)
+
+    def get_as_matrix(self, *args):
+        r"""
+        get_as_matrix(Features self, Mat mat)
+        get_as_matrix(Features self, Mat mat, StringVector names)
+        get_as_matrix(Features self, Mat mat, StringVector names, int * int_in_buf)
+        """
+        return _medpython.Features_get_as_matrix(self, *args)
+
+    def set_as_matrix(self, mat):
+        r"""set_as_matrix(Features self, Mat mat)"""
+        return _medpython.Features_set_as_matrix(self, mat)
+
+    def append_samples(self, *args):
+        r"""
+        append_samples(Features self, IdSamples in_samples)
+        append_samples(Features self, Samples in_samples)
+        """
+        return _medpython.Features_append_samples(self, *args)
+
+    def insert_samples(self, in_samples, index):
+        r"""insert_samples(Features self, IdSamples in_samples, int index)"""
+        return _medpython.Features_insert_samples(self, in_samples, index)
+
+    def init_all_samples(self, in_samples):
+        r"""init_all_samples(Features self, IdSamplesVectorAdaptor in_samples)"""
+        return _medpython.Features_init_all_samples(self, in_samples)
+
+    def init_pid_pos_len(self):
+        r"""init_pid_pos_len(Features self)"""
+        return _medpython.Features_init_pid_pos_len(self)
+
+    def get_pid_pos(self, pid):
+        r"""get_pid_pos(Features self, int pid) -> int"""
+        return _medpython.Features_get_pid_pos(self, pid)
+
+    def get_pid_len(self, pid):
+        r"""get_pid_len(Features self, int pid) -> int"""
+        return _medpython.Features_get_pid_len(self, pid)
+
+    def get_crc(self):
+        r"""get_crc(Features self) -> unsigned int"""
+        return _medpython.Features_get_crc(self)
+
+    def print_csv(self):
+        r"""print_csv(Features self)"""
+        return _medpython.Features_print_csv(self)
+
+    def get_samples(self, outSamples):
+        r"""get_samples(Features self, Samples outSamples)"""
+        return _medpython.Features_get_samples(self, outSamples)
+
+    def get_max_serial_id_cnt(self):
+        r"""get_max_serial_id_cnt(Features self) -> int"""
+        return _medpython.Features_get_max_serial_id_cnt(self)
+
+    def write_as_csv_mat(self, csv_fname):
+        r"""write_as_csv_mat(Features self, string const & csv_fname) -> int"""
+        return _medpython.Features_write_as_csv_mat(self, csv_fname)
+
+    def read_from_csv_mat(self, csv_fname):
+        r"""read_from_csv_mat(Features self, string const & csv_fname) -> int"""
+        return _medpython.Features_read_from_csv_mat(self, csv_fname)
+
+    def filter(self, selectedFeatures):
+        r"""filter(Features self, StringVector selectedFeatures) -> int"""
+        return _medpython.Features_filter(self, selectedFeatures)
+
+    def version(self):
+        r"""version(Features self) -> int"""
+        return _medpython.Features_version(self)
+
+    def asSerializable(self):
+        r"""asSerializable(Features self) -> SerializableObject"""
+        return _medpython.Features_asSerializable(self)
+
+    def split_by_fold(self, outMatrix, iFold, isLearning):
+        r"""split_by_fold(Features self, Features outMatrix, int iFold, bool isLearning)"""
+        return _medpython.Features_split_by_fold(self, outMatrix, iFold, isLearning)
+
+    data = property(MEDPY_GET_data,None)
+    weights = property(MEDPY_GET_weights,None)
+    samples = property(MEDPY_GET_samples,None)
+    pid_pos_len = property(MEDPY_GET_pid_pos_len,None)
+    attributes = property(MEDPY_GET_attributes,None)
+    tags = property(MEDPY_GET_tags,None)
+    time_unit = property(MEDPY_GET_time_unit,MEDPY_SET_time_unit)
+    global_serial_id_cnt = property(MEDPY_GET_global_serial_id_cnt,MEDPY_SET_global_serial_id_cnt)
+
+
+# Register Features in _medpython:
+_medpython.Features_swigregister(Features)
+class RNG(object):
+    r"""Proxy of C++ MPRNG class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def rand(self):
+        r"""rand(RNG self) -> int"""
+        return _medpython.RNG_rand(self)
+
+    def rand30(self):
+        r"""rand30(RNG self) -> int"""
+        return _medpython.RNG_rand30(self)
+
+    def srand(self, val):
+        r"""srand(RNG self, int val)"""
+        return _medpython.RNG_srand(self, val)
+
+    def max(self):
+        r"""max(RNG self) -> int"""
+        return _medpython.RNG_max(self)
+
+    def __init__(self):
+        r"""__init__(RNG self) -> RNG"""
+        _medpython.RNG_swiginit(self, _medpython.new_RNG())
+    __swig_destroy__ = _medpython.delete_RNG
+
+# Register RNG in _medpython:
+_medpython.RNG_swigregister(RNG)
+class GlobalClass(object):
+    r"""Proxy of C++ MPGlobalClass class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def MEDPY_GET_default_time_unit(self):
+        r"""MEDPY_GET_default_time_unit(GlobalClass self) -> int"""
+        return _medpython.GlobalClass_MEDPY_GET_default_time_unit(self)
+
+    def MEDPY_SET_default_time_unit(self, new_val):
+        r"""MEDPY_SET_default_time_unit(GlobalClass self, int new_val)"""
+        return _medpython.GlobalClass_MEDPY_SET_default_time_unit(self, new_val)
+
+    def MEDPY_GET_default_windows_time_unit(self):
+        r"""MEDPY_GET_default_windows_time_unit(GlobalClass self) -> int"""
+        return _medpython.GlobalClass_MEDPY_GET_default_windows_time_unit(self)
+
+    def MEDPY_SET_default_windows_time_unit(self, new_val):
+        r"""MEDPY_SET_default_windows_time_unit(GlobalClass self, int new_val)"""
+        return _medpython.GlobalClass_MEDPY_SET_default_windows_time_unit(self, new_val)
+    RNG = property(_medpython.GlobalClass_RNG_get, _medpython.GlobalClass_RNG_set, doc=r"""RNG : MPRNG""")
+    logger = property(_medpython.GlobalClass_logger_get, _medpython.GlobalClass_logger_set, doc=r"""logger : MPLogger""")
+    version_info = property(_medpython.GlobalClass_version_info_get, _medpython.GlobalClass_version_info_set, doc=r"""version_info : string""")
+
+    def __init__(self):
+        r"""__init__(GlobalClass self) -> GlobalClass"""
+        _medpython.GlobalClass_swiginit(self, _medpython.new_GlobalClass())
+
+    default_time_unit = property(MEDPY_GET_default_time_unit,MEDPY_SET_default_time_unit)
+    default_windows_time_unit = property(MEDPY_GET_default_windows_time_unit,MEDPY_SET_default_windows_time_unit)
+
+    __swig_destroy__ = _medpython.delete_GlobalClass
+
+# Register GlobalClass in _medpython:
+_medpython.GlobalClass_swigregister(GlobalClass)
+class CommonLib(object):
+    r"""Proxy of C++ MPCommonLib class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    @staticmethod
+    def print_auc_performance(samples, folds, outFile):
+        r"""print_auc_performance(Samples samples, int * folds, string outFile)"""
+        return _medpython.CommonLib_print_auc_performance(samples, folds, outFile)
+
+    @staticmethod
+    def shuffleMatrix(matrix):
+        r"""shuffleMatrix(Features matrix)"""
+        return _medpython.CommonLib_shuffleMatrix(matrix)
+
+    @staticmethod
+    def read_predictor_from_file(pred, predictorFile):
+        r"""read_predictor_from_file(Predictor pred, string predictorFile)"""
+        return _medpython.CommonLib_read_predictor_from_file(pred, predictorFile)
+
+    def __init__(self):
+        r"""__init__(CommonLib self) -> CommonLib"""
+        _medpython.CommonLib_swiginit(self, _medpython.new_CommonLib())
+    __swig_destroy__ = _medpython.delete_CommonLib
+
+# Register CommonLib in _medpython:
+_medpython.CommonLib_swigregister(CommonLib)
+class Logger(object):
+    r"""Proxy of C++ MPLogger class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def init_all_levels(self, level):
+        r"""init_all_levels(Logger self, int level)"""
+        return _medpython.Logger_init_all_levels(self, level)
+
+    def init_all_files(self, fname):
+        r"""init_all_files(Logger self, string const & fname) -> int"""
+        return _medpython.Logger_init_all_files(self, fname)
+
+    def init_level(self, section, level):
+        r"""init_level(Logger self, int section, int level)"""
+        return _medpython.Logger_init_level(self, section, level)
+
+    def init_file(self, section, fname):
+        r"""init_file(Logger self, int section, string const & fname) -> int"""
+        return _medpython.Logger_init_file(self, section, fname)
+
+    def add_file(self, section, fname):
+        r"""add_file(Logger self, int section, string const & fname) -> int"""
+        return _medpython.Logger_add_file(self, section, fname)
+
+    def init_out(self, *args):
+        r"""init_out(Logger self, string const & fname="")"""
+        return _medpython.Logger_init_out(self, *args)
+
+    def __init__(self):
+        r"""__init__(Logger self) -> Logger"""
+        _medpython.Logger_swiginit(self, _medpython.new_Logger())
+    __swig_destroy__ = _medpython.delete_Logger
+
+# Register Logger in _medpython:
+_medpython.Logger_swigregister(Logger)
+cvar = _medpython.cvar
+Logger.LOG_APP_ = _medpython.cvar.Logger_LOG_APP_
+Logger.LOG_DEF_ = _medpython.cvar.Logger_LOG_DEF_
+Logger.LOG_INFRA_ = _medpython.cvar.Logger_LOG_INFRA_
+Logger.LOG_REP_ = _medpython.cvar.Logger_LOG_REP_
+Logger.LOG_INDEX_ = _medpython.cvar.Logger_LOG_INDEX_
+Logger.LOG_DICT_ = _medpython.cvar.Logger_LOG_DICT_
+Logger.LOG_SIG_ = _medpython.cvar.Logger_LOG_SIG_
+Logger.LOG_CONVERT_ = _medpython.cvar.Logger_LOG_CONVERT_
+Logger.LOG_MED_UTILS_ = _medpython.cvar.Logger_LOG_MED_UTILS_
+Logger.LOG_MEDMAT_ = _medpython.cvar.Logger_LOG_MEDMAT_
+Logger.LOG_MEDIO_ = _medpython.cvar.Logger_LOG_MEDIO_
+Logger.LOG_DATA_STRUCTURES_ = _medpython.cvar.Logger_LOG_DATA_STRUCTURES_
+Logger.LOG_MEDALGO_ = _medpython.cvar.Logger_LOG_MEDALGO_
+Logger.LOG_MEDFEAT_ = _medpython.cvar.Logger_LOG_MEDFEAT_
+Logger.LOG_MEDSTAT_ = _medpython.cvar.Logger_LOG_MEDSTAT_
+Logger.LOG_REPCLEANER_ = _medpython.cvar.Logger_LOG_REPCLEANER_
+Logger.LOG_FTRGNRTR_ = _medpython.cvar.Logger_LOG_FTRGNRTR_
+Logger.LOG_CV_ = _medpython.cvar.Logger_LOG_CV_
+Logger.LOG_FEATCLEANER_ = _medpython.cvar.Logger_LOG_FEATCLEANER_
+Logger.LOG_VALCLNR_ = _medpython.cvar.Logger_LOG_VALCLNR_
+Logger.MED_SAMPLES_CV_ = _medpython.cvar.Logger_MED_SAMPLES_CV_
+Logger.LOG_FEAT_SELECTOR_ = _medpython.cvar.Logger_LOG_FEAT_SELECTOR_
+Logger.LOG_SMPL_FILTER_ = _medpython.cvar.Logger_LOG_SMPL_FILTER_
+Logger.LOG_SRL_ = _medpython.cvar.Logger_LOG_SRL_
+Logger.LOG_MED_MODEL_ = _medpython.cvar.Logger_LOG_MED_MODEL_
+Logger.LOG_REPTYPE_ = _medpython.cvar.Logger_LOG_REPTYPE_
+Logger.MAX_LOG_SECTION_ = _medpython.cvar.Logger_MAX_LOG_SECTION_
+Logger.NO_LOG_LEVEL_ = _medpython.cvar.Logger_NO_LOG_LEVEL_
+Logger.MIN_LOG_LEVEL_ = _medpython.cvar.Logger_MIN_LOG_LEVEL_
+Logger.DEBUG_LOG_LEVEL_ = _medpython.cvar.Logger_DEBUG_LOG_LEVEL_
+Logger.LOG_DEF_LEVEL_ = _medpython.cvar.Logger_LOG_DEF_LEVEL_
+Logger.MAX_LOG_LEVEL_ = _medpython.cvar.Logger_MAX_LOG_LEVEL_
+Logger.VERBOSE_LOG_LEVEL_ = _medpython.cvar.Logger_VERBOSE_LOG_LEVEL_
+
+class Mat(object):
+    r"""Proxy of C++ MPMat class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        r"""
+        __init__(Mat self) -> Mat
+        __init__(Mat self, int n_rows, int n_cols) -> Mat
+        __init__(Mat self, float * IN_ARRAY2) -> Mat
+        """
+        _medpython.Mat_swiginit(self, _medpython.new_Mat(*args))
+    __swig_destroy__ = _medpython.delete_Mat
+
+    def get_numpy_copy(self):
+        r"""get_numpy_copy(Mat self)"""
+        return _medpython.Mat_get_numpy_copy(self)
+
+    def get_numpy_view_unsafe(self):
+        r"""get_numpy_view_unsafe(Mat self)"""
+        return _medpython.Mat_get_numpy_view_unsafe(self)
+
+    def test(self, n_rows, n_cols):
+        r"""test(Mat self, int n_rows, int n_cols)"""
+        return _medpython.Mat_test(self, n_rows, n_cols)
+
+    def load_numpy(self, IN_ARRAY2):
+        r"""load_numpy(Mat self, float * IN_ARRAY2)"""
+        return _medpython.Mat_load_numpy(self, IN_ARRAY2)
+
+    @staticmethod
+    def MEDPY_GET_Normalize_Cols():
+        r"""MEDPY_GET_Normalize_Cols() -> int"""
+        return _medpython.Mat_MEDPY_GET_Normalize_Cols()
+
+    @staticmethod
+    def MEDPY_GET_Normalize_Rows():
+        r"""MEDPY_GET_Normalize_Rows() -> int"""
+        return _medpython.Mat_MEDPY_GET_Normalize_Rows()
+
+    def MEDPY_GET_nrows(self):
+        r"""MEDPY_GET_nrows(Mat self) -> int"""
+        return _medpython.Mat_MEDPY_GET_nrows(self)
+
+    def MEDPY_GET_ncols(self):
+        r"""MEDPY_GET_ncols(Mat self) -> int"""
+        return _medpython.Mat_MEDPY_GET_ncols(self)
+
+    def __len__(self):
+        r"""__len__(Mat self) -> unsigned long long"""
+        return _medpython.Mat___len__(self)
+
+    def is_valid(self, output=False):
+        r"""is_valid(Mat self, bool output=False) -> bool"""
+        return _medpython.Mat_is_valid(self, output)
+
+    def __getitem__(self, index):
+        r"""__getitem__(Mat self, IntVector index) -> float"""
+        return _medpython.Mat___getitem__(self, index)
+
+    def __setitem__(self, index, val):
+        r"""__setitem__(Mat self, IntVector index, float val)"""
+        return _medpython.Mat___setitem__(self, index, val)
+
+    def MEDPY_GET_row_ids(self):
+        r"""MEDPY_GET_row_ids(Mat self)"""
+        return _medpython.Mat_MEDPY_GET_row_ids(self)
+
+    def MEDPY_SET_row_ids(self, row_ids_buf):
+        r"""MEDPY_SET_row_ids(Mat self, int * row_ids_buf)"""
+        return _medpython.Mat_MEDPY_SET_row_ids(self, row_ids_buf)
+
+    def MEDPY_GET_signals(self):
+        r"""MEDPY_GET_signals(Mat self) -> StringVector"""
+        return _medpython.Mat_MEDPY_GET_signals(self)
+
+    def MEDPY_GET_avg(self):
+        r"""MEDPY_GET_avg(Mat self)"""
+        return _medpython.Mat_MEDPY_GET_avg(self)
+
+    def MEDPY_GET_std(self):
+        r"""MEDPY_GET_std(Mat self)"""
+        return _medpython.Mat_MEDPY_GET_std(self)
+
+    def MEDPY_GET_normalized_flag(self):
+        r"""MEDPY_GET_normalized_flag(Mat self) -> int"""
+        return _medpython.Mat_MEDPY_GET_normalized_flag(self)
+
+    def MEDPY_SET_normalized_flag(self, newval):
+        r"""MEDPY_SET_normalized_flag(Mat self, int newval)"""
+        return _medpython.Mat_MEDPY_SET_normalized_flag(self, newval)
+
+    def MEDPY_GET_transposed_flag(self):
+        r"""MEDPY_GET_transposed_flag(Mat self) -> int"""
+        return _medpython.Mat_MEDPY_GET_transposed_flag(self)
+
+    def MEDPY_SET_transposed_flag(self, newval):
+        r"""MEDPY_SET_transposed_flag(Mat self, int newval)"""
+        return _medpython.Mat_MEDPY_SET_transposed_flag(self, newval)
+
+    def MEDPY_GET_missing_value(self):
+        r"""MEDPY_GET_missing_value(Mat self) -> float"""
+        return _medpython.Mat_MEDPY_GET_missing_value(self)
+
+    def MEDPY_SET_missing_value(self, newval):
+        r"""MEDPY_SET_missing_value(Mat self, float newval)"""
+        return _medpython.Mat_MEDPY_SET_missing_value(self, newval)
+
+    def zero(self):
+        r"""zero(Mat self)"""
+        return _medpython.Mat_zero(self)
+
+    def set_val(self, val):
+        r"""set_val(Mat self, float val)"""
+        return _medpython.Mat_set_val(self, val)
+
+    def clear(self):
+        r"""clear(Mat self)"""
+        return _medpython.Mat_clear(self)
+
+    def resize(self, n_rows, n_cols):
+        r"""resize(Mat self, int n_rows, int n_cols)"""
+        return _medpython.Mat_resize(self, n_rows, n_cols)
+
+    def read_from_bin_file(self, fname):
+        r"""read_from_bin_file(Mat self, string const & fname) -> int"""
+        return _medpython.Mat_read_from_bin_file(self, fname)
+
+    def write_to_bin_file(self, fname):
+        r"""write_to_bin_file(Mat self, string const & fname) -> int"""
+        return _medpython.Mat_write_to_bin_file(self, fname)
+
+    def write_to_csv_file(self, fname):
+        r"""write_to_csv_file(Mat self, string const & fname) -> int"""
+        return _medpython.Mat_write_to_csv_file(self, fname)
+
+    def read_from_csv_file(self, fname, titles_line_flag):
+        r"""read_from_csv_file(Mat self, string const & fname, int titles_line_flag) -> int"""
+        return _medpython.Mat_read_from_csv_file(self, fname, titles_line_flag)
+
+    def transpose(self):
+        r"""transpose(Mat self)"""
+        return _medpython.Mat_transpose(self)
+
+    def get_sub_mat(self, rows_to_take, cols_to_take):
+        r"""get_sub_mat(Mat self, IntVector rows_to_take, IntVector cols_to_take)"""
+        return _medpython.Mat_get_sub_mat(self, rows_to_take, cols_to_take)
+
+    def get_sub_mat_by_flags(self, rows_to_take_flag, cols_to_take_flag):
+        r"""get_sub_mat_by_flags(Mat self, IntVector rows_to_take_flag, IntVector cols_to_take_flag)"""
+        return _medpython.Mat_get_sub_mat_by_flags(self, rows_to_take_flag, cols_to_take_flag)
+
+    def add_rows(self, *args):
+        r"""
+        add_rows(Mat self, Mat m_add)
+        add_rows(Mat self, float * m_add)
+        """
+        return _medpython.Mat_add_rows(self, *args)
+
+    def add_cols(self, *args):
+        r"""
+        add_cols(Mat self, Mat m_add)
+        add_cols(Mat self, float * m_add)
+        """
+        return _medpython.Mat_add_cols(self, *args)
+
+    def get_row(self, i_row):
+        r"""get_row(Mat self, int i_row)"""
+        return _medpython.Mat_get_row(self, i_row)
+
+    def get_col(self, i_col):
+        r"""get_col(Mat self, int i_col)"""
+        return _medpython.Mat_get_col(self, i_col)
+
+    def normalize(self, *args):
+        r"""
+        normalize(Mat self, int norm_type, float * wgts)
+        normalize(Mat self, int norm_type=Normalize_Cols)
+        normalize(Mat self, float * external_avg, float * external_std, int norm_type=1)
+        """
+        return _medpython.Mat_normalize(self, *args)
+
+    def get_cols_avg_std(self):
+        r"""get_cols_avg_std(Mat self)"""
+        return _medpython.Mat_get_cols_avg_std(self)
+
+    def set_signals(self, sigs):
+        r"""set_signals(Mat self, StringVector sigs)"""
+        return _medpython.Mat_set_signals(self, sigs)
+
+    def load_transposed(self, IN_ARRAY2):
+        r"""load_transposed(Mat self, float * IN_ARRAY2)"""
+        return _medpython.Mat_load_transposed(self, IN_ARRAY2)
+
+    def load(self, *args):
+        r"""
+        load(Mat self, float * IN_ARRAY2)
+        load(Mat self, Mat x)
+        """
+        return _medpython.Mat_load(self, *args)
+
+    def asSerializable(self):
+        r"""asSerializable(Mat self) -> SerializableObject"""
+        return _medpython.Mat_asSerializable(self)
+
+    Normalize_Cols = property(MEDPY_GET_Normalize_Cols,None)
+    Normalize_Rows = property(MEDPY_GET_Normalize_Rows,None)
+    nrows = property(MEDPY_GET_nrows,None)
+    ncols = property(MEDPY_GET_ncols,None)
+    row_ids = property(MEDPY_GET_row_ids,MEDPY_SET_row_ids)
+    signals = property(MEDPY_GET_signals,None)
+    avg = property(MEDPY_GET_avg,None)
+    std = property(MEDPY_GET_std,None)
+    normalized_flag = property(MEDPY_GET_normalized_flag,MEDPY_SET_normalized_flag)
+    transposed_flag = property(MEDPY_GET_transposed_flag,MEDPY_SET_transposed_flag)
+    missing_value = property(MEDPY_GET_missing_value,MEDPY_SET_missing_value)
+
+
+# Register Mat in _medpython:
+_medpython.Mat_swigregister(Mat)
+Mat.Normalize_Cols = _medpython.cvar.Mat_Normalize_Cols
+Mat.Normalize_Rows = _medpython.cvar.Mat_Normalize_Rows
+Mat.MISSING_VALUE = _medpython.cvar.Mat_MISSING_VALUE
+
+class ModelStage(object):
+    r"""Proxy of C++ MPModelStage class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(ModelStage self) -> ModelStage"""
+        _medpython.ModelStage_swiginit(self, _medpython.new_ModelStage())
+    __swig_destroy__ = _medpython.delete_ModelStage
+
+# Register ModelStage in _medpython:
+_medpython.ModelStage_swigregister(ModelStage)
+ModelStage.LEARN_REP_PROCESSORS = _medpython.cvar.ModelStage_LEARN_REP_PROCESSORS
+ModelStage.LEARN_FTR_GENERATORS = _medpython.cvar.ModelStage_LEARN_FTR_GENERATORS
+ModelStage.APPLY_FTR_GENERATORS = _medpython.cvar.ModelStage_APPLY_FTR_GENERATORS
+ModelStage.LEARN_FTR_PROCESSORS = _medpython.cvar.ModelStage_LEARN_FTR_PROCESSORS
+ModelStage.APPLY_FTR_PROCESSORS = _medpython.cvar.ModelStage_APPLY_FTR_PROCESSORS
+ModelStage.LEARN_PREDICTOR = _medpython.cvar.ModelStage_LEARN_PREDICTOR
+ModelStage.APPLY_PREDICTOR = _medpython.cvar.ModelStage_APPLY_PREDICTOR
+ModelStage.INSERT_PREDS = _medpython.cvar.ModelStage_INSERT_PREDS
+ModelStage.LEARN_POST_PROCESSORS = _medpython.cvar.ModelStage_LEARN_POST_PROCESSORS
+ModelStage.APPLY_POST_PROCESSORS = _medpython.cvar.ModelStage_APPLY_POST_PROCESSORS
+ModelStage.END = _medpython.cvar.ModelStage_END
+
+class Model(object):
+    r"""Proxy of C++ MPModel class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Model self) -> Model"""
+        _medpython.Model_swiginit(self, _medpython.new_Model())
+    __swig_destroy__ = _medpython.delete_Model
+
+    def init_from_json_file(self, fname):
+        r"""init_from_json_file(Model self, std::string const & fname)"""
+        return _medpython.Model_init_from_json_file(self, fname)
+
+    def init_from_json_file_with_alterations(self, fname, json_alt):
+        r"""init_from_json_file_with_alterations(Model self, std::string const & fname, StringVector json_alt) -> StringVector"""
+        return _medpython.Model_init_from_json_file_with_alterations(self, fname, json_alt)
+
+    def add_pre_processors_json_string_to_model(self, in_json, fname, add_rep_first):
+        r"""add_pre_processors_json_string_to_model(Model self, std::string const & in_json, std::string const & fname, bool add_rep_first)"""
+        return _medpython.Model_add_pre_processors_json_string_to_model(self, in_json, fname, add_rep_first)
+
+    def add_post_processors_json_string_to_model(self, in_json, fname):
+        r"""add_post_processors_json_string_to_model(Model self, std::string const & in_json, std::string const & fname)"""
+        return _medpython.Model_add_post_processors_json_string_to_model(self, in_json, fname)
+
+    def get_required_signal_names(self):
+        r"""get_required_signal_names(Model self) -> StringVector"""
+        return _medpython.Model_get_required_signal_names(self)
+
+    def learn(self, *args):
+        r"""
+        learn(Model self, PidRepository rep, Samples samples) -> int
+        learn(Model self, PidRepository rep, Samples samples, int start_stage, int end_stage) -> int
+        """
+        return _medpython.Model_learn(self, *args)
+
+    def apply(self, *args):
+        r"""
+        apply(Model self, PidRepository rep, Samples samples) -> int
+        apply(Model self, PidRepository rep, Samples samples, int start_stage, int end_stage) -> int
+        """
+        return _medpython.Model_apply(self, *args)
+
+    def write_to_file(self, fname):
+        r"""write_to_file(Model self, std::string const & fname) -> int"""
+        return _medpython.Model_write_to_file(self, fname)
+
+    def read_from_file(self, fname):
+        r"""read_from_file(Model self, std::string const & fname) -> int"""
+        return _medpython.Model_read_from_file(self, fname)
+
+    def MEDPY_GET_features(self):
+        r"""MEDPY_GET_features(Model self) -> Features"""
+        return _medpython.Model_MEDPY_GET_features(self)
+
+    def MEDPY_GET_predictor(self):
+        r"""MEDPY_GET_predictor(Model self) -> Predictor"""
+        return _medpython.Model_MEDPY_GET_predictor(self)
+
+    def clear(self):
+        r"""clear(Model self)"""
+        return _medpython.Model_clear(self)
+
+    def MEDPY_GET_verbosity(self):
+        r"""MEDPY_GET_verbosity(Model self) -> int"""
+        return _medpython.Model_MEDPY_GET_verbosity(self)
+
+    def MEDPY_SET_verbosity(self, new_vval):
+        r"""MEDPY_SET_verbosity(Model self, int new_vval)"""
+        return _medpython.Model_MEDPY_SET_verbosity(self, new_vval)
+
+    def add_feature_generator(self, name, signal):
+        r"""add_feature_generator(Model self, std::string & name, std::string & signal)"""
+        return _medpython.Model_add_feature_generator(self, name, signal)
+
+    def add_feature_generators(self, *args):
+        r"""
+        add_feature_generators(Model self, std::string & name, StringVector signals)
+        add_feature_generators(Model self, std::string & name, StringVector signals, string init_string)
+        add_feature_generators(Model self, std::string & name, std::string & signal, std::string init_string)
+        """
+        return _medpython.Model_add_feature_generators(self, *args)
+
+    def add_age(self):
+        r"""add_age(Model self)"""
+        return _medpython.Model_add_age(self)
+
+    def add_gender(self):
+        r"""add_gender(Model self)"""
+        return _medpython.Model_add_gender(self)
+
+    def get_all_features_names(self, feat_names, before_process_set):
+        r"""get_all_features_names(Model self, StringVector feat_names, int before_process_set)"""
+        return _medpython.Model_get_all_features_names(self, feat_names, before_process_set)
+
+    def add_normalizers(self, *args):
+        r"""
+        add_normalizers(Model self)
+        add_normalizers(Model self, std::string init_string)
+        add_normalizers(Model self, StringVector features)
+        add_normalizers(Model self, StringVector features, std::string init_string)
+        """
+        return _medpython.Model_add_normalizers(self, *args)
+
+    def add_imputers(self, *args):
+        r"""
+        add_imputers(Model self)
+        add_imputers(Model self, std::string init_string)
+        add_imputers(Model self, StringVector features)
+        add_imputers(Model self, StringVector features, std::string init_string)
+        """
+        return _medpython.Model_add_imputers(self, *args)
+
+    def add_rep_processor_to_set(self, i_set, init_string):
+        r"""add_rep_processor_to_set(Model self, int i_set, std::string const & init_string)"""
+        return _medpython.Model_add_rep_processor_to_set(self, i_set, init_string)
+
+    def add_feature_generator_to_set(self, i_set, init_string):
+        r"""add_feature_generator_to_set(Model self, int i_set, std::string const & init_string)"""
+        return _medpython.Model_add_feature_generator_to_set(self, i_set, init_string)
+
+    def add_feature_processor_to_set(self, i_set, duplicate, init_string):
+        r"""add_feature_processor_to_set(Model self, int i_set, int duplicate, std::string const & init_string)"""
+        return _medpython.Model_add_feature_processor_to_set(self, i_set, duplicate, init_string)
+
+    def add_process_to_set(self, *args):
+        r"""
+        add_process_to_set(Model self, int i_set, int duplicate, std::string const & init_string)
+        add_process_to_set(Model self, int i_set, std::string const & init_string)
+        """
+        return _medpython.Model_add_process_to_set(self, *args)
+
+    def make_predictor(self, name):
+        r"""make_predictor(Model self, std::string name)"""
+        return _medpython.Model_make_predictor(self, name)
+
+    def set_predictor(self, *args):
+        r"""
+        set_predictor(Model self, Predictor _predictor)
+        set_predictor(Model self, std::string name, std::string init_string)
+        """
+        return _medpython.Model_set_predictor(self, *args)
+
+    def collect_and_add_virtual_signals(self, rep):
+        r"""collect_and_add_virtual_signals(Model self, PidRepository rep) -> int"""
+        return _medpython.Model_collect_and_add_virtual_signals(self, rep)
+
+    def quick_learn_rep_processors(self, rep, samples):
+        r"""quick_learn_rep_processors(Model self, PidRepository rep, Samples samples) -> int"""
+        return _medpython.Model_quick_learn_rep_processors(self, rep, samples)
+
+    def learn_rep_processors(self, rep, samples):
+        r"""learn_rep_processors(Model self, PidRepository rep, Samples samples) -> int"""
+        return _medpython.Model_learn_rep_processors(self, rep, samples)
+
+    def filter_rep_processors(self):
+        r"""filter_rep_processors(Model self)"""
+        return _medpython.Model_filter_rep_processors(self)
+
+    def learn_feature_generators(self, rep, learn_samples):
+        r"""learn_feature_generators(Model self, PidRepository rep, Samples learn_samples) -> int"""
+        return _medpython.Model_learn_feature_generators(self, rep, learn_samples)
+
+    def generate_all_features(self, rep, samples, features, req_feature_generators):
+        r"""generate_all_features(Model self, PidRepository rep, Samples samples, Features features, StringVector req_feature_generators) -> int"""
+        return _medpython.Model_generate_all_features(self, rep, samples, features, req_feature_generators)
+
+    def learn_and_apply_feature_processors(self, features):
+        r"""learn_and_apply_feature_processors(Model self, Features features) -> int"""
+        return _medpython.Model_learn_and_apply_feature_processors(self, features)
+
+    def learn_feature_processors(self, features):
+        r"""learn_feature_processors(Model self, Features features) -> int"""
+        return _medpython.Model_learn_feature_processors(self, features)
+
+    def apply_feature_processors(self, features, learning):
+        r"""apply_feature_processors(Model self, Features features, bool learning) -> int"""
+        return _medpython.Model_apply_feature_processors(self, features, learning)
+
+    def fit_for_repository(self, rep):
+        r"""fit_for_repository(Model self, PidRepository rep)"""
+        return _medpython.Model_fit_for_repository(self, rep)
+
+    def calc_contribs(self, mat, mat_out):
+        r"""calc_contribs(Model self, Mat mat, Mat mat_out)"""
+        return _medpython.Model_calc_contribs(self, mat, mat_out)
+
+    def calc_feature_contribs_conditional(self, mat_x_in, features_cond_string, features_cond_float, mat_x_out, mat_contribs):
+        r"""calc_feature_contribs_conditional(Model self, Mat mat_x_in, std::string const & features_cond_string, float features_cond_float, Mat mat_x_out, Mat mat_contribs)"""
+        return _medpython.Model_calc_feature_contribs_conditional(self, mat_x_in, features_cond_string, features_cond_float, mat_x_out, mat_contribs)
+
+    def dprint_process(self, pref, rp_flag, fg_flag, fp_flag, pp_flag, predictor_type):
+        r"""dprint_process(Model self, std::string const & pref, int rp_flag, int fg_flag, int fp_flag, bool pp_flag, bool predictor_type)"""
+        return _medpython.Model_dprint_process(self, pref, rp_flag, fg_flag, fp_flag, pp_flag, predictor_type)
+
+    def write_feature_matrix(self, mat_fname):
+        r"""write_feature_matrix(Model self, std::string const mat_fname) -> int"""
+        return _medpython.Model_write_feature_matrix(self, mat_fname)
+
+    def asSerializable(self):
+        r"""asSerializable(Model self) -> SerializableObject"""
+        return _medpython.Model_asSerializable(self)
+
+    def apply_model_change(self, change_json_content):
+        r"""apply_model_change(Model self, std::string const & change_json_content)"""
+        return _medpython.Model_apply_model_change(self, change_json_content)
+
+    def get_model_weights_info(self):
+        r"""get_model_weights_info(Model self) -> std::string"""
+        return _medpython.Model_get_model_weights_info(self)
+
+    def get_model_version_info(self):
+        r"""get_model_version_info(Model self) -> std::string"""
+        return _medpython.Model_get_model_version_info(self)
+
+    def get_model_processors_info(self):
+        r"""get_model_processors_info(Model self) -> std::string"""
+        return _medpython.Model_get_model_processors_info(self)
+
+    def train_rep_processor_by_index(self, index, rep, samples):
+        r"""train_rep_processor_by_index(Model self, int index, PidRepository rep, Samples samples)"""
+        return _medpython.Model_train_rep_processor_by_index(self, index, rep, samples)
+
+    def print_rep_processor_by_index(self, index):
+        r"""print_rep_processor_by_index(Model self, int index) -> std::string"""
+        return _medpython.Model_print_rep_processor_by_index(self, index)
+
+    def delete_rep_processor_by_index(self, index):
+        r"""delete_rep_processor_by_index(Model self, int index)"""
+        return _medpython.Model_delete_rep_processor_by_index(self, index)
+
+    def print_feature_generator_by_index(self, index):
+        r"""print_feature_generator_by_index(Model self, int index) -> std::string"""
+        return _medpython.Model_print_feature_generator_by_index(self, index)
+
+    def print_feature_processor_by_index(self, index):
+        r"""print_feature_processor_by_index(Model self, int index) -> std::string"""
+        return _medpython.Model_print_feature_processor_by_index(self, index)
+
+    def delete_feature_processor_by_index(self, index):
+        r"""delete_feature_processor_by_index(Model self, int index)"""
+        return _medpython.Model_delete_feature_processor_by_index(self, index)
+
+    def print_post_processor_by_index(self, index):
+        r"""print_post_processor_by_index(Model self, int index) -> std::string"""
+        return _medpython.Model_print_post_processor_by_index(self, index)
+
+    def delete_post_processor_by_index(self, index):
+        r"""delete_post_processor_by_index(Model self, int index)"""
+        return _medpython.Model_delete_post_processor_by_index(self, index)
+
+    def train_post_processor_by_index(self, index, features):
+        r"""train_post_processor_by_index(Model self, int index, Features features)"""
+        return _medpython.Model_train_post_processor_by_index(self, index, features)
+
+    def debug_rep_processor_signal(self, rep, signal_name, pid, prediction_time):
+        r"""debug_rep_processor_signal(Model self, PidRepository rep, std::string & signal_name, int pid, int prediction_time) -> SigVectorAdaptor"""
+        return _medpython.Model_debug_rep_processor_signal(self, rep, signal_name, pid, prediction_time)
+
+    features = property(MEDPY_GET_features,None)
+    predictor = property(MEDPY_GET_predictor,None)
+    verbosity = property(MEDPY_GET_verbosity,MEDPY_SET_verbosity)
+
+
+# Register Model in _medpython:
+_medpython.Model_swigregister(Model)
+class PandasAdaptor(object):
+    r"""Proxy of C++ MPPandasAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    type_requirements = property(_medpython.PandasAdaptor_type_requirements_get, _medpython.PandasAdaptor_type_requirements_set, doc=r"""type_requirements : MPStringStringMapAdaptor""")
+
+    def keys(self):
+        r"""keys(PandasAdaptor self) -> StringVector"""
+        return _medpython.PandasAdaptor_keys(self)
+    __swig_destroy__ = _medpython.delete_PandasAdaptor
+
+    def clear(self):
+        r"""clear(PandasAdaptor self)"""
+        return _medpython.PandasAdaptor_clear(self)
+
+    def export_column(self, key):
+        r"""export_column(PandasAdaptor self, std::string const & key)"""
+        return _medpython.PandasAdaptor_export_column(self, key)
+
+    def __getitem__(self, key):
+        r"""__getitem__(PandasAdaptor self, std::string const & key)"""
+        return _medpython.PandasAdaptor___getitem__(self, key)
+
+    def __iter__(self):
+        r"""__iter__(PandasAdaptor self) -> MPPandasAdaptor_iter"""
+        return _medpython.PandasAdaptor___iter__(self)
+
+    def get_categorial_col_dict(self, col_name):
+        r"""get_categorial_col_dict(PandasAdaptor self, std::string const & col_name) -> IntStringMapAdaptor"""
+        return _medpython.PandasAdaptor_get_categorial_col_dict(self, col_name)
+
+    def get_categorical_cols(self):
+        r"""get_categorical_cols(PandasAdaptor self) -> StringVector"""
+        return _medpython.PandasAdaptor_get_categorical_cols(self)
+
+    def import_column(self, col_name, IN_ARRAY1, make_a_copy=False):
+        r"""import_column(PandasAdaptor self, string const & col_name, void * IN_ARRAY1, bool make_a_copy=False)"""
+        return _medpython.PandasAdaptor_import_column(self, col_name, IN_ARRAY1, make_a_copy)
+
+    def __init__(self):
+        r"""__init__(PandasAdaptor self) -> PandasAdaptor"""
+        _medpython.PandasAdaptor_swiginit(self, _medpython.new_PandasAdaptor())
+
+# Register PandasAdaptor in _medpython:
+_medpython.PandasAdaptor_swigregister(PandasAdaptor)
+class MPPandasAdaptor_iter(object):
+    r"""Proxy of C++ MPPandasAdaptor_iter class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args):
+        r"""
+        __init__(MPPandasAdaptor_iter self, PandasAdaptor o, StringVector keys_param) -> MPPandasAdaptor_iter
+        __init__(MPPandasAdaptor_iter self, MPPandasAdaptor_iter orig) -> MPPandasAdaptor_iter
+        """
+        _medpython.MPPandasAdaptor_iter_swiginit(self, _medpython.new_MPPandasAdaptor_iter(*args))
+
+    def next(self):
+        r"""next(MPPandasAdaptor_iter self) -> std::string"""
+        return _medpython.MPPandasAdaptor_iter_next(self)
+
+    def __repr__(self):
+        r"""__repr__(MPPandasAdaptor_iter self) -> std::string"""
+        return _medpython.MPPandasAdaptor_iter___repr__(self)
+    __swig_destroy__ = _medpython.delete_MPPandasAdaptor_iter
+
+# Register MPPandasAdaptor_iter in _medpython:
+_medpython.MPPandasAdaptor_iter_swigregister(MPPandasAdaptor_iter)
+class PidRepository(object):
+    r"""Proxy of C++ MPPidRepository class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+    dict = property(_medpython.PidRepository_dict_get, _medpython.PidRepository_dict_set, doc=r"""dict : MPDictionary""")
+
+    def __init__(self):
+        r"""__init__(PidRepository self) -> PidRepository"""
+        _medpython.PidRepository_swiginit(self, _medpython.new_PidRepository())
+    __swig_destroy__ = _medpython.delete_PidRepository
+
+    def read_all(self, *args):
+        r"""
+        read_all(conf_file_fname, [pids_to_take_array], [list_str_signals_to_take]) -> int
+        returns -1 if fails
+        reading a repository for a group of pids and signals.Empty group means all of it.read_all(conf_file_fname, [pids_to_take_array], [list_str_signals_to_take]) -> int
+        returns -1 if fails
+        reading a repository for a group of pids and signals.Empty group means all of it.
+        """
+        return _medpython.PidRepository_read_all(self, *args)
+
+    def read_all_i(self, conf_fname, pids_to_take, signals_to_take):
+        r"""read_all_i(PidRepository self, std::string const & conf_fname, IntVector pids_to_take, IntVector signals_to_take) -> int"""
+        return _medpython.PidRepository_read_all_i(self, conf_fname, pids_to_take, signals_to_take)
+
+    def init(self, conf_fname):
+        r"""
+        init(conf_file_name) -> int
+        returns -1 if fails
+        """
+        return _medpython.PidRepository_init(self, conf_fname)
+
+    def loadsig(self, signame):
+        r"""
+        loadsig(str_signame) -> int
+          load a signal
+        """
+        return _medpython.PidRepository_loadsig(self, signame)
+
+    def loadsig_pids(self, signame, pids_to_take):
+        r"""loadsig_pids(PidRepository self, std::string const & signame, int * pids_to_take) -> int"""
+        return _medpython.PidRepository_loadsig_pids(self, signame, pids_to_take)
+
+    def list_signals(self):
+        r"""list_signals(PidRepository self) -> StringVector"""
+        return _medpython.PidRepository_list_signals(self)
+
+    def sig_id(self, signame):
+        r"""
+        sig_id(str_signame) -> int
+          returns signal id number for a given signal name
+        """
+        return _medpython.PidRepository_sig_id(self, signame)
+
+    def sig_type(self, signame):
+        r"""
+        sig_type(str_signame) -> int
+          returns signal type
+        """
+        return _medpython.PidRepository_sig_type(self, signame)
+
+    def sig_description(self, signame):
+        r"""
+        sig_description(str_signame) -> string
+          returns signal string description
+        """
+        return _medpython.PidRepository_sig_description(self, signame)
+
+    def is_categorical(self, signame, val_channel):
+        r"""
+        is_categorical(str_signame, int_val_channel) -> bool
+          returns True is channel is categorical
+        """
+        return _medpython.PidRepository_is_categorical(self, signame, val_channel)
+
+    def MEDPY_GET_pids(self):
+        r"""MEDPY_GET_pids(PidRepository self) -> IntVector"""
+        return _medpython.PidRepository_MEDPY_GET_pids(self)
+
+    def uget(self, pid, sid):
+        r"""
+        uget(int_pid, int_sid) -> SigVectorAdaptor
+          returns a vector of universal signals
+        """
+        return _medpython.PidRepository_uget(self, pid, sid)
+
+    def dict_section_id(self, secName):
+        r"""
+        dict_section_id(str_secName) -> int
+          returns section id number for a given section name
+        """
+        return _medpython.PidRepository_dict_section_id(self, secName)
+
+    def dict_name(self, section_id, id):
+        r"""
+        dict_name(int_section_id, int_id) -> string
+          returns name of section + id
+        """
+        return _medpython.PidRepository_dict_name(self, section_id, id)
+
+    def dict_prep_sets_lookup_table(self, section_id, set_names):
+        r"""
+        dict_prep_sets_lookup_table(int_section_id, list_String set_names) -> BoolVector
+          returns a look-up-table for given set names
+        """
+        return _medpython.PidRepository_dict_prep_sets_lookup_table(self, section_id, set_names)
+
+    def get_lut_from_regex(self, section_id, regex_s):
+        r"""
+        get get_lut_from_regex to names -> BoolVector
+          returns a lut  - boolean vector
+        """
+        return _medpython.PidRepository_get_lut_from_regex(self, section_id, regex_s)
+
+    def export_to_numpy(self, signame, pids_to_take, use_all_pids, translate_flag, free_sig, filter_regex_str):
+        r"""
+        export_to_numpy(str_signame) -> SigExporter
+          Returns the signal data represented as a list of numpy arrays, one for each field
+        """
+        return _medpython.PidRepository_export_to_numpy(self, signame, pids_to_take, use_all_pids, translate_flag, free_sig, filter_regex_str)
+
+    def free(self, signame):
+        r"""
+        free(signame) -> int
+          Free the signal data specified by signame
+        """
+        return _medpython.PidRepository_free(self, signame)
+
+    def switch_to_in_mem(self):
+        r"""
+        switch_to_in_mem()
+          Switch to in mem repository mode
+        """
+        return _medpython.PidRepository_switch_to_in_mem(self)
+
+    def load_from_json(self, json_file_path):
+        r"""
+        load_from_json(json_file_path)
+          Loads patient data into in-mem repository. If patient exists, adds more data
+        """
+        return _medpython.PidRepository_load_from_json(self, json_file_path)
+
+    def load_from_json_str(self, json_content):
+        r"""
+        load_from_json_str(json_string)
+          Loads patient data into in-mem repository. If patient exists, adds more data
+        """
+        return _medpython.PidRepository_load_from_json_str(self, json_content)
+
+    def clear(self):
+        r"""
+        load_from_json()
+          Clear repository memory. erase in-memory patient data
+        """
+        return _medpython.PidRepository_clear(self)
+
+    def finish_load_data(self):
+        r"""
+        finish_load_data()
+          prepare for model apply. not need to call it specifically.
+        """
+        return _medpython.PidRepository_finish_load_data(self)
+
+    def get_sig(self, sig_name_str, translate=True, pids=None, float32to64=True, free_signal=True, regex_str=None, regex_filter=None):
+        r"""get_sig(PidRepository self, char const * sig_name_str, bool translate=True, IntVector pids=None, bool float32to64=True, bool free_signal=True, char const * regex_str=None, char const * regex_filter=None)"""
+        return _medpython.PidRepository_get_sig(self, sig_name_str, translate, pids, float32to64, free_signal, regex_str, regex_filter)
+
+    pids = property(MEDPY_GET_pids,None)
+
+
+# Register PidRepository in _medpython:
+_medpython.PidRepository_swigregister(PidRepository)
+class Sig(object):
+    r"""Proxy of C++ MPSig class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, other):
+        r"""__init__(Sig self, Sig other) -> Sig"""
+        _medpython.Sig_swiginit(self, _medpython.new_Sig(other))
+
+    def time(self, chan=0):
+        r"""time(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_time(self, chan)
+
+    def val(self, chan=0):
+        r"""val(Sig self, int chan=0) -> float"""
+        return _medpython.Sig_val(self, chan)
+
+    def timeU(self, to_time_unit):
+        r"""timeU(Sig self, int to_time_unit) -> int"""
+        return _medpython.Sig_timeU(self, to_time_unit)
+
+    def date(self, chan=0):
+        r"""date(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_date(self, chan)
+
+    def years(self, chan=0):
+        r"""years(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_years(self, chan)
+
+    def months(self, chan=0):
+        r"""months(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_months(self, chan)
+
+    def days(self, chan=0):
+        r"""days(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_days(self, chan)
+
+    def hours(self, chan=0):
+        r"""hours(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_hours(self, chan)
+
+    def minutes(self, chan=0):
+        r"""minutes(Sig self, int chan=0) -> int"""
+        return _medpython.Sig_minutes(self, chan)
+    __swig_destroy__ = _medpython.delete_Sig
+
+# Register Sig in _medpython:
+_medpython.Sig_swigregister(Sig)
+class SigVectorAdaptor(object):
+    r"""Proxy of C++ MPSigVectorAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, other):
+        r"""__init__(SigVectorAdaptor self, SigVectorAdaptor other) -> SigVectorAdaptor"""
+        _medpython.SigVectorAdaptor_swiginit(self, _medpython.new_SigVectorAdaptor(other))
+    __swig_destroy__ = _medpython.delete_SigVectorAdaptor
+
+    def __len__(self):
+        r"""__len__(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(SigVectorAdaptor self, int i) -> Sig"""
+        return _medpython.SigVectorAdaptor___getitem__(self, i)
+
+    def MEDPY_GET_type(self):
+        r"""MEDPY_GET_type(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor_MEDPY_GET_type(self)
+
+    def MEDPY_GET_n_time_channels(self):
+        r"""MEDPY_GET_n_time_channels(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor_MEDPY_GET_n_time_channels(self)
+
+    def MEDPY_GET_n_val_channels(self):
+        r"""MEDPY_GET_n_val_channels(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor_MEDPY_GET_n_val_channels(self)
+
+    def MEDPY_GET_time_unit(self):
+        r"""MEDPY_GET_time_unit(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor_MEDPY_GET_time_unit(self)
+
+    def MEDPY_GET_size(self):
+        r"""MEDPY_GET_size(SigVectorAdaptor self) -> int"""
+        return _medpython.SigVectorAdaptor_MEDPY_GET_size(self)
+
+    type = property(MEDPY_GET_type,None)
+    n_time_channels = property(MEDPY_GET_n_time_channels,None)
+    n_val_channels = property(MEDPY_GET_n_val_channels,None)
+    time_unit = property(MEDPY_GET_time_unit,None)
+    size = property(MEDPY_GET_size,None)
+
+
+# Register SigVectorAdaptor in _medpython:
+_medpython.SigVectorAdaptor_swigregister(SigVectorAdaptor)
+class MedConvert(object):
+    r"""Proxy of C++ MPMedConvert class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(MedConvert self) -> MedConvert"""
+        _medpython.MedConvert_swiginit(self, _medpython.new_MedConvert())
+    __swig_destroy__ = _medpython.delete_MedConvert
+
+    def init_load_params(self, load_args):
+        r"""init_load_params(MedConvert self, std::string const & load_args)"""
+        return _medpython.MedConvert_init_load_params(self, load_args)
+
+    def create_rep(self, conf_fname):
+        r"""create_rep(MedConvert self, std::string const & conf_fname)"""
+        return _medpython.MedConvert_create_rep(self, conf_fname)
+
+    def create_index(self, conf_fname):
+        r"""create_index(MedConvert self, std::string & conf_fname) -> int"""
+        return _medpython.MedConvert_create_index(self, conf_fname)
+
+# Register MedConvert in _medpython:
+_medpython.MedConvert_swigregister(MedConvert)
+class PredictorTypes(object):
+    r"""Proxy of C++ MPPredictorTypes class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(PredictorTypes self) -> PredictorTypes"""
+        _medpython.PredictorTypes_swiginit(self, _medpython.new_PredictorTypes())
+    __swig_destroy__ = _medpython.delete_PredictorTypes
+
+# Register PredictorTypes in _medpython:
+_medpython.PredictorTypes_swigregister(PredictorTypes)
+PredictorTypes.LINEAR_MODEL = _medpython.cvar.PredictorTypes_LINEAR_MODEL
+PredictorTypes.QRF = _medpython.cvar.PredictorTypes_QRF
+PredictorTypes.GBM = _medpython.cvar.PredictorTypes_GBM
+PredictorTypes.KNN = _medpython.cvar.PredictorTypes_KNN
+PredictorTypes.BP = _medpython.cvar.PredictorTypes_BP
+PredictorTypes.MARS = _medpython.cvar.PredictorTypes_MARS
+PredictorTypes.GD_LINEAR = _medpython.cvar.PredictorTypes_GD_LINEAR
+PredictorTypes.MULTI_CLASS = _medpython.cvar.PredictorTypes_MULTI_CLASS
+PredictorTypes.XGB = _medpython.cvar.PredictorTypes_XGB
+PredictorTypes.LASSO = _medpython.cvar.PredictorTypes_LASSO
+PredictorTypes.MIC_NET = _medpython.cvar.PredictorTypes_MIC_NET
+PredictorTypes.BOOSTER = _medpython.cvar.PredictorTypes_BOOSTER
+PredictorTypes.DEEP_BIT = _medpython.cvar.PredictorTypes_DEEP_BIT
+PredictorTypes.LIGHTGBM = _medpython.cvar.PredictorTypes_LIGHTGBM
+PredictorTypes.SPECIFIC_GROUPS_MODELS = _medpython.cvar.PredictorTypes_SPECIFIC_GROUPS_MODELS
+PredictorTypes.SVM = _medpython.cvar.PredictorTypes_SVM
+PredictorTypes.LINEAR_SGD = _medpython.cvar.PredictorTypes_LINEAR_SGD
+PredictorTypes.VW = _medpython.cvar.PredictorTypes_VW
+PredictorTypes.TQRF = _medpython.cvar.PredictorTypes_TQRF
+PredictorTypes.BART = _medpython.cvar.PredictorTypes_BART
+
+class Predictor(object):
+    r"""Proxy of C++ MPPredictor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def asSerializable(self):
+        r"""asSerializable(Predictor self) -> SerializableObject"""
+        return _medpython.Predictor_asSerializable(self)
+
+    def __init__(self, *args):
+        r"""
+        __init__(Predictor self) -> Predictor
+        __init__(Predictor self, string model_type, string params="") -> Predictor
+        """
+        _medpython.Predictor_swiginit(self, _medpython.new_Predictor(*args))
+
+    def MEDPY_GET_transpose_for_learn(self):
+        r"""MEDPY_GET_transpose_for_learn(Predictor self) -> bool"""
+        return _medpython.Predictor_MEDPY_GET_transpose_for_learn(self)
+
+    def MEDPY_SET_transpose_for_learn(self, new_val):
+        r"""MEDPY_SET_transpose_for_learn(Predictor self, bool new_val)"""
+        return _medpython.Predictor_MEDPY_SET_transpose_for_learn(self, new_val)
+
+    def MEDPY_GET_normalize_for_learn(self):
+        r"""MEDPY_GET_normalize_for_learn(Predictor self) -> bool"""
+        return _medpython.Predictor_MEDPY_GET_normalize_for_learn(self)
+
+    def MEDPY_SET_normalize_for_learn(self, new_val):
+        r"""MEDPY_SET_normalize_for_learn(Predictor self, bool new_val)"""
+        return _medpython.Predictor_MEDPY_SET_normalize_for_learn(self, new_val)
+
+    def MEDPY_GET_normalize_y_for_learn(self):
+        r"""MEDPY_GET_normalize_y_for_learn(Predictor self) -> bool"""
+        return _medpython.Predictor_MEDPY_GET_normalize_y_for_learn(self)
+
+    def MEDPY_SET_normalize_y_for_learn(self, new_val):
+        r"""MEDPY_SET_normalize_y_for_learn(Predictor self, bool new_val)"""
+        return _medpython.Predictor_MEDPY_SET_normalize_y_for_learn(self, new_val)
+
+    def MEDPY_GET_transpose_for_predict(self):
+        r"""MEDPY_GET_transpose_for_predict(Predictor self) -> bool"""
+        return _medpython.Predictor_MEDPY_GET_transpose_for_predict(self)
+
+    def MEDPY_SET_transpose_for_predict(self, new_val):
+        r"""MEDPY_SET_transpose_for_predict(Predictor self, bool new_val)"""
+        return _medpython.Predictor_MEDPY_SET_transpose_for_predict(self, new_val)
+
+    def MEDPY_GET_normalize_for_predict(self):
+        r"""MEDPY_GET_normalize_for_predict(Predictor self) -> bool"""
+        return _medpython.Predictor_MEDPY_GET_normalize_for_predict(self)
+
+    def MEDPY_SET_normalize_for_predict(self, new_val):
+        r"""MEDPY_SET_normalize_for_predict(Predictor self, bool new_val)"""
+        return _medpython.Predictor_MEDPY_SET_normalize_for_predict(self, new_val)
+
+    def MEDPY_GET_model_features(self):
+        r"""MEDPY_GET_model_features(Predictor self) -> StringVector"""
+        return _medpython.Predictor_MEDPY_GET_model_features(self)
+
+    def MEDPY_SET_model_features(self, new_val):
+        r"""MEDPY_SET_model_features(Predictor self, StringVector new_val)"""
+        return _medpython.Predictor_MEDPY_SET_model_features(self, new_val)
+
+    def MEDPY_GET_features_count(self):
+        r"""MEDPY_GET_features_count(Predictor self) -> int"""
+        return _medpython.Predictor_MEDPY_GET_features_count(self)
+
+    def MEDPY_SET_features_count(self, new_val):
+        r"""MEDPY_SET_features_count(Predictor self, int new_val)"""
+        return _medpython.Predictor_MEDPY_SET_features_count(self, new_val)
+
+    @staticmethod
+    def make_predictor(*args):
+        r"""
+        make_predictor(string model_type) -> Predictor
+        make_predictor(string model_type, string params) -> Predictor
+        """
+        return _medpython.Predictor_make_predictor(*args)
+
+    def learn(self, features):
+        r"""learn(Predictor self, Features features) -> int"""
+        return _medpython.Predictor_learn(self, features)
+
+    def predict(self, features):
+        r"""predict(Predictor self, Features features) -> int"""
+        return _medpython.Predictor_predict(self, features)
+
+    def calc_feature_contribs(self, features, res):
+        r"""calc_feature_contribs(Predictor self, Features features, Features res)"""
+        return _medpython.Predictor_calc_feature_contribs(self, features, res)
+
+    def write_predictor_to_file(self, outFile):
+        r"""write_predictor_to_file(Predictor self, string & outFile)"""
+        return _medpython.Predictor_write_predictor_to_file(self, outFile)
+
+    def export_predictor(self, outFile):
+        r"""export_predictor(Predictor self, string & outFile)"""
+        return _medpython.Predictor_export_predictor(self, outFile)
+
+    transpose_for_learn = property(MEDPY_GET_transpose_for_learn,MEDPY_SET_transpose_for_learn)
+    normalize_for_learn = property(MEDPY_GET_normalize_for_learn,MEDPY_SET_normalize_for_learn)
+    normalize_y_for_learn = property(MEDPY_GET_normalize_y_for_learn,MEDPY_SET_normalize_y_for_learn)
+    transpose_for_predict = property(MEDPY_GET_transpose_for_predict,MEDPY_SET_transpose_for_predict)
+    normalize_for_predict = property(MEDPY_GET_normalize_for_predict,MEDPY_SET_normalize_for_predict)
+    model_features = property(MEDPY_GET_model_features,MEDPY_SET_model_features)
+    features_count = property(MEDPY_GET_features_count,MEDPY_SET_features_count)
+
+    __swig_destroy__ = _medpython.delete_Predictor
+
+# Register Predictor in _medpython:
+_medpython.Predictor_swigregister(Predictor)
+class SampleFilter(object):
+    r"""Proxy of C++ MPSampleFilter class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    @staticmethod
+    def from_name(name):
+        r"""from_name(string name) -> SampleFilter"""
+        return _medpython.SampleFilter_from_name(name)
+
+    @staticmethod
+    def from_type(type):
+        r"""from_type(int type) -> SampleFilter"""
+        return _medpython.SampleFilter_from_type(type)
+
+    @staticmethod
+    def from_name_params(name, params):
+        r"""from_name_params(string name, string params) -> SampleFilter"""
+        return _medpython.SampleFilter_from_name_params(name, params)
+
+    @staticmethod
+    def from_type_params(type, params):
+        r"""from_type_params(int type, string params) -> SampleFilter"""
+        return _medpython.SampleFilter_from_type_params(type, params)
+    __swig_destroy__ = _medpython.delete_SampleFilter
+
+    def filter(self, rep, samples):
+        r"""
+        filter(rep, samples) -> int
+        in-place filtering with repository. returns -1 if fails.
+        """
+        return _medpython.SampleFilter_filter(self, rep, samples)
+
+    def asSerializable(self):
+        r"""asSerializable(SampleFilter self) -> SerializableObject"""
+        return _medpython.SampleFilter_asSerializable(self)
+
+    def __init__(self):
+        r"""__init__(SampleFilter self) -> SampleFilter"""
+        _medpython.SampleFilter_swiginit(self, _medpython.new_SampleFilter())
+
+# Register SampleFilter in _medpython:
+_medpython.SampleFilter_swigregister(SampleFilter)
+SampleFilter.SMPL_FILTER_TRN_ = _medpython.cvar.SampleFilter_SMPL_FILTER_TRN_
+SampleFilter.SMPL_FILTER_TST_ = _medpython.cvar.SampleFilter_SMPL_FILTER_TST_
+SampleFilter.SMPL_FILTER_OUTLIERS_ = _medpython.cvar.SampleFilter_SMPL_FILTER_OUTLIERS_
+SampleFilter.SMPL_FILTER_MATCH_ = _medpython.cvar.SampleFilter_SMPL_FILTER_MATCH_
+SampleFilter.SMPL_FILTER_REQ_SIGNAL_ = _medpython.cvar.SampleFilter_SMPL_FILTER_REQ_SIGNAL_
+SampleFilter.SMPL_FILTER_BASIC_ = _medpython.cvar.SampleFilter_SMPL_FILTER_BASIC_
+SampleFilter.SMPL_FILTER_LAST_ = _medpython.cvar.SampleFilter_SMPL_FILTER_LAST_
+
+class Sample(object):
+    r"""Proxy of C++ MPSample class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def MEDPY_GET_id(self):
+        r"""MEDPY_GET_id(Sample self) -> int"""
+        return _medpython.Sample_MEDPY_GET_id(self)
+
+    def MEDPY_SET_id(self, new_id):
+        r"""MEDPY_SET_id(Sample self, int new_id)"""
+        return _medpython.Sample_MEDPY_SET_id(self, new_id)
+
+    def MEDPY_GET_split(self):
+        r"""MEDPY_GET_split(Sample self) -> int"""
+        return _medpython.Sample_MEDPY_GET_split(self)
+
+    def MEDPY_SET_split(self, new_sp):
+        r"""MEDPY_SET_split(Sample self, int new_sp)"""
+        return _medpython.Sample_MEDPY_SET_split(self, new_sp)
+
+    def MEDPY_GET_time(self):
+        r"""MEDPY_GET_time(Sample self) -> int"""
+        return _medpython.Sample_MEDPY_GET_time(self)
+
+    def MEDPY_SET_time(self, new_time):
+        r"""MEDPY_SET_time(Sample self, int new_time)"""
+        return _medpython.Sample_MEDPY_SET_time(self, new_time)
+
+    def MEDPY_GET_outcome(self):
+        r"""MEDPY_GET_outcome(Sample self) -> int"""
+        return _medpython.Sample_MEDPY_GET_outcome(self)
+
+    def MEDPY_SET_outcome(self, new_outcome):
+        r"""MEDPY_SET_outcome(Sample self, int new_outcome)"""
+        return _medpython.Sample_MEDPY_SET_outcome(self, new_outcome)
+
+    def MEDPY_GET_outcomeTime(self):
+        r"""MEDPY_GET_outcomeTime(Sample self) -> int"""
+        return _medpython.Sample_MEDPY_GET_outcomeTime(self)
+
+    def MEDPY_SET_outcomeTime(self, new_outcome_time):
+        r"""MEDPY_SET_outcomeTime(Sample self, int new_outcome_time)"""
+        return _medpython.Sample_MEDPY_SET_outcomeTime(self, new_outcome_time)
+
+    def MEDPY_GET_prediction(self):
+        r"""MEDPY_GET_prediction(Sample self)"""
+        return _medpython.Sample_MEDPY_GET_prediction(self)
+
+    def MEDPY_SET_prediction(self, in_predbuf):
+        r"""MEDPY_SET_prediction(Sample self, float * in_predbuf)"""
+        return _medpython.Sample_MEDPY_SET_prediction(self, in_predbuf)
+
+    def __init__(self):
+        r"""__init__(Sample self) -> Sample"""
+        _medpython.Sample_swiginit(self, _medpython.new_Sample())
+    __swig_destroy__ = _medpython.delete_Sample
+
+    def print_(self, *args):
+        r"""
+        print_(Sample self, string const prefix)
+        print_(Sample self)
+        """
+        return _medpython.Sample_print_(self, *args)
+
+    def parse_from_string(self, s, time_unit):
+        r"""parse_from_string(Sample self, string & s, int time_unit) -> int"""
+        return _medpython.Sample_parse_from_string(self, s, time_unit)
+
+    def write_to_string(self, s, time_unit):
+        r"""write_to_string(Sample self, string & s, int time_unit)"""
+        return _medpython.Sample_write_to_string(self, s, time_unit)
+
+    def __copy__(self):
+        r"""__copy__(Sample self) -> Sample"""
+        return _medpython.Sample___copy__(self)
+
+    def asSerializable(self):
+        r"""asSerializable(Sample self) -> SerializableObject"""
+        return _medpython.Sample_asSerializable(self)
+
+    id = property(MEDPY_GET_id,MEDPY_SET_id)
+    split = property(MEDPY_GET_split,MEDPY_SET_split)
+    time = property(MEDPY_GET_time,MEDPY_SET_time)
+    outcome = property(MEDPY_GET_outcome,MEDPY_SET_outcome)
+    outcomeTime = property(MEDPY_GET_outcomeTime,MEDPY_SET_outcomeTime)
+    prediction = property(MEDPY_GET_prediction,MEDPY_SET_prediction)
+
+
+# Register Sample in _medpython:
+_medpython.Sample_swigregister(Sample)
+class SampleVectorAdaptor(object):
+    r"""Proxy of C++ MPSampleVectorAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(SampleVectorAdaptor self) -> SampleVectorAdaptor"""
+        _medpython.SampleVectorAdaptor_swiginit(self, _medpython.new_SampleVectorAdaptor())
+    __swig_destroy__ = _medpython.delete_SampleVectorAdaptor
+
+    def __len__(self):
+        r"""__len__(SampleVectorAdaptor self) -> int"""
+        return _medpython.SampleVectorAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(SampleVectorAdaptor self, int i) -> Sample"""
+        return _medpython.SampleVectorAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(SampleVectorAdaptor self, int i, Sample val)"""
+        return _medpython.SampleVectorAdaptor___setitem__(self, i, val)
+
+    def append(self, val):
+        r"""append(SampleVectorAdaptor self, Sample val)"""
+        return _medpython.SampleVectorAdaptor_append(self, val)
+
+    def append_vec(self, other):
+        r"""append_vec(SampleVectorAdaptor self, SampleVectorAdaptor other)"""
+        return _medpython.SampleVectorAdaptor_append_vec(self, other)
+
+    def override_splits(self, nfolds):
+        r"""override_splits(SampleVectorAdaptor self, int nfolds)"""
+        return _medpython.SampleVectorAdaptor_override_splits(self, nfolds)
+
+    def nSplits(self):
+        r"""nSplits(SampleVectorAdaptor self) -> int"""
+        return _medpython.SampleVectorAdaptor_nSplits(self)
+
+# Register SampleVectorAdaptor in _medpython:
+_medpython.SampleVectorAdaptor_swigregister(SampleVectorAdaptor)
+class IdSamples(object):
+    r"""Proxy of C++ MPIdSamples class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def MEDPY_GET_id(self):
+        r"""MEDPY_GET_id(IdSamples self) -> int"""
+        return _medpython.IdSamples_MEDPY_GET_id(self)
+
+    def MEDPY_SET_id(self, new_id):
+        r"""MEDPY_SET_id(IdSamples self, int new_id)"""
+        return _medpython.IdSamples_MEDPY_SET_id(self, new_id)
+
+    def MEDPY_GET_split(self):
+        r"""MEDPY_GET_split(IdSamples self) -> int"""
+        return _medpython.IdSamples_MEDPY_GET_split(self)
+
+    def MEDPY_SET_split(self, new_id):
+        r"""MEDPY_SET_split(IdSamples self, int new_id)"""
+        return _medpython.IdSamples_MEDPY_SET_split(self, new_id)
+
+    def MEDPY_GET_samples(self):
+        r"""MEDPY_GET_samples(IdSamples self) -> SampleVectorAdaptor"""
+        return _medpython.IdSamples_MEDPY_GET_samples(self)
+
+    def __init__(self, *args):
+        r"""
+        __init__(IdSamples self, int _id) -> IdSamples
+        __init__(IdSamples self) -> IdSamples
+        """
+        _medpython.IdSamples_swiginit(self, _medpython.new_IdSamples(*args))
+    __swig_destroy__ = _medpython.delete_IdSamples
+
+    def set_split(self, _split):
+        r"""set_split(IdSamples self, int _split)"""
+        return _medpython.IdSamples_set_split(self, _split)
+
+    def same_as(self, other, mode):
+        r"""same_as(IdSamples self, IdSamples other, int mode) -> bool"""
+        return _medpython.IdSamples_same_as(self, other, mode)
+
+    def asSerializable(self):
+        r"""asSerializable(IdSamples self) -> SerializableObject"""
+        return _medpython.IdSamples_asSerializable(self)
+
+    id = property(MEDPY_GET_id,MEDPY_SET_id)
+    split = property(MEDPY_GET_split,MEDPY_SET_split)
+    samples = property(MEDPY_GET_samples,None)
+
+
+# Register IdSamples in _medpython:
+_medpython.IdSamples_swigregister(IdSamples)
+class IdSamplesVectorAdaptor(object):
+    r"""Proxy of C++ MPIdSamplesVectorAdaptor class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self, *args):
+        r"""
+        __init__(IdSamplesVectorAdaptor self) -> IdSamplesVectorAdaptor
+        __init__(IdSamplesVectorAdaptor self, vector< MedIdSamples > * ptr) -> IdSamplesVectorAdaptor
+        """
+        _medpython.IdSamplesVectorAdaptor_swiginit(self, _medpython.new_IdSamplesVectorAdaptor(*args))
+    __swig_destroy__ = _medpython.delete_IdSamplesVectorAdaptor
+
+    def __len__(self):
+        r"""__len__(IdSamplesVectorAdaptor self) -> int"""
+        return _medpython.IdSamplesVectorAdaptor___len__(self)
+
+    def __getitem__(self, i):
+        r"""__getitem__(IdSamplesVectorAdaptor self, int i) -> IdSamples"""
+        return _medpython.IdSamplesVectorAdaptor___getitem__(self, i)
+
+    def __setitem__(self, i, val):
+        r"""__setitem__(IdSamplesVectorAdaptor self, int i, IdSamples val)"""
+        return _medpython.IdSamplesVectorAdaptor___setitem__(self, i, val)
+
+    def append(self, val):
+        r"""append(IdSamplesVectorAdaptor self, IdSamples val)"""
+        return _medpython.IdSamplesVectorAdaptor_append(self, val)
+
+# Register IdSamplesVectorAdaptor in _medpython:
+_medpython.IdSamplesVectorAdaptor_swigregister(IdSamplesVectorAdaptor)
+class Samples(object):
+    r"""Proxy of C++ MPSamples class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def MEDPY_GET_time_unit(self):
+        r"""MEDPY_GET_time_unit(Samples self) -> int"""
+        return _medpython.Samples_MEDPY_GET_time_unit(self)
+
+    def MEDPY_SET_time_unit(self, new_time_unit):
+        r"""MEDPY_SET_time_unit(Samples self, int new_time_unit)"""
+        return _medpython.Samples_MEDPY_SET_time_unit(self, new_time_unit)
+
+    def MEDPY_GET_idSamples(self):
+        r"""MEDPY_GET_idSamples(Samples self) -> IdSamplesVectorAdaptor"""
+        return _medpython.Samples_MEDPY_GET_idSamples(self)
+
+    def __init__(self):
+        r"""__init__(Samples self) -> Samples"""
+        _medpython.Samples_swiginit(self, _medpython.new_Samples())
+    __swig_destroy__ = _medpython.delete_Samples
+
+    def clear(self):
+        r"""clear(Samples self)"""
+        return _medpython.Samples_clear(self)
+
+    def insert_preds(self, featuresData):
+        r"""insert_preds(Samples self, Features featuresData) -> int"""
+        return _medpython.Samples_insert_preds(self, featuresData)
+
+    def get_ids(self):
+        r"""get_ids(Samples self)"""
+        return _medpython.Samples_get_ids(self)
+
+    def append(self, newSamples):
+        r"""append(Samples self, Samples newSamples)"""
+        return _medpython.Samples_append(self, newSamples)
+
+    def subtract(self, _dont_use):
+        r"""subtract(Samples self, Samples _dont_use)"""
+        return _medpython.Samples_subtract(self, _dont_use)
+
+    def split_train_test(self, train, test, p_test):
+        r"""split_train_test(Samples self, Samples train, Samples test, float p_test)"""
+        return _medpython.Samples_split_train_test(self, train, test, p_test)
+
+    def read_from_bin_file(self, file_name):
+        r"""read_from_bin_file(Samples self, string const & file_name) -> int"""
+        return _medpython.Samples_read_from_bin_file(self, file_name)
+
+    def write_to_bin_file(self, file_name):
+        r"""write_to_bin_file(Samples self, string const & file_name) -> int"""
+        return _medpython.Samples_write_to_bin_file(self, file_name)
+
+    def read_from_file(self, file_name):
+        r"""read_from_file(Samples self, string const & file_name) -> int"""
+        return _medpython.Samples_read_from_file(self, file_name)
+
+    def write_to_file(self, fname):
+        r"""write_to_file(Samples self, string const & fname) -> int"""
+        return _medpython.Samples_write_to_file(self, fname)
+
+    def get_preds(self):
+        r"""get_preds(Samples self)"""
+        return _medpython.Samples_get_preds(self)
+
+    def get_y(self):
+        r"""get_y(Samples self)"""
+        return _medpython.Samples_get_y(self)
+
+    def get_categs(self):
+        r"""get_categs(Samples self)"""
+        return _medpython.Samples_get_categs(self)
+
+    def filter_by_bt(self, rep_path, json_mat, bt_cohort):
+        r"""filter_by_bt(Samples self, string const & rep_path, string const & json_mat, string const & bt_cohort)"""
+        return _medpython.Samples_filter_by_bt(self, rep_path, json_mat, bt_cohort)
+
+    def export_to_sample_vec(self):
+        r"""export_to_sample_vec(Samples self) -> SampleVectorAdaptor"""
+        return _medpython.Samples_export_to_sample_vec(self)
+
+    def import_from_sample_vec(self, vec_samples, allow_split_inconsistency=False):
+        r"""import_from_sample_vec(Samples self, SampleVectorAdaptor vec_samples, bool allow_split_inconsistency=False)"""
+        return _medpython.Samples_import_from_sample_vec(self, vec_samples, allow_split_inconsistency)
+
+    def MEDPY__from_df(self, pandas_df):
+        r"""MEDPY__from_df(Samples self, PandasAdaptor pandas_df)"""
+        return _medpython.Samples_MEDPY__from_df(self, pandas_df)
+
+    def MEDPY__from_df_adaptor(self):
+        r"""MEDPY__from_df_adaptor(Samples self) -> PandasAdaptor"""
+        return _medpython.Samples_MEDPY__from_df_adaptor(self)
+
+    def MEDPY__to_df(self):
+        r"""MEDPY__to_df(Samples self) -> PandasAdaptor"""
+        return _medpython.Samples_MEDPY__to_df(self)
+
+    def sort_by_id_date(self):
+        r"""sort_by_id_date(Samples self)"""
+        return _medpython.Samples_sort_by_id_date(self)
+
+    def normalize(self):
+        r"""normalize(Samples self)"""
+        return _medpython.Samples_normalize(self)
+
+    def same_as(self, other, mode):
+        r"""same_as(Samples self, Samples other, int mode) -> bool"""
+        return _medpython.Samples_same_as(self, other, mode)
+
+    def nSamples(self):
+        r"""nSamples(Samples self) -> int"""
+        return _medpython.Samples_nSamples(self)
+
+    def nSplits(self):
+        r"""
+        nSplits() -> int
+        Return number of splits, also check mismatches between idSample and internal MedSamples and set idSamples.split if missing
+        """
+        return _medpython.Samples_nSplits(self)
+
+    def get_predictions_size(self):
+        r"""get_predictions_size(Samples self) -> int"""
+        return _medpython.Samples_get_predictions_size(self)
+
+    def get_attributes(self):
+        r"""get_attributes(Samples self) -> StringVector"""
+        return _medpython.Samples_get_attributes(self)
+
+    def get_str_attributes(self):
+        r"""get_str_attributes(Samples self) -> StringVector"""
+        return _medpython.Samples_get_str_attributes(self)
+
+    def get_str_attributes_by_name(self, attr_name):
+        r"""get_str_attributes_by_name(Samples self, string const & attr_name) -> StringVector"""
+        return _medpython.Samples_get_str_attributes_by_name(self, attr_name)
+
+    def dilute(self, prob):
+        r"""dilute(Samples self, float prob)"""
+        return _medpython.Samples_dilute(self, prob)
+
+    def insertRec(self, *args):
+        r"""
+        insertRec(Samples self, int pid, int time, float outcome, int outcomeTime)
+        insertRec(Samples self, int pid, int time, float outcome, int outcomeTime, float pred)
+        insertRec(Samples self, int pid, int time)
+        """
+        return _medpython.Samples_insertRec(self, *args)
+
+    def version(self):
+        r"""version(Samples self) -> int"""
+        return _medpython.Samples_version(self)
+
+    def asSerializable(self):
+        r"""asSerializable(Samples self) -> SerializableObject"""
+        return _medpython.Samples_asSerializable(self)
+
+    def override_splits(self, nfolds):
+        r"""override_splits(Samples self, int nfolds)"""
+        return _medpython.Samples_override_splits(self, nfolds)
+
+    def set_samples(self, patients, _time=-1):
+        r"""set_samples(Samples self, int * patients, int _time=-1)"""
+        return _medpython.Samples_set_samples(self, patients, _time)
+
+    time_unit = property(MEDPY_GET_time_unit,MEDPY_SET_time_unit)
+    idSamples = property(MEDPY_GET_idSamples,None)
+
+
+# Register Samples in _medpython:
+_medpython.Samples_swigregister(Samples)
+class SerializableObject(object):
+    r"""Proxy of C++ MPSerializableObject class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(SerializableObject self) -> SerializableObject"""
+        _medpython.SerializableObject_swiginit(self, _medpython.new_SerializableObject())
+    __swig_destroy__ = _medpython.delete_SerializableObject
+
+    def version(self):
+        r"""version(SerializableObject self) -> int"""
+        return _medpython.SerializableObject_version(self)
+
+    def my_class_name(self):
+        r"""my_class_name(SerializableObject self) -> string"""
+        return _medpython.SerializableObject_my_class_name(self)
+
+    def get_size(self):
+        r"""
+        get_size() -> int
+            Gets bytes sizes for serializations
+        """
+        return _medpython.SerializableObject_get_size(self)
+
+    def read_from_file(self, fname):
+        r"""
+        read_from_file(fname) -> int
+            read and deserialize object
+        """
+        return _medpython.SerializableObject_read_from_file(self, fname)
+
+    def write_to_file(self, fname):
+        r"""
+        write_to_file(fname) -> int
+            serialize object and write to file
+        """
+        return _medpython.SerializableObject_write_to_file(self, fname)
+
+    def read_from_file_unsafe(self, fname):
+        r"""
+        read_from_file_unsafe(fname) -> int
+            read and deserialize model without checking version number - unsafe read
+        """
+        return _medpython.SerializableObject_read_from_file_unsafe(self, fname)
+
+# Register SerializableObject in _medpython:
+_medpython.SerializableObject_swigregister(SerializableObject)
+class SigExporter(object):
+    r"""Proxy of C++ MPSigExporter class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def keys(self):
+        r"""keys(SigExporter self) -> StringVector"""
+        return _medpython.SigExporter_keys(self)
+    sig_name = property(_medpython.SigExporter_sig_name_get, _medpython.SigExporter_sig_name_set, doc=r"""sig_name : std::string""")
+    sig_id = property(_medpython.SigExporter_sig_id_get, _medpython.SigExporter_sig_id_set, doc=r"""sig_id : int""")
+    sig_type = property(_medpython.SigExporter_sig_type_get, _medpython.SigExporter_sig_type_set, doc=r"""sig_type : int""")
+    record_count = property(_medpython.SigExporter_record_count_get, _medpython.SigExporter_record_count_set, doc=r"""record_count : size_t""")
+    record_count_updated = property(_medpython.SigExporter_record_count_updated_get, _medpython.SigExporter_record_count_updated_set, doc=r"""record_count_updated : bool""")
+
+    def __init__(self, rep, signame_str, pids_to_take, use_all_pids, translate_flag, free_sig_flag, filter_regex_str):
+        r"""__init__(SigExporter self, PidRepository rep, std::string signame_str, int * pids_to_take, int use_all_pids, int translate_flag, int free_sig_flag, std::string filter_regex_str) -> SigExporter"""
+        _medpython.SigExporter_swiginit(self, _medpython.new_SigExporter(rep, signame_str, pids_to_take, use_all_pids, translate_flag, free_sig_flag, filter_regex_str))
+
+    def update_record_count(self):
+        r"""update_record_count(SigExporter self)"""
+        return _medpython.SigExporter_update_record_count(self)
+
+    def get_all_data(self):
+        r"""get_all_data(SigExporter self)"""
+        return _medpython.SigExporter_get_all_data(self)
+
+    def clear(self):
+        r"""clear(SigExporter self)"""
+        return _medpython.SigExporter_clear(self)
+
+    def transfer_column(self, key):
+        r"""transfer_column(SigExporter self, std::string const & key)"""
+        return _medpython.SigExporter_transfer_column(self, key)
+
+    def __getitem__(self, key):
+        r"""__getitem__(SigExporter self, std::string const & key)"""
+        return _medpython.SigExporter___getitem__(self, key)
+
+    def __iter__(self):
+        r"""__iter__(SigExporter self) -> MPSigExporter_iter"""
+        return _medpython.SigExporter___iter__(self)
+
+    def get_categorical_field_dict(self, field):
+        r"""get_categorical_field_dict(SigExporter self, std::string const & field) -> StringVector"""
+        return _medpython.SigExporter_get_categorical_field_dict(self, field)
+
+    def get_categorical_field_dict_int(self, field):
+        r"""get_categorical_field_dict_int(SigExporter self, std::string const & field) -> IntVector"""
+        return _medpython.SigExporter_get_categorical_field_dict_int(self, field)
+
+    def get_categorical_fields(self):
+        r"""get_categorical_fields(SigExporter self) -> StringVector"""
+        return _medpython.SigExporter_get_categorical_fields(self)
+    __swig_destroy__ = _medpython.delete_SigExporter
+
+# Register SigExporter in _medpython:
+_medpython.SigExporter_swigregister(SigExporter)
+class MPSigExporter_iter(object):
+    r"""Proxy of C++ MPSigExporter_iter class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+
+    def __init__(self, *args):
+        r"""
+        __init__(MPSigExporter_iter self, SigExporter o, StringVector keys_param) -> MPSigExporter_iter
+        __init__(MPSigExporter_iter self, MPSigExporter_iter orig) -> MPSigExporter_iter
+        """
+        _medpython.MPSigExporter_iter_swiginit(self, _medpython.new_MPSigExporter_iter(*args))
+
+    def __next__(self):
+        r"""__next__(MPSigExporter_iter self) -> std::string"""
+        return _medpython.MPSigExporter_iter___next__(self)
+
+    def __repr__(self):
+        r"""__repr__(MPSigExporter_iter self) -> std::string"""
+        return _medpython.MPSigExporter_iter___repr__(self)
+    __swig_destroy__ = _medpython.delete_MPSigExporter_iter
+
+# Register MPSigExporter_iter in _medpython:
+_medpython.MPSigExporter_iter_swigregister(MPSigExporter_iter)
+class Split(object):
+    r"""Proxy of C++ MPSplit class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Split self) -> Split"""
+        _medpython.Split_swiginit(self, _medpython.new_Split())
+    __swig_destroy__ = _medpython.delete_Split
+
+    def MEDPY_GET_nsplits(self):
+        r"""MEDPY_GET_nsplits(Split self) -> int"""
+        return _medpython.Split_MEDPY_GET_nsplits(self)
+
+    def MEDPY_GET_pid2split(self):
+        r"""MEDPY_GET_pid2split(Split self) -> IntIntMapAdaptor"""
+        return _medpython.Split_MEDPY_GET_pid2split(self)
+
+    def clear(self):
+        r"""clear(Split self)"""
+        return _medpython.Split_clear(self)
+
+    def read_from_file(self, fname):
+        r"""read_from_file(Split self, string const & fname) -> int"""
+        return _medpython.Split_read_from_file(self, fname)
+
+    def write_to_file(self, fname):
+        r"""write_to_file(Split self, string const & fname) -> int"""
+        return _medpython.Split_write_to_file(self, fname)
+
+    nsplits = property(MEDPY_GET_nsplits,None)
+    pid2split = property(MEDPY_GET_pid2split,None)
+
+
+# Register Split in _medpython:
+_medpython.Split_swigregister(Split)
+class Time(object):
+    r"""Proxy of C++ MPTime class."""
+
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
+    __repr__ = _swig_repr
+
+    def __init__(self):
+        r"""__init__(Time self) -> Time"""
+        _medpython.Time_swiginit(self, _medpython.new_Time())
+    __swig_destroy__ = _medpython.delete_Time
+
+# Register Time in _medpython:
+_medpython.Time_swigregister(Time)
+Time.Undefined = _medpython.cvar.Time_Undefined
+Time.Date = _medpython.cvar.Time_Date
+Time.Years = _medpython.cvar.Time_Years
+Time.Months = _medpython.cvar.Time_Months
+Time.Days = _medpython.cvar.Time_Days
+Time.Hours = _medpython.cvar.Time_Hours
+Time.Minutes = _medpython.cvar.Time_Minutes
+Time.DateTimeString = _medpython.cvar.Time_DateTimeString
+
+
+def get_public_objects():
+    r"""get_public_objects() -> StringVector"""
+    return _medpython.get_public_objects()
+
+
+__all__ = list(_medpython.get_public_objects())
+
+"""
+Enable stderr capturing under ipynb
+"""
+class _stderr_fix:
+  STDERR_FD = 2
+  prevfd = None
+  tmp = None
+  reader = None
+  is_in_ipynb = None
+
+  def in_ipynb(self):
+    try:
+        if str(type(get_ipython())) == "<class 'ipykernel.zmqshell.ZMQInteractiveShell'>":
+            return True
+        else:
+            return False
+    except NameError:
+        return False
+
+  def __init__(self):
+    from os import dup,dup2
+    from tempfile import NamedTemporaryFile
+    self.is_in_ipynb = self.in_ipynb()
+    if self.is_in_ipynb:
+      self.tmp = NamedTemporaryFile()
+      self.prevfd = dup(self.STDERR_FD)
+      dup2(self.tmp.fileno(), self.STDERR_FD)
+      self.reader = open(self.tmp.name)
+
+  def __del__(self):
+    if self.is_in_ipynb:
+      from os import dup2
+      dup2(self.prevfd, self.STDERR_FD)
+
+  def get_cerr(self):
+    if self.is_in_ipynb:
+      return self.reader.read()
+    return ''
+
+
+_stderr_fix_instance = _stderr_fix()
+
+
+def cerr():
+  return _stderr_fix_instance.get_cerr()
+
+
+"""
+Enable iterators on vector and map adaptor objects
+"""
+
+
+class MapAdaptorKeyIter:
+    def __init__(self,o):
+        self.obj = o.keys()
+        self.i = 0
+        self.prev_i = None
+        self.max_i = len(self.obj)
+    def __next__(self):
+        if self.i >= self.max_i:
+            raise StopIteration
+        else:
+            self.prev_i, self.i = self.i, self.i+1
+            return self.obj[self.prev_i]
+    def next(self):
+        return self.__next__()
+
+
+class IntIndexIter:
+    def __init__(self,o):
+        self.obj = o
+        self.i = 0
+        self.prev_i = None
+        self.max_i = len(o)
+    def __next__(self):
+        if self.i >= self.max_i:
+            raise StopIteration
+        else:
+            self.prev_i, self.i = self.i, self.i+1
+            return self.obj[self.prev_i]
+    def next(self):
+        return self.__next__()
+
+def __to_df_imp(self):
+    import pandas as pd
+    return pd.DataFrame.from_dict(dict(self.MEDPY__to_df()))
+
+def __from_df_imp(self, df):
+    import re
+    adaptor = self.MEDPY__from_df_adaptor()
+    type_requirements = dict(adaptor.type_requirements)
+    for col_name in df.columns: 
+        for col_req_name in type_requirements: 
+            if re.match('^'+col_req_name+'$',col_name):
+                if str(df[col_name].dtype) != type_requirements[col_req_name]:
+                    df[col_name] = df[col_name].astype(type_requirements[col_req_name],copy=False)
+        adaptor.import_column(col_name ,df[col_name].values)
+    self.MEDPY__from_df(adaptor)
+
+
+def ___fix_vecmap_iter():
+    from inspect import isclass
+    glob = globals()
+    for i in glob:
+        o = glob[i]
+        try:
+          if (isclass(o) and '__len__' in dir(o) and '__getitem__' in dir(o) and not '__iter__' in dir(o) 
+              and i.endswith('VectorAdaptor')) :
+              setattr(o, '__iter__', lambda x: IntIndexIter(x))
+          elif (isclass(o) and '__getitem__' in dir(o) and 'keys' in dir(o) and not '__iter__' in dir(o) 
+              and i.endswith('MapAdaptor')) :
+              setattr(o, '__iter__', lambda x: MapAdaptorKeyIter(x))
+          if (isclass(o) and 'MEDPY__from_df' in dir(o) and 'MEDPY__from_df_adaptor' in dir(o)):
+              setattr(o, 'from_df', __from_df_imp)
+          if (isclass(o) and 'MEDPY__to_df' in dir(o)):
+              setattr(o, 'to_df', __to_df_imp)
+        except: pass
+
+___fix_vecmap_iter()
+
+
+
+"""
+External Methods in addition to api
+"""
+def __export_to_pandas(self, sig_name_str:str, translate:bool=True, pids:list[int]|str|None=None, float32to64:bool=True, free_signal:bool=True, regex_str:str|None = None, regex_filter:str = '') -> 'pd.DataFrame':
+    """get_sig(signame [, translate=True][, pids=None, float32to64=True][,regex_str = None]) -> Pandas DataFrame
+         translate : If True, will decode categorical fields into a readable representation in Pandas
+         pid : If list is provided, will load only pids from the given list
+               If 'All' is provided, will use all available pids
+         float32to64 : If True, will convert all float32 columns to float64
+         free_signal : If True, will free signal memory as soon as it is loaded into export arrays
+         regex_str :  string (if string, defualt column is 'val') or dictionary between column name (e.g, 'val') to regex string to filter
+         regex_filter :  string to filter categories paretns this match regex
+    """
+    import pandas as pd
+    import numpy as np
+    use_all_pids = 0
+    if isinstance(pids, str) and pids.upper()=='ALL':
+      use_all_pids = 1
+      pids=list()
+    if pids is None: pids=list()
+    df = self.export_to_numpy(sig_name_str, pids, use_all_pids, int(translate), int(free_signal), regex_filter)
+
+
+    cat_dict = dict()
+    cat_dict_int = dict()
+    if translate:
+      for fld in df.get_categorical_fields():
+        cat_dict[fld] = df.get_categorical_field_dict(fld)      
+        cat_dict_int[fld] = df.get_categorical_field_dict_int(fld)
+    df = dict(df)
+    df = pd.DataFrame.from_dict(df)
+
+    if not (regex_str is None):
+      dict_id = self.dict_section_id(sig_name_str)
+      if (dict_id == 0):
+        print("Invalid sig name - skip filter")
+      else:
+        if not(type(regex_str) == dict):
+          regex_str = {'val' : regex_str}
+
+        for fld in regex_str:
+          lut = self.get_lut_from_regex(dict_id, regex_str[fld])
+          lut_np = np.array(lut)
+          if translate:
+            lut_np = lut_np[np.array(cat_dict_int[fld])]
+          tt = df[fld].astype(int).values
+          df = df[lut_np[tt - 1]].reset_index(drop=True) # values start from 1 
+    if float32to64:
+      for column_name in df:
+        if df[column_name].dtype == np.float32:
+           df[column_name] = df[column_name].astype(np.float64)
+    if not translate:
+      return df
+    for fld in cat_dict:
+        df[fld] = pd.Categorical.from_codes(codes=df[fld],categories=cat_dict[fld])
+    return df
+
+def __features__to_df_imp(self):
+    import pandas as pd
+    featMatFull = Mat()
+    self.get_as_matrix(featMatFull)
+    featMatFullNew = featMatFull.get_numpy_view_unsafe()
+    col_names = self.get_feature_names()
+    dfFeatures2 = pd.DataFrame(data = featMatFullNew, columns = col_names )
+
+    samps = Samples()
+    self.get_samples(samps)
+    samps_df = samps.to_df()
+    out = pd.concat([samps_df,dfFeatures2], axis=1, copy=False)
+    return out
+
+def __features__from_df_imp(self, features_df):
+# Dataframe to MedFeatures:
+
+    mat = Mat()
+    samples = Samples() 
+    ind_sampes = features_df.columns.str.contains('pred_\\d+') | features_df.columns.isin(['id', 'split', 'time', 'outcome', 'outcomeTime']) 
+    featuresNames = features_df.columns[~(ind_sampes)]
+# Build data matrix
+    mat.set_signals(StringVector(list(featuresNames)))
+    mat.load_numpy(features_df.loc[:,features_df.columns[~(ind_sampes)]].values)
+    self.set_as_matrix(mat)
+# append Samples
+    samples.from_df(features_df.loc[:,features_df.columns[ind_sampes]])
+    self.append_samples(samples)
+
+def __bootstrapResult_to_df(self):
+    import pandas as pd
+    dict_obj={'Cohort' : [], 'Measurement': [], 'Value': []}
+    for cohort in self.keys():
+        cohort_res=self[cohort]
+        for measure in cohort_res.keys():
+            dict_obj['Cohort'].append(cohort)
+            dict_obj['Measurement'].append(measure)
+            dict_obj['Value'].append(cohort_res[measure])
+    df=pd.DataFrame(dict_obj)
+    return df
+
+def convert_to_bootstrap_input(x, arg_name=None):
+    import pandas as pd
+    import numpy as np
+    if type(x) is list:
+        x=np.array(x)
+    if type(x) is np.ndarray:
+        x=x.astype(float)
+    if type(x) is pd.Series:
+        x=x.astype(float).to_numpy()
+    if np.isnan(x).sum()>0:
+        if arg_name is None:
+            raise NameError('Error - input array has nan inside')
+        else:
+            raise NameError('Error - input array %s has nan inside'%(arg_name))
+    return x
+
+def __bootstrap_wrapper(self, preds, labels):
+    import pandas as pd
+    import numpy as np
+    preds=convert_to_bootstrap_input(preds, 'preds')
+    labels=convert_to_bootstrap_input(labels, 'labels')
+    res = self._bootstrap(preds, labels)
+    return res
+
+def __bootstrap_pid_wrapper(self, pids, preds, labels):
+    import pandas as pd
+    import numpy as np
+    pids=convert_to_bootstrap_input(pids, 'pids')
+    preds=convert_to_bootstrap_input(preds, 'preds')
+    labels=convert_to_bootstrap_input(labels, 'labels')
+    res = self._bootstrap_pid(pids, preds, labels)
+    return res
+
+def __btsimple_to_df(self):
+    import pandas as pd
+    dict_obj={'Measurement': [], 'Value': []}
+    for measure in self.keys():
+        dict_obj['Measurement'].append(measure)
+        dict_obj['Value'].append(self[measure])
+    df=pd.DataFrame(dict_obj)
+    return df
+
+def __get_model_weights(self) -> str:
+    """
+    Returns the model as json
+    """
+    import re
+    js_model_outputs = self.get_model_weights_info()
+    reg_unquoted = re.compile(r'(?<=[:\[,])\s*(?![{\["\'\d])([A-Za-z]+::[0-9]+)(?=\s*[,}\]])')
+    fixed_text = reg_unquoted.sub(r'"\1"', js_model_outputs)
+    return fixed_text
+
+def __bind_external_methods():
+    setattr(globals()['PidRepository'],'get_sig', __export_to_pandas)
+    setattr(globals()['Features'],'to_df', __features__to_df_imp)
+    setattr(globals()['Features'],'from_df', __features__from_df_imp)
+    setattr(globals()['StringBtResultMap'],'to_df', __bootstrapResult_to_df)
+    setattr(globals()['StringFloatMapAdaptor'],'to_df', __btsimple_to_df)
+    setattr(globals()['Bootstrap'],'bootstrap', __bootstrap_wrapper)
+    setattr(globals()['Bootstrap'],'bootstrap_pid', __bootstrap_pid_wrapper)
+    setattr(globals()['Model'],'get_model_arch_json', __get_model_weights)
+
+__bind_external_methods()
+
+"""
+Remove SWIG's global variable access which makes issues for reflection actions
+#if 'cvar' in __dict__: del cvar
+"""
+try:
+    del cvar
+except: pass
+
+Global = GlobalClass()
+
+
+