PyOpenMagnetics 1.5.1__tar.gz → 1.6.0__tar.gz

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/CMakeLists.txt

@@ -42,6 +42,9 @@ else ()
 endif()
 
 SET(MAS_DIRECTORY "${CMAKE_BINARY_DIR}/MAS/")
+# quicktype does not create the output directory; a FRESH build dir has no MAS/ yet
+# (mirrors the CAS_DIRECTORY MAKE_DIRECTORY below).
+file(MAKE_DIRECTORY "${MAS_DIRECTORY}")
 if(DEFINED ENV{LOCAL_MKF_DIR})
     SET(LOCAL_MKF_MAS TRUE)
     SET(MAS_DIR "${PROJECT_SOURCE_DIR}/_mas_local")
@@ -124,8 +127,22 @@ include_directories("${CMAKE_BINARY_DIR}/_deps/eigen-src")
 
 if(NOT LOCAL_MKF_MAS)
     message(STATUS "Fetching MKF")
-    # Force fresh clone by using a unique timestamp - update this when MKF changes
-    set(MKF_FORCE_REFRESH "2026-04-29-extra-components")
+    # --------------------------------------------------------------------
+    # MKF tracks main (ABT #73 resolved).
+    #
+    # MKF main deleted converter_models and links the Kirchhoff converter-model
+    # library (libKirchhoffApi.so) via KirchhoffBridge.cpp. The vendored build
+    # globs MKF's .cpp into the PyOpenMagnetics module, so it needs that .so at
+    # link time — which the Kirchhoff ExternalProject wired below (mirroring
+    # MKF's own MKF_USE_KIRCHHOFF) now provides. Kirchhoff and its AAS/PSMA
+    # siblings are published, so a clean checkout resolves the whole tree. The
+    # earlier 2ae859dc SHA pin (pre-converter_models-deletion) is no longer
+    # needed now that the Kirchhoff lib build is wired in — the prerequisite the
+    # old pin comment named. Tracks main so MKF fixes reach the wheel.
+    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-07-03-track-main-kirchhoff")
     # 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
@@ -140,7 +157,7 @@ if(NOT LOCAL_MKF_MAS)
     # leave it out, otherwise FetchContent doubles the clone.
     FetchContent_Declare(MKF
             GIT_REPOSITORY https://github.com/OpenMagnetics/MKF.git
-            GIT_TAG main
+            GIT_TAG ${MKF_GIT_TAG}
             GIT_PROGRESS TRUE
             GIT_SUBMODULES "CAS" "PEAS" "cci_coords"
             GIT_SUBMODULES_RECURSE TRUE)
@@ -182,28 +199,40 @@ if(NOT LOCAL_MKF_MAS)
         message(STATUS "MAS git error: ${MAS_GIT_ERROR}")
     endif()
 
-    # Always delete and repopulate MKF to ensure we get the latest main,
-    # mirroring the MAS refresh above. FetchContent will NOT re-fetch an
-    # already-cloned source dir even with GIT_TAG main, so a persisted build
-    # dir (incremental CI cache, local rebuilds) otherwise keeps a STALE MKF
-    # checkout — fixes merged to MKF main would silently never reach the wheel.
+    # Always delete and repopulate MKF so the checkout matches ${MKF_GIT_TAG}
+    # exactly, mirroring the MAS refresh above. FetchContent will NOT re-checkout
+    # an already-cloned source dir when the pin changes, so a persisted build dir
+    # (incremental CI cache, or a local build that previously tracked main) would
+    # otherwise keep a STALE MKF checkout at the wrong SHA — e.g. a main tip that
+    # needs the unpublished libKirchhoffApi.so and fails to link (ABT #73).
     if(EXISTS ${CMAKE_BINARY_DIR}/_deps/mkf-src)
