PyOpenMagnetics 1.1.0__cp311-cp311-win_amd64.whl

include/pybind11_json/pybind11_json.hpp

@@ -0,0 +1,249 @@
+/***************************************************************************
+* Copyright (c) 2019, Martin Renou                                         *
+*                                                                          *
+* Distributed under the terms of the BSD 3-Clause License.                 *
+*                                                                          *
+* The full license is in the file LICENSE, distributed with this software. *
+****************************************************************************/
+
+#ifndef PYBIND11_JSON_HPP
+#define PYBIND11_JSON_HPP
+
+#include <set>
+#include <string>
+#include <vector>
+
+#include "nlohmann/json.hpp"
+
+#include "pybind11/pybind11.h"
+
+namespace py = pybind11;
+namespace nl = nlohmann;
+
+namespace pyjson
+{
+    inline py::object from_json(const nl::json& j)
+    {
+        if (j.is_null())
+        {
+            return py::none();
+        }
+        else if (j.is_boolean())
+        {
+            return py::bool_(j.get<bool>());
+        }
+        else if (j.is_number_unsigned())
+        {
+            return py::int_(j.get<nl::json::number_unsigned_t>());
+        }
+        else if (j.is_number_integer())
+        {
+            return py::int_(j.get<nl::json::number_integer_t>());
+        }
+        else if (j.is_number_float())
+        {
+            return py::float_(j.get<double>());
+        }
+        else if (j.is_string())
+        {
+            return py::str(j.get<std::string>());
+        }
+        else if (j.is_array())
+        {
+            py::list obj(j.size());
+            for (std::size_t i = 0; i < j.size(); i++)
+            {
+                obj[i] = from_json(j[i]);
+            }
+            return obj;
+        }
+        else // Object
+        {
+            py::dict obj;
+            for (nl::json::const_iterator it = j.cbegin(); it != j.cend(); ++it)
+            {
+                obj[py::str(it.key())] = from_json(it.value());
+            }
+            return obj;
+        }
+    }
+
+    inline nl::json to_json(const py::handle& obj, std::set<const PyObject*>& refs)
+    {
+        if (obj.ptr() == nullptr || obj.is_none())
+        {
+            return nullptr;
+        }
+        if (py::isinstance<py::bool_>(obj))
+        {
+            return obj.cast<bool>();
+        }
+        if (py::isinstance<py::int_>(obj))
+        {
+            try
+            {
+                nl::json::number_integer_t s = obj.cast<nl::json::number_integer_t>();
+                if (py::int_(s).equal(obj))
+                {
+                    return s;
+                }
+            }
+            catch (...)
+            {
+            }
+            try
+            {
+                nl::json::number_unsigned_t u = obj.cast<nl::json::number_unsigned_t>();
+                if (py::int_(u).equal(obj))
+                {
+                    return u;
+                }
+            }
+            catch (...)
+            {
+            }
+            throw std::runtime_error("to_json received an integer out of range for both nl::json::number_integer_t and nl::json::number_unsigned_t type: " + py::repr(obj).cast<std::string>());
+        }
+        if (py::isinstance<py::float_>(obj))
+        {
+            return obj.cast<double>();
+        }
+        if (py::isinstance<py::bytes>(obj))
+        {
+            py::module base64 = py::module::import("base64");
+            return base64.attr("b64encode")(obj).attr("decode")("utf-8").cast<std::string>();
+        }
+        if (py::isinstance<py::str>(obj))
+        {
+            return obj.cast<std::string>();
+        }
+        if (py::isinstance<py::tuple>(obj) || py::isinstance<py::list>(obj))
+        {
+            auto insert_ret = refs.insert(obj.ptr());
+            if (!insert_ret.second) {
+                throw std::runtime_error("Circular reference detected");
+            }
+
+            auto out = nl::json::array();
+            for (const py::handle value : obj)
+            {
+                out.push_back(to_json(value, refs));
+            }
+
+            refs.erase(insert_ret.first);
+
+            return out;
+        }
+        if (py::isinstance<py::dict>(obj))
+        {
+            auto insert_ret = refs.insert(obj.ptr());
+            if (!insert_ret.second) {
+                throw std::runtime_error("Circular reference detected");
+            }
+
+            auto out = nl::json::object();
+            for (const py::handle key : obj)
+            {
+                out[py::str(key).cast<std::string>()] = to_json(obj[key], refs);
+            }
+
+            refs.erase(insert_ret.first);
+
+            return out;
+        }
+
+        throw std::runtime_error("to_json not implemented for this type of object: " + py::repr(obj).cast<std::string>());
+    }
+
+    inline nl::json to_json(const py::handle& obj)
+    {
+        std::set<const PyObject*> refs;
+        return to_json(obj, refs);
+    }
+
+}
+
+// nlohmann_json serializers
+namespace nlohmann
+{
+    #define MAKE_NLJSON_SERIALIZER_DESERIALIZER(T)         \
+    template <>                                            \
+    struct adl_serializer<T>                               \
+    {                                                      \
+        inline static void to_json(json& j, const T& obj)  \
+        {                                                  \
+            j = pyjson::to_json(obj);                      \
+        }                                                  \
+                                                           \
+        inline static T from_json(const json& j)           \
+        {                                                  \
+            return pyjson::from_json(j);                   \
+        }                                                  \
+    }
+
+    #define MAKE_NLJSON_SERIALIZER_ONLY(T)                 \
+    template <>                                            \
+    struct adl_serializer<T>                               \
+    {                                                      \
+        inline static void to_json(json& j, const T& obj)  \
+        {                                                  \
+            j = pyjson::to_json(obj);                      \
+        }                                                  \
+    }
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::object);
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::bool_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::int_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::float_);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::str);
+
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::list);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::tuple);
+    MAKE_NLJSON_SERIALIZER_DESERIALIZER(py::dict);
+
+    MAKE_NLJSON_SERIALIZER_ONLY(py::handle);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::item_accessor);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::list_accessor);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::tuple_accessor);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::sequence_accessor);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::str_attr_accessor);
+    MAKE_NLJSON_SERIALIZER_ONLY(py::detail::obj_attr_accessor);
+
+    #undef MAKE_NLJSON_SERIALIZER
+    #undef MAKE_NLJSON_SERIALIZER_ONLY
+}
+
+// pybind11 caster
+namespace pybind11
+{
+    namespace detail
+    {
+        template <> struct type_caster<nl::json>
+        {
+        public:
+            PYBIND11_TYPE_CASTER(nl::json, _("json"));
+
+            bool load(handle src, bool)
+            {
+                try
+                {
+                    value = pyjson::to_json(src);
+                    return true;
+                }
+                catch (...)
+                {
+                    return false;
+                }
+            }
+
+            static handle cast(nl::json src, return_value_policy /* policy */, handle /* parent */)
+            {
+                object obj = pyjson::from_json(src);
+                return obj.release();
+            }
+        };
+    }
+}
+
+#endif

