PyOpenMagnetics 1.1.2__tar.gz → 1.1.4__tar.gz

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: PyOpenMagnetics
-Version: 1.1.2
+Version: 1.1.4
 Summary: Python wrapper for OpenMagnetics
 Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
 Classifier: Development Status :: 4 - Beta
@@ -121,12 +121,13 @@ processed_inputs = PyOpenMagnetics.process_inputs(inputs)
 
 # Get magnetic recommendations
 # core_mode: "available cores" (stock cores) or "standard cores" (all standard shapes)
-magnetics = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "standard cores")
+result = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "standard cores")
 
-for i, mag in enumerate(magnetics):
-    if "magnetic" in mag:
-        core = mag["magnetic"]["core"]["functionalDescription"]
-        print(f"{i+1}. {core['shape']['name']} - {core['material']['name']}")
+# Result format: {"data": [{"mas": {...}, "scoring": float, "scoringPerFilter": {...}}, ...]}
+for i, item in enumerate(result["data"]):
+    mag = item["mas"]["magnetic"]
+    core = mag["core"]["functionalDescription"]
+    print(f"{i+1}. {core['shape']['name']} - {core['material']['name']} (score: {item['scoring']:.3f})")
 ```
 
 ### Calculate Core Losses

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/PyOpenMagnetics.pyi

@@ -505,6 +505,13 @@ def calculate_advised_cores(
         weights: {"EFFICIENCY": 1.0, "DIMENSIONS": 0.5, "COST": 0.3}.
         max_results: Maximum number of recommendations.
         core_mode: "STANDARD_CORES" or "AVAILABLE_CORES" (stock only).
+        
+    Returns:
+        JSON object with "data" array containing ranked results.
+        Each result has:
+        - "mas": Mas object with magnetic, inputs, and optionally outputs
+        - "scoring": Overall float score
+        - "scoringPerFilter": Object with individual scores per filter
     """
     ...
 
@@ -512,11 +519,27 @@ def calculate_advised_magnetics(
     inputs: Inputs,
     max_results: int = 5,
     core_mode: str = "STANDARD_CORES"
-) -> List[Mas]:
+) -> JsonDict:
     """Get complete magnetic designs (core + winding).
     
+    Args:
+        inputs: Processed inputs (from process_inputs).
+        max_results: Maximum number of recommendations.
+        core_mode: "STANDARD_CORES" or "AVAILABLE_CORES" (stock only).
+    
     Returns:
-        List of Mas objects with magnetic and outputs populated.
+        JSON object with "data" array containing ranked results.
+        Each result has:
+        - "mas": Mas object with magnetic, inputs, and optionally outputs
+        - "scoring": Overall float score
+        - "scoringPerFilter": Object with individual scores per filter
+          (e.g., {"COST": 0.8, "LOSSES": 0.9, "DIMENSIONS": 0.7})
+    
+    Example:
+        >>> result = PyOpenMagnetics.calculate_advised_magnetics(inputs, 5, "STANDARD_CORES")
+        >>> for item in result["data"]:
+        ...     mag = item["mas"]["magnetic"]
+        ...     print(f"Score: {item['scoring']}, Core: {mag['core']['functionalDescription']['shape']['name']}")
     """
     ...
 
@@ -524,8 +547,16 @@ def calculate_advised_magnetics_from_catalog(
     inputs: Inputs,
     catalog: List[Magnetic],
     max_results: int = 5
-) -> List[Mas]:
-    """Get designs from custom catalog of magnetics."""
+) -> JsonDict:
+    """Get designs from custom catalog of magnetics.
+    
+    Returns:
+        JSON object with "data" array containing ranked results.
+        Each result has:
+        - "mas": Mas object with magnetic data
+        - "scoring": Overall float score
+        - "scoringPerFilter": Object with individual scores per filter
+    """
     ...
 
 # =============================================================================

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/README.md

@@ -104,12 +104,13 @@ processed_inputs = PyOpenMagnetics.process_inputs(inputs)
 
 # Get magnetic recommendations
 # core_mode: "available cores" (stock cores) or "standard cores" (all standard shapes)
-magnetics = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "standard cores")
+result = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "standard cores")
 
-for i, mag in enumerate(magnetics):
-    if "magnetic" in mag:
-        core = mag["magnetic"]["core"]["functionalDescription"]
-        print(f"{i+1}. {core['shape']['name']} - {core['material']['name']}")
+# Result format: {"data": [{"mas": {...}, "scoring": float, "scoringPerFilter": {...}}, ...]}
+for i, item in enumerate(result["data"]):
+    mag = item["mas"]["magnetic"]
+    core = mag["core"]["functionalDescription"]
+    print(f"{i+1}. {core['shape']['name']} - {core['material']['name']} (score: {item['scoring']:.3f})")
 ```
 
 ### Calculate Core Losses

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/examples/README.md