-        message(STATUS "Removing old MKF source to force fresh clone")
+        message(STATUS "Removing old MKF source to force fresh checkout at ${MKF_GIT_TAG}")
         file(REMOVE_RECURSE ${CMAKE_BINARY_DIR}/_deps/mkf-src)
     endif()
     message(STATUS "Populating MKF")
     FetchContent_Populate(MKF)
-    # Show git log to verify we built against MKF main HEAD
+    # Show git log AND assert the checkout is exactly the pinned SHA. A silent
+    # drift here would resurface the libKirchhoffApi.so link failure ABT #73
+    # guards against, so fail LOUDLY at configure time instead.
     execute_process(
-        COMMAND git -C ${mkf_SOURCE_DIR} log --oneline -1
-        OUTPUT_VARIABLE MKF_GIT_LOG
+        COMMAND git -C ${mkf_SOURCE_DIR} rev-parse HEAD
+        OUTPUT_VARIABLE MKF_GIT_HEAD
         OUTPUT_STRIP_TRAILING_WHITESPACE
         ERROR_VARIABLE MKF_GIT_ERROR
     )
-    message(STATUS "MKF version: ${MKF_GIT_LOG}")
+    message(STATUS "MKF version: ${MKF_GIT_HEAD}")
     if(MKF_GIT_ERROR)
         message(STATUS "MKF git error: ${MKF_GIT_ERROR}")
     endif()
+    # Only assert when the pin is a full 40-char SHA (a branch/tag ref can't be
+    # compared to a resolved HEAD; that path is opt-in and the builder owns it).
+    string(LENGTH "${MKF_GIT_TAG}" _mkf_pin_len)
+    if(_mkf_pin_len EQUAL 40 AND NOT "${MKF_GIT_HEAD}" STREQUAL "${MKF_GIT_TAG}")
+        message(FATAL_ERROR
+            "Vendored PyOM built MKF at ${MKF_GIT_HEAD} but the pin is "
+            "${MKF_GIT_TAG} (ABT #73). Delete ${CMAKE_BINARY_DIR}/_deps/mkf-src "
+            "and reconfigure, or fetch the pinned commit.")
+    endif()
 
     message(STATUS ${MAS_SOURCE_DIR})
 else()
