PyOpenMagnetics 1.1.3__tar.gz → 1.1.4__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "PyOpenMagnetics"
-version = "1.1.3"
+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.3 → 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