pyopenmagnetics-1.1.0.dist-info/METADATA

@@ -0,0 +1,373 @@
+Metadata-Version: 2.2
+Name: PyOpenMagnetics
+Version: 1.1.0
+Summary: Python wrapper for OpenMagnetics
+Author-Email: Alfonso Martinez <Alfonso_VII@hotmail.com>
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Project-URL: Homepage, https://openmagnetics.com
+Project-URL: Repository, https://github.com/OpenMagnetics/PyOpenMagnetics
+Project-URL: Contact, https://www.linkedin.com/in/alfonso-martinez-de-la-torre/
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# PyOpenMagnetics - Python Wrapper for OpenMagnetics
+
+[![Python](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**PyOpenMagnetics** is a Python wrapper for [MKF (Magnetics Knowledge Foundation)](https://github.com/OpenMagnetics/MKF), the simulation engine of [OpenMagnetics](https://github.com/OpenMagnetics), providing a comprehensive toolkit for designing and analyzing magnetic components such as transformers and inductors.
+
+## Features
+
+- 🧲 **Core Database**: Access to extensive database of core shapes, materials, and manufacturers
+- 🔌 **Winding Design**: Automatic winding calculations with support for various wire types (round, litz, rectangular, planar)
+- 📊 **Loss Calculations**: Core losses (Steinmetz), winding losses (DC, skin effect, proximity effect)
+- 🎯 **Design Adviser**: Automated recommendations for optimal magnetic designs
+- 📈 **Signal Processing**: Harmonic analysis, waveform processing
+- 🖼️ **Visualization**: SVG plotting of cores, windings, magnetic fields
+- 🔧 **SPICE Export**: Export magnetic components as SPICE subcircuits
+
+## Installation
+
+### From PyPI (recommended)
+
+```bash
+pip install PyOpenMagnetics
+```
+
+### From Source
+
+```bash
+git clone https://github.com/OpenMagnetics/PyOpenMagnetics.git
+cd PyOpenMagnetics
+pip install .
+```
+
+## Quick Start
+
+### Basic Example: Creating a Core
+
+```python
+import PyOpenMagnetics
+
+# Find a core shape by name
+shape = PyOpenMagnetics.find_core_shape_by_name("E 42/21/15")
+
+# Find a core material by name
+material = PyOpenMagnetics.find_core_material_by_name("3C95")
+
+# Create a core with gapping
+core_data = {
+    "functionalDescription": {
+        "shape": shape,
+        "material": material,
+        "gapping": [{"type": "subtractive", "length": 0.001}],  # 1mm gap
+        "numberStacks": 1
+    }
+}
+
+# Calculate complete core data
+core = PyOpenMagnetics.calculate_core_data(core_data, False)
+print(f"Effective area: {core['processedDescription']['effectiveParameters']['effectiveArea']} m²")
+```
+
+### Design Adviser: Get Magnetic Recommendations
+
+```python
+import PyOpenMagnetics
+
+# Define design requirements
+inputs = {
+    "designRequirements": {
+        "magnetizingInductance": {
+            "minimum": 100e-6,  # 100 µH minimum
+            "nominal": 110e-6   # 110 µH nominal
+        },
+        "turnsRatios": [{"nominal": 5.0}]  # 5:1 turns ratio
+    },
+    "operatingPoints": [
+        {
+            "name": "Nominal",
+            "conditions": {"ambientTemperature": 25},
+            "excitationsPerWinding": [
+                {
+                    "name": "Primary",
+                    "frequency": 100000,  # 100 kHz
+                    "current": {
+                        "waveform": {
+                            "data": [0, 1.0, 0],
+                            "time": [0, 5e-6, 10e-6]
+                        }
+                    },
+                    "voltage": {
+                        "waveform": {
+                            "data": [50, 50, -50, -50],
+                            "time": [0, 5e-6, 5e-6, 10e-6]
+                        }
+                    }
+                }
+            ]
+        }
+    ]
+}
+
+# Process inputs (adds harmonics and validation)
+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")
+
+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']}")
+```
+
+### Calculate Core Losses
+
+```python
+import PyOpenMagnetics
+
+# Define core and operating point
+core_data = {...}  # Your core definition
+operating_point = {
+    "name": "Nominal",
+    "conditions": {"ambientTemperature": 25},
+    "excitationsPerWinding": [
+        {
+            "frequency": 100000,
+            "magneticFluxDensity": {
+                "processed": {
+                    "peakToPeak": 0.2,  # 200 mT peak-to-peak
+                    "offset": 0
+                }
+            }
+        }
+    ]
+}
+
+losses = PyOpenMagnetics.calculate_core_losses(core_data, operating_point, "IGSE")
+print(f"Core losses: {losses['coreLosses']} W")
+```
+
+### Winding a Coil
+
+```python
+import PyOpenMagnetics
+
+# Define coil requirements
+coil_functional_description = [
+    {
+        "name": "Primary",
+        "numberTurns": 50,
+        "numberParallels": 1,
+        "wire": "Round 0.5 - Grade 1"
+    },
+    {
+        "name": "Secondary",
+        "numberTurns": 10,
+        "numberParallels": 3,
+        "wire": "Round 1.0 - Grade 1"
+    }
+]
+
+# Wind the coil on the core
+result = PyOpenMagnetics.wind(core_data, coil_functional_description, bobbin_data, [1, 1], [])
+print(f"Winding successful: {result.get('windingResult', 'unknown')}")
+```
+
+## Flyback Converter Wizard
+
+PyOpenMagnetics includes a complete flyback converter design wizard. See `flyback.py` for a full example:
+
+```python
+from flyback import design_flyback, create_mas_inputs, get_advised_magnetics
+
+# Define flyback specifications
+specs = {
+    "input_voltage_min": 90,
+    "input_voltage_max": 375,
+    "outputs": [{"voltage": 12, "current": 2, "diode_drop": 0.5}],
+    "switching_frequency": 100000,
+    "max_duty_cycle": 0.45,
+    "efficiency": 0.85,
+    "current_ripple_ratio": 0.4,
+    "force_dcm": False,
+    "safety_margin": 0.85,
+    "ambient_temperature": 40,
+    "max_drain_source_voltage": None,
+}
+
+# Calculate magnetic requirements
+design = design_flyback(specs)
+print(f"Required inductance: {design['min_inductance']*1e6:.1f} µH")
+print(f"Turns ratio: {design['turns_ratios'][0]:.2f}")
+
+# Create inputs for PyOpenMagnetics
+inputs = create_mas_inputs(specs, design)
+
+# Get recommended magnetics
+magnetics = get_advised_magnetics(inputs, max_results=5)
+```
+
+## API Reference
+
+### Database Access
+
+| Function | Description |
+|----------|-------------|
+| `get_core_materials()` | Get all available core materials |
+| `get_core_shapes()` | Get all available core shapes |
+| `get_wires()` | Get all available wires |
+| `get_bobbins()` | Get all available bobbins |
+| `find_core_material_by_name(name)` | Find core material by name |
+| `find_core_shape_by_name(name)` | Find core shape by name |
+| `find_wire_by_name(name)` | Find wire by name |
+
+### Core Calculations
+
+| Function | Description |
+|----------|-------------|
+| `calculate_core_data(core, process)` | Calculate complete core data |
+| `calculate_core_gapping(core, gapping)` | Calculate gapping configuration |
+| `calculate_inductance_from_number_turns_and_gapping(...)` | Calculate inductance |
+| `calculate_core_losses(core, operating_point, model)` | Calculate core losses |
+
+### Winding Functions
+
+| Function | Description |
+|----------|-------------|
+| `wind(core, coil, bobbin, pattern, layers)` | Wind coils on a core |
+| `calculate_winding_losses(...)` | Calculate total winding losses |
+| `calculate_ohmic_losses(...)` | Calculate DC losses |
+| `calculate_skin_effect_losses(...)` | Calculate skin effect losses |
+| `calculate_proximity_effect_losses(...)` | Calculate proximity effect losses |
+
+### Design Adviser
+
+| Function | Description |
+|----------|-------------|
+| `calculate_advised_cores(inputs, max_results)` | Get recommended cores |
+| `calculate_advised_magnetics(inputs, max, mode)` | Get complete designs |
+| `process_inputs(inputs)` | Process and validate inputs |
+
+### Visualization
+
+| Function | Description |
+|----------|-------------|
+| `plot_core(core, ...)` | Generate SVG of core |
+| `plot_sections(magnetic, ...)` | Plot winding sections |
+| `plot_layers(magnetic, ...)` | Plot winding layers |
+| `plot_turns(magnetic, ...)` | Plot individual turns |
+| `plot_field(magnetic, ...)` | Plot magnetic field |
+
+### Settings
+
+| Function | Description |
+|----------|-------------|
+| `get_settings()` | Get current settings |
+| `set_settings(settings)` | Configure settings |
+| `reset_settings()` | Reset to defaults |
+
+### SPICE Export
+
+| Function | Description |
+|----------|-------------|
+| `export_magnetic_as_subcircuit(magnetic, ...)` | Export as SPICE model |
+
+## Core Materials
+
+PyOpenMagnetics includes materials from major manufacturers:
+
+- **TDK/EPCOS**: N27, N49, N87, N95, N97, etc.
+- **Ferroxcube**: 3C90, 3C94, 3C95, 3F3, 3F4, etc.
+- **Fair-Rite**: Various ferrite materials
+- **Magnetics Inc.**: Powder cores (MPP, High Flux, Kool Mu)
+- **Micrometals**: Iron powder cores
+
+## Core Shapes
+
+Supported shape families include:
+
+- **E cores**: E, EI, EFD, EQ, ER
+- **ETD/EC cores**: ETD, EC
+- **PQ/PM cores**: PQ, PM
+- **RM cores**: RM, RM/ILP
+- **Toroidal**: Various sizes
+- **Pot cores**: P, PT
+- **U/UI cores**: U, UI, UR
+- **Planar**: E-LP, EQ-LP, etc.
+
+## Wire Types
+
+- **Round enamelled wire**: Various AWG and IEC sizes
+- **Litz wire**: Multiple strand configurations
+- **Rectangular wire**: For high-current applications
+- **Foil**: For planar magnetics
+- **Planar PCB**: For integrated designs
+
+## Configuration
+
+Use `set_settings()` to configure:
+
+```python
+settings = PyOpenMagnetics.get_settings()
+settings["coilAllowMarginTape"] = True
+settings["coilWindEvenIfNotFit"] = False
+settings["painterNumberPointsX"] = 50
+PyOpenMagnetics.set_settings(settings)
+```
+
+## Contributing
+
+Contributions are welcome! Please see the [OpenMagnetics](https://github.com/OpenMagnetics) organization for contribution guidelines.
+
+## Documentation
+
+### Quick Start
+- **[llms.txt](llms.txt)** - Comprehensive API reference optimized for AI assistants and quick lookup
+- **[examples/](examples/)** - Practical example scripts for common design workflows
+- **[PyOpenMagnetics.pyi](PyOpenMagnetics.pyi)** - Type stubs for IDE autocompletion
+
+### Tutorials
+- **[notebooks/](notebooks/)** - Interactive Jupyter notebook tutorials with visualizations
+  - [Getting Started](notebooks/01_getting_started.ipynb) - Introduction to PyOpenMagnetics
+  - [Buck Inductor](notebooks/02_buck_inductor.ipynb) - Complete inductor design workflow
+  - [Core Losses](notebooks/03_core_losses.ipynb) - In-depth core loss analysis
+
+### Reference
+- **[docs/errors.md](docs/errors.md)** - Common errors and solutions
+- **[docs/performance.md](docs/performance.md)** - Performance optimization guide
+- **[docs/compatibility.md](docs/compatibility.md)** - Python/platform version compatibility
+
+### Validation
+- **[api/validation.py](api/validation.py)** - Runtime JSON schema validation for inputs
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Related Projects
+
+- [MKF](https://github.com/OpenMagnetics/MKF) - C++ magnetics library
+- [MAS](https://github.com/OpenMagnetics/MAS) - Magnetic Agnostic Structure schema
+- [OpenMagnetics Web](https://openmagnetics.com) - Online design tool
+
+## References
+
+- Maniktala, S. "Switching Power Supplies A-Z", 2nd Edition
+- Basso, C. "Switch-Mode Power Supplies", 2nd Edition
+- McLyman, C. "Transformer and Inductor Design Handbook"
+
+## Support
+
+For questions and support:
+- 🐛 [GitHub Issues](https://github.com/OpenMagnetics/PyOpenMagnetics/issues)
+- 💬 [Discussions](https://github.com/OpenMagnetics/PyOpenMagnetics/discussions)
+- 📧 Contact the maintainers

pyopenmagnetics-1.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+include/pybind11_json/pybind11_json.hpp,sha256=ycNMrjBBpmzNwIuszG-Ni7YWHzHHCivVvNzvgEBNk14,8095
+PyOpenMagnetics.cp311-win_amd64.pyd,sha256=kJk1U1pE4KS08q8oQq57tQZyzVzpEHmxmrGMHM7uWdM,19409920
+share/cmake/pybind11_json/pybind11_jsonConfig.cmake,sha256=yqt4qHnKv1yQ3mG7vu4zmPMDXQQ0GZUXwt0yr8_Epic,2058
+share/cmake/pybind11_json/pybind11_jsonConfigVersion.cmake,sha256=wJpbsnHNM9IdCw8SYdh07PgYQyMH_p9E6374xgrfpo4,1435
+share/cmake/pybind11_json/pybind11_jsonTargets.cmake,sha256=2YDTY75tk0daY1uvV7Rw6Ph0Od4BCcMaaB7mxapP8-0,4227
+share/pkgconfig/pybind11_json.pc,sha256=1IIOiR0JKkuoiENHuuHk9KRG6VuMfTQuMjwZFHvWp1A,147
+pyopenmagnetics-1.1.0.dist-info/METADATA,sha256=6fT7O3BjyVRfwgFVB6LZA0O26w2SbYuSkCzwCgtkexY,12141
+pyopenmagnetics-1.1.0.dist-info/WHEEL,sha256=oXhHG6ewLm-FNdEna2zwgy-K0KEl4claZ1ztR4VTx0I,106
+pyopenmagnetics-1.1.0.dist-info/licenses/LICENSE,sha256=n5beBRUVTrqihyXW7-COpKNiKVZiNzdYn9yUGtLcvZE,1091
+pyopenmagnetics-1.1.0.dist-info/RECORD,,

pyopenmagnetics-1.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

pyopenmagnetics-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenMagnetics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

share/cmake/pybind11_json/pybind11_jsonConfig.cmake

@@ -0,0 +1,52 @@
+############################################################################
+# Copyright (c) 2019, Martin Renou                                         #
+#                                                                          #
+# Distributed under the terms of the BSD 3-Clause License.                 #
+#                                                                          #
+# The full license is in the file LICENSE, distributed with this software. #
+############################################################################
+
+# pybind11_json cmake module
+# This module sets the following variables in your project::
+#
+#   pybind11_json_FOUND - true if pybind11_json found on the system
+#   pybind11_json_INCLUDE_DIRS - the directory containing pybind11_json headers
+#   pybind11_json_LIBRARY - empty
+
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was pybind11_jsonConfig.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+macro(check_required_components _NAME)
+  foreach(comp ${${_NAME}_FIND_COMPONENTS})
+    if(NOT ${_NAME}_${comp}_FOUND)
+      if(${_NAME}_FIND_REQUIRED_${comp})
+        set(${_NAME}_FOUND FALSE)
+      endif()
+    endif()
+  endforeach()
+endmacro()
+
+####################################################################################
+
+
+
+include(CMakeFindDependencyMacro)
+find_dependency(pybind11 2.2.4)
+find_dependency(nlohmann_json 3.2.0)
+
+if(NOT TARGET pybind11_json)
+  include("${CMAKE_CURRENT_LIST_DIR}/pybind11_jsonTargets.cmake")
+
+  get_target_property(pybind11_json_INCLUDE_DIRS pybind11_json INTERFACE_INCLUDE_DIRECTORIES)
+endif()

share/cmake/pybind11_json/pybind11_jsonConfigVersion.cmake

@@ -0,0 +1,32 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+set(PACKAGE_VERSION "0.2.15")
+
+if (PACKAGE_FIND_VERSION_RANGE)
+  # Package version must be in the requested version range
+  if ((PACKAGE_FIND_VERSION_RANGE_MIN STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MIN)
+      OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_GREATER PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MAX)))
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+else()
+  if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+    set(PACKAGE_VERSION_COMPATIBLE FALSE)
+  else()
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+

share/cmake/pybind11_json/pybind11_jsonTargets.cmake

@@ -0,0 +1,106 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...4.0)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS pybind11_json)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target pybind11_json
+add_library(pybind11_json INTERFACE IMPORTED)
+
+set_target_properties(pybind11_json PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/pybind11_jsonTargets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

share/pkgconfig/pybind11_json.pc

@@ -0,0 +1,7 @@
+prefix=
+includedir=${prefix}/include
+
+Name: pybind11_json
+Description: Using nlohmann::json with pybind11
+Version: 
+Cflags: -I${includedir}