@@ -60,17 +60,18 @@ inputs = {
 processed = PyOpenMagnetics.process_inputs(inputs)
 
 # 3. Get recommendations
-magnetics = PyOpenMagnetics.calculate_advised_magnetics(processed, 5, "STANDARD_CORES")
+result = PyOpenMagnetics.calculate_advised_magnetics(processed, 5, "STANDARD_CORES")
 
-# 4. Analyze results
-for mag in magnetics:
+# 4. Analyze results - result["data"] contains list of {mas, scoring, scoringPerFilter}
+for item in result["data"]:
+    mag = item["mas"]["magnetic"]
     losses = PyOpenMagnetics.calculate_core_losses(
-        mag["magnetic"]["core"],
-        mag["magnetic"]["coil"],
+        mag["core"],
+        mag["coil"],
         processed,
         {"coreLosses": "IGSE", "reluctance": "ZHANG"}
     )
-    print(f"Core losses: {losses['coreLosses']:.3f} W")
+    print(f"Core losses: {losses['coreLosses']:.3f} W, Score: {item['scoring']:.3f}")
 ```
 
 ## Additional Resources

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/examples/buck_inductor.py

@@ -104,12 +104,13 @@ def design_buck_inductor():
         "COST": 0.3
     }
     
-    magnetics = PyOpenMagnetics.calculate_advised_magnetics(
-        processed,
-        max_results=5,
-        core_mode="STANDARD_CORES"
+    result = PyOpenMagnetics.calculate_advised_magnetics(
+        processed, 5, "STANDARD_CORES"
     )
     
+    # Extract magnetics list from result (v1.1.2+ format: {"data": [...]})
+    magnetics = result["data"] if isinstance(result, dict) and "data" in result else result
+    
     print(f"  Found {len(magnetics)} suitable designs")
     
     # Analyze designs
@@ -121,8 +122,10 @@ def design_buck_inductor():
         "reluctance": "ZHANG"
     }
     
-    for i, mas in enumerate(magnetics[:3]):
-        if "magnetic" not in mas:
+    for i, item in enumerate(magnetics[:3]):
+        # In v1.1.2+, each item has "mas" containing the magnetic data
+        mas = item.get("mas", item) if isinstance(item, dict) else item
+        if not isinstance(mas, dict) or "magnetic" not in mas:
             continue
             
         magnetic = mas["magnetic"]

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/examples/flyback_design.py

@@ -107,12 +107,18 @@ def design_flyback_transformer():
         "COST": 0.3           # Tertiary: low cost
     }
     
-    magnetics = PyOpenMagnetics.calculate_advised_magnetics(
-        processed_inputs,
-        max_results=3,
-        core_mode="STANDARD_CORES"
+    result = PyOpenMagnetics.calculate_advised_magnetics(
+        processed_inputs, 3, "STANDARD_CORES"
     )
     
+    # Extract magnetics list from result (v1.1.2+ format: {"data": [...]})
+    # Note: If there's an error, data will be a string containing the exception message
+    data = result.get("data", result) if isinstance(result, dict) else result
+    if isinstance(data, str):
+        print(f"    ✗ Error: {data}")
+        return None
+    magnetics = data
+    
     print(f"    ✓ Found {len(magnetics)} suitable designs")
     
     # Step 4: Analyze top recommendations
@@ -125,8 +131,10 @@ def design_flyback_transformer():
         "coreTemperature": "MANIKTALA"
     }
     
-    for i, mas in enumerate(magnetics):
-        if "magnetic" not in mas:
+    for i, item in enumerate(magnetics):
+        # In v1.1.2+, each item has "mas" containing the magnetic data
+        mas = item.get("mas", item) if isinstance(item, dict) else item
+        if not isinstance(mas, dict) or "magnetic" not in mas:
             continue
             
         magnetic = mas["magnetic"]
@@ -154,6 +162,9 @@ def design_flyback_transformer():
         total_loss = core_loss + winding_loss
         
         print(f"\nDesign #{i+1}: {shape_name} / {material_name}")
+        # Show scoring if available (v1.1.2+)
+        if 'scoring' in item:
+            print(f"  Score:          {item['scoring']:.3f}")
         print(f"  Core losses:    {core_loss:.3f} W")
         print(f"  Winding losses: {winding_loss:.3f} W")
         print(f"  Total losses:   {total_loss:.3f} W")
@@ -167,7 +178,11 @@ def design_flyback_transformer():
     print("\n" + "=" * 60)
     print("Design complete! Best design is #1")
     
-    return magnetics[0] if magnetics else None
+    # Return the first item's mas for backward compatibility
+    if magnetics:
+        first_item = magnetics[0]
+        return first_item.get("mas", first_item) if isinstance(first_item, dict) else first_item
+    return None
 
 
 def explore_core_database():

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/llms.txt

@@ -368,21 +368,25 @@ cores = PyOpenMagnetics.calculate_advised_cores(
 )
 
 # Get complete magnetic designs
-magnetics = PyOpenMagnetics.calculate_advised_magnetics(
+result = PyOpenMagnetics.calculate_advised_magnetics(
     processed,
     max_results=5,
     core_mode="STANDARD_CORES"
 )
 
-# Each result contains complete Mas object:
-for mag in magnetics:
-    core_name = mag["magnetic"]["core"]["functionalDescription"]["shape"]["name"]
-    material = mag["magnetic"]["core"]["functionalDescription"]["material"]["name"]
+# Result structure: {"data": [{"mas": {...}, "scoring": float, "scoringPerFilter": {...}}, ...]}
+for item in result["data"]:
+    mag = item["mas"]["magnetic"]
+    core_name = mag["core"]["functionalDescription"]["shape"]["name"]
+    material = mag["core"]["functionalDescription"]["material"]["name"]
+    score = item["scoring"]
+    print(f"{core_name} - {material} (score: {score:.3f})")
     
 # From custom catalog
-catalog_results = PyOpenMagnetics.calculate_advised_magnetics_from_catalog(
+catalog_result = PyOpenMagnetics.calculate_advised_magnetics_from_catalog(
     processed, catalog_magnetics, max_results=5
 )
+# Same result structure as calculate_advised_magnetics
 ```
 
 ### Simulation
@@ -538,7 +542,8 @@ flyback = {
     "desiredTurnsRatios": [8.0, 19.2]        # N_pri/N_sec for each output
 }
 inputs = PyOpenMagnetics.process_flyback(flyback)
-magnetics = PyOpenMagnetics.calculate_advised_magnetics(inputs, 5, "STANDARD_CORES")
+result = PyOpenMagnetics.calculate_advised_magnetics(inputs, 5, "STANDARD_CORES")
+# Result format: {"data": [{"mas": {...}, "scoring": float, "scoringPerFilter": {...}}, ...]}
 ```
 
 ### Buck Converter (Non-Isolated Step-Down)

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/notebooks/02_buck_inductor.ipynb

@@ -153,20 +153,26 @@
     "# Get magnetic design recommendations\n",
     "print(\"\\nSearching for optimal designs...\")\n",
     "try:\n",
-    "    magnetics = PyOpenMagnetics.calculate_advised_magnetics(\n",
+    "    result = PyOpenMagnetics.calculate_advised_magnetics(\n",
     "        processed,\n",
     "        max_results=5,\n",
     "        core_mode=\"STANDARD_CORES\"\n",
     "    )\n",
     "    \n",
+    "    # Extract magnetics list from result (v1.1.2+ format: {\"data\": [...]})\n",
+    "    magnetics = result[\"data\"] if isinstance(result, dict) and \"data\" in result else result\n",
+    "    \n",
     "    print(f\"\\nFound {len(magnetics)} suitable designs:\")\n",
-    "    for i, result in enumerate(magnetics[:5]):\n",
-    "        if 'magnetic' in result:\n",
-    "            magnetic = result['magnetic']\n",
+    "    for i, item in enumerate(magnetics[:5]):\n",
+    "        # In v1.1.2+, each item has \"mas\" containing the magnetic data\n",
+    "        mas = item.get(\"mas\", item) if isinstance(item, dict) else item\n",
+    "        if isinstance(mas, dict) and 'magnetic' in mas:\n",
+    "            magnetic = mas['magnetic']\n",
     "            core = magnetic['core']['functionalDescription']\n",
     "            shape_name = core['shape']['name'] if isinstance(core['shape'], dict) else core['shape']\n",
     "            mat_name = core['material']['name'] if isinstance(core['material'], dict) else core['material']\n",
-    "            print(f\"  {i+1}. {shape_name} / {mat_name}\")\n",
+    "            score = item.get('scoring', 'N/A')\n",
+    "            print(f\"  {i+1}. {shape_name} / {mat_name} (score: {score})\")\n",
     "except Exception as e:\n",
     "    print(f\"Adviser error (may need more compute time): {e}\")"
    ]
@@ -236,9 +242,14 @@
     "    if 'magnetics' in dir() and len(magnetics) > 0:\n",
     "        print(\"=== Best Design Analysis ===\\n\")\n",
     "        \n",
-    "        best = magnetics[0]\n",
-    "        if 'magnetic' in best:\n",
-    "            magnetic = best['magnetic']\n",
+    "        # Get best result (first in the list)\n",
+    "        best_item = magnetics[0]\n",
+    "        \n",
+    "        # In v1.1.2+, each item has \"mas\" containing the magnetic data\n",
+    "        best_mas = best_item.get(\"mas\", best_item) if isinstance(best_item, dict) else best_item\n",
+    "        \n",
+    "        if isinstance(best_mas, dict) and 'magnetic' in best_mas:\n",
+    "            magnetic = best_mas['magnetic']\n",
     "            core_fd = magnetic['core']['functionalDescription']\n",
     "            \n",
     "            # Extract shape and material names\n",
@@ -248,6 +259,10 @@
     "            print(f\"Shape: {shape}\")\n",
     "            print(f\"Material: {material}\")\n",
     "            \n",
+    "            # Show scoring if available (v1.1.2+)\n",
+    "            if 'scoring' in best_item:\n",
+    "                print(f\"Score: {best_item['scoring']:.3f}\")\n",
+    "            \n",
     "            # Check gapping\n",
     "            gapping = core_fd.get('gapping', [])\n",
     "            total_gap = sum(g.get('length', 0) for g in gapping) * 1000\n",
@@ -263,8 +278,8 @@
     "                        print(f\"  Parallels: {winding.get('numberParallels', 1)}\")\n",
     "            \n",
     "            # Show outputs if available\n",
-    "            if 'outputs' in best:\n",
-    "                outputs = best['outputs']\n",
+    "            if 'outputs' in best_mas:\n",
+    "                outputs = best_mas['outputs']\n",
     "                print(f\"\\nSimulation Results:\")\n",
     "                if 'coreLosses' in outputs:\n",
     "                    print(f\"  Core losses: {outputs['coreLosses']:.3f} W\")\n",

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "PyOpenMagnetics"
-version = "1.1.2"
+version = "1.1.4"
 requires-python = ">=3.8"
 authors = [
   { name="Alfonso Martinez", email="Alfonso_VII@hotmail.com" },
@@ -56,11 +56,13 @@ before-all = [
   "npm --version",
   "npm install -g quicktype@23.0.170"
 ]
+environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="4" }
 
 [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 }
+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"]
+archs = ["AMD64"]
+environment = { GIT_LFS_SKIP_SMUDGE=1, CMAKE_BUILD_PARALLEL_LEVEL="2" }

pyopenmagnetics-1.1.4/src/logging.cpp

@@ -0,0 +1,191 @@
+#include "logging.h"
+
+// On Windows, ERROR is defined as a macro in windows.h/wingdi.h
+// We need to undef it to use LogLevel::ERROR without macro expansion issues
+#ifdef ERROR
+#undef ERROR
+#endif
+
+namespace PyMKF {
+
+// Static shared pointer to the string sink for capturing logs
+static std::shared_ptr<OpenMagnetics::StringSink> stringSink = nullptr;
+
+OpenMagnetics::LogLevel parse_log_level(const std::string& level) {
+    if (level == "TRACE" || level == "trace") return OpenMagnetics::LogLevel::TRACE;
+    if (level == "DEBUG" || level == "debug") return OpenMagnetics::LogLevel::DEBUG;
+    if (level == "INFO" || level == "info") return OpenMagnetics::LogLevel::INFO;
+    if (level == "WARNING" || level == "warning") return OpenMagnetics::LogLevel::WARNING;
+    if (level == "ERROR" || level == "error") return OpenMagnetics::LogLevel::ERROR;
+    if (level == "CRITICAL" || level == "critical") return OpenMagnetics::LogLevel::CRITICAL;
+    if (level == "OFF" || level == "off") return OpenMagnetics::LogLevel::OFF;
+    throw std::invalid_argument("Invalid log level: " + level + ". Valid levels: TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL, OFF");
+}
+
+void set_log_level(std::string level) {
+    auto& logger = OpenMagnetics::Logger::getInstance();
+    logger.setLevel(parse_log_level(level));
+}
+
+std::string get_log_level() {
+    auto& logger = OpenMagnetics::Logger::getInstance();
+    return OpenMagnetics::to_string(logger.getLevel());
+}
+
+void enable_string_sink() {
+    auto& logger = OpenMagnetics::Logger::getInstance();
+    if (!stringSink) {
+        stringSink = std::make_shared<OpenMagnetics::StringSink>();
+        logger.addSink(stringSink);
+    }
+}
+
+void disable_string_sink() {
+    if (stringSink) {
+        // Clear and reset the string sink
+        // Note: We can't remove sinks individually, so we just clear it
+        stringSink->clear();
+        stringSink = nullptr;
+        // Reinitialize logger with default console sink
+        auto& logger = OpenMagnetics::Logger::getInstance();
+        logger.clearSinks();
+        logger.addSink(std::make_shared<OpenMagnetics::ConsoleSink>());
+    }
+}
+
+std::string get_logs() {
+    if (stringSink) {
+        return stringSink->getContents();
+    }
+    return "";
+}
+
+void clear_logs() {
+    if (stringSink) {
+        stringSink->clear();
+    }
+}
+
+void log_message(std::string level, std::string message, std::string module) {
+    auto& logger = OpenMagnetics::Logger::getInstance();
+    logger.log(parse_log_level(level), module, message);
+}
+
+void register_logging_bindings(py::module& m) {
+    m.def("set_log_level", &set_log_level,
+        py::arg("level"),
+        R"pbdoc(
+        Set the minimum log level for the MKF logger.
+        
+        Messages below this level will be ignored. The logger uses a 
+        severity-based filtering system.
+        
+        Args:
+            level: The minimum log level. One of:
+                - "TRACE": Most detailed, for debugging internals
+                - "DEBUG": Debug information
+                - "INFO": General information
+                - "WARNING": Warning messages
+                - "ERROR": Error messages
+                - "CRITICAL": Critical errors
+                - "OFF": Disable all logging
+        
+        Example:
+            >>> PyOpenMagnetics.set_log_level("DEBUG")
+            >>> PyOpenMagnetics.set_log_level("WARNING")
+        )pbdoc");
+    
+    m.def("get_log_level", &get_log_level,
+        R"pbdoc(
+        Get the current minimum log level.
+        
+        Returns:
+            String representation of the current log level
+            (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL, or OFF).
+        
+        Example:
+            >>> level = PyOpenMagnetics.get_log_level()
+            >>> print(level)  # e.g., "ERROR"
+        )pbdoc");
+    
+    m.def("enable_string_sink", &enable_string_sink,
+        R"pbdoc(
+        Enable capturing logs to an in-memory string buffer.
+        
+        This is useful for testing or programmatic access to log messages.
+        Logs can be retrieved using get_logs() and cleared using clear_logs().
+        
+        Note: The string sink is added in addition to the default console sink.
+        
+        Example:
+            >>> PyOpenMagnetics.enable_string_sink()
+            >>> PyOpenMagnetics.set_log_level("DEBUG")
+            >>> # ... perform operations that generate logs ...
+            >>> logs = PyOpenMagnetics.get_logs()
+        )pbdoc");
+    
+    m.def("disable_string_sink", &disable_string_sink,
+        R"pbdoc(
+        Disable the in-memory string sink and reset to console-only logging.
+        
+        This clears any captured logs and removes the string sink,
+        restoring the default console-only logging behavior.
+        )pbdoc");
+    
+    m.def("get_logs", &get_logs,
+        R"pbdoc(
+        Get all captured log messages from the string sink.
+        
+        Returns the contents of the in-memory log buffer. Requires
+        enable_string_sink() to have been called first.
+        
+        Returns:
+            String containing all captured log messages, or empty string
+            if string sink is not enabled.
+        
+        Example:
+            >>> PyOpenMagnetics.enable_string_sink()
+            >>> PyOpenMagnetics.set_log_level("INFO")
+            >>> # ... perform operations ...
+            >>> logs = PyOpenMagnetics.get_logs()
+            >>> print(logs)
+        )pbdoc");
+    
+    m.def("clear_logs", &clear_logs,
+        R"pbdoc(
+        Clear all captured log messages from the string sink.
+        
+        Empties the in-memory log buffer without disabling the string sink.
+        Useful for clearing logs between test cases.
+        
+        Example:
+            >>> PyOpenMagnetics.enable_string_sink()
+            >>> # ... perform some operations ...
+            >>> PyOpenMagnetics.clear_logs()  # Start fresh
+            >>> # ... perform more operations ...
+            >>> logs = PyOpenMagnetics.get_logs()  # Only new logs
+        )pbdoc");
+    
+    m.def("log_message", &log_message,
+        py::arg("level"),
+        py::arg("message"),
+        py::arg("module") = "",
+        R"pbdoc(
+        Log a message at the specified level.
+        
+        This allows Python code to log messages through the MKF logging
+        system, which can be useful for unified logging in mixed
+        Python/C++ workflows.
+        
+        Args:
+            level: Log level (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            message: The message to log
+            module: Optional module name for categorization
+        
+        Example:
+            >>> PyOpenMagnetics.log_message("INFO", "Starting calculation")
+            >>> PyOpenMagnetics.log_message("DEBUG", "Value computed", "MyModule")
+        )pbdoc");
+}
+
+} // namespace PyMKF

pyopenmagnetics-1.1.4/src/logging.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "common.h"
+#include "support/Logger.h"
+
+namespace PyMKF {
+
+// Logging functions
+void set_log_level(std::string level);
+std::string get_log_level();
+void enable_string_sink();
+void disable_string_sink();
+std::string get_logs();
+void clear_logs();
+void log_message(std::string level, std::string message, std::string module = "");
+
+void register_logging_bindings(py::module& m);
+
+} // namespace PyMKF

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/src/module.cpp

@@ -10,6 +10,7 @@
 #include "plotting.h"
 #include "settings.h"
 #include "utils.h"
+#include "logging.h"
 
 PYBIND11_MODULE(PyOpenMagnetics, m) {
     m.doc() = "OpenMagnetics Python bindings for magnetic component design";
@@ -26,4 +27,5 @@ PYBIND11_MODULE(PyOpenMagnetics, m) {
     PyMKF::register_plotting_bindings(m);
     PyMKF::register_settings_bindings(m);
     PyMKF::register_utils_bindings(m);
+    PyMKF::register_logging_bindings(m);
 }

pyopenmagnetics-1.1.4/tests/test_logging.py

@@ -0,0 +1,259 @@
+"""
+Tests for PyOpenMagnetics logging functionality.
+
+These tests verify that the MKF logger is properly exposed in PyMKF
+and that verbosity levels and log capture work correctly.
+"""
+import pytest
+import PyOpenMagnetics
+
+
+class TestLogLevel:
+    """Tests for log level get/set functionality."""
+    
+    def test_get_default_log_level(self):
+        """Default log level should be ERROR."""
+        # Reset to ensure default state
+        PyOpenMagnetics.disable_string_sink()
+        level = PyOpenMagnetics.get_log_level()
+        assert level == "ERROR"
+    
+    def test_set_log_level_debug(self):
+        """Should be able to set log level to DEBUG."""
+        PyOpenMagnetics.set_log_level("DEBUG")
+        assert PyOpenMagnetics.get_log_level() == "DEBUG"
+    
+    def test_set_log_level_info(self):
+        """Should be able to set log level to INFO."""
+        PyOpenMagnetics.set_log_level("INFO")
+        assert PyOpenMagnetics.get_log_level() == "INFO"
+    
+    def test_set_log_level_warning(self):
+        """Should be able to set log level to WARNING."""
+        PyOpenMagnetics.set_log_level("WARNING")
+        assert PyOpenMagnetics.get_log_level() == "WARNING"
+    
+    def test_set_log_level_error(self):
+        """Should be able to set log level to ERROR."""
+        PyOpenMagnetics.set_log_level("ERROR")
+        assert PyOpenMagnetics.get_log_level() == "ERROR"
+    
+    def test_set_log_level_critical(self):
+        """Should be able to set log level to CRITICAL."""
+        PyOpenMagnetics.set_log_level("CRITICAL")
+        assert PyOpenMagnetics.get_log_level() == "CRITICAL"
+    
+    def test_set_log_level_trace(self):
+        """Should be able to set log level to TRACE."""
+        PyOpenMagnetics.set_log_level("TRACE")
+        assert PyOpenMagnetics.get_log_level() == "TRACE"
+    
+    def test_set_log_level_off(self):
+        """Should be able to disable logging with OFF."""
+        PyOpenMagnetics.set_log_level("OFF")
+        assert PyOpenMagnetics.get_log_level() == "OFF"
+    
+    def test_set_log_level_lowercase(self):
+        """Log level should accept lowercase input."""
+        PyOpenMagnetics.set_log_level("debug")
+        assert PyOpenMagnetics.get_log_level() == "DEBUG"
+    
+    def test_set_invalid_log_level(self):
+        """Invalid log level should raise an exception."""
+        with pytest.raises(Exception) as exc_info:
+            PyOpenMagnetics.set_log_level("INVALID")
+        assert "Invalid log level" in str(exc_info.value)
+
+
+class TestStringSink:
+    """Tests for capturing logs to string buffer."""
+    
+    def setup_method(self):
+        """Reset logging state before each test."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.set_log_level("ERROR")
+    
+    def teardown_method(self):
+        """Clean up after each test."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.set_log_level("ERROR")
+    
+    def test_enable_string_sink(self):
+        """Should be able to enable string sink."""
+        PyOpenMagnetics.enable_string_sink()
+        # Should not raise
+        logs = PyOpenMagnetics.get_logs()
+        assert logs == ""  # Initially empty
+    
+    def test_get_logs_without_sink(self):
+        """get_logs should return empty string when sink not enabled."""
+        PyOpenMagnetics.disable_string_sink()
+        logs = PyOpenMagnetics.get_logs()
+        assert logs == ""
+    
+    def test_clear_logs(self):
+        """Should be able to clear captured logs."""
+        PyOpenMagnetics.enable_string_sink()
+        PyOpenMagnetics.set_log_level("INFO")
+        PyOpenMagnetics.log_message("INFO", "Test message")
+        
+        logs_before = PyOpenMagnetics.get_logs()
+        assert "Test message" in logs_before
+        
+        PyOpenMagnetics.clear_logs()
+        logs_after = PyOpenMagnetics.get_logs()
+        assert logs_after == ""
+    
+    def test_disable_string_sink(self):
+        """Should be able to disable string sink."""
+        PyOpenMagnetics.enable_string_sink()
+        PyOpenMagnetics.set_log_level("INFO")
+        PyOpenMagnetics.log_message("INFO", "Test message")
+        
+        PyOpenMagnetics.disable_string_sink()
+        # After disabling, get_logs should return empty
+        logs = PyOpenMagnetics.get_logs()
+        assert logs == ""
+
+
+class TestLogMessage:
+    """Tests for logging messages from Python."""
+    
+    def setup_method(self):
+        """Set up string sink for capturing logs."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.enable_string_sink()
+        PyOpenMagnetics.set_log_level("TRACE")
+        PyOpenMagnetics.clear_logs()
+    
+    def teardown_method(self):
+        """Clean up after each test."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.set_log_level("ERROR")
+    
+    def test_log_info_message(self):
+        """Should capture INFO level messages."""
+        PyOpenMagnetics.log_message("INFO", "Test info message")
+        logs = PyOpenMagnetics.get_logs()
+        assert "INFO" in logs
+        assert "Test info message" in logs
+    
+    def test_log_debug_message(self):
+        """Should capture DEBUG level messages."""
+        PyOpenMagnetics.log_message("DEBUG", "Debug details")
+        logs = PyOpenMagnetics.get_logs()
+        assert "DEBUG" in logs
+        assert "Debug details" in logs
+    
+    def test_log_warning_message(self):
+        """Should capture WARNING level messages."""
+        PyOpenMagnetics.log_message("WARNING", "Warning occurred")
+        logs = PyOpenMagnetics.get_logs()
+        assert "WARNING" in logs
+        assert "Warning occurred" in logs
+    
+    def test_log_error_message(self):
+        """Should capture ERROR level messages."""
+        PyOpenMagnetics.log_message("ERROR", "An error happened")
+        logs = PyOpenMagnetics.get_logs()
+        assert "ERROR" in logs
+        assert "An error happened" in logs
+    
+    def test_log_with_module_name(self):
+        """Should include module name in log output."""
+        PyOpenMagnetics.log_message("INFO", "Module test", "MyTestModule")
+        logs = PyOpenMagnetics.get_logs()
+        assert "MyTestModule" in logs
+        assert "Module test" in logs
+    
+    def test_log_filtering_by_level(self):
+        """Messages below current level should be filtered."""
+        PyOpenMagnetics.set_log_level("WARNING")
+        PyOpenMagnetics.clear_logs()
+        
+        PyOpenMagnetics.log_message("DEBUG", "Debug should be filtered")
+        PyOpenMagnetics.log_message("INFO", "Info should be filtered")
+        PyOpenMagnetics.log_message("WARNING", "Warning should appear")
+        PyOpenMagnetics.log_message("ERROR", "Error should appear")
+        
+        logs = PyOpenMagnetics.get_logs()
+        assert "Debug should be filtered" not in logs
+        assert "Info should be filtered" not in logs
+        assert "Warning should appear" in logs
+        assert "Error should appear" in logs
+    
+    def test_log_off_filters_all(self):
+        """OFF level should filter all messages."""
+        PyOpenMagnetics.set_log_level("OFF")
+        PyOpenMagnetics.clear_logs()
+        
+        PyOpenMagnetics.log_message("CRITICAL", "Critical message")
+        PyOpenMagnetics.log_message("ERROR", "Error message")
+        
+        logs = PyOpenMagnetics.get_logs()
+        assert logs == ""
+
+
+class TestLogTimestamp:
+    """Tests for log timestamp formatting."""
+    
+    def setup_method(self):
+        """Set up string sink for capturing logs."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.enable_string_sink()
+        PyOpenMagnetics.set_log_level("INFO")
+        PyOpenMagnetics.clear_logs()
+    
+    def teardown_method(self):
+        """Clean up after each test."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.set_log_level("ERROR")
+    
+    def test_log_has_timestamp(self):
+        """Log messages should include timestamp."""
+        PyOpenMagnetics.log_message("INFO", "Timestamp test")
+        logs = PyOpenMagnetics.get_logs()
+        # Timestamp format: [YYYY-MM-DD HH:MM:SS.mmm]
+        import re
+        timestamp_pattern = r'\[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}\]'
+        assert re.search(timestamp_pattern, logs), f"Expected timestamp in logs: {logs}"
+
+
+class TestMultipleLogMessages:
+    """Tests for multiple sequential log messages."""
+    
+    def setup_method(self):
+        """Set up string sink for capturing logs."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.enable_string_sink()
+        PyOpenMagnetics.set_log_level("DEBUG")
+        PyOpenMagnetics.clear_logs()
+    
+    def teardown_method(self):
+        """Clean up after each test."""
+        PyOpenMagnetics.disable_string_sink()
+        PyOpenMagnetics.set_log_level("ERROR")
+    
+    def test_multiple_messages_captured(self):
+        """Multiple log messages should all be captured."""
+        PyOpenMagnetics.log_message("INFO", "First message")
+        PyOpenMagnetics.log_message("DEBUG", "Second message")
+        PyOpenMagnetics.log_message("WARNING", "Third message")
+        
+        logs = PyOpenMagnetics.get_logs()
+        assert "First message" in logs
+        assert "Second message" in logs
+        assert "Third message" in logs
+    
+    def test_messages_in_order(self):
+        """Log messages should appear in chronological order."""
+        PyOpenMagnetics.log_message("INFO", "AAA_FIRST")
+        PyOpenMagnetics.log_message("INFO", "BBB_SECOND")
+        PyOpenMagnetics.log_message("INFO", "CCC_THIRD")
+        
+        logs = PyOpenMagnetics.get_logs()
+        pos_first = logs.find("AAA_FIRST")
+        pos_second = logs.find("BBB_SECOND")
+        pos_third = logs.find("CCC_THIRD")
+        
+        assert pos_first < pos_second < pos_third

{pyopenmagnetics-1.1.2 → pyopenmagnetics-1.1.4}/tests/test_magnetic_adviser.py

@@ -17,6 +17,19 @@ def parse_json_result(result):
     return result
 
 
+def extract_magnetics_list(result):
+    """
+    Extract list of magnetics from result.
+    
+    In version 1.1.2+, the function returns {"data": [{"mas": {...}, "scoring": ..., ...}, ...]}
+    In version 1.1.0, it returned a list directly.
+    """
+    parsed = parse_json_result(result)
+    if isinstance(parsed, dict) and "data" in parsed:
+        return parsed["data"]
+    return parsed
+
+
 class TestMagneticAdviserBasic:
     """
     Basic magnetic adviser tests.
@@ -32,7 +45,7 @@ class TestMagneticAdviserBasic:
         
         # API: calculate_advised_magnetics(inputs, max_results, core_mode)
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
         # Should return some results
@@ -45,15 +58,16 @@ class TestMagneticAdviserBasic:
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 3, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         if len(results) > 0:
             for result in results:
                 assert isinstance(result, dict)
-                # Each result should be a valid Mas with magnetic
-                # The Mas structure should contain magnetic, inputs, and optionally outputs
-                if "magnetic" in result:
-                    assert "core" in result["magnetic"] or "coil" in result["magnetic"]
+                # Each result should have "mas" containing the magnetic data (v1.1.2+ format)
+                # or "magnetic" directly (v1.1.0 format)
+                mas = result.get("mas", result)
+                if isinstance(mas, dict) and "magnetic" in mas:
+                    assert "core" in mas["magnetic"] or "coil" in mas["magnetic"]
 
 
 class TestMagneticAdviserCoreModes:
@@ -70,7 +84,7 @@ class TestMagneticAdviserCoreModes:
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -82,7 +96,7 @@ class TestMagneticAdviserCoreModes:
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "standard cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -95,7 +109,7 @@ class TestMagneticAdviserInputTypes:
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -108,7 +122,7 @@ class TestMagneticAdviserInputTypes:
         processed_inputs = PyOpenMagnetics.process_inputs(transformer_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -121,7 +135,7 @@ class TestMagneticAdviserInputTypes:
         processed_inputs = PyOpenMagnetics.process_inputs(high_frequency_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -134,7 +148,7 @@ class TestMagneticAdviserInputTypes:
         processed_inputs = PyOpenMagnetics.process_inputs(flyback_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert isinstance(results, list)
 
@@ -149,10 +163,10 @@ class TestMagneticAdviserFiltering:
         """
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
-        results_5 = parse_json_result(
+        results_5 = extract_magnetics_list(
             PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 5, "available cores")
         )
-        results_2 = parse_json_result(
+        results_2 = extract_magnetics_list(
             PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 2, "available cores")
         )
         
@@ -167,7 +181,7 @@ class TestMagneticAdviserFiltering:
         processed_inputs = PyOpenMagnetics.process_inputs(inductor_inputs)
         
         result_json = PyOpenMagnetics.calculate_advised_magnetics(processed_inputs, 1, "available cores")
-        results = parse_json_result(result_json)
+        results = extract_magnetics_list(result_json)
         
         assert len(results) <= 1