qupled 1.3.4__tar.gz → 1.3.5__tar.gz

{qupled-1.3.4 → qupled-1.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qupled
-Version: 1.3.4
+Version: 1.3.5
 Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
 Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
 License-Expression: GPL-3.0-or-later

{qupled-1.3.4 → qupled-1.3.5}/examples/tests/test_examples.py

@@ -1,5 +1,6 @@
 import importlib
 import os
+import shutil
 import sys
 
 import matplotlib.pyplot as plt
@@ -21,9 +22,9 @@ def run_before_each_test():
 @pytest.fixture(autouse=True)
 def run_after_each_test():
     yield
-    database_name = DataBaseHandler.DEFAULT_DATABASE_NAME
-    if os.path.exists(database_name):
-        os.remove(database_name)
+    output_dir = DataBaseHandler.DATABASE_DIRECTORY
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
 
 
 @pytest.fixture(autouse=True)

{qupled-1.3.4 → qupled-1.3.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qupled"
-version = "v1.3.4"
+version = "v1.3.5"
 description = "qupled: a package to investigate quantum plasmas via the dielectric formalism"
 readme = "README.md"
 requires-python = ">=3.10, <3.14"

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/database.py

@@ -4,12 +4,15 @@ import struct
 from datetime import datetime
 from enum import Enum
 from collections.abc import Callable
+from pathlib import Path
 
 import numpy as np
 import sqlalchemy as sql
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 import blosc2
 
+from . import native
+
 
 class DataBaseHandler:
     """
@@ -18,10 +21,13 @@ class DataBaseHandler:
     and deleting data, as well as managing the database schema."
     """
 
+    BLOB_STORAGE_DIRECTORY = "blob_data"
+    DATABASE_DIRECTORY = "qupled_store"
     DEFAULT_DATABASE_NAME = "qupled.db"
-    RUN_TABLE_NAME = "runs"
+    FIXED_TABLE_NAME = "fixed"
     INPUT_TABLE_NAME = "inputs"
     RESULT_TABLE_NAME = "results"
+    RUN_TABLE_NAME = "runs"
 
     class TableKeys(Enum):
         COUPLING = "coupling"
@@ -61,12 +67,23 @@ class DataBaseHandler:
             result_table (sqlalchemy.Table): The table schema for storing result data.
             run_id (int | None): The ID of the current run, or None if no run is active.
         """
-        self.database_name = (
-            database_name if database_name is not None else self.DEFAULT_DATABASE_NAME
+        # Database path
+        database_name = (
+            self.DEFAULT_DATABASE_NAME if database_name is None else database_name
         )
-        self.engine = sql.create_engine(f"sqlite:///{self.database_name}")
-        # Enforce foreign keys in sqlite
+        database_path = Path(self.DATABASE_DIRECTORY) / database_name
+        database_path.parent.mkdir(parents=True, exist_ok=True)
+        # Blob data storage
+        self.blob_storage = (
+            Path(self.DATABASE_DIRECTORY) / self.BLOB_STORAGE_DIRECTORY / database_name
+        )
+        self.blob_storage.mkdir(parents=True, exist_ok=True)
+        self.blob_storage = str(self.blob_storage)
+        # Create database
+        self.engine = sql.create_engine(f"sqlite:///{database_path}")
+        # Set sqlite properties
         DataBaseHandler._set_sqlite_pragma(self.engine)
+        # Create tables
         self.table_metadata = sql.MetaData()
         self.run_table = self._build_run_table()
         self.input_table = self._build_inputs_table()
@@ -252,6 +269,7 @@ class DataBaseHandler:
         Returns:
             None
         """
+        self._delete_blob_data_on_disk(run_id)
         condition = self.run_table.c[self.TableKeys.PRIMARY_KEY.value] == run_id
         statement = sql.delete(self.run_table).where(condition)
         self._execute(statement)
@@ -430,6 +448,9 @@ class DataBaseHandler:
         if run_id := result.inserted_primary_key:
             self.run_id = run_id[0]
 
+    def _delete_blob_data_on_disk(self, run_id: int):
+        native.delete_blob_data_on_disk(self.engine.url.database, run_id)
+
     @staticmethod
     def _set_sqlite_pragma(engine):
         """

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/hf.py

@@ -87,7 +87,11 @@ class Solver:
         `self.inputs` with the current `run_id`.
         """
         self.db_handler.insert_run(self.inputs)
-        self.inputs.database_info.run_id = self.run_id
+        self.inputs.database_info = DatabaseInfo(
+            blob_storage=self.db_handler.blob_storage,
+            name=self.db_handler.engine.url.database,
+            run_id=self.run_id,
+        )
 
     def _compute_native(self):
         """
@@ -197,7 +201,7 @@ class Input:
     processes: int = 1
     """Number of MPI processes for parallel calculations. Default =  ``1``"""
     theory: str = "HF"
-    database_info: DatabaseInfo = field(default_factory=lambda: DatabaseInfo())
+    database_info: DatabaseInfo = None
 
     def to_native(self, native_input: any):
         """
@@ -290,7 +294,9 @@ class DatabaseInfo:
     Class used to store the database information passed to the native code.
     """
 
-    name: str = database.DataBaseHandler.DEFAULT_DATABASE_NAME
+    blob_storage: str = None
+    """Directory used to store the blob data"""
+    name: str = None
     """Database name"""
     run_id: int = None
     """ID of the run in the database"""

qupled-1.3.5/src/qupled/native/include/database.hpp

@@ -0,0 +1,27 @@
+#ifndef DATABASE_HPP
+#define DATABASE_HPP
+
+#include "num_util.hpp"
+#include <string>
+
+namespace databaseUtil {
+
+  struct DatabaseInfo {
+    DatabaseInfo()
+        : runId(numUtil::iNaN) {}
+    // Database name
+    std::string name;
+    // Fodler used to store the blob data
+    std::string blobStorage;
+    // Run id in the database
+    int runId;
+    // Name of the table with the runs in the database
+    std::string runTableName;
+  };
+
+  void deleteBlobDataOnDisk(const std::string &dbInfo, int runId);
+  bool blobDataTableExists(const std::string &dbName);
+
+} // namespace databaseUtil
+
+#endif // DATABASE_HPP

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/include/input.hpp

@@ -40,7 +40,7 @@ public:
   virtual ~Input() = default;
   // Setters
   void setCoupling(const double &rs);
-  void setDatabaseInfo(const DatabaseInfo &dbInfo);
+  void setDatabaseInfo(const databaseUtil::DatabaseInfo &dbInfo);
   void setDegeneracy(const double &Theta);
   void setInt2DScheme(const std::string &int2DScheme);
   void setIntError(const double &intError);
@@ -54,7 +54,7 @@ public:
 
   // Getters
   double getCoupling() const { return rs; }
-  DatabaseInfo getDatabaseInfo() const { return dbInfo; }
+  databaseUtil::DatabaseInfo getDatabaseInfo() const { return dbInfo; }
   double getDegeneracy() const { return Theta; }
   std::string getInt2DScheme() const { return int2DScheme; }
   double getIntError() const { return intError; }
@@ -85,7 +85,7 @@ protected:
   // Theory to be solved
   std::string theory;
   // Database information
-  DatabaseInfo dbInfo;
+  databaseUtil::DatabaseInfo dbInfo;
   // Wave-vector grid resolution
   double dx;
   // Cutoff for the wave-vector grid

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/include/qstls.hpp

@@ -52,7 +52,7 @@ private:
 namespace QstlsUtil {
 
   // -----------------------------------------------------------------
-  // SQL queries
+  // Utility functions for handling the database
   // -----------------------------------------------------------------
 
   constexpr const char *SQL_TABLE_NAME = "fixed";
@@ -61,17 +61,26 @@ namespace QstlsUtil {
       CREATE TABLE IF NOT EXISTS {} (
           run_id INTEGER NOT NULL,
           name TEXT NOT NULL,
-          adr BLOB NOT NULL,
+          value TEXT NOT NULL,
           PRIMARY KEY (run_id, name),
           FOREIGN KEY(run_id) REFERENCES {}(id) ON DELETE CASCADE
       );
     )";
 
   constexpr const char *SQL_INSERT =
-      "INSERT OR REPLACE INTO {} (run_id, name, adr) VALUES (?, ?, ?);";
+      "INSERT OR REPLACE INTO {} (run_id, name, value) VALUES (?, ?, ?);";
 
   constexpr const char *SQL_SELECT =
-      "SELECT adr FROM {} WHERE run_id = ? AND name = ?;";
+      "SELECT value FROM {} WHERE run_id = ? AND name = ?;";
+
+  constexpr const char *SQL_SELECT_RUN_ID =
+      "SELECT value FROM {} WHERE run_id = ?";
+
+  constexpr const char *SQL_SELECT_TABLE =
+      "SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?";
+
+  void deleteBlobDataOnDisk(const std::string &dbName, int runId);
+
   // -----------------------------------------------------------------
   // Classes for the auxiliary density response
   // -----------------------------------------------------------------

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/CMakeLists.txt

@@ -49,6 +49,7 @@ add_compile_options(-Wall -Wextra -Wpedantic -O3)
 # Source code
 pybind11_add_module(native
 	logger.cpp
+	database.cpp
 	numerics.cpp
 	vector2D.cpp
 	vector3D.cpp

qupled-1.3.5/src/qupled/native/src/database.cpp

@@ -0,0 +1,12 @@
+#include "database.hpp"
+#include "format.hpp"
+#include "qstls.hpp"
+
+using namespace std;
+
+namespace databaseUtil {
+
+  void deleteBlobDataOnDisk(const string &dbName, int runId) {
+    QstlsUtil::deleteBlobDataOnDisk(dbName, runId);
+  }
+} // namespace databaseUtil

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/input.cpp

@@ -4,6 +4,7 @@
 #include <cmath>
 
 using namespace std;
+using namespace databaseUtil;
 using namespace MPIUtil;
 
 // -----------------------------------------------------------------

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/python_interface/inputs.cpp

@@ -4,6 +4,7 @@
 #include <pybind11/pybind11.h>
 
 namespace py = pybind11;
+using namespace databaseUtil;
 using namespace pythonUtil;
 
 // -----------------------------------------------------------------
@@ -138,12 +139,16 @@ void exposeQVSStlsInputClass(py::module_ &m) {
 // -----------------------------------------------------------------
 
 namespace pythonDatabaseInfo {
+  std::string getBlobStorage(const DatabaseInfo &db) { return db.blobStorage; }
   std::string getName(const DatabaseInfo &db) { return db.name; }
   std::string getRunTableName(const DatabaseInfo &db) {
     return db.runTableName;
   }
   int getRunId(const DatabaseInfo &db) { return db.runId; }
 
+  void setBlobStorage(DatabaseInfo &db, const std::string &blobStorage) {
+    db.blobStorage = blobStorage;
+  }
   void setName(DatabaseInfo &db, const std::string &name) { db.name = name; }
   void setRunTableName(DatabaseInfo &db, const std::string &runTableName) {
     db.runTableName = runTableName;
@@ -154,6 +159,9 @@ namespace pythonDatabaseInfo {
 void exposeDatabaseInfoClass(py::module_ &m) {
   py::class_<DatabaseInfo>(m, "DatabaseInfo")
       .def(py::init<>())
+      .def_property("blob_storage",
+                    pythonDatabaseInfo::getBlobStorage,
+                    pythonDatabaseInfo::setBlobStorage)
       .def_property(
           "name", pythonDatabaseInfo::getName, pythonDatabaseInfo::setName)
       .def_property(

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/python_interface/utilities.cpp

@@ -1,4 +1,5 @@
 #include "python_interface/utilities.hpp"
+#include "database.hpp"
 #include "mpi_util.hpp"
 #include "python_interface/util.hpp"
 #include "thermo_util.hpp"
@@ -56,9 +57,16 @@ namespace pythonWrappers {
     m.attr("uses_mpi") = py::bool_(MPIUtil::isUsed);
   }
 
+  void exposeDatabaseMethods(py::module_ &m) {
+    m.def("delete_blob_data_on_disk",
+          &databaseUtil::deleteBlobDataOnDisk,
+          "Delete blob data on disk for a given run ID");
+  }
+
   void exposeUtilities(py::module_ &m) {
     exposePostProcessingMethods(m);
     exposeMPIClass(m);
+    exposeDatabaseMethods(m);
   }
 
 } // namespace pythonWrappers

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/qstls.cpp

@@ -5,8 +5,10 @@
 #include "vector_util.hpp"
 #include <SQLiteCpp/SQLiteCpp.h>
 #include <cstring>
+#include <fstream>
 
 using namespace std;
+using namespace databaseUtil;
 using namespace vecUtil;
 using namespace MPIUtil;
 using ItgParam = Integrator1D::Param;
@@ -111,16 +113,22 @@ void Qstls::writeAdrFixed(const Vector3D &res, const string &name) const {
                                                   QstlsUtil::SQL_TABLE_NAME,
                                                   dbInfo.runTableName);
     db.exec(createTable);
-    // Prepare binary data
-    const void *adrData = static_cast<const void *>(res.data());
-    const int adrSize = static_cast<int>(res.size() * sizeof(double));
-    // Insert data
+    // Write to disk
+    string filename = formatUtil::format(
+        "{}/run_{}_{}.bin", dbInfo.blobStorage, dbInfo.runId, name);
+    ofstream out(filename, std::ios::binary);
+    if (!out) { throwError("Failed to open file for writing: " + filename); }
+    out.write(reinterpret_cast<const char *>(res.data()),
+              res.size() * sizeof(double));
+    out.close();
+
+    // Insert path into DB
     const string insert =
         formatUtil::format(QstlsUtil::SQL_INSERT, QstlsUtil::SQL_TABLE_NAME);
     SQLite::Statement statement(db, insert);
     statement.bind(1, dbInfo.runId);
     statement.bind(2, name);
-    statement.bind(3, adrData, adrSize);
+    statement.bind(3, filename);
     statement.exec();
   } catch (const std::exception &e) {
     throwError("Failed to write to database: " + string(e.what()));
@@ -137,21 +145,74 @@ void Qstls::readAdrFixed(Vector3D &res, const string &name, int runId) const {
     statement.bind(1, runId);
     statement.bind(2, name);
     if (statement.executeStep()) {
-      const void *adrData = statement.getColumn(0).getBlob();
-      int adrBytes = statement.getColumn(0).getBytes();
-      if (static_cast<size_t>(adrBytes) != res.size() * sizeof(double)) {
+      const string filename = statement.getColumn(0).getString();
+      ifstream in(filename, std::ios::binary);
+      if (!in) { throwError("Failed to open file for reading: " + filename); }
+      in.read(reinterpret_cast<char *>(res.data()),
+              res.size() * sizeof(double));
+      if (in.gcount()
+          != static_cast<std::streamsize>(res.size() * sizeof(double))) {
         throwError(
             formatUtil::format("Size mismatch: expected {} bytes, got {} bytes",
                                res.size() * sizeof(double),
-                               adrBytes));
+                               in.gcount()));
       }
-      memcpy(res.data(), adrData, adrBytes);
+      in.close();
     }
   } catch (const std::exception &e) {
     throwError("Failed to read from database: " + string(e.what()));
   }
 }
 
+// -----------------------------------------------------------------
+// Delete blob data on disk
+// -----------------------------------------------------------------
+
+bool blobDataTableExists(const SQLite::Database &db) {
+  const string select = QstlsUtil::SQL_SELECT_TABLE;
+  SQLite::Statement statement(db, select);
+  statement.bind(1, QstlsUtil::SQL_TABLE_NAME);
+  if (statement.executeStep()) { return statement.getColumn(0).getInt() > 0; }
+  return false;
+}
+
+void QstlsUtil::deleteBlobDataOnDisk(const string &dbName, int runId) {
+  try {
+    // Setup the database connection
+    SQLite::Database db(dbName, SQLite::OPEN_READONLY);
+    // Check if the table exists
+    if (!blobDataTableExists(db)) { return; }
+    // Select the correct run
+    const string select = formatUtil::format(QstlsUtil::SQL_SELECT_RUN_ID,
+                                             QstlsUtil::SQL_TABLE_NAME);
+    SQLite::Statement statement(db, select);
+    statement.bind(1, runId);
+    // Execute and collect file paths
+    std::vector<std::string> filePaths;
+    while (statement.executeStep()) {
+      filePaths.push_back(statement.getColumn(0).getString());
+    }
+    // Delete each file path
+    for (const auto &path : filePaths) {
+      try {
+        if (std::filesystem::remove(path)) {
+          // Successfully deleted
+        } else {
+          std::cerr << "Warning: file not found: " << path << std::endl;
+        }
+      } catch (const std::filesystem::filesystem_error &e) {
+        std::cerr << "Warning: failed to delete " << path << ": " << e.what()
+                  << std::endl;
+      }
+    }
+  } catch (const SQLite::Exception &e) {
+    std::cerr << "SQLite error: " << e.what() << std::endl;
+  } catch (const std::exception &e) {
+    std::cerr << "Unexpected error when deleting database files: " << e.what()
+              << std::endl;
+  }
+}
+
 // -----------------------------------------------------------------
 // AdrBase class
 // -----------------------------------------------------------------

{qupled-1.3.4 → qupled-1.3.5}/src/qupled/native/src/qstlsiet.cpp

@@ -10,6 +10,7 @@
 #include <numeric>
 
 using namespace std;
+using namespace databaseUtil;
 using namespace vecUtil;
 using namespace MPIUtil;
 using ItgParam = Integrator1D::Param;

{qupled-1.3.4 → qupled-1.3.5}/src/qupled.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qupled
-Version: 1.3.4
+Version: 1.3.5
 Summary: qupled: a package to investigate quantum plasmas via the dielectric formalism
 Author-email: Federico Lucco Castello <federico.luccocastello@gmail.com>
 License-Expression: GPL-3.0-or-later

{qupled-1.3.4 → qupled-1.3.5}/src/qupled.egg-info/SOURCES.txt

@@ -97,6 +97,7 @@ src/qupled/native/include/python_interface/util.hpp
 src/qupled/native/include/python_interface/utilities.hpp
 src/qupled/native/src/CMakeLists.txt
 src/qupled/native/src/chemical_potential.cpp
+src/qupled/native/src/database.cpp
 src/qupled/native/src/esa.cpp
 src/qupled/native/src/free_energy.cpp
 src/qupled/native/src/hf.cpp

{qupled-1.3.4 → qupled-1.3.5}/tests/test_database.py

@@ -3,6 +3,7 @@ import io
 import json
 import os
 import struct
+from pathlib import Path
 
 import blosc2
 import numpy as np
@@ -19,13 +20,22 @@ from qupled.database import DataBaseHandler
 def db_handler():
     handler = DataBaseHandler()
     yield handler
-    if os.path.exists(handler.database_name):
-        os.remove(handler.database_name)
+    database_url = handler.engine.url.database
+    if os.path.exists(database_url):
+        os.remove(database_url)
 
 
 def test_database_handler_initialization_with_default_name(db_handler):
-    assert db_handler.database_name == DataBaseHandler.DEFAULT_DATABASE_NAME
-    assert db_handler.engine.url.database == DataBaseHandler.DEFAULT_DATABASE_NAME
+    expected_database_path = (
+        Path(DataBaseHandler.DATABASE_DIRECTORY) / DataBaseHandler.DEFAULT_DATABASE_NAME
+    )
+    expected_blob_storage = (
+        Path(DataBaseHandler.DATABASE_DIRECTORY)
+        / DataBaseHandler.BLOB_STORAGE_DIRECTORY
+        / DataBaseHandler.DEFAULT_DATABASE_NAME
+    )
+    assert db_handler.blob_storage == str(expected_blob_storage)
+    assert db_handler.engine.url.database == str(expected_database_path)
     assert db_handler.run_id is None
     inspector = inspect(db_handler.engine)
     assert set(inspector.get_table_names()) == {
@@ -37,9 +47,15 @@ def test_database_handler_initialization_with_default_name(db_handler):
 
 def test_database_handler_initialization_with_custom_name():
     database_name = "custom.db"
+    expected_database_path = Path(DataBaseHandler.DATABASE_DIRECTORY) / database_name
+    expected_blob_storage = (
+        Path(DataBaseHandler.DATABASE_DIRECTORY)
+        / DataBaseHandler.BLOB_STORAGE_DIRECTORY
+        / database_name
+    )
     db_handler = DataBaseHandler(database_name="custom.db")
-    assert db_handler.database_name == database_name
-    assert db_handler.engine.url.database == database_name
+    assert db_handler.blob_storage == str(expected_blob_storage)
+    assert db_handler.engine.url.database == str(expected_database_path)
     assert db_handler.run_id is None
     inspector = inspect(db_handler.engine)
     assert set(inspector.get_table_names()) == {
@@ -47,8 +63,8 @@ def test_database_handler_initialization_with_custom_name():
         DataBaseHandler.INPUT_TABLE_NAME,
         DataBaseHandler.RESULT_TABLE_NAME,
     }
-    if os.path.exists(db_handler.database_name):
-        os.remove(db_handler.database_name)
+    if os.path.exists(expected_database_path):
+        os.remove(expected_database_path)
 
 
 def test_set_sqlite_pragma_valid_engine():

{qupled-1.3.4 → qupled-1.3.5}/tests/test_hf.py

@@ -152,7 +152,7 @@ def test_input_initialization(mocker):
     assert inputs.resolution == 0.1
     assert inputs.threads == 1
     assert inputs.theory == "HF"
-    assert inputs.database_info == dbInfo.return_value
+    assert inputs.database_info is None
 
 
 def test_input_to_native(mocker, inputs):
@@ -209,7 +209,8 @@ def test_result_compute_rdf_with_custom_grid(mocker, results):
 
 def test_database_info_initialization():
     db_info = hf.DatabaseInfo()
-    assert db_info.name == hf.database.DataBaseHandler.DEFAULT_DATABASE_NAME
+    assert db_info.blob_storage is None
+    assert db_info.name is None
     assert db_info.run_id is None
     assert db_info.run_table_name == hf.database.DataBaseHandler.RUN_TABLE_NAME
 
@@ -217,11 +218,13 @@ def test_database_info_initialization():
 def test_database_info_to_native(mocker):
     native_db_info = mocker.patch("qupled.native.DatabaseInfo")
     db_info = hf.DatabaseInfo()
+    db_info.blob_storage = "blob_data"
     db_info.name = "test_db"
     db_info.run_id = 123
     db_info.run_table_name = "test_table"
     native_instance = db_info.to_native()
     assert native_instance == native_db_info.return_value
+    assert native_instance.blob_storage == "blob_data"
     assert native_instance.name == "test_db"
     assert native_instance.run_id == 123
     assert native_instance.run_table_name == "test_table"

qupled-1.3.4/src/qupled/native/include/database.hpp

@@ -1,18 +0,0 @@
-#ifndef DATABASE_HPP
-#define DATABASE_HPP
-
-#include "num_util.hpp"
-#include <string>
-
-struct DatabaseInfo {
-  DatabaseInfo()
-      : runId(numUtil::iNaN) {}
-  // Database name
-  std::string name;
-  // Run id in the database
-  int runId;
-  // Name of the table with the runs in the database
-  std::string runTableName;
-};
-
-#endif // DATABASE_HPP