power-grid-model 1.12.40__tar.gz → 1.12.42__tar.gz

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/.github/workflows/build-test-release.yml

@@ -213,7 +213,7 @@ jobs:
           xcode-version: latest-stable
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v3.1
+        uses: pypa/cibuildwheel@v3.2
         # GitHub Actions specific build parameters
         env:
           # pass GitHub runner info into Linux container

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model
-Version: 1.12.40
+Version: 1.12.42
 Summary: Python/C++ library for distribution power system analysis
 Author-Email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License-Expression: MPL-2.0

power_grid_model-1.12.42/VERSION

@@ -0,0 +1 @@
+1.12.42

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/power_grid_model_c/power_grid_model/include/power_grid_model/job_adapter.hpp

@@ -10,7 +10,6 @@
 #include "main_model_fwd.hpp"
 
 #include "auxiliary/dataset.hpp"
-#include "common/dummy_logging.hpp"
 #include "main_core/update.hpp"
 
 namespace power_grid_model {
@@ -23,9 +22,7 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
 
     JobAdapter(std::reference_wrapper<MainModel> model_reference,
                std::reference_wrapper<MainModelOptions const> options)
-        : model_reference_{model_reference}, options_{options} {
-        reset_logger_impl();
-    }
+        : model_reference_{model_reference}, options_{options} {}
     JobAdapter(JobAdapter const& other)
         : model_copy_{std::make_unique<MainModel>(other.model_reference_.get())},
           model_reference_{std::ref(*model_copy_)},
@@ -33,9 +30,7 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
           components_to_update_{other.components_to_update_},
           update_independence_{other.update_independence_},
           independence_flags_{other.independence_flags_},
-          all_scenarios_sequence_{other.all_scenarios_sequence_} {
-        reset_logger_impl();
-    }
+          all_scenarios_sequence_{other.all_scenarios_sequence_} {}
     JobAdapter& operator=(JobAdapter const& other) {
         if (this != &other) {
             model_copy_ = std::make_unique<MainModel>(other.model_reference_.get());
@@ -45,8 +40,6 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
             update_independence_ = other.update_independence_;
             independence_flags_ = other.independence_flags_;
             all_scenarios_sequence_ = other.all_scenarios_sequence_;
-
-            reset_logger_impl();
         }
         return *this;
     }
@@ -57,9 +50,7 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
           components_to_update_{std::move(other.components_to_update_)},
           update_independence_{std::move(other.update_independence_)},
           independence_flags_{std::move(other.independence_flags_)},
-          all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {
-        reset_logger_impl();
-    }
+          all_scenarios_sequence_{std::move(other.all_scenarios_sequence_)} {}
     JobAdapter& operator=(JobAdapter&& other) noexcept {
         if (this != &other) {
             model_copy_ = std::move(other.model_copy_);
@@ -69,15 +60,10 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
             update_independence_ = std::move(other.update_independence_);
             independence_flags_ = std::move(other.independence_flags_);
             all_scenarios_sequence_ = std::move(other.all_scenarios_sequence_);
-
-            reset_logger_impl();
         }
         return *this;
     }
-    ~JobAdapter() {
-        reset_logger_impl();
-        model_copy_.reset();
-    }
+    ~JobAdapter() { model_copy_.reset(); }
 
   private:
     // Grant the CRTP base (JobInterface<JobAdapter>) access to
@@ -96,14 +82,12 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
     // current_scenario_sequence_cache_ is calculated per scenario, so it is excluded from the constructors.
     typename ModelType::SequenceIdx current_scenario_sequence_cache_{};
 
-    Logger* log_{nullptr};
-
-    void calculate_impl(MutableDataset const& result_data, Idx scenario_idx) const {
+    void calculate_impl(MutableDataset const& result_data, Idx scenario_idx, Logger& logger) const {
         MainModel::calculator(options_.get(), model_reference_.get(), result_data.get_individual_scenario(scenario_idx),
-                              false, logger());
+                              false, logger);
     }
 
-    void cache_calculate_impl() const {
+    void cache_calculate_impl(Logger& logger) const {
         // calculate once to cache topology, ignore results, all math solvers are initialized
         try {
             MainModel::calculator(options_.get(), model_reference_.get(),
@@ -113,7 +97,7 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
                                       "sym_output",
                                       model_reference_.get().meta_data(),
                                   },
-                                  true, logger());
+                                  true, logger);
         } catch (SparseMatrixError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
             // missing entries are provided in the update data
         } catch (NotObservableError const&) { // NOLINT(bugprone-empty-catch) // NOSONAR
@@ -158,13 +142,5 @@ template <class MainModel> class JobAdapter : public JobInterface<JobAdapter<Mai
             return std::span<Idx2D const>{std::get<comp_idx>(current_scenario_sequence_cache_)};
         });
     }
