PyOpenMagnetics 1.7.31__tar.gz → 1.7.32__tar.gz

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.32}/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-03-mkf-5055470b")
     # 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.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.7.31
+Version: 1.7.32
 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.32}/pyproject.toml

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

{pyopenmagnetics-1.7.31 → pyopenmagnetics-1.7.32}/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.32}/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)