PyOpenMagnetics 1.7.31__tar.gz → 1.7.33__tar.gz

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/CMakeLists.txt

@@ -142,7 +142,7 @@ if(NOT LOCAL_MKF_MAS)
     set(MKF_GIT_TAG "main"
         CACHE STRING "MKF git ref for the vendored PyOM build")
     # Force fresh clone by using a unique timestamp - update this when the pin changes
-    set(MKF_FORCE_REFRESH "2026-10-02-mkf-7b80390f")
+    set(MKF_FORCE_REFRESH "2026-10-04-mkf-508edb8b")
     # Tell MKF to disable matplotplusplus and use SVG-based Painter instead
     set(INCLUDE_PYMKF ON CACHE BOOL "Build Python interface" FORCE)
     # GIT_SUBMODULES_RECURSE pulls in CAS/PEAS (added 2026-04 alongside the

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.7.31
+Version: 1.7.33
 Summary: Python wrapper for OpenMagnetics
 Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
 Classifier: Development Status :: 4 - Beta

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/PyOpenMagnetics.pyi

@@ -679,6 +679,8 @@ def calculate_advised_magnetics_from_catalog(
         - "lossesNotEvaluable" (only on such parts): why the part's core losses could not be
           evaluated (its core material has no core-loss model); it is ranked without any
           loss-based filter and returned without simulated outputs.
+        And a "failedCandidates" array next to "data": one {"reference", "error"} per candidate
+        whose evaluation raised (a filter or the final simulation threw); it is not ranked.
     """
     ...
 

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "PyOpenMagnetics"
-version = "1.7.31"
+version = "1.7.33"
 requires-python = ">=3.8"
 authors = [
   { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/src/advisers.cpp

@@ -179,6 +179,17 @@ json calculate_advised_magnetics_fast(json inputsJson, int maximumNumberResults,
     return results;
 }
 
+// The candidates the adviser excluded because evaluating them raised (a filter or the final
+// simulation threw), each with the error. They are not ranked; this says which and why, instead of
+// the result silently holding fewer parts.
+static json failed_candidates_to_json(const OpenMagnetics::MagneticAdviser& magneticAdviser) {
+    json failedCandidates = json::array();
+    for (const auto& [reference, error] : magneticAdviser.get_failed_candidates()) {
+        failedCandidates.push_back({{"reference", reference}, {"error", error}});
+    }
+    return failedCandidates;
+}
+
 json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson, int maximumNumberResults) {
     OpenMagnetics::settings.set_coil_delimit_and_compact(true);
     OpenMagnetics::Inputs inputs(inputsJson);
@@ -224,6 +235,7 @@ json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson,
     sort(results["data"].begin(), results["data"].end(), [](json& b1, json& b2) {
         return b1["scoring"] > b2["scoring"];
     });
+    results["failedCandidates"] = failed_candidates_to_json(magneticAdviser);
 
     return results;
 }
@@ -282,6 +294,7 @@ json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson
     sort(results["data"].begin(), results["data"].end(), [](json& b1, json& b2) {
         return b1["scoring"] > b2["scoring"];
     });
+    results["failedCandidates"] = failed_candidates_to_json(magneticAdviser);
 
     return results;
 }
@@ -506,6 +519,9 @@ void register_adviser_bindings(py::module& m) {
             - "lossesNotEvaluable" (only on such parts): why this part's core losses could
               not be evaluated -- its core material carries no core-loss model. The part is
               ranked without any loss-based filter and returned without simulated outputs.
+            And a "failedCandidates" array next to "data": one {"reference", "error"} per
+            candidate whose evaluation raised (a filter or the final simulation threw). Such a
+            candidate is not ranked; this names it and the error instead of dropping it silently.
 
         Example:
             >>> inputs = PyMKF.process_inputs(raw_inputs)
@@ -550,6 +566,9 @@ void register_adviser_bindings(py::module& m) {
               not be evaluated -- its core material carries no core-loss model. The part is
               ranked on the filters that apply to it, with no loss-based filter scored, and
               is returned without simulated outputs.
+            And a "failedCandidates" array next to "data": one {"reference", "error"} per
+            candidate whose evaluation raised (a filter or the final simulation threw). Such a
+            candidate is not ranked; this names it and the error instead of dropping it silently.
         
         Note:
             Cache must be populated before calling this function.

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/src/database.cpp

@@ -234,12 +234,20 @@ struct RejectedRecord {
 // Read the whole stream before touching the cache, so a strict load is all-or-nothing
 // and a tolerant one is exact about what it dropped. Every failure is reported as
 // "<source>:<line> (part 'X'): <what actually went wrong>".
+//
+// Two records under one manufacturerInfo.reference are an error too. The cache is keyed
+// by the reference, so the second used to replace the first without a word: a catalogue
+// of 2 came back as 1 (nine WE Midcom parts whose OEM P/N cell read "#N/A" collapsed to
+// one). Nothing here can tell which of the two is that part's real record, so a strict
+// load refuses the file and a tolerant one rejects every record sharing the reference.
 std::vector<std::pair<std::string, OpenMagnetics::Magnetic>> stage_magnetics(std::istream& in,
                                                                              const std::string& source,
                                                                              bool expand,
                                                                              bool skipInvalid,
                                                                              std::vector<RejectedRecord>& rejected) {
     std::vector<std::pair<std::string, OpenMagnetics::Magnetic>> staged;
+    std::vector<size_t> stagedLineNumbers;
+    std::map<std::string, size_t> firstLineOfReference;
     std::string line;
     size_t lineNumber = 0;
     while (getline(in, line)) {
@@ -247,8 +255,9 @@ std::vector<std::pair<std::string, OpenMagnetics::Magnetic>> stage_magnetics(std
         if (line.find_first_not_of(" \t\r\n") == std::string::npos) {
             continue;
         }
+        std::pair<std::string, OpenMagnetics::Magnetic> record;
         try {
-            staged.push_back(read_magnetic_line(line, expand));
+            record = read_magnetic_line(line, expand);
         }
         catch (const std::exception& e) {
             std::string reference;
@@ -262,7 +271,46 @@ std::vector<std::pair<std::string, OpenMagnetics::Magnetic>> stage_magnetics(std
                 throw std::runtime_error(locate(source, lineNumber, reference) + ": " + e.what());
             }
             rejected.push_back({lineNumber, reference, e.what()});
+            continue;
+        }
+        auto [first, isNew] = firstLineOfReference.emplace(record.first, lineNumber);
+        if (!isNew && !skipInvalid) {
+            throw std::runtime_error(locate(source, lineNumber, record.first) + ": manufacturerInfo.reference '" +
+                                     record.first + "' is also the reference of line " +
+                                     std::to_string(first->second) + ", and the magnetics cache is keyed by it: "
+                                     "one of the two records would silently replace the other");
+        }
+        staged.push_back(std::move(record));
+        stagedLineNumbers.push_back(lineNumber);
+    }
+
+    if (skipInvalid) {
+        std::map<std::string, std::vector<size_t>> linesOfReference;
+        for (size_t index = 0; index < staged.size(); ++index) {
+            linesOfReference[staged[index].first].push_back(stagedLineNumbers[index]);
+        }
+        std::vector<std::pair<std::string, OpenMagnetics::Magnetic>> unique;
+        for (size_t index = 0; index < staged.size(); ++index) {
+            const auto& lines = linesOfReference[staged[index].first];
+            if (lines.size() == 1) {
+                unique.push_back(std::move(staged[index]));
+                continue;
+            }
+            std::string others;
+            for (auto otherLine : lines) {
+                if (otherLine != stagedLineNumbers[index]) {
+                    others += (others.empty() ? "" : ", ") + std::to_string(otherLine);
+                }
+            }
+            rejected.push_back({stagedLineNumbers[index], staged[index].first,
+                                "manufacturerInfo.reference '" + staged[index].first +
+                                    "' is also the reference of line " + others +
+                                    ", and the magnetics cache is keyed by it: every record under it is rejected,"
+                                    " since nothing tells which one is the part's real record"});
         }
+        staged = std::move(unique);
+        std::stable_sort(rejected.begin(), rejected.end(),
+                         [](const RejectedRecord& a, const RejectedRecord& b) { return a.lineNumber < b.lineNumber; });
     }
     return staged;
 }
@@ -419,7 +467,9 @@ void register_database_bindings(py::module& m) {
         (ABT #823). The first record that cannot be loaded raises EngineError naming
         the file, the line number, the part reference and the underlying reason.
         Blank lines are skipped. Records are keyed by manufacturerInfo.reference, so
-        a record without one is an error rather than an anonymous optional access.
+        a record without one is an error rather than an anonymous optional access, and
+        two records sharing one raise EngineError naming the reference and both lines
+        instead of the second silently replacing the first.
 
         Use load_magnetics_from_file_report() instead when a partial catalogue is
         acceptable and you want the list of rejected records.
@@ -440,7 +490,9 @@ void register_database_bindings(py::module& m) {
         The tolerant counterpart of load_magnetics_from_file (ABT #823): a bad record
         no longer aborts the batch, and the caller is told exactly which records were
         dropped and why instead of silently running on a truncated catalogue. A file
-        that cannot be opened is still an error.
+        that cannot be opened is still an error. Records sharing a
+        manufacturerInfo.reference are all rejected, each naming the other lines,
+        since nothing tells which of them is the part's real record.
 
         Args:
             path: Path to the NDJSON file.

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.33}/tests/test_magnetics_catalogue_load.py

@@ -140,6 +140,27 @@ class TestStrictLoad:
         assert "manufacturerInfo" in message, message
         assert "anonymous.ndjson:1" in message, message
 
+    def test_two_records_sharing_a_reference_raise_and_name_it(self, tmp_path):
+        # The cache is keyed by manufacturerInfo.reference: the second record used to
+        # replace the first without a word (2 offered, "1" returned). Nine WE Midcom
+        # parts whose OEM P/N cell read "#N/A" collapsed to one that way.
+        first = magnetic("#N/A")
+        second = magnetic("#N/A")
+        second["coil"]["functionalDescription"][0]["numberTurns"] = 40
+        path = write_ndjson(tmp_path / "duplicates.ndjson", [magnetic("K1"), first, second])
+
+        with pytest.raises(PyOpenMagnetics.EngineError) as error:
+            PyOpenMagnetics.load_magnetics_from_file(path, True)
+
+        message = str(error.value)
+        assert "duplicates.ndjson:3" in message, message
+        assert "'#N/A'" in message, message
+        assert "line 2" in message, message
+
+        # All or nothing: none of the file reached the cache.
+        good = write_ndjson(tmp_path / "good.ndjson", [magnetic("K9")])
+        assert PyOpenMagnetics.load_magnetics_from_file(good, True) == "1"
+
 
 class TestReportingLoad:
     """load_magnetics_from_file_report: keep the good records, name the dropped ones."""
@@ -167,6 +188,20 @@ class TestReportingLoad:
         assert report["loaded"] == 2
         assert report["rejected"] == []
 
+    def test_records_sharing_a_reference_are_all_rejected(self, tmp_path):
+        path = write_ndjson(
+            tmp_path / "duplicates.ndjson",
+            [magnetic("L1"), magnetic("#N/A"), magnetic("L3"), magnetic("#N/A")],
+        )
+
+        report = PyOpenMagnetics.load_magnetics_from_file_report(path, True)
+
+        assert report["loaded"] == 2
+        assert report["cacheSize"] == 2
+        assert [(r["line"], r["reference"]) for r in report["rejected"]] == [(2, "#N/A"), (4, "#N/A")]
+        assert "line 4" in report["rejected"][0]["reason"]
+        assert "line 2" in report["rejected"][1]["reason"]
+
     def test_missing_file_still_raises(self, tmp_path):
         with pytest.raises(PyOpenMagnetics.EngineError):
             PyOpenMagnetics.load_magnetics_from_file_report(str(tmp_path / "nope.ndjson"), True)