-
-    void reset_logger_impl() { log_ = nullptr; }
-    void set_logger_impl(Logger& log) { log_ = &log; }
-
-    Logger& logger() const {
-        static common::logging::NoLogger no_log{};
-        return log_ != nullptr ? *log_ : no_log;
-    }
 };
 } // namespace power_grid_model

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp

@@ -24,11 +24,8 @@ class JobDispatch {
     static BatchParameter batch_calculation(Adapter& adapter, ResultDataset const& result_data,
                                             UpdateDataset const& update_data, Idx threading,
                                             common::logging::MultiThreadedLogger& log) {
-        adapter.set_logger(log);
-
         if (update_data.empty()) {
-            adapter.calculate(result_data);
-            adapter.reset_logger();
+            adapter.calculate(result_data, log);
             return BatchParameter{};
         }
 
@@ -38,12 +35,11 @@ class JobDispatch {
         // if the batch_size is zero, it is a special case without doing any calculations at all
         // we consider in this case the batch set is independent but not topology cacheable
         if (n_scenarios == 0) {
-            adapter.reset_logger();
             return BatchParameter{};
         }
 
         // calculate once to cache, ignore results
-        adapter.cache_calculate();
+        adapter.cache_calculate(log);
 
         // error messages
         std::vector<std::string> exceptions(n_scenarios, "");
@@ -55,8 +51,6 @@ class JobDispatch {
 
         handle_batch_exceptions(exceptions);
 
-        adapter.reset_logger();
-
         return BatchParameter{};
     }
 
@@ -92,7 +86,6 @@ class JobDispatch {
             auto const copy_adapter_functor = [&base_adapter, &thread_log]() {
                 Timer const t_copy_adapter_functor{thread_log, LogEvent::copy_model};
                 auto result = Adapter{base_adapter};
-                result.set_logger(thread_log);
                 return result;
             };
 
@@ -114,7 +107,9 @@ class JobDispatch {
                 adapter = copy_adapter_functor();
             };
 
-            auto run = [&adapter, &result_data](Idx scenario_idx) { adapter.calculate(result_data, scenario_idx); };
+            auto run = [&adapter, &result_data, &thread_log](Idx scenario_idx) {
+                adapter.calculate(result_data, scenario_idx, thread_log);
+            };
 
             auto calculate_scenario = JobDispatch::call_with<Idx>(std::move(run), std::move(setup), std::move(winddown),
                                                                   JobDispatch::scenario_exception_handler(exceptions),

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/power_grid_model_c/power_grid_model/include/power_grid_model/job_interface.hpp

@@ -18,20 +18,23 @@ template <typename Adapter> class JobInterface {
   public:
     // the multiple  NOSONARs are used to avoid the complaints about the unnamed concepts
     template <typename ResultDataset>
-    void calculate(ResultDataset const& result_data, Idx pos = 0)
+    void calculate(ResultDataset const& result_data, Idx pos, Logger& logger)
         requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.calculate_impl(result_data, pos) } -> std::same_as<void>;
+            { adapter.calculate_impl(result_data, pos, logger) } -> std::same_as<void>;
         }
     {
-        return static_cast<Adapter*>(this)->calculate_impl(result_data, pos);
+        static_cast<Adapter*>(this)->calculate_impl(result_data, pos, logger);
+    }
+    template <typename ResultDataset> void calculate(ResultDataset const& result_data, Logger& logger) {
+        calculate(result_data, Idx{}, logger);
     }
 
-    void cache_calculate()
+    void cache_calculate(Logger& logger)
         requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.cache_calculate_impl() } -> std::same_as<void>;
+            { adapter.cache_calculate_impl(logger) } -> std::same_as<void>;
         }
     {
-        return static_cast<Adapter*>(this)->cache_calculate_impl();
+        static_cast<Adapter*>(this)->cache_calculate_impl(logger);
     }
 
     template <typename UpdateDataset>
@@ -40,7 +43,7 @@ template <typename Adapter> class JobInterface {
             { adapter.prepare_job_dispatch_impl(update_data) } -> std::same_as<void>;
         }
     {
-        return static_cast<Adapter*>(this)->prepare_job_dispatch_impl(update_data);
+        static_cast<Adapter*>(this)->prepare_job_dispatch_impl(update_data);
     }
 
     template <typename UpdateDataset>
@@ -49,7 +52,7 @@ template <typename Adapter> class JobInterface {
             { adapter.setup_impl(update_data, scenario_idx) } -> std::same_as<void>;
         }
     {
-        return static_cast<Adapter*>(this)->setup_impl(update_data, scenario_idx);
+        static_cast<Adapter*>(this)->setup_impl(update_data, scenario_idx);
     }
 
     void winddown()
@@ -57,22 +60,7 @@ template <typename Adapter> class JobInterface {
             { adapter.winddown_impl() } -> std::same_as<void>;
         }
     {
-        return static_cast<Adapter*>(this)->winddown_impl();
-    }
-
-    void reset_logger()
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.reset_logger_impl() } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->reset_logger_impl();
-    }
-    void set_logger(Logger& log)
-        requires requires(Adapter& adapter) { // NOSONAR
-            { adapter.set_logger_impl(log) } -> std::same_as<void>;
-        }
-    {
-        static_cast<Adapter*>(this)->set_logger_impl(log);
+        static_cast<Adapter*>(this)->winddown_impl();
     }
 
   private:

{power_grid_model-1.12.40 → power_grid_model-1.12.42}/tests/cpp_unit_tests/test_job_dispatch.cpp

@@ -4,6 +4,7 @@
 
 #include <power_grid_model/batch_parameter.hpp>
 #include <power_grid_model/common/common.hpp>
+#include <power_grid_model/common/dummy_logging.hpp>
 #include <power_grid_model/common/exception.hpp>
 #include <power_grid_model/common/multi_threaded_logging.hpp>
 #include <power_grid_model/job_dispatch.hpp>
@@ -56,53 +57,37 @@ class JobAdapterMock : public JobInterface<JobAdapterMock> {
     JobAdapterMock& operator=(JobAdapterMock const& other) {
         if (this != &other) {
             counter_ = other.counter_;
-            logger_ = nullptr; // reset logger
         }
         return *this;
     };
-    JobAdapterMock(JobAdapterMock&& other) noexcept : logger_{other.logger_}, counter_{std::move(other.counter_)} {}
+    JobAdapterMock(JobAdapterMock&& other) noexcept : counter_{std::exchange(other.counter_, nullptr)} {}
     JobAdapterMock& operator=(JobAdapterMock&& other) noexcept {
         if (this != &other) {
-            counter_ = std::move(other.counter_);
-            other.counter_ = nullptr;
-            logger_ = other.logger_;
-            other.logger_ = nullptr;
+            counter_ = std::exchange(other.counter_, nullptr);
         }
         return *this;
     }
-    ~JobAdapterMock() { reset_logger(); };
+    ~JobAdapterMock() noexcept { counter_ = nullptr; }
 
     void reset_counters() const { counter_->reset_counters(); }
     Idx get_calculate_counter() const { return counter_->calculate_calls; }
     Idx get_cache_calculate_counter() const { return counter_->cache_calculate_calls; }
     Idx get_setup_counter() const { return counter_->setup_calls; }
     Idx get_winddown_counter() const { return counter_->winddown_calls; }
-    Idx get_set_logger_counter() const { return counter_->set_logger_calls; }
-    Idx get_reset_logger_counter() const { return counter_->reset_logger_calls; }
 
   private:
     friend class JobInterface<JobAdapterMock>;
 
-    Logger* logger_{};
     std::shared_ptr<CallCounter> counter_;
 
-    void calculate_impl(MockResultDataset const& /*result_data*/, Idx /*scenario_idx*/) const {
+    void calculate_impl(MockResultDataset const& /*result_data*/, Idx /*scenario_idx*/,
+                        Logger const& /*logger*/) const {
         ++(counter_->calculate_calls);
     }
-    void cache_calculate_impl() const { ++(counter_->cache_calculate_calls); }
+    void cache_calculate_impl(Logger const& /*logger*/) const { ++(counter_->cache_calculate_calls); }
     void prepare_job_dispatch_impl(MockUpdateDataset const& /*update_data*/) const { /* patch base class function */ }
     void setup_impl(MockUpdateDataset const& /*update_data*/, Idx /*scenario_idx*/) const { ++(counter_->setup_calls); }
     void winddown_impl() const { ++(counter_->winddown_calls); }
-    void reset_logger_impl() {
-        if (counter_ != nullptr) { // this may happen when the destructor is called on a moved object
-            ++(counter_->reset_logger_calls);
-        }
-        logger_ = nullptr;
-    }
-    void set_logger_impl(Logger& logger) {
-        ++(counter_->set_logger_calls);
-        logger_ = &logger;
-    }
 };
 
 class SomeTestException : public std::runtime_error {
@@ -186,8 +171,6 @@ TEST_CASE("Test job dispatch logic") {
             CHECK(expected_result == actual_result);
             CHECK(adapter.get_calculate_counter() == 1);
             CHECK(adapter.get_cache_calculate_counter() == 0); // no cache calculation in this case
-            CHECK(adapter.get_set_logger_counter() == 1);
-            CHECK(adapter.get_reset_logger_counter() == 1);
         }
         SUBCASE("No scenarios") {
             bool const has_data = true;
@@ -200,8 +183,6 @@ TEST_CASE("Test job dispatch logic") {
             // no calculations should be done
             CHECK(adapter.get_calculate_counter() == 0);
             CHECK(adapter.get_cache_calculate_counter() == 0);
-            CHECK(adapter.get_set_logger_counter() == 1);
-            CHECK(adapter.get_reset_logger_counter() == 1);
         }
         SUBCASE("With scenarios and update data") {
             bool const has_data = true;
@@ -214,8 +195,6 @@ TEST_CASE("Test job dispatch logic") {
             // n_scenarios calculations should be done as we run sequentially
             CHECK(adapter.get_calculate_counter() == n_scenarios);
             CHECK(adapter.get_cache_calculate_counter() == 1); // cache calculation is done
-            CHECK(adapter.get_set_logger_counter() == 2);
-            CHECK(adapter.get_reset_logger_counter() == 2);
         }
     }
     SUBCASE("Test single_thread_job") {
@@ -241,8 +220,6 @@ TEST_CASE("Test job dispatch logic") {
             CHECK(adapter_.get_setup_counter() == expected_calls);
             CHECK(adapter_.get_winddown_counter() == expected_calls);
             CHECK(adapter_.get_calculate_counter() == expected_calls);
-            CHECK(adapter_.get_set_logger_counter() == 1);
-            CHECK(adapter_.get_reset_logger_counter() == 1);
         };
 
         adapter.prepare_job_dispatch(update_data); // replicate preparation step from batch_calculation

power_grid_model-1.12.40/VERSION

@@ -1 +0,0 @@
-1.12.40