PyOpenMagnetics 1.7.30__tar.gz → 1.7.32__tar.gz

{pyopenmagnetics-1.7.30 → 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.30 → pyopenmagnetics-1.7.32}/PKG-INFO

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

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

{pyopenmagnetics-1.7.30 → pyopenmagnetics-1.7.32}/src/core.cpp

@@ -567,6 +567,21 @@ json calculate_complex_permeability(json materialJson, double frequency) {
     return result;
 }
 
+json calculate_complex_permeability_frequency_range(json material) {
+    OpenMagnetics::ComplexPermeability complexPermeabilityObj;
+    std::pair<double, double> range;
+    if (material.is_string()) {
+        range = complexPermeabilityObj.get_frequency_range(material.get<std::string>());
+    }
+    else {
+        range = complexPermeabilityObj.get_frequency_range(CoreMaterial(material));
+    }
+    json result;
+    result["minimum"] = range.first;
+    result["maximum"] = range.second;
+    return result;
+}
+
 void register_core_bindings(py::module& m) {
     // Core materials
     m.def("get_core_materials", &get_core_materials,
@@ -1344,6 +1359,24 @@ void register_core_bindings(py::module& m) {
         )pbdoc",
         py::arg("material_json"), py::arg("frequency"),
         py::call_guard<py::gil_scoped_release>());
+
+    m.def("calculate_complex_permeability_frequency_range", &calculate_complex_permeability_frequency_range,
+        R"pbdoc(
+        Frequency span in which a core material's complex permeability is defined.
+
+        calculate_complex_permeability (and every impedance sweep that uses it)
+        throws outside this span: it is the span covered by both the material's
+        tabulated mu'(f) and mu''(f), or by the table MKF derives from its
+        frequency-dependent initial permeability.
+
+        Args:
+            material: JSON CoreMaterial object, or the material name.
+
+        Returns:
+            JSON object {"minimum": Hz, "maximum": Hz}.
+        )pbdoc",
+        py::arg("material"),
+        py::call_guard<py::gil_scoped_release>());
 }
 
 } // namespace PyMKF

{pyopenmagnetics-1.7.30 → pyopenmagnetics-1.7.32}/src/core.h

@@ -59,6 +59,7 @@ std::vector<std::string> get_available_core_filters();
 std::vector<double> get_maximum_dimensions(json magneticJson);
 json calculate_core_data_from_shape(json shapeJson);
 json calculate_complex_permeability(json materialJson, double frequency);
+json calculate_complex_permeability_frequency_range(json material);
 
 void register_core_bindings(py::module& m);
 

{pyopenmagnetics-1.7.30 → 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.30 → pyopenmagnetics-1.7.32}/tests/test_core.py

@@ -312,3 +312,23 @@ class TestCoreProcessedDescription:
             if "windingWindows" in processed:
                 assert isinstance(processed["windingWindows"], list)
                 assert len(processed["windingWindows"]) > 0
+
+
+class TestComplexPermeabilityFrequencyRange:
+    """calculate_complex_permeability throws outside the material's tabulated span; the span is exposed so
+    callers (impedance sweeps) can stay inside it instead of catching the throw."""
+
+    def test_a07_span_ends_at_the_top_of_its_tabulated_mu_imaginary(self):
+        span = PyOpenMagnetics.calculate_complex_permeability_frequency_range("A07")
+        assert 0 < span["minimum"] < span["maximum"]
+        # A07's tabulated mu''(f) ends at ~17 MHz (mu' extended to it by Kramers-Kronig in MAS).
+        assert 1e7 < span["maximum"] < 1e8
+
+    def test_inside_the_span_answers_and_outside_it_throws(self):
+        material = PyOpenMagnetics.find_core_material_by_name("A07")
+        span = PyOpenMagnetics.calculate_complex_permeability_frequency_range(material)
+        assert span == PyOpenMagnetics.calculate_complex_permeability_frequency_range("A07")
+        inside = PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"] * 0.99)
+        assert inside["imaginary"] > 0
+        with pytest.raises(Exception):
+            PyOpenMagnetics.calculate_complex_permeability(material, span["maximum"] * 1.01)

{pyopenmagnetics-1.7.30 → 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)