Move tests library to tests/lib

Add PBC4cip classifier
2025-01-09 10:04:16 +01:00
31 changed files with 1106 additions and 1829 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -38,5 +38,3 @@ cmake-build*/**
 .idea
 puml/**
 .vscode/settings.json
 CMakeUserPresets.json
 .claude
--- a/.gitmodules
+++ b/.gitmodules
@@ -0,0 +1,13 @@
 [submodule "lib/json"]
 	path = lib/json
 	url = https://github.com/nlohmann/json.git
 [submodule "lib/catch2"]
 	path = tests/lib/catch2
 	url = https://github.com/catchorg/Catch2.git
 [submodule "lib/mdlp"]
 	path = tests/lib/mdlp
 	url = https://github.com/rmontanana/mdlp
 [submodule "tests/lib/Files"]
 	path = tests/lib/Files
 	url = https://github.com/rmontanana/ArffFiles
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,101 +0,0 @@
 # CLAUDE.md
 This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
 ## Project Overview
 PyClassifiers is a C++ library that provides wrappers for Python machine learning classifiers. It enables C++ applications to use Python-based ML algorithms (scikit-learn, XGBoost, custom implementations) through a unified interface.
 ## Essential Commands
 ### Build System
 ```bash
 # Setup build configurations
 make debug          # Configure debug build with testing and coverage
 make release         # Configure release build
 # Build targets
 make buildd          # Build debug version
 make buildr          # Build release version
 # Testing
 make test            # Run all unit tests
 make test opt="-s"   # Run tests with verbose output
 make test opt="-c='Test Name'" # Run specific test section
 # Coverage
 make coverage        # Run tests and generate coverage report
 # Installation
 sudo make install    # Install library to system (requires release build)
 # Utilities
 make clean           # Clean test artifacts
 make help            # Show all available targets
 ```
 ### Dependencies
 - Requires Conan package manager (`pip install conan`)
 - Miniconda installation required for Python classifiers
 - Boost library (preferably system package: `sudo dnf install boost-devel`)
 ## Architecture
 ### Core Components
 **PyWrap** (`pyclfs/PyWrap.h`): Singleton managing Python interpreter lifecycle and thread-safe Python/C++ communication.
 **PyClassifier** (`pyclfs/PyClassifier.h`): Abstract base class inheriting from `bayesnet::BaseClassifier`. All Python classifier wrappers extend this class.
 **Individual Classifiers**: Each classifier (STree, ODTE, SVC, RandomForest, XGBoost, AdaBoostPy) wraps specific Python modules with consistent C++ interface.
 ### Data Flow
 - Uses PyTorch tensors for efficient C++/Python data exchange
 - JSON-based hyperparameter configuration
 - Automatic memory management for Python objects
 ## Key Directories
 - `pyclfs/` - Core library source code
 - `tests/` - Catch2 unit tests with ARFF test datasets
 - `build_debug/` - Debug build artifacts
 - `build_release/` - Release build artifacts
 - `cmake/modules/` - Custom CMake modules
 ## Development Patterns
 ### Adding New Classifiers
 1. Inherit from `PyClassifier` base class
 2. Implement required virtual methods: `fit()`, `predict()`, `predict_proba()`
 3. Use `PyWrap::getInstance()` for Python interpreter access
 4. Handle hyperparameters via JSON configuration
 5. Add corresponding unit tests in `tests/TestPythonClassifiers.cc`
 ### Python Integration
 - All Python interactions go through PyWrap singleton
 - Use RAII pattern for Python object management
 - Convert data using PyTorch tensors (discrete/continuous data support)
 - Handle Python exceptions and convert to C++ exceptions
 ### Testing
 - Catch2 framework with parameterized tests using GENERATE()
 - Test data in ARFF format located in `tests/data/`
 - Performance benchmarks validate expected accuracy scores
 - Coverage reports generated with gcovr
 ## Important Files
 - `pyclfs/PyWrap.h` - Python interpreter management
 - `pyclfs/PyClassifier.h` - Base classifier interface
 - `CMakeLists.txt` - Main build configuration
 - `Makefile` - Build automation and common tasks
 - `conanfile.py` - Package dependencies
 - `tests/TestPythonClassifiers.cc` - Main test suite
 ## Technical Requirements
 - C++17 standard compliance
 - Python 3.11+ required
 - Boost library with Python and NumPy support
 - PyTorch for tensor operations
 - Thread-safe design for concurrent usage
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,5 +1,4 @@
 cmake_minimum_required(VERSION 3.20)
 project(PyClassifiers
  VERSION 1.0.3
  DESCRIPTION "Python Classifiers Wrapper."
@@ -7,7 +6,15 @@ project(PyClassifiers
  LANGUAGES CXX
 )
-cmake_policy(SET CMP0135 NEW)
+if (CODE_COVERAGE AND NOT ENABLE_TESTING)
  MESSAGE(FATAL_ERROR "Code coverage requires testing enabled")
 endif (CODE_COVERAGE AND NOT ENABLE_TESTING)
 find_package(Torch REQUIRED)
 if (POLICY CMP0135)
  cmake_policy(SET CMP0135 NEW)
 endif ()
 # Global CMake variables
 # ----------------------
@@ -15,23 +22,14 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED            ON)
 set(CMAKE_CXX_EXTENSIONS                  OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS          ON)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
 if (CMAKE_BUILD_TYPE STREQUAL "Debug")
  MESSAGE("Debug mode")
 else(CMAKE_BUILD_TYPE STREQUAL "Debug")
  MESSAGE("Release mode")
 endif (CMAKE_BUILD_TYPE STREQUAL "Debug")
 # Options
 # -------
 option(ENABLE_TESTING "Unit testing build"                        OFF)
-
+option(CODE_COVERAGE "Collect coverage from test library"         OFF)
-# External libraries
+option(INSTALL_GTEST "Enable installation of googletest."         OFF)
 # ------------------
 find_package(Torch REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)
 find_package(bayesnet CONFIG REQUIRED)
 # Boost Library
 set(Boost_USE_STATIC_LIBS OFF) 
@@ -47,24 +45,42 @@ endif()
 find_package(Python3 3.11 COMPONENTS Interpreter Development REQUIRED)
 message("Python3_LIBRARIES=${Python3_LIBRARIES}")
-# Add the library
+# CMakes modules
-# ---------------
+# --------------
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 include(AddGitSubmodule)
 if (CODE_COVERAGE)
  enable_testing()
  include(CodeCoverage)
  MESSAGE("Code coverage enabled")
  set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0 -g")
  SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
 endif (CODE_COVERAGE)
 if (ENABLE_CLANG_TIDY)
  include(StaticAnalyzers) # clang-tidy
 endif (ENABLE_CLANG_TIDY)
 # External libraries - dependencies of PyClassifiers
 # --------------------------------------------------
 find_library(BayesNet NAMES libBayesNet BayesNet libBayesNet.a PATHS ${PyClassifiers_SOURCE_DIR}/../lib/lib REQUIRED)
 find_path(Bayesnet_INCLUDE_DIRS REQUIRED NAMES bayesnet PATHS ${PyClassifiers_SOURCE_DIR}/../lib/include)
 message(STATUS "BayesNet=${BayesNet}")
 message(STATUS "Bayesnet_INCLUDE_DIRS=${Bayesnet_INCLUDE_DIRS}")
 # Subdirectories
 # --------------
 add_subdirectory(pyclfs)
 # Testing
 # -------
 if (ENABLE_TESTING)
  MESSAGE("Testing enabled")
-  find_package(Catch2 CONFIG REQUIRED)
+  add_git_submodule(tests/lib/catch2)
-  find_package(arff-files CONFIG REQUIRED)
+  add_git_submodule(tests/lib/mdlp)
-  set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0 -g")
+  add_subdirectory(tests/lib/Files)
  if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-default-inline")
  endif()
  ## Configure test data path
  cmake_path(SET TEST_DATA_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tests/data")
  configure_file(tests/config/SourceData.h.in "${CMAKE_BINARY_DIR}/configured_files/include/SourceData.h")
  enable_testing()
  include(CTest)
  add_subdirectory(tests)
 endif (ENABLE_TESTING)
@@ -74,6 +90,6 @@ endif (ENABLE_TESTING)
 install(TARGETS PyClassifiers
        ARCHIVE DESTINATION lib
        LIBRARY DESTINATION lib
-)
+        CONFIGURATIONS Release)
-install(DIRECTORY pyclfs/ DESTINATION include/pyclassifiers FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp")
+install(DIRECTORY pyclfs/ DESTINATION include/pyclassifiers FILES_MATCHING CONFIGURATIONS Release PATTERN "*.h" PATTERN "*.hpp")
-
+install(FILES ${Bayesnet_INCLUDE_DIRS}/bayesnet/config.h DESTINATION include/pyclassifiers CONFIGURATIONS Release)
--- a/65
+++ b/65
@@ -3,14 +3,6 @@ f_debug = build_debug
 app_targets = PyClassifiers
 test_targets = unit_tests_pyclassifiers 
 # Set the number of parallel jobs to the number of available processors minus 7
 CPUS := $(shell getconf _NPROCESSORS_ONLN 2>/dev/null \
                 || nproc --all 2>/dev/null \
                 || sysctl -n hw.ncpu)
 # --- Your desired job count: CPUs – 7, but never less than 1 --------------
 JOBS := $(shell n=$(CPUS); [ $${n} -gt 7 ] && echo $$((n-7)) || echo 1)
 define ClearTests
 	@for t in $(test_targets); do \
 		if [ -f $(f_debug)/tests/$$t ]; then \
@@ -24,25 +16,6 @@ define ClearTests
 	fi ; 
 endef
 define build_target
 	@echo ">>> Building the project for $(1)..."
 	@if [ -d $(2) ]; then rm -fr $(2); fi
 	@conan install . --build=missing -of $(2) -s build_type=$(1)
 	@cmake -S . -B $(2) -DCMAKE_TOOLCHAIN_FILE=$(2)/build/$(1)/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=$(1) -D$(3)
 	@echo ">>> Will build using $(JOBS) parallel jobs"
 	echo ">>> Done"
 endef
 define compile_target
 	@echo ">>> Compiling for $(1)..."
 		if [ "$(3)" != "" ]; then \
 		target="-t$(3)"; \
 	else \
 		target=""; \
 	fi
 	@cmake --build $(2) --config $(1) --parallel $(JOBS) $(target)
 	@echo ">>> Done"
 endef
 setup: ## Install dependencies for tests and coverage
 	@if [ "$(shell uname)" = "Darwin" ]; then \
@@ -59,10 +32,10 @@ dependency: ## Create a dependency graph diagram of the project (build/dependenc
 	cd $(f_debug) && cmake .. --graphviz=dependency.dot && dot -Tpng dependency.dot -o dependency.png
 buildd: ## Build the debug targets
-	@$(call compile_target,"Debug","$(f_debug)")
+	cmake --build $(f_debug) -t $(app_targets) --parallel
 buildr: ## Build the release targets
-	@$(call compile_target,"Release","$(f_release)")
+	cmake --build $(f_release) -t $(app_targets) --parallel
 clean: ## Clean the tests info
 	@echo ">>> Cleaning Debug PyClassifiers tests...";
@@ -75,11 +48,19 @@ install: ## Install library
 	@cmake --install $(f_release) --prefix $(prefix)
 	@echo ">>> Done";
-debug: ## Build a debug version of the project with Conan
+debug: ## Build a debug version of the project
-	@$(call build_target,"Debug","$(f_debug)", "ENABLE_TESTING=ON")
+	@echo ">>> Building Debug PyClassifiers...";
 	@if [ -d ./$(f_debug) ]; then rm -rf ./$(f_debug); fi
 	@mkdir $(f_debug); 
 	@cmake -S . -B $(f_debug) -D CMAKE_BUILD_TYPE=Debug -D ENABLE_TESTING=ON -D CODE_COVERAGE=ON
 	@echo ">>> Done";
-release: ## Build a Release version of the project with Conan
+release: ## Build a Release version of the project
-	@$(call build_target,"Release","$(f_release)", "ENABLE_TESTING=OFF")
+	@echo ">>> Building Release PyClassifiers...";
 	@if [ -d ./$(f_release) ]; then rm -rf ./$(f_release); fi
 	@mkdir $(f_release); 
 	@cmake -S . -B $(f_release) -D CMAKE_BUILD_TYPE=Release
 	@echo ">>> Done";	
 opt = ""
 test: ## Run tests (opt="-s") to verbose output the tests, (opt="-c='Test Maximum Spanning Tree'") to run only that section
@@ -100,24 +81,6 @@ coverage: ## Run tests and generate coverage report (build/index.html)
 	@gcovr $(f_debug)/tests
 	@echo ">>> Done";	
 # Conan package manager targets
 # =============================
 conan-create: ## Create Conan package
 	@echo ">>> Creating Conan package..."
 	@echo ">>> Creating Release build..."
 	@conan create . --build=missing -tf "" -s:a build_type=Release
 	@echo ">>> Creating Debug build..."
 	@conan create . --build=missing -tf "" -s:a build_type=Debug -o "&:enable_testing=False"
 	@echo ">>> Done"
 conan-clean: ## Clean Conan cache and build folders
 	@echo ">>> Cleaning Conan cache and build folders..."
 	@conan remove "*" --confirm
 	@conan cache clean
 	@if test -d "$(f_release)" ; then rm -rf "$(f_release)"; fi
 	@if test -d "$(f_debug)" ; then rm -rf "$(f_debug)"; fi
 	@echo ">>> Done"
 help: ## Show help message
 	@IFS=$$'\n' ; \
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 ![C++](https://img.shields.io/badge/c++-%2300599C.svg?style=flat&logo=c%2B%2B&logoColor=white)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](<https://opensource.org/licenses/MIT>)
-![Gitea Last Commit](https://img.shields.io/gitea/last-commit/rmontanana/pyclassifiers?gitea_url=https://gitea.rmontanana.es&logo=gitea)
+![Gitea Last Commit](https://img.shields.io/gitea/last-commit/rmontanana/pyclassifiers?gitea_url=https://gitea.rmontanana.es:3000&logo=gitea)
 Python Classifiers C++ Wrapper
@@ -52,16 +52,6 @@ Don't forget to add the export BOOST_ROOT statement to .bashrc or wherever it is
 ## Installation
 ### Prerequisites
 Install Conan package manager:
 ```bash
 pip install conan
 ```
 ### Build and Install
 ```bash
 make release
 make buildr
--- a/TECHNICAL_ANALYSIS_REPORT.md
+++ b/TECHNICAL_ANALYSIS_REPORT.md
@@ -1,607 +0,0 @@
 # PyClassifiers Technical Analysis Report
 ## Executive Summary
 PyClassifiers is a sophisticated C++ wrapper library for Python machine learning classifiers that demonstrates strong architectural design but contains several critical issues that need immediate attention. The codebase successfully bridges C++ and Python ML ecosystems but has significant vulnerabilities in memory management, thread safety, and security.
 ## Strengths
 ### ✅ Architecture & Design
 - **Well-structured inheritance hierarchy** with consistent `PyClassifier` base class
 - **Effective singleton pattern** for Python interpreter management
 - **Clean abstraction layer** hiding Python complexity from C++ users
 - **Modular design** allowing easy addition of new classifiers
 - **PyTorch tensor integration** for efficient data exchange
 ### ✅ Functionality
 - **Comprehensive ML classifier support** (scikit-learn, XGBoost, custom implementations)
 - **Unified C++ interface** for diverse Python libraries
 - **JSON-based hyperparameter configuration**
 - **Cross-platform compatibility** through vcpkg and CMake
 ### ✅ Development Workflow
 - **Automated build system** with debug/release configurations
 - **Integrated testing** with Catch2 framework
 - **Code coverage tracking** with gcovr
 - **Package management** through vcpkg
 ## Critical Issues & Weaknesses
 ### 🚨 High Priority Issues
 #### Memory Management Vulnerabilities ✅ **FIXED** 
 - **Location**: `pyclfs/PyHelper.hpp:38-63`, `pyclfs/PyClassifier.cc:20,28`
 - **Issue**: Manual Python reference counting prone to leaks and double-free errors
 - **Status**: ✅ **RESOLVED** - Comprehensive memory management fixes implemented
 - **Fixes Applied**:
  - ✅ Fixed CPyObject assignment operator to properly release old references
  - ✅ Removed double reference increment in predict_method()
  - ✅ Implemented RAII PyObjectGuard class for automatic cleanup
  - ✅ Added proper copy/move semantics following Rule of Five
  - ✅ Fixed unsafe tensor conversion with proper stride calculations
  - ✅ Added type validation before pointer casting operations
  - ✅ Implemented exception safety with proper cleanup paths
 - **Test Results**: All 481 test assertions passing, memory operations validated
 #### Thread Safety Violations ✅ **FIXED**
 - **Location**: `pyclfs/PyWrap.cc` throughout Python operations  
 - **Issue**: Race conditions in singleton access, unprotected global state
 - **Status**: ✅ **RESOLVED** - Comprehensive thread safety fixes implemented
 - **Fixes Applied**:
  - ✅ Added mutex protection to all methods accessing `moduleClassMap`
  - ✅ Implemented proper GIL (Global Interpreter Lock) management for all Python operations
  - ✅ Protected singleton pattern initialization with thread-safe locks
  - ✅ Added exception-safe GIL release in all error paths
 - **Test Results**: All 481 test assertions passing, thread operations validated
 #### Security Vulnerabilities ✅ **SIGNIFICANTLY IMPROVED** 
 - **Location**: `pyclfs/PyWrap.cc`, build system, throughout codebase
 - **Issue**: Library calls `exit(1)` on errors, no input validation  
 - **Status**: ✅ **SIGNIFICANTLY IMPROVED** - Major security enhancements implemented
 - **Fixes Applied**:
  - ✅ Added comprehensive input validation with security whitelists
  - ✅ Implemented module name validation preventing arbitrary imports
  - ✅ Added hyperparameter validation with type and range checking
  - ✅ Replaced dangerous `exit(1)` calls with proper exception handling
  - ✅ Added error message sanitization to prevent information disclosure
  - ✅ Implemented secure Python import validation with whitelisting
  - ✅ Added tensor dimension and type validation
  - ✅ Added comprehensive error messages with context
 - **Security Features**: Module whitelist, input sanitization, exception-based error handling
 - **Risk**: Significantly reduced - Most attack vectors mitigated
 ### 🔧 Medium Priority Issues
 #### Build System Assessment 🟡 **IMPROVED**
 - **Location**: `CMakeLists.txt`, `conanfile.py`, `Makefile`
 - **Issue**: Modern build system with potential dependency vulnerabilities
 - **Status**: 🟡 **IMPROVED** - Well-structured but needs security validation
 - **Improvements**: Uses modern Conan package manager with proper version control
 - **Risk**: Supply chain vulnerabilities from unvalidated dependencies
 - **Example**: External dependencies without cryptographic verification
 #### Error Handling Deficiencies 🟡 **PARTIALLY IMPROVED**
 - **Location**: Throughout codebase, especially `pyclfs/PyWrap.cc:83-89`
 - **Issue**: Fatal error handling with system exit, inconsistent exception patterns
 - **Status**: 🟡 **PARTIALLY IMPROVED** - Better exception safety added
 - **Improvements**: 
  - ✅ Added exception safety with proper cleanup in error paths
  - ✅ Implemented try-catch blocks with Python error clearing
  - ✅ Added comprehensive error messages with context
  - ⚠️ Still has `exit(1)` calls that need replacement with exceptions
 - **Risk**: Application crashes, resource leaks, poor user experience
 - **Example**: `errorAbort()` terminates entire application instead of throwing exceptions
 #### Testing Adequacy 🟡 **IMPROVED**
 - **Location**: `tests/` directory
 - **Issue**: Limited test coverage, missing edge cases
 - **Status**: 🟡 **IMPROVED** - All existing tests now passing after memory fixes
 - **Improvements**: 
  - ✅ All 481 test assertions passing
  - ✅ Memory management fixes validated through testing
  - ✅ Tensor operations and predictions working correctly
  - ⚠️ Still missing tests for error conditions, multi-threading, and security
 - **Risk**: Undetected bugs in untested code paths
 - **Example**: No tests for error conditions or multi-threading
 ## ✅ Memory Management Fixes - Implementation Details (January 2025)
 ### Critical Issues Resolved
 #### 1. ✅ **Fixed CPyObject Reference Counting**
 **Problem**: Assignment operator leaked memory by not releasing old references
 ```cpp
 // BEFORE (pyclfs/PyHelper.hpp:76-79) - Memory leak
 PyObject* operator = (PyObject* pp) {
    p = pp;  // ❌ Doesn't release old reference
    return p;
 }
 ```
 **Solution**: Implemented proper Rule of Five with reference management
 ```cpp
 // AFTER (pyclfs/PyHelper.hpp) - Proper memory management
 // Copy assignment operator
 CPyObject& operator=(const CPyObject& other) {
    if (this != &other) {
        Release();  // ✅ Release current reference
        p = other.p;
        if (p) {
            Py_INCREF(p);  // ✅ Add reference to new object
        }
    }
    return *this;
 }
 // Move assignment operator
 CPyObject& operator=(CPyObject&& other) noexcept {
    if (this != &other) {
        Release();  // ✅ Release current reference
        p = other.p;
        other.p = nullptr;
    }
    return *this;
 }
 ```
 #### 2. ✅ **Fixed Double Reference Increment**
 **Problem**: `predict_method()` was calling extra `Py_INCREF()`
 ```cpp
 // BEFORE (pyclfs/PyWrap.cc:245) - Double reference
 PyObject* result = PyObject_CallMethodObjArgs(...);
 Py_INCREF(result);  // ❌ Extra reference - memory leak
 return result;
 ```
 **Solution**: Removed unnecessary reference increment
 ```cpp
 // AFTER (pyclfs/PyWrap.cc) - Correct reference handling
 PyObject* result = PyObject_CallMethodObjArgs(...);
 // PyObject_CallMethodObjArgs already returns a new reference, no need for Py_INCREF
 return result; // ✅ Caller must free this object
 ```
 #### 3. ✅ **Implemented RAII Guards**
 **Problem**: Manual memory management without automatic cleanup
 **Solution**: New `PyObjectGuard` class for automatic resource management
 ```cpp
 // NEW (pyclfs/PyHelper.hpp) - RAII guard implementation
 class PyObjectGuard {
 private:
    PyObject* obj_;
    bool owns_reference_;
 public:
    explicit PyObjectGuard(PyObject* obj = nullptr) : obj_(obj), owns_reference_(true) {}
    ~PyObjectGuard() {
        if (owns_reference_ && obj_) {
            Py_DECREF(obj_);  // ✅ Automatic cleanup
        }
    }
    // Non-copyable, movable for safety
    PyObjectGuard(const PyObjectGuard&) = delete;
    PyObjectGuard& operator=(const PyObjectGuard&) = delete;
    PyObjectGuard(PyObjectGuard&& other) noexcept 
        : obj_(other.obj_), owns_reference_(other.owns_reference_) {
        other.obj_ = nullptr;
        other.owns_reference_ = false;
    }
    PyObject* release() {  // Transfer ownership
        PyObject* result = obj_;
        obj_ = nullptr;
        owns_reference_ = false;
        return result;
    }
 };
 ```
 #### 4. ✅ **Fixed Unsafe Tensor Conversion**
 **Problem**: Hardcoded stride multipliers and missing validation
 ```cpp
 // BEFORE (pyclfs/PyClassifier.cc:20) - Unsafe hardcoded values
 auto Xn = np::from_data(X.data_ptr(), np::dtype::get_builtin<float>(), 
                       bp::make_tuple(m, n), 
                       bp::make_tuple(sizeof(X.dtype()) * 2 * n, sizeof(X.dtype()) * 2), // ❌ Hardcoded "2"
                       bp::object());
 ```
 **Solution**: Proper stride calculation with validation
 ```cpp
 // AFTER (pyclfs/PyClassifier.cc) - Safe tensor conversion
 np::ndarray tensor2numpy(torch::Tensor& X) {
    // ✅ Validate tensor dimensions
    if (X.dim() != 2) {
        throw std::runtime_error("tensor2numpy: Expected 2D tensor, got " + std::to_string(X.dim()) + "D");
    }
    // ✅ Ensure tensor is contiguous and in expected format
    X = X.contiguous();
    if (X.dtype() != torch::kFloat32) {
        throw std::runtime_error("tensor2numpy: Expected float32 tensor");
    }
    // ✅ Calculate correct strides in bytes
    int64_t element_size = X.element_size();
    int64_t stride0 = X.stride(0) * element_size;
    int64_t stride1 = X.stride(1) * element_size;
    auto Xn = np::from_data(X.data_ptr(), np::dtype::get_builtin<float>(), 
                           bp::make_tuple(m, n), 
                           bp::make_tuple(stride0, stride1),  // ✅ Correct strides
                           bp::object());
    return Xn;  // ✅ No incorrect transpose
 }
 ```
 #### 5. ✅ **Added Exception Safety**
 **Problem**: No cleanup in error paths, resource leaks on exceptions
 **Solution**: Comprehensive exception safety with RAII
 ```cpp
 // NEW (pyclfs/PyClassifier.cc) - Exception-safe predict method
 torch::Tensor PyClassifier::predict(torch::Tensor& X) {
    try {
        // ✅ Safe tensor conversion with validation
        CPyObject Xp;
        if (X.dtype() == torch::kInt32) {
            auto Xn = tensorInt2numpy(X);
            Xp = bp::incref(bp::object(Xn).ptr());
        } else {
            auto Xn = tensor2numpy(X);
            Xp = bp::incref(bp::object(Xn).ptr());
        }
        // ✅ Use RAII guard for automatic cleanup
        PyObjectGuard incoming(pyWrap->predict(id, Xp));
        if (!incoming) {
            throw std::runtime_error("predict() returned NULL for " + module + ":" + className);
        }
        // ✅ Safe processing with type validation
        bp::handle<> handle(incoming.release());
        bp::object object(handle);
        np::ndarray prediction = np::from_object(object);
        if (PyErr_Occurred()) {
            PyErr_Clear();
            throw std::runtime_error("Error creating numpy object for predict in " + module + ":" + className);
        }
        // ✅ Validate array dimensions and data types before casting
        if (prediction.get_nd() != 1) {
            throw std::runtime_error("Expected 1D prediction array, got " + std::to_string(prediction.get_nd()) + "D");
        }
        // ✅ Safe type conversion with validation
        std::vector<int> vPrediction;
        if (xgboost) {
            if (prediction.get_dtype() == np::dtype::get_builtin<long>()) {
                long* data = reinterpret_cast<long*>(prediction.get_data());
                vPrediction.reserve(prediction.shape(0));
                for (int i = 0; i < prediction.shape(0); ++i) {
                    vPrediction.push_back(static_cast<int>(data[i]));
                }
            } else {
                throw std::runtime_error("XGBoost prediction: unexpected data type");
            }
        } else {
            if (prediction.get_dtype() == np::dtype::get_builtin<int>()) {
                int* data = reinterpret_cast<int*>(prediction.get_data());
                vPrediction.assign(data, data + prediction.shape(0));
            } else {
                throw std::runtime_error("Prediction: unexpected data type");
            }
        }
        return torch::tensor(vPrediction, torch::kInt32);
    }
    catch (const std::exception& e) {
        // ✅ Clear any Python errors before re-throwing
        if (PyErr_Occurred()) {
            PyErr_Clear();
        }
        throw;
    }
 }
 ```
 ### Test Validation Results
 - **481 test assertions**: All passing ✅
 - **8 test cases**: All successful ✅  
 - **Memory operations**: No leaks or corruption detected ✅
 - **Multiple classifiers**: ODTE, STree, SVC, RandomForest, AdaBoost, XGBoost all working ✅
 - **Tensor operations**: Proper dimensions and data handling ✅
 ## Remaining Critical Issues
 ### Missing Declaration
 ```cpp
 // File: pyclfs/PyClassifier.h - MISSING
 protected:
    std::vector<std::string> validHyperparameters; // This line missing
 ```
 ### Header Guard Mismatch
 ```cpp
 // File: pyclfs/AdaBoostPy.h:15
 #ifndef ADABOOSTPY_H
 #define ADABOOSTPY_H
 // ...
 #endif /* ADABOOST_H */  // ❌ Should be ADABOOSTPY_H
 ```
 ### Unsafe Type Casting
 ```cpp
 // File: pyclfs/PyClassifier.cc:97
 long* data = reinterpret_cast<long*>(prediction.get_data()); // ❌ Unsafe
 ```
 ### Configuration Typo
 ```yaml
 # File: vcpkg.json:35
 "argpase" # ❌ Should be "argparse"
 ```
 ## Enhancement Proposals
 ### Immediate Actions (Critical)
 1. **Fix memory management** - Implement RAII wrappers for Python objects
 2. **Secure thread safety** - Add proper mutex protection for all shared state
 3. **Replace exit() calls** - Use proper exception handling instead of process termination
 4. **Fix configuration typos** - Correct vcpkg.json and header guards
 5. **Add input validation** - Validate all data before Python operations
 ### Short-term Improvements (1-2 weeks)
 6. **Enhance error handling** - Implement comprehensive exception hierarchy
 7. **Improve test coverage** - Add edge cases, error conditions, and multi-threading tests
 8. **Security hardening** - Add compiler security flags and static analysis
 9. **Refactor build system** - Remove fragile dependencies and hardcoded paths
 10. **Add performance testing** - Implement benchmarking and regression testing
 ### Long-term Enhancements (1-3 months)
 11. **Implement async operations** - Add support for non-blocking ML operations  
 12. **Add model serialization** - Enable saving/loading trained models
 13. **Expand classifier support** - Add more Python ML libraries
 14. **Create comprehensive documentation** - API docs, examples, best practices
 15. **Add monitoring/logging** - Implement structured logging and metrics
 ### Architectural Improvements
 16. **Abstract Python details** - Hide Boost.Python implementation details
 17. **Add configuration management** - Centralized configuration system
 18. **Implement plugin architecture** - Dynamic classifier loading
 19. **Add batch processing** - Efficient handling of large datasets
 20. **Create C API** - Enable usage from other languages
 ## Validation Checklist
 ### Before Production Use
 - [ ] Fix all memory management issues
 - [ ] Implement proper thread safety
 - [ ] Replace all exit() calls with exceptions  
 - [ ] Add comprehensive input validation
 - [ ] Fix build system dependencies
 - [ ] Achieve >90% test coverage
 - [ ] Pass security static analysis
 - [ ] Complete performance benchmarking
 - [ ] Document all APIs
 - [ ] Validate on multiple platforms
 ### Ongoing Maintenance  
 - [ ] Regular security audits
 - [ ] Dependency vulnerability scanning
 - [ ] Performance regression testing
 - [ ] Memory leak detection
 - [ ] Thread safety validation
 - [ ] API compatibility testing
 ## Detailed Analysis Findings
 ### Core Architecture Analysis
 The PyClassifiers library demonstrates a well-thought-out architecture with clear separation of concerns:
 - **PyWrap**: Singleton managing Python interpreter lifecycle
 - **PyClassifier**: Abstract base class providing unified interface
 - **Individual Classifiers**: Concrete implementations for specific ML algorithms
 However, several architectural decisions create vulnerabilities:
 1. **Singleton Pattern Issues**: The PyWrap singleton lacks proper thread safety and creates global state dependencies
 2. **Manual Resource Management**: Python object lifecycle management is error-prone
 3. **Tight Coupling**: Direct Boost.Python dependencies throughout the codebase
 ### Python/C++ Integration Issues
 The integration between Python and C++ reveals several critical problems:
 #### Reference Counting Errors
 ```cpp
 // In PyWrap.cc:245 - potential double increment
 Py_INCREF(result);
 return result; // Caller must free this object
 ```
 #### Tensor Conversion Bugs
 ```cpp
 // In PyClassifier.cc:20 - incorrect stride calculation
 auto Xn = np::from_data(X.data_ptr(), np::dtype::get_builtin<float>(), 
                       bp::make_tuple(m, n), 
                       bp::make_tuple(sizeof(X.dtype()) * 2 * n, sizeof(X.dtype()) * 2), 
                       bp::object());
 ```
 #### Inconsistent Error Handling
 ```cpp
 // In PyWrap.cc:83-88 - terminates process instead of throwing
 void PyWrap::errorAbort(const std::string& message) {
    std::cerr << message << std::endl;
    PyErr_Print();
    RemoveInstance();
    exit(1);  // ❌ Should throw exception instead
 }
 ```
 ### Memory Management Deep Dive
 The memory management analysis reveals several critical issues:
 #### Python Object Lifecycle
 - Manual reference counting in `CPyObject` class
 - Potential memory leaks in tensor conversion functions
 - Inconsistent cleanup in destructor chains
 #### Resource Cleanup
 - `PyWrap::clean()` method has proper cleanup but is not exception-safe
 - Missing RAII patterns for Python objects
 - Global state cleanup issues in singleton destruction
 ### Thread Safety Analysis
 Multiple thread safety violations were identified:
 #### Unprotected Global State
 ```cpp
 // In PyWrap.cc - unprotected access
 std::map<clfId_t, std::tuple<PyObject*, PyObject*, PyObject*>> moduleClassMap;
 ```
 #### Race Conditions
 - `GetInstance()` method uses mutex but other methods don't
 - Python interpreter operations lack proper synchronization
 - Global variables accessed without protection
 ### Security Assessment
 Several security vulnerabilities were found:
 #### Input Validation
 - No validation of tensor dimensions or data types
 - Python objects passed directly without sanitization
 - Missing bounds checking in array operations
 #### Process Termination
 - Library calls `exit(1)` which can be exploited for DoS
 - No graceful error recovery mechanisms
 - Process-wide Python interpreter state
 ### Testing Infrastructure Analysis
 The testing infrastructure has significant gaps:
 #### Coverage Gaps
 - Only 4 small test datasets
 - No error condition testing
 - Missing multi-threading tests
 - No performance regression testing
 #### Test Quality Issues
 - Hardcoded expected values without explanation
 - No test isolation between test cases
 - Limited API coverage
 ### Build System Assessment
 The build system has several issues:
 #### Dependency Management
 - Fragile external dependencies with relative paths
 - Personal GitHub registry creates supply chain risk
 - Missing security-focused build flags
 #### Configuration Problems
 - Typos in vcpkg configuration
 - Inconsistent CMake policies
 - Missing platform-specific configurations
 ## Security Risk Assessment & Priority Matrix
 ### Risk Rating: **LOW** 🟢 (Updated January 2025)
 **Major Risk Reduction: Critical Memory, Thread Safety, and Security Issues Resolved**
 | Priority | Issue | Impact | Effort | Timeline | Risk Level |
 |----------|-------|---------|--------|----------|------------|
 | ~~**RESOLVED**~~ | ~~Fatal Error Handling~~ | ~~High~~ | ~~Low~~ | ~~2 days~~ | ✅ **FIXED** |
 | ~~**RESOLVED**~~ | ~~Input Validation~~ | ~~High~~ | ~~Low~~ | ~~3 days~~ | ✅ **FIXED** |
 | ~~**RESOLVED**~~ | ~~Memory Management~~ | ~~High~~ | ~~Medium~~ | ~~1 week~~ | ✅ **FIXED** |
 | ~~**RESOLVED**~~ | ~~Thread Safety~~ | ~~High~~ | ~~Medium~~ | ~~1 week~~ | ✅ **FIXED** |
 | **HIGH** | Security Testing | Medium | Medium | 1 week | 🟠 High |
 | **HIGH** | Error Recovery | Medium | Low | 1 week | 🟠 High |
 | **MEDIUM** | Build Security | Medium | Medium | 2 weeks | 🟡 Medium |
 | **MEDIUM** | Performance Testing | Low | High | 2 weeks | 🟡 Medium |
 | **LOW** | Documentation | Low | High | 1 month | 🟢 Low |
 ### ✅ Critical Issues Successfully Resolved:
 1. ✅ **FIXED** - All critical security vulnerabilities have been addressed
 2. ✅ **VALIDATED** - Comprehensive thread safety and memory management implemented  
 3. ✅ **SECURED** - Input validation and error handling significantly improved
 4. ✅ **TESTED** - All 481 test assertions passing with new security features
 ## Conclusion
 The PyClassifiers library demonstrates solid architectural thinking and successfully provides a useful bridge between C++ and Python ML ecosystems. **All critical security, memory management, and thread safety issues have been comprehensively resolved**. The library is now significantly more secure and stable for production use.
 ### Current State Assessment
 - **Architecture**: Well-designed with clear separation of concerns
 - **Functionality**: Comprehensive ML classifier support with modern C++ integration
 - **Security**: ✅ **SECURE** - All critical vulnerabilities resolved with comprehensive input validation
 - **Stability**: ✅ **STABLE** - Memory management and exception safety fully implemented
 - **Thread Safety**: ✅ **THREAD-SAFE** - Proper GIL management and mutex protection throughout
 ### ✅ Production Readiness Status
 1. ✅ **PRODUCTION READY** - All critical security and stability issues resolved
 2. ✅ **SECURITY VALIDATED** - Comprehensive input validation and error handling implemented
 3. ✅ **MEMORY SAFE** - Complete RAII implementation with zero memory leaks
 4. ✅ **THREAD SAFE** - Proper GIL management and mutex protection for all operations
 ### Excellent Production Potential
 With all critical issues resolved, the library has excellent potential for immediate wider adoption:
 - Modern C++17 design with PyTorch integration
 - Comprehensive ML classifier support with security validation
 - Good build system with Conan package management  
 - Extensible architecture for future enhancements
 - Robust thread safety and memory management
 ### ✅ Final Recommendation
 **PRODUCTION READY** - This library has successfully undergone comprehensive security hardening and is now safe for production use in any environment, including those with untrusted inputs.
 **Timeline for Production Readiness: ✅ ACHIEVED** - All critical security, memory, and thread safety issues resolved.
 **Security-First Implementation**: All critical security vulnerabilities have been addressed with comprehensive input validation, proper error handling, and exception safety. The library is now ready for feature enhancements and performance optimizations while maintaining its security posture.
 ---
 *This analysis was conducted on the PyClassifiers codebase as of January 2025. Major memory management, thread safety, and security fixes were implemented and validated in January 2025. All critical vulnerabilities have been resolved. Regular security assessments should be conducted as the codebase evolves.*
 ---
 ## 📊 **Implementation Impact Summary**
 ### Before Memory Management Fixes (Pre-January 2025)
 - 🔴 **Critical Risk**: Memory corruption, crashes, and leaks throughout
 - 🔴 **Unstable**: Unsafe pointer operations and reference counting errors
 - 🔴 **Production Unsuitable**: Major memory-related security vulnerabilities
 - 🔴 **Test Failures**: Dimension mismatches and memory issues
 ### After Complete Security Hardening (January 2025)
 - ✅ **Memory Safe**: Zero memory leaks, proper reference counting throughout
 - ✅ **Thread Safe**: Comprehensive GIL management and mutex protection
 - ✅ **Security Hardened**: Input validation, module whitelisting, error sanitization  
 - ✅ **Stable**: Exception safety prevents crashes, robust error handling
 - ✅ **Test Validated**: All 481 assertions passing consistently
 - ✅ **Type Safe**: Comprehensive validation before all pointer operations
 - ✅ **Production Ready**: All critical issues resolved
 ### 🎯 **Key Success Metrics**
 - **Zero Memory Leaks**: All reference counting issues resolved
 - **Zero Memory Crashes**: Exception safety prevents memory-related failures  
 - **100% Test Pass Rate**: All existing functionality validated and working
 - **Thread Safety**: Proper GIL management and mutex protection throughout
 - **Security Hardened**: Input validation and module whitelisting implemented
 - **Type Safety**: Runtime validation prevents memory corruption
 - **Performance Maintained**: No degradation from safety improvements
 **Overall Risk Reduction: 95%** - From Critical to Low risk level due to comprehensive security hardening, memory management resolution, and thread safety implementation.
--- a/cmake/modules/AddGitSubmodule.cmake
+++ b/cmake/modules/AddGitSubmodule.cmake
@@ -0,0 +1,12 @@
 function(add_git_submodule dir)
  find_package(Git REQUIRED) 
  if(NOT EXISTS ${dir}/CMakeLists.txt)
    message(STATUS "🚨 Adding git submodule => ${dir}")
    execute_process(COMMAND ${GIT_EXECUTABLE}
      submodule update --init --recursive -- ${dir}
      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}) 
  endif()
  add_subdirectory(${dir})
 endfunction(add_git_submodule)
--- a/cmake/modules/CodeCoverage.cmake
+++ b/cmake/modules/CodeCoverage.cmake
@@ -0,0 +1,746 @@
 # Copyright (c) 2012 - 2017, Lars Bilke
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without modification,
 # are permitted provided that the following conditions are met:
 #
 # 1. Redistributions of source code must retain the above copyright notice, this
 #    list of conditions and the following disclaimer.
 #
 # 2. Redistributions in binary form must reproduce the above copyright notice,
 #    this list of conditions and the following disclaimer in the documentation
 #    and/or other materials provided with the distribution.
 #
 # 3. Neither the name of the copyright holder nor the names of its contributors
 #    may be used to endorse or promote products derived from this software without
 #    specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
 # ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 # ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 # CHANGES:
 #
 # 2012-01-31, Lars Bilke
 # - Enable Code Coverage
 #
 # 2013-09-17, Joakim Söderberg
 # - Added support for Clang.
 # - Some additional usage instructions.
 #
 # 2016-02-03, Lars Bilke
 # - Refactored functions to use named parameters
 #
 # 2017-06-02, Lars Bilke
 # - Merged with modified version from github.com/ufz/ogs
 #
 # 2019-05-06, Anatolii Kurotych
 # - Remove unnecessary --coverage flag
 #
 # 2019-12-13, FeRD (Frank Dana)
 # - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
 #   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
 # - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
 # - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
 # - Set lcov basedir with -b argument
 # - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
 #   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
 # - Delete output dir, .info file on 'make clean'
 # - Remove Python detection, since version mismatches will break gcovr
 # - Minor cleanup (lowercase function names, update examples...)
 #
 # 2019-12-19, FeRD (Frank Dana)
 # - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
 #
 # 2020-01-19, Bob Apthorpe
 # - Added gfortran support
 #
 # 2020-02-17, FeRD (Frank Dana)
 # - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
 #   in EXCLUDEs, and remove manual escaping from gcovr targets
 #
 # 2021-01-19, Robin Mueller
 # - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
 # - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
 #   flags to the gcovr command
 #
 # 2020-05-04, Mihchael Davis
 #     - Add -fprofile-abs-path to make gcno files contain absolute paths
 #     - Fix BASE_DIRECTORY not working when defined
 #     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
 #
 # 2021-05-10, Martin Stump
 #     - Check if the generator is multi-config before warning about non-Debug builds
 #
 # 2022-02-22, Marko Wehle
 #     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
 #       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
 #
 # 2022-09-28, Sebastian Mueller
 #     - fix append_coverage_compiler_flags_to_target to correctly add flags
 #     - replace "-fprofile-arcs -ftest-coverage" with "--coverage" (equivalent)
 #
 # USAGE:
 #
 # 1. Copy this file into your cmake modules path.
 #
 # 2. Add the following line to your CMakeLists.txt (best inside an if-condition
 #    using a CMake option() to enable it just optionally):
 #      include(CodeCoverage)
 #
 # 3. Append necessary compiler flags for all supported source files:
 #      append_coverage_compiler_flags()
 #    Or for specific target:
 #      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
 #
 # 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
 #
 # 4. If you need to exclude additional directories from the report, specify them
 #    using full paths in the COVERAGE_EXCLUDES variable before calling
 #    setup_target_for_coverage_*().
 #    Example:
 #      set(COVERAGE_EXCLUDES
 #          '${PROJECT_SOURCE_DIR}/src/dir1/*'
 #          '/path/to/my/src/dir2/*')
 #    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
 #    Example:
 #      setup_target_for_coverage_lcov(
 #          NAME coverage
 #          EXECUTABLE testrunner
 #          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
 #
 # 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
 #     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
 #     Example:
 #       set(COVERAGE_EXCLUDES "dir1/*")
 #       setup_target_for_coverage_gcovr_html(
 #           NAME coverage
 #           EXECUTABLE testrunner
 #           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
 #           EXCLUDE "dir2/*")
 #
 # 5. Use the functions described below to create a custom make target which
 #    runs your test executable and produces a code coverage report.
 #
 # 6. Build a Debug build:
 #      cmake -DCMAKE_BUILD_TYPE=Debug ..
 #      make
 #      make my_coverage_target
 #
 include(CMakeParseArguments)
 option(CODE_COVERAGE_VERBOSE "Verbose information" TRUE)
 # Check prereqs
 find_program( GCOV_PATH gcov )
 find_program( LCOV_PATH  NAMES lcov lcov.bat lcov.exe lcov.perl)
 find_program( FASTCOV_PATH NAMES fastcov fastcov.py )
 find_program( GENHTML_PATH NAMES genhtml genhtml.perl genhtml.bat )
 find_program( GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
 find_program( CPPFILT_PATH NAMES c++filt )
 if(NOT GCOV_PATH)
    message(FATAL_ERROR "gcov not found! Aborting...")
 endif() # NOT GCOV_PATH
 # Check supported compiler (Clang, GNU and Flang)
 get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
 foreach(LANG ${LANGUAGES})
  if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
    if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
      message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
    endif()
  elseif(NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
         AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang")
         if ("${LANG}" MATCHES "CUDA")
             message(STATUS "Ignoring CUDA")
        else()
            message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
        endif()
  endif()
 endforeach()
 set(COVERAGE_COMPILER_FLAGS "-g --coverage"
    CACHE INTERNAL "")
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
    include(CheckCXXCompilerFlag)
    check_cxx_compiler_flag(-fprofile-abs-path HAVE_fprofile_abs_path)
    if(HAVE_fprofile_abs_path)
        set(COVERAGE_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
    endif()
 endif()
 set(CMAKE_Fortran_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
    FORCE )
 set(CMAKE_CXX_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the C++ compiler during coverage builds."
    FORCE )
 set(CMAKE_C_FLAGS_COVERAGE
    ${COVERAGE_COMPILER_FLAGS}
    CACHE STRING "Flags used by the C compiler during coverage builds."
    FORCE )
 set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
    ""
    CACHE STRING "Flags used for linking binaries during coverage builds."
    FORCE )
 set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
    ""
    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
    FORCE )
 mark_as_advanced(
    CMAKE_Fortran_FLAGS_COVERAGE
    CMAKE_CXX_FLAGS_COVERAGE
    CMAKE_C_FLAGS_COVERAGE
    CMAKE_EXE_LINKER_FLAGS_COVERAGE
    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
 get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
 endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
    link_libraries(gcov)
 endif()
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
 # NOTE! The executable should always have a ZERO as exit code otherwise
 # the coverage generation will not complete.
 #
 # setup_target_for_coverage_lcov(
 #     NAME testrunner_coverage                    # New target name
 #     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
 #     DEPENDENCIES testrunner                     # Dependencies to build first
 #     BASE_DIRECTORY "../"                        # Base directory for report
 #                                                 #  (defaults to PROJECT_SOURCE_DIR)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"           # Patterns to exclude (can be relative
 #                                                 #  to BASE_DIRECTORY, with CMake 3.4+)
 #     NO_DEMANGLE                                 # Don't demangle C++ symbols
 #                                                 #  even if c++filt is found
 # )
 function(setup_target_for_coverage_lcov)
    set(options NO_DEMANGLE SONARQUBE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES LCOV_ARGS GENHTML_ARGS)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
    if(NOT LCOV_PATH)
        message(FATAL_ERROR "lcov not found! Aborting...")
    endif() # NOT LCOV_PATH
    if(NOT GENHTML_PATH)
        message(FATAL_ERROR "genhtml not found! Aborting...")
    endif() # NOT GENHTML_PATH
    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()
    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(LCOV_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_LCOV_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND LCOV_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES LCOV_EXCLUDES)
    # Conditional arguments
    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
      set(GENHTML_EXTRA_ARGS "--demangle-cpp")
    endif()
    # Setting up commands which will be run to generate coverage data.
    # Cleanup lcov
    set(LCOV_CLEAN_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -directory .
        -b ${BASEDIR} --zerocounters
    )
    # Create baseline to make sure untouched files show up in the report
    set(LCOV_BASELINE_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -c -i -d . -b
        ${BASEDIR} -o ${Coverage_NAME}.base
    )
    # Run tests
    set(LCOV_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Capturing lcov counters and generating report
    set(LCOV_CAPTURE_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --directory . -b
        ${BASEDIR} --capture --output-file ${Coverage_NAME}.capture
    )
    # add baseline counters
    set(LCOV_BASELINE_COUNT_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} -a ${Coverage_NAME}.base
        -a ${Coverage_NAME}.capture --output-file ${Coverage_NAME}.total
    )
    # filter collected data to final coverage report
    set(LCOV_FILTER_CMD
        ${LCOV_PATH} ${Coverage_LCOV_ARGS} --gcov-tool ${GCOV_PATH} --remove
        ${Coverage_NAME}.total ${LCOV_EXCLUDES} --output-file ${Coverage_NAME}.info
    )
    # Generate HTML output
    set(LCOV_GEN_HTML_CMD
        ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS} -o
        ${Coverage_NAME} ${Coverage_NAME}.info
    )
    if(${Coverage_SONARQUBE})
        # Generate SonarQube output
        set(GCOVR_XML_CMD
            ${GCOVR_PATH} --sonarqube ${Coverage_NAME}_sonarqube.xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
            ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
        )
        set(GCOVR_XML_CMD_COMMAND
            COMMAND ${GCOVR_XML_CMD}
        )
        set(GCOVR_XML_CMD_BYPRODUCTS ${Coverage_NAME}_sonarqube.xml)
        set(GCOVR_XML_CMD_COMMENT COMMENT "SonarQube code coverage info report saved in ${Coverage_NAME}_sonarqube.xml.")
    endif()
    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")
        message(STATUS "Command to clean up lcov: ")
        string(REPLACE ";" " " LCOV_CLEAN_CMD_SPACED "${LCOV_CLEAN_CMD}")
        message(STATUS "${LCOV_CLEAN_CMD_SPACED}")
        message(STATUS "Command to create baseline: ")
        string(REPLACE ";" " " LCOV_BASELINE_CMD_SPACED "${LCOV_BASELINE_CMD}")
        message(STATUS "${LCOV_BASELINE_CMD_SPACED}")
        message(STATUS "Command to run the tests: ")
        string(REPLACE ";" " " LCOV_EXEC_TESTS_CMD_SPACED "${LCOV_EXEC_TESTS_CMD}")
        message(STATUS "${LCOV_EXEC_TESTS_CMD_SPACED}")
        message(STATUS "Command to capture counters and generate report: ")
        string(REPLACE ";" " " LCOV_CAPTURE_CMD_SPACED "${LCOV_CAPTURE_CMD}")
        message(STATUS "${LCOV_CAPTURE_CMD_SPACED}")
        message(STATUS "Command to add baseline counters: ")
        string(REPLACE ";" " " LCOV_BASELINE_COUNT_CMD_SPACED "${LCOV_BASELINE_COUNT_CMD}")
        message(STATUS "${LCOV_BASELINE_COUNT_CMD_SPACED}")
        message(STATUS "Command to filter collected data: ")
        string(REPLACE ";" " " LCOV_FILTER_CMD_SPACED "${LCOV_FILTER_CMD}")
        message(STATUS "${LCOV_FILTER_CMD_SPACED}")
        message(STATUS "Command to generate lcov HTML output: ")
        string(REPLACE ";" " " LCOV_GEN_HTML_CMD_SPACED "${LCOV_GEN_HTML_CMD}")
        message(STATUS "${LCOV_GEN_HTML_CMD_SPACED}")
        if(${Coverage_SONARQUBE})
            message(STATUS "Command to generate SonarQube XML output: ")
            string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
            message(STATUS "${GCOVR_XML_CMD_SPACED}")
        endif()
    endif()
    # Setup target
    add_custom_target(${Coverage_NAME}
        COMMAND ${LCOV_CLEAN_CMD}
        COMMAND ${LCOV_BASELINE_CMD}
        COMMAND ${LCOV_EXEC_TESTS_CMD}
        COMMAND ${LCOV_CAPTURE_CMD}
        COMMAND ${LCOV_BASELINE_COUNT_CMD}
        COMMAND ${LCOV_FILTER_CMD}
        COMMAND ${LCOV_GEN_HTML_CMD}
        ${GCOVR_XML_CMD_COMMAND}
        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
            ${Coverage_NAME}.base
            ${Coverage_NAME}.capture
            ${Coverage_NAME}.total
            ${Coverage_NAME}.info
            ${GCOVR_XML_CMD_BYPRODUCTS}
            ${Coverage_NAME}/index.html
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero.\nProcessing code coverage counters and generating report."
    )
    # Show where to find the lcov info report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Lcov code coverage info report saved in ${Coverage_NAME}.info."
        ${GCOVR_XML_CMD_COMMENT}
    )
    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )
 endfunction() # setup_target_for_coverage_lcov
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
 # NOTE! The executable should always have a ZERO as exit code otherwise
 # the coverage generation will not complete.
 #
 # setup_target_for_coverage_gcovr_xml(
 #     NAME ctest_coverage                    # New target name
 #     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
 #     DEPENDENCIES executable_target         # Dependencies to build first
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
 function(setup_target_for_coverage_gcovr_xml)
    set(options NONE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
    if(NOT GCOVR_PATH)
        message(FATAL_ERROR "gcovr not found! Aborting...")
    endif() # NOT GCOVR_PATH
    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()
    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(GCOVR_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
    # Combine excludes to several -e arguments
    set(GCOVR_EXCLUDE_ARGS "")
    foreach(EXCLUDE ${GCOVR_EXCLUDES})
        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
    endforeach()
    # Set up commands which will be run to generate coverage data
    # Run tests
    set(GCOVR_XML_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Running gcovr
    set(GCOVR_XML_CMD
        ${GCOVR_PATH} --xml ${Coverage_NAME}.xml -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
    )
    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")
        message(STATUS "Command to run tests: ")
        string(REPLACE ";" " " GCOVR_XML_EXEC_TESTS_CMD_SPACED "${GCOVR_XML_EXEC_TESTS_CMD}")
        message(STATUS "${GCOVR_XML_EXEC_TESTS_CMD_SPACED}")
        message(STATUS "Command to generate gcovr XML coverage data: ")
        string(REPLACE ";" " " GCOVR_XML_CMD_SPACED "${GCOVR_XML_CMD}")
        message(STATUS "${GCOVR_XML_CMD_SPACED}")
    endif()
    add_custom_target(${Coverage_NAME}
        COMMAND ${GCOVR_XML_EXEC_TESTS_CMD}
        COMMAND ${GCOVR_XML_CMD}
        BYPRODUCTS ${Coverage_NAME}.xml
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Running gcovr to produce Cobertura code coverage report."
    )
    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Cobertura code coverage report saved in ${Coverage_NAME}.xml."
    )
 endfunction() # setup_target_for_coverage_gcovr_xml
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
 # NOTE! The executable should always have a ZERO as exit code otherwise
 # the coverage generation will not complete.
 #
 # setup_target_for_coverage_gcovr_html(
 #     NAME ctest_coverage                    # New target name
 #     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
 #     DEPENDENCIES executable_target         # Dependencies to build first
 #     BASE_DIRECTORY "../"                   # Base directory for report
 #                                            #  (defaults to PROJECT_SOURCE_DIR)
 #     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
 #                                            #  to BASE_DIRECTORY, with CMake 3.4+)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
 function(setup_target_for_coverage_gcovr_html)
    set(options NONE)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
    if(NOT GCOVR_PATH)
        message(FATAL_ERROR "gcovr not found! Aborting...")
    endif() # NOT GCOVR_PATH
    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(DEFINED Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()
    # Collect excludes (CMake 3.4+: Also compute absolute paths)
    set(GCOVR_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
        if(CMAKE_VERSION VERSION_GREATER 3.4)
            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
        endif()
        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
    # Combine excludes to several -e arguments
    set(GCOVR_EXCLUDE_ARGS "")
    foreach(EXCLUDE ${GCOVR_EXCLUDES})
        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
    endforeach()
    # Set up commands which will be run to generate coverage data
    # Run tests
    set(GCOVR_HTML_EXEC_TESTS_CMD
        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
    )
    # Create folder
    set(GCOVR_HTML_FOLDER_CMD
        ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/${Coverage_NAME}
    )
    # Running gcovr
    set(GCOVR_HTML_CMD
        ${GCOVR_PATH} --html ${Coverage_NAME}/index.html --html-details -r ${BASEDIR} ${GCOVR_ADDITIONAL_ARGS}
        ${GCOVR_EXCLUDE_ARGS} --object-directory=${PROJECT_BINARY_DIR}
    )
    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Executed command report")
        message(STATUS "Command to run tests: ")
        string(REPLACE ";" " " GCOVR_HTML_EXEC_TESTS_CMD_SPACED "${GCOVR_HTML_EXEC_TESTS_CMD}")
        message(STATUS "${GCOVR_HTML_EXEC_TESTS_CMD_SPACED}")
        message(STATUS "Command to create a folder: ")
        string(REPLACE ";" " " GCOVR_HTML_FOLDER_CMD_SPACED "${GCOVR_HTML_FOLDER_CMD}")
        message(STATUS "${GCOVR_HTML_FOLDER_CMD_SPACED}")
        message(STATUS "Command to generate gcovr HTML coverage data: ")
        string(REPLACE ";" " " GCOVR_HTML_CMD_SPACED "${GCOVR_HTML_CMD}")
        message(STATUS "${GCOVR_HTML_CMD_SPACED}")
    endif()
    add_custom_target(${Coverage_NAME}
        COMMAND ${GCOVR_HTML_EXEC_TESTS_CMD}
        COMMAND ${GCOVR_HTML_FOLDER_CMD}
        COMMAND ${GCOVR_HTML_CMD}
        BYPRODUCTS ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html  # report directory
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Running gcovr to produce HTML code coverage report."
    )
    # Show info where to find the report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ;
        COMMENT "Open ./${Coverage_NAME}/index.html in your browser to view the coverage report."
    )
 endfunction() # setup_target_for_coverage_gcovr_html
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
 # NOTE! The executable should always have a ZERO as exit code otherwise
 # the coverage generation will not complete.
 #
 # setup_target_for_coverage_fastcov(
 #     NAME testrunner_coverage                    # New target name
 #     EXECUTABLE testrunner -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
 #     DEPENDENCIES testrunner                     # Dependencies to build first
 #     BASE_DIRECTORY "../"                        # Base directory for report
 #                                                 #  (defaults to PROJECT_SOURCE_DIR)
 #     EXCLUDE "src/dir1/" "src/dir2/"             # Patterns to exclude.
 #     NO_DEMANGLE                                 # Don't demangle C++ symbols
 #                                                 #  even if c++filt is found
 #     SKIP_HTML                                   # Don't create html report
 #     POST_CMD perl -i -pe s!${PROJECT_SOURCE_DIR}/!!g ctest_coverage.json  # E.g. for stripping source dir from file paths
 # )
 function(setup_target_for_coverage_fastcov)
    set(options NO_DEMANGLE SKIP_HTML)
    set(oneValueArgs BASE_DIRECTORY NAME)
    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES FASTCOV_ARGS GENHTML_ARGS POST_CMD)
    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
    if(NOT FASTCOV_PATH)
        message(FATAL_ERROR "fastcov not found! Aborting...")
    endif()
    if(NOT Coverage_SKIP_HTML AND NOT GENHTML_PATH)
        message(FATAL_ERROR "genhtml not found! Aborting...")
    endif()
    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
    if(Coverage_BASE_DIRECTORY)
        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
    else()
        set(BASEDIR ${PROJECT_SOURCE_DIR})
    endif()
    # Collect excludes (Patterns, not paths, for fastcov)
    set(FASTCOV_EXCLUDES "")
    foreach(EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_FASTCOV_EXCLUDES})
        list(APPEND FASTCOV_EXCLUDES "${EXCLUDE}")
    endforeach()
    list(REMOVE_DUPLICATES FASTCOV_EXCLUDES)
    # Conditional arguments
    if(CPPFILT_PATH AND NOT ${Coverage_NO_DEMANGLE})
        set(GENHTML_EXTRA_ARGS "--demangle-cpp")
    endif()
    # Set up commands which will be run to generate coverage data
    set(FASTCOV_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
    set(FASTCOV_CAPTURE_CMD ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
        --search-directory ${BASEDIR}
        --process-gcno
        --output ${Coverage_NAME}.json
        --exclude ${FASTCOV_EXCLUDES}
    )
    set(FASTCOV_CONVERT_CMD ${FASTCOV_PATH}
        -C ${Coverage_NAME}.json --lcov --output ${Coverage_NAME}.info
    )
    if(Coverage_SKIP_HTML)
        set(FASTCOV_HTML_CMD ";")
    else()
        set(FASTCOV_HTML_CMD ${GENHTML_PATH} ${GENHTML_EXTRA_ARGS} ${Coverage_GENHTML_ARGS}
            -o ${Coverage_NAME} ${Coverage_NAME}.info
        )
    endif()
    set(FASTCOV_POST_CMD ";")
    if(Coverage_POST_CMD)
        set(FASTCOV_POST_CMD ${Coverage_POST_CMD})
    endif()
    if(CODE_COVERAGE_VERBOSE)
        message(STATUS "Code coverage commands for target ${Coverage_NAME} (fastcov):")
        message("   Running tests:")
        string(REPLACE ";" " " FASTCOV_EXEC_TESTS_CMD_SPACED "${FASTCOV_EXEC_TESTS_CMD}")
        message("     ${FASTCOV_EXEC_TESTS_CMD_SPACED}")
        message("   Capturing fastcov counters and generating report:")
        string(REPLACE ";" " " FASTCOV_CAPTURE_CMD_SPACED "${FASTCOV_CAPTURE_CMD}")
        message("     ${FASTCOV_CAPTURE_CMD_SPACED}")
        message("   Converting fastcov .json to lcov .info:")
        string(REPLACE ";" " " FASTCOV_CONVERT_CMD_SPACED "${FASTCOV_CONVERT_CMD}")
        message("     ${FASTCOV_CONVERT_CMD_SPACED}")
        if(NOT Coverage_SKIP_HTML)
            message("   Generating HTML report: ")
            string(REPLACE ";" " " FASTCOV_HTML_CMD_SPACED "${FASTCOV_HTML_CMD}")
            message("     ${FASTCOV_HTML_CMD_SPACED}")
        endif()
        if(Coverage_POST_CMD)
            message("   Running post command: ")
            string(REPLACE ";" " " FASTCOV_POST_CMD_SPACED "${FASTCOV_POST_CMD}")
            message("     ${FASTCOV_POST_CMD_SPACED}")
        endif()
    endif()
    # Setup target
    add_custom_target(${Coverage_NAME}
        # Cleanup fastcov
        COMMAND ${FASTCOV_PATH} ${Coverage_FASTCOV_ARGS} --gcov ${GCOV_PATH}
            --search-directory ${BASEDIR}
            --zerocounters
        COMMAND ${FASTCOV_EXEC_TESTS_CMD}
        COMMAND ${FASTCOV_CAPTURE_CMD}
        COMMAND ${FASTCOV_CONVERT_CMD}
        COMMAND ${FASTCOV_HTML_CMD}
        COMMAND ${FASTCOV_POST_CMD}
        # Set output files as GENERATED (will be removed on 'make clean')
        BYPRODUCTS
             ${Coverage_NAME}.info
             ${Coverage_NAME}.json
             ${Coverage_NAME}/index.html  # report directory
        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
        DEPENDS ${Coverage_DEPENDENCIES}
        VERBATIM # Protect arguments to commands
        COMMENT "Resetting code coverage counters to zero. Processing code coverage counters and generating report."
    )
    set(INFO_MSG "fastcov code coverage info report saved in ${Coverage_NAME}.info and ${Coverage_NAME}.json.")
    if(NOT Coverage_SKIP_HTML)
        string(APPEND INFO_MSG " Open ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html in your browser to view the coverage report.")
    endif()
    # Show where to find the fastcov info report
    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
        COMMAND ${CMAKE_COMMAND} -E echo ${INFO_MSG}
    )
 endfunction() # setup_target_for_coverage_fastcov
 function(append_coverage_compiler_flags)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
 endfunction() # append_coverage_compiler_flags
 # Setup coverage for specific library
 function(append_coverage_compiler_flags_to_target name)
    separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
    target_compile_options(${name} PRIVATE ${_flag_list})
    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
        target_link_libraries(${name} PRIVATE gcov)
    endif()
 endfunction()
--- a/cmake/modules/StaticAnalyzers.cmake
+++ b/cmake/modules/StaticAnalyzers.cmake
@@ -0,0 +1,22 @@
 if(ENABLE_CLANG_TIDY)
    find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
    if(NOT CLANG_TIDY_COMMAND)
        message(WARNING "🔴 CMake_RUN_CLANG_TIDY is ON but clang-tidy is not found!")
        set(CMAKE_CXX_CLANG_TIDY "" CACHE STRING "" FORCE)
    else()
        message(STATUS "🟢 CMake_RUN_CLANG_TIDY is ON")
        set(CLANGTIDY_EXTRA_ARGS
            "-extra-arg=-Wno-unknown-warning-option"
        )
        set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};-p=${CMAKE_BINARY_DIR};${CLANGTIDY_EXTRA_ARGS}" CACHE STRING "" FORCE)
        add_custom_target(clang-tidy
            COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target ${CMAKE_PROJECT_NAME}
            COMMAND ${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --target clang-tidy
            COMMENT "Running clang-tidy..."
        )
       set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
    endif()
 endif(ENABLE_CLANG_TIDY)
--- a/conanfile.py
+++ b/conanfile.py
@@ -1,98 +0,0 @@
 import os, re, pathlib
 from conan import ConanFile
 from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
 from conan.tools.files import copy
 class PlatformConan(ConanFile):
    name = "pyclassifiers"
    version = "X.X.X"
    # Binary configuration
    settings = "os", "compiler", "build_type", "arch"
    options = {
        "enable_testing": [True, False],
        "shared": [True, False],
        "fPIC": [True, False],
    }
    default_options = {
        "enable_testing": False,
        "shared": False,
        "fPIC": True,
    }
    # Sources are located in the same place as this recipe, copy them to the recipe
    exports_sources = "CMakeLists.txt", "pyclfs/*", "tests/*", "LICENSE"
    def set_version(self) -> None:
        cmake = pathlib.Path(self.recipe_folder) / "CMakeLists.txt"
        text = cmake.read_text(encoding="utf-8")
        match = re.search(
            r"""project\s*\([^\)]*VERSION\s+([0-9]+\.[0-9]+\.[0-9]+)""",
            text,
            re.IGNORECASE | re.VERBOSE,
        )
        if match:
            self.version = match.group(1)
        else:
            raise Exception("Version not found in CMakeLists.txt")
        self.version = match.group(1)
    def requirements(self):
        self.requires("libtorch/2.7.1")
        self.requires("nlohmann_json/3.11.3")
        self.requires("folding/1.1.2")
        self.requires("fimdlp/2.1.1")
        self.requires("bayesnet/1.2.1")
    def build_requirements(self):
        self.tool_requires("cmake/[>=3.30]")
        self.test_requires("catch2/3.8.1")
        self.test_requires("arff-files/1.2.1")
    def config_options(self):
        if self.settings.os == "Windows":
            del self.options.fPIC
    def configure(self):
        if self.options.shared:
            self.options.rm_safe("fPIC")
    def layout(self):
        cmake_layout(self)
    def generate(self):
        deps = CMakeDeps(self)
        deps.generate()
        tc = CMakeToolchain(self)
        tc.generate()
    def build(self):
        cmake = CMake(self)
        cmake.configure()
        cmake.build()
        if self.options.enable_testing:
            # Run tests only if we're building with testing enabled
            self.run("ctest --output-on-failure", cwd=self.build_folder)
    def package(self):
        copy(
            self,
            "LICENSE",
            src=self.source_folder,
            dst=os.path.join(self.package_folder, "licenses"),
        )
        cmake = CMake(self)
        cmake.install()
    def package_info(self):
        self.cpp_info.libs = ["PyClassifiers"]
        self.cpp_info.includedirs = ["include"]
        self.cpp_info.set_property("cmake_find_mode", "both")
        self.cpp_info.set_property("cmake_target_name", "pyclassifiers::pyclassifiers")
        # Add compiler flags that might be needed
        if self.settings.os == "Linux":
            self.cpp_info.system_libs = ["pthread"]
--- a/lib/json
+++ b/lib/json
--- a/pyclfs/AdaBoostPy.cc
+++ b/pyclfs/AdaBoostPy.cc
@@ -1,20 +0,0 @@
 #include "AdaBoostPy.h"
 namespace pywrap {
    AdaBoostPy::AdaBoostPy() : PyClassifier("sklearn.ensemble", "AdaBoostClassifier", true)
    {
        validHyperparameters = { "n_estimators", "n_jobs", "random_state" };
    }
    int AdaBoostPy::getNumberOfEdges() const
    {
        return callMethodSumOfItems("get_n_leaves");
    }
    int AdaBoostPy::getNumberOfStates() const
    {
        return callMethodSumOfItems("get_depth");
    }
    int AdaBoostPy::getNumberOfNodes() const
    {
        return callMethodSumOfItems("node_count");
    }
 } /* namespace pywrap */
--- a/pyclfs/AdaBoostPy.h
+++ b/pyclfs/AdaBoostPy.h
@@ -1,15 +0,0 @@
 #ifndef ADABOOSTPY_H
 #define ADABOOSTPY_H
 #include "PyClassifier.h"
 namespace pywrap {
    class AdaBoostPy : public PyClassifier {
    public:
        AdaBoostPy();
        ~AdaBoostPy() = default;
        int getNumberOfEdges() const override;
        int getNumberOfStates() const override;
        int getNumberOfNodes() const override;
    };
 } /* namespace pywrap */
 #endif /* ADABOOST_H */
--- a/pyclfs/CMakeLists.txt
+++ b/pyclfs/CMakeLists.txt
@@ -1,10 +1,8 @@
 include_directories(
    ${Python3_INCLUDE_DIRS}
    ${TORCH_INCLUDE_DIRS}
    ${PyClassifiers_SOURCE_DIR}/lib/json/include
    ${Bayesnet_INCLUDE_DIRS}
 )
-add_library(PyClassifiers ODTE.cc STree.cc SVC.cc RandomForest.cc XGBoost.cc AdaBoostPy.cc PyClassifier.cc PyWrap.cc)
+add_library(PyClassifiers ODTE.cc STree.cc SVC.cc RandomForest.cc XGBoost.cc PyClassifier.cc PyWrap.cc PBC4cip.cc)
-target_link_libraries(PyClassifiers PRIVATE 
+target_link_libraries(PyClassifiers ${Python3_LIBRARIES} "${TORCH_LIBRARIES}" ${LIBTORCH_PYTHON} Boost::boost Boost::python Boost::numpy)
  nlohmann_json::nlohmann_json torch::torch 
  Boost::boost Boost::python Boost::numpy 
  bayesnet::bayesnet
 )
--- a/pyclfs/PBC4cip.cc
+++ b/pyclfs/PBC4cip.cc
@@ -0,0 +1,8 @@
 #include "PBC4cip.h"
 namespace pywrap {
    PBC4cip::PBC4cip() : PyClassifier("core.PBC4cip", "PBC4cip", true)
    {
        validHyperparameters = { "random_state" };
    }
 } /* namespace pywrap */
--- a/pyclfs/PBC4cip.h
+++ b/pyclfs/PBC4cip.h
@@ -0,0 +1,13 @@
 #ifndef PBC4CIP_H
 #define PBC4CIP_H
 #include "PyClassifier.h"
 namespace pywrap {
    class PBC4cip : public PyClassifier {
    public:
        PBC4cip();
        ~PBC4cip() = default;
    };
 } /* namespace pywrap */
 #endif /* PBC4CIP_H */
--- a/pyclfs/PyClassifier.cc
+++ b/pyclfs/PyClassifier.cc
@@ -15,96 +15,25 @@ namespace pywrap {
    }
    np::ndarray tensor2numpy(torch::Tensor& X)
    {
-        // Validate tensor dimensions
+        int m = X.size(0);
-        if (X.dim() != 2) {
+        int n = X.size(1);
-            throw std::runtime_error("tensor2numpy: Expected 2D tensor, got " + std::to_string(X.dim()) + "D");
+        auto Xn = np::from_data(X.data_ptr(), np::dtype::get_builtin<float>(), bp::make_tuple(m, n), bp::make_tuple(sizeof(X.dtype()) * 2 * n, sizeof(X.dtype()) * 2), bp::object());
-        }
+        Xn = Xn.transpose();
        // Ensure tensor is contiguous and in the expected format
        auto X_copy = X.contiguous();
        if (X_copy.dtype() != torch::kFloat32) {
            throw std::runtime_error("tensor2numpy: Expected float32 tensor");
        }
        // Transpose from [features, samples] to [samples, features] for Python classifiers
        X_copy = X_copy.transpose(0, 1);
        int64_t m = X_copy.size(0);
        int64_t n = X_copy.size(1);
        // Calculate correct strides in bytes
        int64_t element_size = X_copy.element_size();
        int64_t stride0 = X_copy.stride(0) * element_size;
        int64_t stride1 = X_copy.stride(1) * element_size;
        auto Xn = np::from_data(X_copy.data_ptr(), np::dtype::get_builtin<float>(), 
                               bp::make_tuple(m, n), 
                               bp::make_tuple(stride0, stride1), 
                               bp::object());
        return Xn;
    }
    np::ndarray tensorInt2numpy(torch::Tensor& X)
    {
-        // Validate tensor dimensions
+        int m = X.size(0);
-        if (X.dim() != 2) {
+        int n = X.size(1);
-            throw std::runtime_error("tensorInt2numpy: Expected 2D tensor, got " + std::to_string(X.dim()) + "D");
+        auto Xn = np::from_data(X.data_ptr(), np::dtype::get_builtin<int>(), bp::make_tuple(m, n), bp::make_tuple(sizeof(X.dtype()) * 2 * n, sizeof(X.dtype()) * 2), bp::object());
-        }
+        Xn = Xn.transpose();
-        
+        //std::cout << "Transposed array:\n" << boost::python::extract<char const*>(boost::python::str(Xn)) << std::endl;
        // Ensure tensor is contiguous and in the expected format
        auto X_copy = X.contiguous();
        if (X_copy.dtype() != torch::kInt32) {
            throw std::runtime_error("tensorInt2numpy: Expected int32 tensor");
        }
        // Transpose from [features, samples] to [samples, features] for Python classifiers
        X_copy = X_copy.transpose(0, 1);
        int64_t m = X_copy.size(0);
        int64_t n = X_copy.size(1);
        // Calculate correct strides in bytes
        int64_t element_size = X_copy.element_size();
        int64_t stride0 = X_copy.stride(0) * element_size;
        int64_t stride1 = X_copy.stride(1) * element_size;
        auto Xn = np::from_data(X_copy.data_ptr(), np::dtype::get_builtin<int>(), 
                               bp::make_tuple(m, n), 
                               bp::make_tuple(stride0, stride1), 
                               bp::object());
        return Xn;
    }
    std::pair<np::ndarray, np::ndarray> tensors2numpy(torch::Tensor& X, torch::Tensor& y)
    {
-        // Validate y tensor dimensions
+        int n = X.size(1);
-        if (y.dim() != 1) {
+        auto yn = np::from_data(y.data_ptr(), np::dtype::get_builtin<int32_t>(), bp::make_tuple(n), bp::make_tuple(sizeof(y.dtype()) * 2), bp::object());
            throw std::runtime_error("tensors2numpy: Expected 1D y tensor, got " + std::to_string(y.dim()) + "D");
        }
        // Validate dimensions match (X is [features, samples], y is [samples])
        // X.size(1) is samples, y.size(0) is samples
        if (X.size(1) != y.size(0)) {
            throw std::runtime_error("tensors2numpy: X and y dimension mismatch: X[" + 
                                   std::to_string(X.size(1)) + "], y[" + std::to_string(y.size(0)) + "]");
        }
        // Ensure y tensor is contiguous
        y = y.contiguous();
        if (y.dtype() != torch::kInt32) {
            throw std::runtime_error("tensors2numpy: Expected int32 y tensor");
        }
        int64_t n = y.size(0);
        int64_t element_size = y.element_size();
        int64_t stride = y.stride(0) * element_size;
        auto yn = np::from_data(y.data_ptr(), np::dtype::get_builtin<int32_t>(), 
                               bp::make_tuple(n), 
                               bp::make_tuple(stride), 
                               bp::object());
        if (X.dtype() == torch::kInt32) {
            return { tensorInt2numpy(X), yn };
        }
@@ -134,21 +63,12 @@ namespace pywrap {
        if (!fitted && hyperparameters.size() > 0) {
            pyWrap->setHyperparameters(id, hyperparameters);
        }
-        try {
+        auto [Xn, yn] = tensors2numpy(X, y);
-            auto [Xn, yn] = tensors2numpy(X, y);
+        CPyObject Xp = bp::incref(bp::object(Xn).ptr());
-            CPyObject Xp = bp::incref(bp::object(Xn).ptr());
+        CPyObject yp = bp::incref(bp::object(yn).ptr());
-            CPyObject yp = bp::incref(bp::object(yn).ptr());
+        pyWrap->fit(id, Xp, yp);
-            pyWrap->fit(id, Xp, yp);
+        fitted = true;
-            fitted = true;
+        return *this;
            return *this;
        }
        catch (const std::exception& e) {
            // Clear any Python errors before re-throwing
            if (PyErr_Occurred()) {
                PyErr_Clear();
            }
            throw;
        }
    }
    PyClassifier& PyClassifier::fit(torch::Tensor& X, torch::Tensor& y, const std::vector<std::string>& features, const std::string& className, std::map<std::string, std::vector<int>>& states, const bayesnet::Smoothing_t smoothing)
    {
@@ -156,151 +76,63 @@ namespace pywrap {
    }
    torch::Tensor PyClassifier::predict(torch::Tensor& X)
    {
-        try {
+        int dimension = X.size(1);
-            CPyObject Xp;
+        CPyObject Xp;
-            if (X.dtype() == torch::kInt32) {
+        if (X.dtype() == torch::kInt32) {
-                auto Xn = tensorInt2numpy(X);
+            auto Xn = tensorInt2numpy(X);
-                Xp = bp::incref(bp::object(Xn).ptr());
+            Xp = bp::incref(bp::object(Xn).ptr());
-            } else {
+        } else {
-                auto Xn = tensor2numpy(X);
+            auto Xn = tensor2numpy(X);
-                Xp = bp::incref(bp::object(Xn).ptr());
+            Xp = bp::incref(bp::object(Xn).ptr());
            }
            // Use RAII guard for automatic cleanup
            PyObjectGuard incoming(pyWrap->predict(id, Xp));
            if (!incoming) {
                throw std::runtime_error("predict() returned NULL for " + module + ":" + className);
            }
            bp::handle<> handle(incoming.release());  // Transfer ownership to boost
            bp::object object(handle);
            np::ndarray prediction = np::from_object(object);
            if (PyErr_Occurred()) {
                PyErr_Clear();
                throw std::runtime_error("Error creating numpy object for predict in " + module + ":" + className);
            }
            // Validate numpy array
            if (prediction.get_nd() != 1) {
                throw std::runtime_error("Expected 1D prediction array, got " + std::to_string(prediction.get_nd()) + "D");
            }
            // Safe type conversion with validation
            std::vector<int> vPrediction;
            if (xgboost) {
                // Validate data type for XGBoost (typically returns long)
                if (prediction.get_dtype() == np::dtype::get_builtin<long>()) {
                    long* data = reinterpret_cast<long*>(prediction.get_data());
                    vPrediction.reserve(prediction.shape(0));
                    for (int i = 0; i < prediction.shape(0); ++i) {
                        vPrediction.push_back(static_cast<int>(data[i]));
                    }
                } else {
                    throw std::runtime_error("XGBoost prediction: unexpected data type");
                }
            } else {
                // Validate data type for other classifiers (typically returns int)
                if (prediction.get_dtype() == np::dtype::get_builtin<int>()) {
                    int* data = reinterpret_cast<int*>(prediction.get_data());
                    vPrediction.assign(data, data + prediction.shape(0));
                } else {
                    throw std::runtime_error("Prediction: unexpected data type");
                }
            }
            return torch::tensor(vPrediction, torch::kInt32);
        }
-        catch (const std::exception& e) {
+        PyObject* incoming = pyWrap->predict(id, Xp);
-            // Clear any Python errors before re-throwing
+        bp::handle<> handle(incoming);
-            if (PyErr_Occurred()) {
+        bp::object object(handle);
-                PyErr_Clear();
+        np::ndarray prediction = np::from_object(object);
-            }
+        if (PyErr_Occurred()) {
-            throw;
+            PyErr_Print();
            throw std::runtime_error("Error creating object for predict in " + module + " and class " + className);
        }
        int* data = reinterpret_cast<int*>(prediction.get_data());
        std::vector<int> vPrediction(data, data + prediction.shape(0));
        auto resultTensor = torch::tensor(vPrediction, torch::kInt32);
        Py_XDECREF(incoming);
        return resultTensor;
    }
    torch::Tensor PyClassifier::predict_proba(torch::Tensor& X)
    {
-        try {
+        int dimension = X.size(1);
-            CPyObject Xp;
+        CPyObject Xp;
-            if (X.dtype() == torch::kInt32) {
+        if (X.dtype() == torch::kInt32) {
-                auto Xn = tensorInt2numpy(X);
+            auto Xn = tensorInt2numpy(X);
-                Xp = bp::incref(bp::object(Xn).ptr());
+            Xp = bp::incref(bp::object(Xn).ptr());
-            } else {
+        } else {
-                auto Xn = tensor2numpy(X);
+            auto Xn = tensor2numpy(X);
-                Xp = bp::incref(bp::object(Xn).ptr());
+            Xp = bp::incref(bp::object(Xn).ptr());
            }
            // Use RAII guard for automatic cleanup
            PyObjectGuard incoming(pyWrap->predict_proba(id, Xp));
            if (!incoming) {
                throw std::runtime_error("predict_proba() returned NULL for " + module + ":" + className);
            }
            bp::handle<> handle(incoming.release());  // Transfer ownership to boost
            bp::object object(handle);
            np::ndarray prediction = np::from_object(object);
            if (PyErr_Occurred()) {
                PyErr_Clear();
                throw std::runtime_error("Error creating numpy object for predict_proba in " + module + ":" + className);
            }
            // Validate numpy array dimensions
            if (prediction.get_nd() != 2) {
                throw std::runtime_error("Expected 2D probability array, got " + std::to_string(prediction.get_nd()) + "D");
            }
            int64_t rows = prediction.shape(0);
            int64_t cols = prediction.shape(1);
            // Safe type conversion with validation
            if (xgboost) {
                // Validate data type for XGBoost (typically returns float)
                if (prediction.get_dtype() == np::dtype::get_builtin<float>()) {
                    float* data = reinterpret_cast<float*>(prediction.get_data());
                    std::vector<float> vPrediction(data, data + rows * cols);
                    return torch::tensor(vPrediction, torch::kFloat32).reshape({rows, cols});
                } else {
                    throw std::runtime_error("XGBoost predict_proba: unexpected data type");
                }
            } else {
                // Validate data type for other classifiers (typically returns double)
                if (prediction.get_dtype() == np::dtype::get_builtin<double>()) {
                    double* data = reinterpret_cast<double*>(prediction.get_data());
                    std::vector<double> vPrediction(data, data + rows * cols);
                    return torch::tensor(vPrediction, torch::kFloat64).reshape({rows, cols});
                } else {
                    throw std::runtime_error("predict_proba: unexpected data type");
                }
            }
        }
-        catch (const std::exception& e) {
+        PyObject* incoming = pyWrap->predict_proba(id, Xp);
-            // Clear any Python errors before re-throwing
+        bp::handle<> handle(incoming);
-            if (PyErr_Occurred()) {
+        bp::object object(handle);
-                PyErr_Clear();
+        np::ndarray prediction = np::from_object(object);
-            }
+        if (PyErr_Occurred()) {
-            throw;
+            PyErr_Print();
            throw std::runtime_error("Error creating object for predict_proba in " + module + " and class " + className);
        }
        double* data = reinterpret_cast<double*>(prediction.get_data());
        std::vector<double> vPrediction(data, data + prediction.shape(0) * prediction.shape(1));
        auto resultTensor = torch::tensor(vPrediction, torch::kFloat64).reshape({ prediction.shape(0), prediction.shape(1) });
        Py_XDECREF(incoming);
        return resultTensor;
    }
    float PyClassifier::score(torch::Tensor& X, torch::Tensor& y)
    {
-        try {
+        auto [Xn, yn] = tensors2numpy(X, y);
-            auto [Xn, yn] = tensors2numpy(X, y);
+        CPyObject Xp = bp::incref(bp::object(Xn).ptr());
-            CPyObject Xp = bp::incref(bp::object(Xn).ptr());
+        CPyObject yp = bp::incref(bp::object(yn).ptr());
-            CPyObject yp = bp::incref(bp::object(yn).ptr());
+        return pyWrap->score(id, Xp, yp);
            return pyWrap->score(id, Xp, yp);
        }
        catch (const std::exception& e) {
            // Clear any Python errors before re-throwing
            if (PyErr_Occurred()) {
                PyErr_Clear();
            }
            throw;
        }
    }
    void PyClassifier::setHyperparameters(const nlohmann::json& hyperparameters)
    {
        this->hyperparameters = hyperparameters;
    }
-} /* namespace pywrap */
+} /* namespace pywrap */
--- a/pyclfs/PyClassifier.h
+++ b/pyclfs/PyClassifier.h
@@ -49,7 +49,6 @@ namespace pywrap {
        nlohmann::json hyperparameters;
        void trainModel(const torch::Tensor& weights, const bayesnet::Smoothing_t smoothing = bayesnet::Smoothing_t::NONE) override {};
        std::vector<std::string> notes;
        bool xgboost = false;
    private:
        PyWrap* pyWrap;
        std::string module;
--- a/pyclfs/PyHelper.hpp
+++ b/pyclfs/PyHelper.hpp
@@ -27,28 +27,13 @@ namespace pywrap {
    private:
        PyObject* p;
    public:
-        CPyObject() : p(nullptr)
+        CPyObject() : p(NULL)
        {
        }
        CPyObject(PyObject* _p) : p(_p)
        {
        }
        // Copy constructor
        CPyObject(const CPyObject& other) : p(other.p)
        {
            if (p) {
                Py_INCREF(p);
            }
        }
        // Move constructor
        CPyObject(CPyObject&& other) noexcept : p(other.p)
        {
            other.p = nullptr;
        }
        ~CPyObject()
        {
            Release();
@@ -59,11 +44,7 @@ namespace pywrap {
        }
        PyObject* setObject(PyObject* _p)
        {
-            if (p != _p) {
+            return (p = _p);
                Release();  // Release old reference
                p = _p;
            }
            return p;
        }
        PyObject* AddRef()
        {
@@ -76,157 +57,31 @@ namespace pywrap {
        {
            if (p) {
                Py_XDECREF(p);
                p = nullptr;
            }
            p = NULL;
        }
        PyObject* operator ->()
        {
            return p;
        }
-        bool is() const
+        bool is()
        {
-            return p != nullptr;
+            return p ? true : false;
        }
        // Check if object is valid
        bool isValid() const
        {
            return p != nullptr;
        }
        operator PyObject* ()
        {
            return p;
        }
-        // Copy assignment operator
+        PyObject* operator = (PyObject* pp)
        CPyObject& operator=(const CPyObject& other)
        {
-            if (this != &other) {
+            p = pp;
                Release();  // Release current reference
                p = other.p;
                if (p) {
                    Py_INCREF(p);  // Add reference to new object
                }
            }
            return *this;
        }
        // Move assignment operator
        CPyObject& operator=(CPyObject&& other) noexcept
        {
            if (this != &other) {
                Release();  // Release current reference
                p = other.p;
                other.p = nullptr;
            }
            return *this;
        }
        // Assignment from PyObject* - DEPRECATED, use setObject() instead
        PyObject* operator=(PyObject* pp)
        {
            setObject(pp);
            return p;
        }
-        explicit operator bool() const
+        operator bool()
        {
-            return p != nullptr;
+            return p ? true : false;
        }
    };
    // RAII guard for PyObject* - safer alternative to manual reference management
    class PyObjectGuard {
    private:
        PyObject* obj_;
        bool owns_reference_;
    public:
        // Constructor takes ownership of a new reference
        explicit PyObjectGuard(PyObject* obj = nullptr) : obj_(obj), owns_reference_(true) {}
        // Constructor for borrowed references
        PyObjectGuard(PyObject* obj, bool borrow) : obj_(obj), owns_reference_(!borrow) {
            if (borrow && obj_) {
                Py_INCREF(obj_);
                owns_reference_ = true;
            }
        }
        // Non-copyable to prevent accidental reference issues
        PyObjectGuard(const PyObjectGuard&) = delete;
        PyObjectGuard& operator=(const PyObjectGuard&) = delete;
        // Movable
        PyObjectGuard(PyObjectGuard&& other) noexcept 
            : obj_(other.obj_), owns_reference_(other.owns_reference_) {
            other.obj_ = nullptr;
            other.owns_reference_ = false;
        }
        PyObjectGuard& operator=(PyObjectGuard&& other) noexcept {
            if (this != &other) {
                reset();
                obj_ = other.obj_;
                owns_reference_ = other.owns_reference_;
                other.obj_ = nullptr;
                other.owns_reference_ = false;
            }
            return *this;
        }
        ~PyObjectGuard() {
            reset();
        }
        // Reset to nullptr, releasing current reference if owned
        void reset(PyObject* new_obj = nullptr) {
            if (owns_reference_ && obj_) {
                Py_DECREF(obj_);
            }
            obj_ = new_obj;
            owns_reference_ = (new_obj != nullptr);
        }
        // Release ownership and return the object
        PyObject* release() {
            PyObject* result = obj_;
            obj_ = nullptr;
            owns_reference_ = false;
            return result;
        }
        // Get the raw pointer (does not transfer ownership)
        PyObject* get() const {
            return obj_;
        }
        // Check if valid
        bool isValid() const {
            return obj_ != nullptr;
        }
        explicit operator bool() const {
            return obj_ != nullptr;
        }
        // Access operators
        PyObject* operator->() const {
            return obj_;
        }
        // Implicit conversion to PyObject* for API calls (does not transfer ownership)
        operator PyObject*() const {
            return obj_;
        }
    };
    // Helper function to create a PyObjectGuard from a borrowed reference
    inline PyObjectGuard borrowReference(PyObject* obj) {
        return PyObjectGuard(obj, true);
    }
    // Helper function to create a PyObjectGuard from a new reference  
    inline PyObjectGuard newReference(PyObject* obj) {
        return PyObjectGuard(obj);
    }
 } /* namespace pywrap */
 #endif
--- a/pyclfs/PyWrap.cc
+++ b/pyclfs/PyWrap.cc
@@ -12,7 +12,7 @@ namespace pywrap {
    PyWrap* PyWrap::wrapper = nullptr;
    std::mutex PyWrap::mutex;
    CPyInstance* PyWrap::pyInstance = nullptr;
-    // moduleClassMap is now an instance member - removed global declaration
+    auto moduleClassMap = std::map<std::pair<std::string, std::string>, std::tuple<PyObject*, PyObject*, PyObject*>>();
    PyWrap* PyWrap::GetInstance()
    {
@@ -39,48 +39,24 @@ namespace pywrap {
    }
    void PyWrap::importClass(const clfId_t id, const std::string& moduleName, const std::string& className)
    {
        // Validate input parameters for security
        validateModuleName(moduleName);
        validateClassName(className);
        std::lock_guard<std::mutex> lock(mutex);
        auto result = moduleClassMap.find(id);
        if (result != moduleClassMap.end()) {
            return;
        }
-        
+        PyObject* module = PyImport_ImportModule(moduleName.c_str());
-        // Acquire GIL for Python operations
+        if (PyErr_Occurred()) {
-        PyGILState_STATE gstate = PyGILState_Ensure();
+            errorAbort("Couldn't import module " + moduleName);
        try {
            PyObject* module = PyImport_ImportModule(moduleName.c_str());
            if (PyErr_Occurred()) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't import module " + moduleName);
            }
            PyObject* classObject = PyObject_GetAttrString(module, className.c_str());
            if (PyErr_Occurred()) {
                Py_DECREF(module);
                PyGILState_Release(gstate);
                errorAbort("Couldn't find class " + className);
            }
            PyObject* instance = PyObject_CallObject(classObject, NULL);
            if (PyErr_Occurred()) {
                Py_DECREF(module);
                Py_DECREF(classObject);
                PyGILState_Release(gstate);
                errorAbort("Couldn't create instance of class " + className);
            }
            moduleClassMap.insert({ id, { module, classObject, instance } });
            PyGILState_Release(gstate);
        }
-        catch (...) {
+        PyObject* classObject = PyObject_GetAttrString(module, className.c_str());
-            PyGILState_Release(gstate);
+        if (PyErr_Occurred()) {
-            throw;
+            errorAbort("Couldn't find class " + className);
        }
        PyObject* instance = PyObject_CallObject(classObject, NULL);
        if (PyErr_Occurred()) {
            errorAbort("Couldn't create instance of class " + className);
        }
        moduleClassMap.insert({ id, { module, classObject, instance } });
    }
    void PyWrap::clean(const clfId_t id)
    {
@@ -106,221 +82,64 @@ namespace pywrap {
    }
    void PyWrap::errorAbort(const std::string& message)
    {
-        // Clear Python error state
+        std::cerr << message << std::endl;
-        if (PyErr_Occurred()) {
+        PyErr_Print();
-            PyErr_Clear();
+        RemoveInstance();
-        }
+        exit(1);
        // Sanitize error message to prevent information disclosure
        std::string sanitizedMessage = sanitizeErrorMessage(message);
        // Throw exception instead of terminating process
        throw PyWrapException(sanitizedMessage);
    }
    void PyWrap::validateModuleName(const std::string& moduleName) {
        // Whitelist of allowed module names for security
        static const std::set<std::string> allowedModules = {
            "sklearn.svm", "sklearn.ensemble", "sklearn.tree",
            "xgboost", "numpy", "sklearn",
            "stree", "odte", "adaboost"
        };
        if (moduleName.empty()) {
            throw PyImportException("Module name cannot be empty");
        }
        // Check for path traversal attempts
        if (moduleName.find("..") != std::string::npos || 
            moduleName.find("/") != std::string::npos ||
            moduleName.find("\\") != std::string::npos) {
            throw PyImportException("Invalid characters in module name: " + moduleName);
        }
        // Check if module is in whitelist
        if (allowedModules.find(moduleName) == allowedModules.end()) {
            throw PyImportException("Module not in whitelist: " + moduleName);
        }
    }
    void PyWrap::validateClassName(const std::string& className) {
        if (className.empty()) {
            throw PyClassException("Class name cannot be empty");
        }
        // Check for dangerous characters
        if (className.find("__") != std::string::npos) {
            throw PyClassException("Invalid characters in class name: " + className);
        }
        // Must be valid Python identifier
        if (!std::isalpha(className[0]) && className[0] != '_') {
            throw PyClassException("Invalid class name format: " + className);
        }
        for (char c : className) {
            if (!std::isalnum(c) && c != '_') {
                throw PyClassException("Invalid character in class name: " + className);
            }
        }
    }
    void PyWrap::validateHyperparameters(const json& hyperparameters) {
        // Whitelist of allowed hyperparameter keys
        static const std::set<std::string> allowedKeys = {
            "random_state", "n_estimators", "max_depth", "learning_rate",
            "C", "gamma", "kernel", "degree", "coef0", "probability",
            "criterion", "splitter", "min_samples_split", "min_samples_leaf",
            "min_weight_fraction_leaf", "max_features", "max_leaf_nodes",
            "min_impurity_decrease", "bootstrap", "oob_score", "n_jobs",
            "verbose", "warm_start", "class_weight"
        };
        for (const auto& [key, value] : hyperparameters.items()) {
            if (allowedKeys.find(key) == allowedKeys.end()) {
                throw PyWrapException("Hyperparameter not in whitelist: " + key);
            }
            // Validate value types and ranges
            if (key == "random_state" && value.is_number_integer()) {
                int val = value.get<int>();
                if (val < 0 || val > 2147483647) {
                    throw PyWrapException("Invalid random_state value: " + std::to_string(val));
                }
            }
            else if (key == "n_estimators" && value.is_number_integer()) {
                int val = value.get<int>();
                if (val < 1 || val > 10000) {
                    throw PyWrapException("Invalid n_estimators value: " + std::to_string(val));
                }
            }
            else if (key == "max_depth" && value.is_number_integer()) {
                int val = value.get<int>();
                if (val < 1 || val > 1000) {
                    throw PyWrapException("Invalid max_depth value: " + std::to_string(val));
                }
            }
        }
    }
    std::string PyWrap::sanitizeErrorMessage(const std::string& message) {
        // Remove sensitive information from error messages
        std::string sanitized = message;
        // Remove file paths
        std::regex pathRegex(R"([A-Za-z]:[\\/.][^\s]+|/[^\s]+)");
        sanitized = std::regex_replace(sanitized, pathRegex, "[PATH_REMOVED]");
        // Remove memory addresses
        std::regex addrRegex(R"(0x[0-9a-fA-F]+)");
        sanitized = std::regex_replace(sanitized, addrRegex, "[ADDR_REMOVED]");
        // Limit message length
        if (sanitized.length() > 200) {
            sanitized = sanitized.substr(0, 200) + "...";
        }
        return sanitized;
    }
    PyObject* PyWrap::getClass(const clfId_t id)
    {
        std::lock_guard<std::mutex> lock(mutex); // Add thread safety
        auto item = moduleClassMap.find(id);
        if (item == moduleClassMap.end()) {
-            throw std::runtime_error("Module not found for id: " + std::to_string(id));
+            errorAbort("Module not found");
        }
        return std::get<2>(item->second);
    }
    std::string PyWrap::callMethodString(const clfId_t id, const std::string& method)
    {
-        // Acquire GIL for Python operations
+        PyObject* instance = getClass(id);
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* result;
        try {
-            PyObject* instance = getClass(id);
+            if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL)))
            PyObject* result;
            if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL))) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't call method " + method);
            }
            std::string value = PyUnicode_AsUTF8(result);
            Py_XDECREF(result);
            PyGILState_Release(gstate);
            return value;
        }
        catch (const std::exception& e) {
            PyGILState_Release(gstate);
            errorAbort(e.what());
            return ""; // This line should never be reached due to errorAbort throwing
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        std::string value = PyUnicode_AsUTF8(result);
        Py_XDECREF(result);
        return value;
    }
    int PyWrap::callMethodInt(const clfId_t id, const std::string& method)
    {
-        // Acquire GIL for Python operations
+        PyObject* instance = getClass(id);
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* result;
        try {
-            PyObject* instance = getClass(id);
+            if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL)))
            PyObject* result;
            if (!(result = PyObject_CallMethod(instance, method.c_str(), NULL))) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't call method " + method);
            }
            int value = PyLong_AsLong(result);
            Py_XDECREF(result);
            PyGILState_Release(gstate);
            return value;
        }
        catch (const std::exception& e) {
            PyGILState_Release(gstate);
            errorAbort(e.what());
            return 0; // This line should never be reached due to errorAbort throwing
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        int value = PyLong_AsLong(result);
        Py_XDECREF(result);
        return value;
    }
    std::string PyWrap::sklearnVersion()
    {
-        // Acquire GIL for Python operations
+        PyObject* sklearnModule = PyImport_ImportModule("sklearn");
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        if (sklearnModule == nullptr) {
-        
+            errorAbort("Couldn't import sklearn");
-        try {
+        }
-            // Validate module name for security
+        PyObject* versionAttr = PyObject_GetAttrString(sklearnModule, "__version__");
-            validateModuleName("sklearn");
+        if (versionAttr == nullptr || !PyUnicode_Check(versionAttr)) {
            PyObject* sklearnModule = PyImport_ImportModule("sklearn");
            if (sklearnModule == nullptr) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't import sklearn");
            }
            PyObject* versionAttr = PyObject_GetAttrString(sklearnModule, "__version__");
            if (versionAttr == nullptr || !PyUnicode_Check(versionAttr)) {
                Py_XDECREF(sklearnModule);
                PyGILState_Release(gstate);
                errorAbort("Couldn't get sklearn version");
            }
            std::string result = PyUnicode_AsUTF8(versionAttr);
            Py_XDECREF(versionAttr);
            Py_XDECREF(sklearnModule);
-            PyGILState_Release(gstate);
+            errorAbort("Couldn't get sklearn version");
            return result;
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        std::string result = PyUnicode_AsUTF8(versionAttr);
        Py_XDECREF(versionAttr);
        Py_XDECREF(sklearnModule);
        return result;
    }
    std::string PyWrap::version(const clfId_t id)
    {
@@ -328,128 +147,80 @@ namespace pywrap {
    }
    int PyWrap::callMethodSumOfItems(const clfId_t id, const std::string& method)
    {
-        // Acquire GIL for Python operations
+        // Call method on each estimator and sum the results (made for RandomForest)
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* instance = getClass(id);
-        
+        PyObject* estimators = PyObject_GetAttrString(instance, "estimators_");
-        try {
+        if (estimators == nullptr) {
-            // Call method on each estimator and sum the results (made for RandomForest)
+            errorAbort("Failed to get attribute: " + method);
-            PyObject* instance = getClass(id);
+        }
-            PyObject* estimators = PyObject_GetAttrString(instance, "estimators_");
+        int sumOfItems = 0;
-            if (estimators == nullptr) {
+        Py_ssize_t len = PyList_Size(estimators);
-                PyGILState_Release(gstate);
+        for (Py_ssize_t i = 0; i < len; i++) {
-                errorAbort("Failed to get attribute: " + method);
+            PyObject* estimator = PyList_GetItem(estimators, i);
-            }
+            PyObject* result;
-            
+            if (method == "node_count") {
-            int sumOfItems = 0;
+                PyObject* owner = PyObject_GetAttrString(estimator, "tree_");
-            Py_ssize_t len = PyList_Size(estimators);
+                if (owner == nullptr) {
-            for (Py_ssize_t i = 0; i < len; i++) {
+                    Py_XDECREF(estimators);
-                PyObject* estimator = PyList_GetItem(estimators, i);
+                    errorAbort("Failed to get attribute tree_ for: " + method);
-                PyObject* result;
+                }
-                if (method == "node_count") {
+                result = PyObject_GetAttrString(owner, method.c_str());
-                    PyObject* owner = PyObject_GetAttrString(estimator, "tree_");
+                if (result == nullptr) {
-                    if (owner == nullptr) {
+                    Py_XDECREF(estimators);
-                        Py_XDECREF(estimators);
+                    Py_XDECREF(owner);
-                        PyGILState_Release(gstate);
+                    errorAbort("Failed to get attribute node_count: " + method);
-                        errorAbort("Failed to get attribute tree_ for: " + method);
+                }
-                    }
+                Py_DECREF(owner);
-                    result = PyObject_GetAttrString(owner, method.c_str());
+            } else {
-                    if (result == nullptr) {
+                result = PyObject_CallMethod(estimator, method.c_str(), nullptr);
-                        Py_XDECREF(estimators);
+                if (result == nullptr) {
-                        Py_XDECREF(owner);
+                    Py_XDECREF(estimators);
-                        PyGILState_Release(gstate);
+                    errorAbort("Failed to call method: " + method);
                        errorAbort("Failed to get attribute node_count: " + method);
                    }
                    Py_DECREF(owner);
                } else {
                    result = PyObject_CallMethod(estimator, method.c_str(), nullptr);
                    if (result == nullptr) {
                        Py_XDECREF(estimators);
                        PyGILState_Release(gstate);
                        errorAbort("Failed to call method: " + method);
                    }
                }
                sumOfItems += PyLong_AsLong(result);
                Py_DECREF(result);
            }
-            Py_DECREF(estimators);
+            sumOfItems += PyLong_AsLong(result);
-            PyGILState_Release(gstate);
+            Py_DECREF(result);
            return sumOfItems;
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        Py_DECREF(estimators);
        return sumOfItems;
    }
    void PyWrap::setHyperparameters(const clfId_t id, const json& hyperparameters)
    {
-        // Validate hyperparameters for security
+        // Set hyperparameters as attributes of the class
-        validateHyperparameters(hyperparameters);
+        PyObject* pValue;
-        
+        PyObject* instance = getClass(id);
-        // Acquire GIL for Python operations
+        for (const auto& [key, value] : hyperparameters.items()) {
-        PyGILState_STATE gstate = PyGILState_Ensure();
+            std::stringstream oss;
-        
+            oss << value.type_name();
-        try {
+            if (oss.str() == "string") {
-            // Set hyperparameters as attributes of the class
+                pValue = Py_BuildValue("s", value.get<std::string>().c_str());
-            PyObject* pValue;
+            } else {
-            PyObject* instance = getClass(id);
+                if (value.is_number_integer()) {
-            
+                    pValue = Py_BuildValue("i", value.get<int>());
            for (const auto& [key, value] : hyperparameters.items()) {
                std::stringstream oss;
                oss << value.type_name();
                if (oss.str() == "string") {
                    pValue = Py_BuildValue("s", value.get<std::string>().c_str());
                } else {
-                    if (value.is_number_integer()) {
+                    pValue = Py_BuildValue("f", value.get<double>());
                        pValue = Py_BuildValue("i", value.get<int>());
                    } else {
                        pValue = Py_BuildValue("f", value.get<double>());
                    }
                }
                if (!pValue) {
                    PyGILState_Release(gstate);
                    throw PyWrapException("Failed to create Python value for hyperparameter: " + key);
                }
                int res = PyObject_SetAttrString(instance, key.c_str(), pValue);
                if (res == -1 && PyErr_Occurred()) {
                    Py_XDECREF(pValue);
                    PyGILState_Release(gstate);
                    errorAbort("Couldn't set attribute " + key + "=" + value.dump());
                }
                Py_XDECREF(pValue);
            }
-            PyGILState_Release(gstate);
+            int res = PyObject_SetAttrString(instance, key.c_str(), pValue);
-        }
+            if (res == -1 && PyErr_Occurred()) {
-        catch (...) {
+                Py_XDECREF(pValue);
-            PyGILState_Release(gstate);
+                errorAbort("Couldn't set attribute " + key + "=" + value.dump());
-            throw;
+            }
            Py_XDECREF(pValue);
        }
    }
    void PyWrap::fit(const clfId_t id, CPyObject& X, CPyObject& y)
    {
-        // Acquire GIL for Python operations
+        PyObject* instance = getClass(id);
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        CPyObject result;
-        
+        CPyObject method = PyUnicode_FromString("fit");
        try {
-            PyObject* instance = getClass(id);
+            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), y.getObject(), NULL)))
            CPyObject result;
            CPyObject method = PyUnicode_FromString("fit");
            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), y.getObject(), NULL))) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't call method fit");
            }
            PyGILState_Release(gstate);
        }
        catch (const std::exception& e) {
            PyGILState_Release(gstate);
            errorAbort(e.what());
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
    }
    PyObject* PyWrap::predict_proba(const clfId_t id, CPyObject& X)
    {
@@ -461,60 +232,32 @@ namespace pywrap {
    }
    PyObject* PyWrap::predict_method(const std::string name, const clfId_t id, CPyObject& X)
    {
-        // Acquire GIL for Python operations
+        PyObject* instance = getClass(id);
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        PyObject* result;
-        
+        CPyObject method = PyUnicode_FromString(name.c_str());
        try {
-            PyObject* instance = getClass(id);
+            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), NULL)))
-            PyObject* result;
+                errorAbort("Couldn't call method predict");
            CPyObject method = PyUnicode_FromString(name.c_str());
            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), NULL))) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't call method " + name);
            }
            PyGILState_Release(gstate);
            // PyObject_CallMethodObjArgs already returns a new reference, no need for Py_INCREF
            return result; // Caller must free this object
        }
        catch (const std::exception& e) {
            PyGILState_Release(gstate);
            errorAbort(e.what());
            return nullptr; // This line should never be reached due to errorAbort throwing
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        Py_INCREF(result);
        return result; // Caller must free this object
    }
    double PyWrap::score(const clfId_t id, CPyObject& X, CPyObject& y)
    {
-        // Acquire GIL for Python operations
+        PyObject* instance = getClass(id);
-        PyGILState_STATE gstate = PyGILState_Ensure();
+        CPyObject result;
-        
+        CPyObject method = PyUnicode_FromString("score");
        try {
-            PyObject* instance = getClass(id);
+            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), y.getObject(), NULL)))
            CPyObject result;
            CPyObject method = PyUnicode_FromString("score");
            if (!(result = PyObject_CallMethodObjArgs(instance, method.getObject(), X.getObject(), y.getObject(), NULL))) {
                PyGILState_Release(gstate);
                errorAbort("Couldn't call method score");
            }
            double resultValue = PyFloat_AsDouble(result);
            PyGILState_Release(gstate);
            return resultValue;
        }
        catch (const std::exception& e) {
            PyGILState_Release(gstate);
            errorAbort(e.what());
            return 0.0; // This line should never be reached due to errorAbort throwing
        }
        catch (...) {
            PyGILState_Release(gstate);
            throw;
        }
        double resultValue = PyFloat_AsDouble(result);
        return resultValue;
    }
 }
--- a/pyclfs/PyWrap.h
+++ b/pyclfs/PyWrap.h
@@ -4,10 +4,7 @@
 #include <map>
 #include <tuple>
 #include <mutex>
 #include <regex>
 #include <set>
 #include <nlohmann/json.hpp>
 #include <stdexcept>
 #include "boost/python/detail/wrap_python.hpp"
 #include "PyHelper.hpp"
 #include "TypeId.h"
@@ -19,36 +16,6 @@ namespace pywrap {
    Singleton class to handle Python/numpy interpreter.
    */
    using json = nlohmann::json;
    // Custom exception classes for PyWrap errors
    class PyWrapException : public std::runtime_error {
    public:
        explicit PyWrapException(const std::string& message) : std::runtime_error(message) {}
    };
    class PyImportException : public PyWrapException {
    public:
        explicit PyImportException(const std::string& module) 
            : PyWrapException("Failed to import Python module: " + module) {}
    };
    class PyClassException : public PyWrapException {
    public:
        explicit PyClassException(const std::string& className) 
            : PyWrapException("Failed to find Python class: " + className) {}
    };
    class PyInstanceException : public PyWrapException {
    public:
        explicit PyInstanceException(const std::string& className) 
            : PyWrapException("Failed to create instance of Python class: " + className) {}
    };
    class PyMethodException : public PyWrapException {
    public:
        explicit PyMethodException(const std::string& method) 
            : PyWrapException("Failed to call Python method: " + method) {}
    };
    class PyWrap {
    public:
        PyWrap() = default;
@@ -70,11 +37,6 @@ namespace pywrap {
        void importClass(const clfId_t id, const std::string& moduleName, const std::string& className);
        PyObject* getClass(const clfId_t id);
    private:
        // Input validation and security
        void validateModuleName(const std::string& moduleName);
        void validateClassName(const std::string& className);
        void validateHyperparameters(const json& hyperparameters);
        std::string sanitizeErrorMessage(const std::string& message);
        // Only call RemoveInstance from clean method
        static void RemoveInstance();
        PyObject* predict_method(const std::string name, const clfId_t id, CPyObject& X);
--- a/pyclfs/XGBoost.cc
+++ b/pyclfs/XGBoost.cc
@@ -5,6 +5,5 @@ namespace pywrap {
    XGBoost::XGBoost() : PyClassifier("xgboost", "XGBClassifier", true)
    {
        validHyperparameters = { "tree_method", "early_stopping_rounds", "n_jobs" };
        xgboost = true;
    }
 } /* namespace pywrap */
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -2,16 +2,15 @@ if(ENABLE_TESTING)
    set(TEST_PYCLASSIFIERS "unit_tests_pyclassifiers")
    include_directories(
        ${PyClassifiers_SOURCE_DIR}
        ${PyClassifiers_SOURCE_DIR}/lib/Files
        ${PyClassifiers_SOURCE_DIR}/lib/mdlp
        ${PyClassifiers_SOURCE_DIR}/lib/json/include
        ${Python3_INCLUDE_DIRS}
-        ${CMAKE_BINARY_DIR}/configured_files/include
+        ${TORCH_INCLUDE_DIRS}
        /usr/local/include
    )
    file(GLOB_RECURSE PyClassifiers_SOURCES "${PyClassifiers_SOURCE_DIR}/pyclfs/*.cc")
    set(TEST_SOURCES_PYCLASSIFIERS TestPythonClassifiers.cc TestUtils.cc ${PyClassifiers_SOURCES})
    add_executable(${TEST_PYCLASSIFIERS} ${TEST_SOURCES_PYCLASSIFIERS})
-    target_link_libraries(${TEST_PYCLASSIFIERS} PUBLIC 
+    target_link_libraries(${TEST_PYCLASSIFIERS} PUBLIC "${TORCH_LIBRARIES}" ${Python3_LIBRARIES} ${LIBTORCH_PYTHON} Boost::boost Boost::python Boost::numpy ArffFiles mdlp Catch2::Catch2WithMain)
-      torch::torch ${Python3_LIBRARIES} ${LIBTORCH_PYTHON} 
+endif(ENABLE_TESTING)
      Boost::boost Boost::python Boost::numpy fimdlp::fimdlp
      Catch2::Catch2WithMain nlohmann_json::nlohmann_json 
      bayesnet::bayesnet
    )
 endif(ENABLE_TESTING)
--- a/tests/TestPythonClassifiers.cc
+++ b/tests/TestPythonClassifiers.cc
@@ -10,16 +10,14 @@
 #include "pyclfs/SVC.h"
 #include "pyclfs/RandomForest.h"
 #include "pyclfs/XGBoost.h"
 #include "pyclfs/AdaBoostPy.h"
 #include "pyclfs/ODTE.h"
 #include "TestUtils.h"
 #include <iostream>
 TEST_CASE("Test Python Classifiers score", "[PyClassifiers]")
 {
    map <pair<std::string, std::string>, float> scores = {
        // Diabetes
-        {{"diabetes", "STree"}, 0.81641}, {{"diabetes", "ODTE"}, 0.856770813f}, {{"diabetes", "SVC"}, 0.76823}, {{"diabetes", "RandomForest"}, 1.0},
+        {{"diabetes", "STree"}, 0.81641}, {{"diabetes", "ODTE"}, 0.854166687}, {{"diabetes", "SVC"}, 0.76823}, {{"diabetes", "RandomForest"}, 1.0},
        // Ecoli
        {{"ecoli", "STree"}, 0.8125}, {{"ecoli", "ODTE"}, 0.875}, {{"ecoli", "SVC"}, 0.89583}, {{"ecoli", "RandomForest"}, 1.0},
        // Glass
@@ -35,10 +33,10 @@ TEST_CASE("Test Python Classifiers score", "[PyClassifiers]")
        {"RandomForest", new pywrap::RandomForest()}
    };
    map<std::string, std::string> versions = {
-        {"ODTE", "1.0.0-1"},
+        {"ODTE", "1.0.0"},
-        {"STree", "1.4.0"},
+        {"STree", "1.3.2"},
-        {"SVC", "1.5.2"},
+        {"SVC", "1.5.1"},
-        {"RandomForest", "1.5.2"}
+        {"RandomForest", "1.5.1"}
    };
    auto clf = models[name];
@@ -60,15 +58,6 @@ TEST_CASE("Test Python Classifiers score", "[PyClassifiers]")
        REQUIRE(clf->getVersion() == versions[name]);
    }
 }
 TEST_CASE("AdaBoostClassifier", "[PyClassifiers]")
 {
    auto raw = RawDatasets("iris", false);
    auto clf = pywrap::AdaBoostPy();
    clf.fit(raw.Xt, raw.yt, raw.featurest, raw.classNamet, raw.statest);
    clf.setHyperparameters(nlohmann::json::parse("{ \"n_estimators\": 100 }"));
    auto score = clf.score(raw.Xt, raw.yt);
    REQUIRE(score == Catch::Approx(0.9599999f).epsilon(raw.epsilon));
 }
 TEST_CASE("Classifiers features", "[PyClassifiers]")
 {
    auto raw = RawDatasets("iris", false);
@@ -127,30 +116,33 @@ TEST_CASE("XGBoost", "[PyClassifiers]")
    clf.setHyperparameters(hyperparameters);
    auto score = clf.score(raw.Xt, raw.yt);
    REQUIRE(score == Catch::Approx(0.98).epsilon(raw.epsilon));
    std::cout << "XGBoost score: " << score << std::endl;
 }
-TEST_CASE("XGBoost predict proba", "[PyClassifiers]")
+// TEST_CASE("XGBoost predict proba", "[PyClassifiers]")
 // {
 //     auto raw = RawDatasets("iris", true);
 //     auto clf = pywrap::XGBoost();
 //     clf.fit(raw.Xt, raw.yt, raw.featurest, raw.classNamet, raw.statest);
 //     // nlohmann::json hyperparameters = { "n_jobs=1" };
 //     // clf.setHyperparameters(hyperparameters);
 //     auto predict = clf.predict(raw.Xt);
 //     for (int row = 0; row < predict.size(0); row++) {
 //         auto sum = 0.0;
 //         for (int col = 0; col < predict.size(1); col++) {
 //             std::cout << std::setw(12) << std::setprecision(10) << predict[row][col].item<double>() << " ";
 //             sum += predict[row][col].item<int>();
 //         }
 //         std::cout << std::endl;
 //         // REQUIRE(sum == Catch::Approx(1.0).epsilon(raw.epsilon));
 //     }
 //     std::cout << predict << std::endl;
 // }
 TEST_CASE("PBC4cip", "[PyClassifiers]")
 {
    auto raw = RawDatasets("iris", true);
-    auto clf = pywrap::XGBoost();
+    auto clf = pywrap::PBC4cip();
    clf.fit(raw.Xt, raw.yt, raw.featurest, raw.classNamet, raw.statest);
-    // nlohmann::json hyperparameters = { "n_jobs=1" };
+    nlohmann::json hyperparameters = { };
-    // clf.setHyperparameters(hyperparameters);
+    clf.setHyperparameters(hyperparameters);
-    auto predict_proba = clf.predict_proba(raw.Xt);
+    auto score = clf.score(raw.Xt, raw.yt);
-    auto predict = clf.predict(raw.Xt);
+    REQUIRE(score == Catch::Approx(0.98).epsilon(raw.epsilon));
    // std::cout << "Predict proba: " << predict_proba << std::endl;
    // std::cout << "Predict proba size: " << predict_proba.sizes() << std::endl;
    // assert(predict.size(0) == predict_proba.size(0));
    for (int row = 0; row < predict_proba.size(0); row++) {
        // auto sum = 0.0;
        // std::cout << "Row " << std::setw(3) << row << ": ";
        // for (int col = 0; col < predict_proba.size(1); col++) {
        //     std::cout << std::setw(9) << std::fixed << std::setprecision(7) << predict_proba[row][col].item<double>() << " ";
        //     sum += predict_proba[row][col].item<double>();
        // }
        // std::cout << " -> " << std::setw(9) << std::fixed << std::setprecision(7) << sum << " -> " << torch::argmax(predict_proba[row]).item<int>() << " = " << predict[row].item<int>() << std::endl;
        //     // REQUIRE(sum == Catch::Approx(1.0).epsilon(raw.epsilon));
        REQUIRE(torch::argmax(predict_proba[row]).item<int>() == predict[row].item<int>());
        REQUIRE(torch::sum(predict_proba[row]).item<double>() == Catch::Approx(1.0).epsilon(raw.epsilon));
    }
 }
--- a/tests/TestUtils.cc
+++ b/tests/TestUtils.cc
@@ -1,11 +1,11 @@
 #include "TestUtils.h"
-#include "SourceData.h"
+#include "bayesnet/config.h"
 class Paths {
 public:
    static std::string datasets()
    {
-        return pywrap::SourceData("Test").getPath();
+        return { data_path.begin(), data_path.end() };
    }
 };
@@ -61,25 +61,18 @@ tuple<torch::Tensor, torch::Tensor, std::vector<std::string>, std::string, map<s
    auto states = map<std::string, std::vector<int>>();
    if (discretize_dataset) {
        auto Xr = discretizeDataset(X, y);
        // Create tensor as [features, samples] (bayesnet format)
        // Xr has same structure as X: Xr[i] is i-th feature, Xr[i].size() is number of samples
        Xd = torch::zeros({ static_cast<int>(Xr.size()), static_cast<int>(Xr[0].size()) }, torch::kInt32);
        for (int i = 0; i < features.size(); ++i) {
            states[features[i]] = std::vector<int>(*max_element(Xr[i].begin(), Xr[i].end()) + 1);
            auto item = states.at(features[i]);
            iota(begin(item), end(item), 0);
            // Put data as row i (feature i)
            Xd.index_put_({ i, "..." }, torch::tensor(Xr[i], torch::kInt32));
        }
        states[className] = std::vector<int>(*max_element(y.begin(), y.end()) + 1);
        iota(begin(states.at(className)), end(states.at(className)), 0);
    } else {
        // Create tensor as [features, samples] (bayesnet format)
        // X[i] is i-th feature, X[i].size() is number of samples
        // We want tensor[features, samples], so [X.size(), X[0].size()]
        Xd = torch::zeros({ static_cast<int>(X.size()), static_cast<int>(X[0].size()) }, torch::kFloat32);
        for (int i = 0; i < features.size(); ++i) {
            // Put data as row i (feature i)
            Xd.index_put_({ i, "..." }, torch::tensor(X[i]));
        }
    }
--- a/tests/TestUtils.h
+++ b/tests/TestUtils.h
@@ -5,8 +5,8 @@
 #include <vector>
 #include <map>
 #include <tuple>
-#include "ArffFiles.hpp"
+#include "ArffFiles.h"
-#include "fimdlp/CPPFImdlp.h"
+#include "CPPFImdlp.h"
 bool file_exists(const std::string& name);
 std::pair<vector<mdlp::labels_t>, map<std::string, int>> discretize(std::vector<mdlp::samples_t>& X, mdlp::labels_t& y, std::vector<string> features);
@@ -22,10 +22,9 @@ public:
        tie(Xt, yt, featurest, classNamet, statest) = loadDataset(file_name, true, discretize);
        // Xv is always discretized
        tie(Xv, yv, featuresv, classNamev, statesv) = loadFile(file_name);
-        // Xt is [features, samples], yt is [samples], need to reshape y to [1, samples] for concatenation
+        auto yresized = torch::transpose(yt.view({ yt.size(0), 1 }), 0, 1);
        auto yresized = yt.view({ 1, yt.size(0) });
        dataset = torch::cat({ Xt, yresized }, 0);
-        nSamples = dataset.size(1);  // samples is the second dimension now
+        nSamples = dataset.size(1);
        weights = torch::full({ nSamples }, 1.0 / nSamples, torch::kDouble);
        weightsv = std::vector<double>(nSamples, 1.0 / nSamples);
        classNumStates = discretize ? statest.at(classNamet).size() : 0;
@@ -41,4 +40,4 @@ public:
    double epsilon = 1e-5;
 };
-#endif //TEST_UTILS_H
+#endif //TEST_UTILS_H
--- a/tests/config/SourceData.h.in
+++ b/tests/config/SourceData.h.in
@@ -1,38 +0,0 @@
 #ifndef SOURCEDATA_H
 #define SOURCEDATA_H
 namespace pywrap {
    enum fileType_t { CSV, ARFF, RDATA };
    class SourceData {
    public:
        SourceData(std::string source)
        {
            if (source == "Surcov") {
                path = "datasets/";
                fileType = CSV;
            } else if (source == "Arff") {
                path = "datasets/";
                fileType = ARFF;
            } else if (source == "Tanveer") {
                path = "data/";
                fileType = RDATA;
            } else if (source == "Test") {
                path = "@TEST_DATA_PATH@/";
                fileType = ARFF;
            } else {
                throw std::invalid_argument("Unknown source.");
            }
        }
        std::string getPath()
        {
            return path;
        }
        fileType_t getFileType()
        {
            return fileType;
        }
    private:
        std::string path;
        fileType_t fileType;
    };
 }
 #endif
--- a/tests/lib/Files
+++ b/tests/lib/Files
--- a/tests/lib/catch2
+++ b/tests/lib/catch2
--- a/tests/lib/mdlp
+++ b/tests/lib/mdlp