@@ -226,6 +255,13 @@ add_custom_command(
     -S ${MKF_DIR}/PEAS/schemas/utils.json
     -S ${MKF_DIR}/PEAS/schemas/inputs/operatingPointExcitation.json
     -S ${MKF_DIR}/PEAS/schemas/outputs/insulationCoordination.json
+    # outputBase.json must precede/accompany lossElementPerHarmonic.json: the
+    # latter's allOf[0] is {"$ref": "./outputBase.json"}. On Linux quicktype
+    # resolves that relative ref off the file path, but on Windows the file-URI
+    # resolution yields an empty URI ("Could not fetch schema") and the build
+    # fails. Feeding outputBase.json as a source lets quicktype resolve it by
+    # $id (https://psma.com/peas/outputs/outputBase.json) on every platform.
+    -S ${MKF_DIR}/PEAS/schemas/outputs/outputBase.json
     -S ${MKF_DIR}/PEAS/schemas/outputs/lossElementPerHarmonic.json
     -S ${MAS_DIR}/schemas/magnetic.json
     -S ${MAS_DIR}/schemas/magnetic/core.json
@@ -257,7 +293,8 @@ add_custom_command(
     -S ${MAS_DIR}/schemas/inputs/designRequirements.json
     -S ${MAS_DIR}/schemas/inputs/operatingConditions.json
     -S ${MAS_DIR}/schemas/inputs/operatingPoint.json
-    -S ${MAS_DIR}/schemas/inputs/operatingPointExcitation.json
+    # operatingPointExcitation moved from MAS to PEAS (MAS 76d5e9e "consolidate on PEAS");
+    # the PEAS copy is already fed above (${MKF_DIR}/PEAS/schemas/inputs/operatingPointExcitation.json).
     -S ${MAS_DIR}/schemas/inputs/topologies/flyback.json
     -S ${MAS_DIR}/schemas/inputs/topologies/currentTransformer.json
     -S ${MAS_DIR}/schemas/inputs/topologies/boost.json
@@ -341,6 +378,8 @@ file(GLOB SOURCES src/*.cpp
     ${MKF_DIR}/src/support/*.cpp
     )
 
+# converter.cpp is now a thin shim over the Kirchhoff string API (libKirchhoffApi) — re-enabled.
+
 set(CCI_GENERATED_CPP "${CMAKE_BINARY_DIR}/generated/CciCoordinatesData.cpp")
 find_package(Python3 REQUIRED COMPONENTS Interpreter)
 add_custom_command(
@@ -408,6 +447,45 @@ include_directories("${CMAKE_BINARY_DIR}/_cmrc/include")
 include_directories("${MAS_DIRECTORY}")
 include_directories("src/")
 
+# Kirchhoff: the externalised converter-model library that replaced MKF's converter_models. converter.cpp
+# and cmc.cpp are thin shims over its Kirchhoff::api string/JSON facade (libKirchhoffApi.so), and MKF's
+# converter_models/KirchhoffBridge.cpp links it too. Built ISOLATED via ExternalProject so Kirchhoff's own
+# `namespace MAS` types stay hidden inside the .so and never collide with MKF's identically-named ones —
+# only JSON strings cross the boundary. Mirrors MKF/CMakeLists.txt's MKF_USE_KIRCHHOFF wiring.
+#   * Default: clone from GitHub at KIRCHHOFF_GIT_TAG (recursive submodules).
+#   * Local dev: -DKIRCHHOFF_SOURCE_DIR=/path/to/Kirchhoff to build a working tree instead.
+include(ExternalProject)
+set(KIRCHHOFF_GIT_TAG "main" CACHE STRING "Kirchhoff git tag/branch to build (when fetching from GitHub)")
+set(KIRCHHOFF_SOURCE_DIR "" CACHE PATH "Local Kirchhoff working tree (leave empty to fetch from GitHub)")
+set(KIRCHHOFF_BUILD_DIR "${CMAKE_BINARY_DIR}/kirchhoff-build")
+set(KIRCHHOFF_API_LIB "${KIRCHHOFF_BUILD_DIR}/libKirchhoffApi.so")
+if(KIRCHHOFF_SOURCE_DIR)
+    set(_kirchhoff_src SOURCE_DIR "${KIRCHHOFF_SOURCE_DIR}")
+    set(_kirchhoff_hdr_dir "${KIRCHHOFF_SOURCE_DIR}/src")
+else()
+    set(_kirchhoff_src GIT_REPOSITORY "git@github.com:OpenConverters/Kirchhoff.git"
+                       GIT_TAG "${KIRCHHOFF_GIT_TAG}")
+    set(_kirchhoff_hdr_dir "${CMAKE_BINARY_DIR}/kirchhoff-ext-prefix/src/kirchhoff_ext/src")
+endif()
+ExternalProject_Add(kirchhoff_ext
+    ${_kirchhoff_src}
+    PREFIX "${CMAKE_BINARY_DIR}/kirchhoff-ext-prefix"
+    BINARY_DIR "${KIRCHHOFF_BUILD_DIR}"
+    CMAKE_ARGS
+        -DCMAKE_BUILD_TYPE=Release
+        -DKIRCHHOFF_BUILD_SHARED_API=ON   # emit libKirchhoffApi.so (string facade, hidden internals)
+        -DKIRCHHOFF_BUILD_PYBIND=OFF
+        -DENABLE_NGSPICE=ON               # KH carries the simulator MKF stopped building
+    BUILD_ALWAYS OFF
+    INSTALL_COMMAND ""
+    BUILD_BYPRODUCTS "${KIRCHHOFF_API_LIB}")
+include_directories("${_kirchhoff_hdr_dir}")
+add_library(KirchhoffApi SHARED IMPORTED)
+set_target_properties(KirchhoffApi PROPERTIES IMPORTED_LOCATION "${KIRCHHOFF_API_LIB}")
+add_dependencies(KirchhoffApi kirchhoff_ext)
+target_link_libraries(PyOpenMagnetics PRIVATE KirchhoffApi)
+add_dependencies(PyOpenMagnetics kirchhoff_ext)
+
 # target_link_libraries(PyOpenMagnetics PUBLIC MKF)
 
 

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.5.1
+Version: 1.6.0
 Summary: Python wrapper for OpenMagnetics
 Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
 Classifier: Development Status :: 4 - Beta
@@ -57,6 +57,29 @@ cd PyOpenMagnetics
 pip install .
 ```
 
+#### MKF is pinned to a SHA (build reproducibility — ABT #73)
+
+This build compiles MKF by **globbing its `.cpp` files directly** into the
+extension (it does not drive MKF's own CMake). MKF `main` has since moved to
+"delete `converter_models` + link the Kirchhoff converter-model library
+(`libKirchhoffApi.so`)"; because Kirchhoff and its AAS sibling are **not yet
+published**, a from-scratch build of newer `main` cannot obtain that library
+and **fails to link**.
+
+`CMakeLists.txt` therefore pins the MKF FetchContent to the last self-contained
+commit — `MKF_GIT_TAG=2ae859dcae6c3b2e5a128893247b7714360e863f`, the exact SHA
+the shipping `.so` was built from — and a configure-time guard fails loudly if
+the checkout drifts. A clean rebuild is reproducible as-is:
+
+```bash
+rm -rf build && pip install . --no-deps -v        # or: cmake -S . -B build && ninja -C build
+```
+
+To **advance** the pin you must first wire the Kirchhoff library build into
+`CMakeLists.txt` (publish AAS/Kirchhoff, then `add_subdirectory` +
+`target_link_libraries(... libKirchhoffApi.so)`). Overriding
+`-DMKF_GIT_TAG=main` before that lands will break the link.
+
 ### ⚠️ Import Instructions
 
 **Important:** The compiled extension module may require special import handling:

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/README.md

@@ -40,6 +40,29 @@ cd PyOpenMagnetics
 pip install .
 ```
 
+#### MKF is pinned to a SHA (build reproducibility — ABT #73)
+
+This build compiles MKF by **globbing its `.cpp` files directly** into the
+extension (it does not drive MKF's own CMake). MKF `main` has since moved to
+"delete `converter_models` + link the Kirchhoff converter-model library
+(`libKirchhoffApi.so`)"; because Kirchhoff and its AAS sibling are **not yet
+published**, a from-scratch build of newer `main` cannot obtain that library
+and **fails to link**.
+
+`CMakeLists.txt` therefore pins the MKF FetchContent to the last self-contained
+commit — `MKF_GIT_TAG=2ae859dcae6c3b2e5a128893247b7714360e863f`, the exact SHA
+the shipping `.so` was built from — and a configure-time guard fails loudly if
+the checkout drifts. A clean rebuild is reproducible as-is:
+
+```bash
+rm -rf build && pip install . --no-deps -v        # or: cmake -S . -B build && ninja -C build
+```
+
+To **advance** the pin you must first wire the Kirchhoff library build into
+`CMakeLists.txt` (publish AAS/Kirchhoff, then `add_subdirectory` +
+`target_link_libraries(... libKirchhoffApi.so)`). Overriding
+`-DMKF_GIT_TAG=main` before that lands will break the link.
+
 ### ⚠️ Import Instructions
 
 **Important:** The compiled extension module may require special import handling:

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/pyproject.toml

@@ -1,78 +1,78 @@
-[build-system]
-requires = ["scikit-build-core", "pybind11"]
-build-backend = "scikit_build_core.build"
-
-[project]
-name = "PyOpenMagnetics"
-version = "1.5.1"
-requires-python = ">=3.8"
-authors = [
-  { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },
-]
-description = "Python wrapper for OpenMagnetics"
-readme = "README.md"
-classifiers = [
-  "Development Status :: 4 - Beta",
-  "Programming Language :: Python :: 3",
-  "Operating System :: Microsoft :: Windows :: Windows 11",
-  "Operating System :: POSIX :: Linux",
-  "Programming Language :: C++",
-  "License :: OSI Approved :: MIT License",
-]
-
-[project.urls]
-Homepage = "https://openmagnetics.com"
-Repository = "https://github.com/OpenMagnetics/PyOpenMagnetics"
-Contact = "https://www.linkedin.com/in/alfonso-martinez-de-la-torre/"
-
-[tool.scikit-build]
-build-dir = "build/{wheel_tag}"
-cmake.verbose = true
-sdist.exclude = [".venv*", ".venv*/**", "build", "build/**", "dist", "dist/**", "*.egg-info", "__pycache__", "*.pyc"]
-# Include additional files in the wheel
-wheel.packages = ["."]
-wheel.install-dir = "PyOpenMagnetics"
-# Ensure AGENTS.md and llms.txt are included in sdist and wheel
-sdist.include = ["__init__.py", "AGENTS.md", "llms.txt", "PyOpenMagnetics.pyi"]
-
-[[tool.scikit-build.overrides]]
-if.platform-system = "^linux"
-# build.tool-args = ["-j8"]
-[[tool.scikit-build.overrides]]
-if.platform-system = "^win32"
-# build.tool-args = ["-maxcpucount:8"]
-
-[tool.cibuildwheel]
-skip=["pp*", "*-win32", "*mul*"]
-manylinux-x86_64-image = "manylinux_2_28"
-manylinux-aarch64-image = "manylinux_2_28"
-manylinux-ppc64le-image = "manylinux_2_28"
-manylinux-s390x-image = "manylinux_2_28"
-manylinux-pypy_x86_64-image = "manylinux_2_28"
-manylinux-pypy_aarch64-image = "manylinux_2_28"
-environment = { GIT_LFS_SKIP_SMUDGE=1 }
-build-verbosity = 1
-
-[tool.cibuildwheel.linux]
-before-all = [
-  "rm -rf /project/build /root/.cmake",
-  "dnf -y module reset nodejs",
-  "dnf -y module enable nodejs:20",
-  "dnf -y install nodejs npm",
-  "npm --version",
-  "npm install -g quicktype@23.0.170"
-]
-# Parallel level 2 (not 3): two large pybind11 TUs compiling at once stays
-# within the runner's RAM. Combined with dropping -g (see CMakeLists.txt),
-# this avoids the OOM that recycled the runner mid-compile (exit 143).
-environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="2" }
-
-[tool.cibuildwheel.macos]
-before-all = "npm --version && npm install -g quicktype@23.0.170"
-environment = { MACOSX_DEPLOYMENT_TARGET="14.0", GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="3" }
-
-[tool.cibuildwheel.windows]
-before-all = "rmdir /S /Q build && npm --version && npm install -g quicktype@23.0.170"
-archs = ["AMD64"]
-
-environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="2" }
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "PyOpenMagnetics"
+version = "1.6.0"
+requires-python = ">=3.8"
+authors = [
+  { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },
+]
+description = "Python wrapper for OpenMagnetics"
+readme = "README.md"
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python :: 3",
+  "Operating System :: Microsoft :: Windows :: Windows 11",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: C++",
+  "License :: OSI Approved :: MIT License",
+]
+
+[project.urls]
+Homepage = "https://openmagnetics.com"
+Repository = "https://github.com/OpenMagnetics/PyOpenMagnetics"
+Contact = "https://www.linkedin.com/in/alfonso-martinez-de-la-torre/"
+
+[tool.scikit-build]
+build-dir = "build/{wheel_tag}"
+cmake.verbose = true
+sdist.exclude = [".venv*", ".venv*/**", "build", "build/**", "dist", "dist/**", "*.egg-info", "__pycache__", "*.pyc"]
+# Include additional files in the wheel
+wheel.packages = ["."]
+wheel.install-dir = "PyOpenMagnetics"
+# Ensure AGENTS.md and llms.txt are included in sdist and wheel
+sdist.include = ["__init__.py", "AGENTS.md", "llms.txt", "PyOpenMagnetics.pyi"]
+
+[[tool.scikit-build.overrides]]
+if.platform-system = "^linux"
+# build.tool-args = ["-j8"]
+[[tool.scikit-build.overrides]]
+if.platform-system = "^win32"
+# build.tool-args = ["-maxcpucount:8"]
+
+[tool.cibuildwheel]
+skip=["pp*", "*-win32", "*mul*"]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+manylinux-ppc64le-image = "manylinux_2_28"
+manylinux-s390x-image = "manylinux_2_28"
+manylinux-pypy_x86_64-image = "manylinux_2_28"
+manylinux-pypy_aarch64-image = "manylinux_2_28"
+environment = { GIT_LFS_SKIP_SMUDGE=1 }
+build-verbosity = 1
+
+[tool.cibuildwheel.linux]
+before-all = [
+  "rm -rf /project/build /root/.cmake",
+  "dnf -y module reset nodejs",
+  "dnf -y module enable nodejs:20",
+  "dnf -y install nodejs npm",
+  "npm --version",
+  "npm install -g quicktype@23.0.170"
+]
+# Parallel level 2 (not 3): two large pybind11 TUs compiling at once stays
+# within the runner's RAM. Combined with dropping -g (see CMakeLists.txt),
+# this avoids the OOM that recycled the runner mid-compile (exit 143).
+environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="2" }
+
+[tool.cibuildwheel.macos]
+before-all = "npm --version && npm install -g quicktype@23.0.170"
+environment = { MACOSX_DEPLOYMENT_TARGET="14.0", GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="3" }
+
+[tool.cibuildwheel.windows]
+before-all = "rmdir /S /Q build && npm --version && npm install -g quicktype@23.0.170"
+archs = ["AMD64"]
+
+environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="2" }

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/src/advisers.cpp

@@ -104,6 +104,61 @@ json calculate_advised_magnetics(json inputsJson, int maximumNumberResults, json
     }
 }
 
+json calculate_advised_magnetics_with_filters(json inputsJson, json filterFlowJson, int maximumNumberResults, json coreModeJson) {
+    // FAST custom design driven by a CALLER-SUPPLIED filter flow: strictlyRequired
+    // filters (e.g. DC/EFFECTIVE_CURRENT_DENSITY, which the default custom flow
+    // omits) DROP any wound candidate that fails them, so designed windings are
+    // current-density gated while the fast path's loss ranking + core search are
+    // preserved. Exposes MagneticAdviser::get_advised_magnetic_fast(inputs, flow, n).
+    try {
+        OpenMagnetics::Inputs inputs(inputsJson);
+        OpenMagnetics::CoreAdviser::CoreAdviserModes coreMode;
+        from_json(coreModeJson, coreMode);
+
+        std::vector<OpenMagnetics::MagneticFilterOperation> filterFlow;
+        for (auto filterJson : filterFlowJson) {
+            OpenMagnetics::MagneticFilterOperation filter(filterJson);
+            filterFlow.push_back(filter);
+        }
+
+        OpenMagnetics::MagneticAdviser magneticAdviser;
+        magneticAdviser.set_core_mode(coreMode);
+        auto masMagnetics = magneticAdviser.get_advised_magnetic_fast(inputs, filterFlow, maximumNumberResults);
+
+        auto scoringsPerFilter = magneticAdviser.get_scorings();
+
+        json results = json();
+        results["data"] = json::array();
+        for (auto& [masMagnetic, scoring] : masMagnetics) {
+            std::string name = masMagnetic.get_magnetic().get_manufacturer_info().value().get_reference().value();
+            json result;
+            json masJson;
+            to_json(masJson, masMagnetic);
+            result["mas"] = masJson;
+            result["scoring"] = scoring;
+            if (scoringsPerFilter.count(name)) {
+                json filterScorings;
+                for (auto& [filter, filterScore] : scoringsPerFilter[name]) {
+                    filterScorings[std::string(magic_enum::enum_name(filter))] = filterScore;
+                }
+                result["scoringPerFilter"] = filterScorings;
+            }
+            results["data"].push_back(result);
+        }
+
+        sort(results["data"].begin(), results["data"].end(), [](json& b1, json& b2) {
+            return b1["scoring"] > b2["scoring"];
+        });
+
+        return results;
+    }
+    catch (const std::exception &exc) {
+        json exception;
+        exception["data"] = "Exception: " + std::string{exc.what()};
+        return exception;
+    }
+}
+
 json calculate_advised_magnetics_fast(json inputsJson, int maximumNumberResults, json coreModeJson) {
     try {
         OpenMagnetics::Inputs inputs(inputsJson);
@@ -391,7 +446,20 @@ void register_adviser_bindings(py::module& m) {
             ...     print(f"Score: {item['scoring']}, Per filter: {item['scoringPerFilter']}")
         )pbdoc",
         py::arg("inputs_json"), py::arg("max_results"), py::arg("core_mode_json"));
-    
+
+    m.def("calculate_advised_magnetics_with_filters", &calculate_advised_magnetics_with_filters,
+        R"pbdoc(
+        Fast custom magnetic design with a CALLER-SUPPLIED filter flow.
+
+        Like calculate_advised_magnetics_fast(), but strictlyRequired filters in
+        filter_flow_json DROP any wound candidate that fails them — e.g. add
+        DC_CURRENT_DENSITY / EFFECTIVE_CURRENT_DENSITY so designed windings are
+        current-density gated. Each filter op is
+        {"filter": <TitleCaseName>, "invert": bool, "log": bool,
+         "strictlyRequired": bool, "weight": float}.
+        )pbdoc",
+        py::arg("inputs_json"), py::arg("filter_flow_json"), py::arg("max_results"), py::arg("core_mode_json"));
+
     m.def("calculate_advised_magnetics_fast", &calculate_advised_magnetics_fast,
         R"pbdoc(
         Get recommended complete magnetic designs using fast analytical mode.

{pyopenmagnetics-1.5.1 → pyopenmagnetics-1.6.0}/src/advisers.h

@@ -9,6 +9,7 @@ json calculate_advised_cores(json inputsJson, json weightsJson, int maximumNumbe
 
 // Magnetic adviser
 json calculate_advised_magnetics(json inputsJson, int maximumNumberResults, json coreModeJson);
+json calculate_advised_magnetics_with_filters(json inputsJson, json filterFlowJson, int maximumNumberResults, json coreModeJson);
 json calculate_advised_magnetics_fast(json inputsJson, int maximumNumberResults, json coreModeJson);
 json calculate_advised_magnetics_from_catalog(json inputsJson, json catalogJson, int maximumNumberResults);
 json calculate_advised_magnetics_from_cache(json inputsJson, json filterFlowJson, int maximumNumberResults);

pyopenmagnetics-1.6.0/src/cmc.cpp

@@ -0,0 +1,67 @@
+#include "cmc.h"
+
+// The CMC design moved to Kirchhoff with the rest of the converter models (MKF 3e0261fd deleted
+// converter_models). This TU is a THIN shim over Kirchhoff::api::design_cmc — the string-in/JSON-out
+// facade of libKirchhoffApi.so — that re-shapes its {"inputs", "cmcDiagnostics"} result into the
+// legacy calculate_cmc_inputs contract El Choker and the WASM wizard consume: the MAS Inputs spread
+// at the ROOT plus a "cmcDiagnostics" sibling, or {"error": "..."} on failure (never a throw).
+// Only KirchhoffApi.hpp is included, so no Kirchhoff MAS type ever enters an MKF translation unit.
+
+#include "pybind11_json/pybind11_json.hpp"
+#include "json.hpp"
+#include <KirchhoffApi.hpp>
+
+#include <string>
+
+namespace py = pybind11;
+using json = nlohmann::json;
+
+namespace PyMKF {
+
+namespace {
+
+json cmc_inputs_via_kirchhoff(const json& cmcInputsJson, const char* functionName) {
+    const std::string out = Kirchhoff::api::design_cmc(cmcInputsJson.dump());
+    constexpr const char* kExceptionPrefix = "Exception: ";
+    if (out.rfind(kExceptionPrefix, 0) == 0) {
+        return json{{"error", std::string(functionName) + ": " +
+                              out.substr(std::string(kExceptionPrefix).size())}};
+    }
+    json parsed = json::parse(out);
+    // Legacy contract: the MAS Inputs at the root + the diagnostics as a sibling key.
+    json result = std::move(parsed.at("inputs"));
+    result["cmcDiagnostics"] = std::move(parsed.at("cmcDiagnostics"));
+    return result;
+}
+
+json calculate_cmc_inputs(json cmcInputsJson) {
+    return cmc_inputs_via_kirchhoff(cmcInputsJson, "calculate_cmc_inputs");
+}
+
+json calculate_advanced_cmc_inputs(json cmcInputsJson) {
+    // The advanced entry REQUIRES the pinned inductance (the legacy AdvancedCommonModeChoke ctor
+    // did j.at("desiredInductance")); Kirchhoff treats its presence as the mode switch.
+    if (!cmcInputsJson.contains("desiredInductance")) {
+        return json{{"error", "calculate_advanced_cmc_inputs: 'desiredInductance' is required"}};
+    }
+    return cmc_inputs_via_kirchhoff(cmcInputsJson, "calculate_advanced_cmc_inputs");
+}
+
+} // namespace
+
+void register_cmc_bindings(py::module& m) {
+    m.def("calculate_cmc_inputs", &calculate_cmc_inputs,
+        "Build MAS Inputs (designRequirements + operatingPoints) for a CMC from "
+        "wizard params (operatingVoltage, operatingCurrent, lineFrequency, "
+        "numberOfWindings, and an impedance/insertion-loss/noise spec). Mirrors "
+        "the WASM `calculate_cmc_inputs` used by el-choker's CMC wizard. "
+        "Delegates to Kirchhoff api::design_cmc.",
+        py::arg("cmc_inputs"));
+    m.def("calculate_advanced_cmc_inputs", &calculate_advanced_cmc_inputs,
+        "Advanced-mode CMC inputs builder (user supplies `desiredInductance` + "
+        "`designFrequency` directly rather than a spec). Delegates to Kirchhoff "
+        "api::design_cmc.",
+        py::arg("cmc_inputs"));
+}
+
+} // namespace PyMKF

pyopenmagnetics-1.6.0/src/cmc.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+namespace PyMKF {
+
+// Common-mode-choke bindings (calculate_cmc_inputs / calculate_advanced_cmc_inputs), re-pointed at
+// the Kirchhoff string API after the converter_models externalisation removed MKF's own
+// CommonModeChoke. Split out of converter.cpp (still excluded from the build) so El Choker's CMC
+// path works without re-enabling the whole legacy converter surface.
+void register_cmc_bindings(pybind11::module& m);
+
+} // namespace PyMKF