FlowPlotPy 0.9.0__tar.gz

flowplotpy-0.9.0/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.18)
+
+project(${SKBUILD_PROJECT_NAME} VERSION ${SKBUILD_PROJECT_VERSION} LANGUAGES CXX)
+
+set(PYBIND11_FINDPYTHON ON)
+find_package(pybind11 CONFIG REQUIRED)
+
+pybind11_add_module(_flowplot flowplot_py.cpp)
+
+target_compile_features(_flowplot PRIVATE cxx_std_20)
+
+target_include_directories(_flowplot PRIVATE
+	${CMAKE_CURRENT_SOURCE_DIR}
+	${CMAKE_CURRENT_SOURCE_DIR}/..
+)
+
+target_compile_definitions(_flowplot PRIVATE
+	FLOW_PLOT_IMPLEMENTATION
+	FLOW_PLOT_RENDERER
+	FLOW_PLOT_COMPLETE_JSON
+)
+
+install(TARGETS _flowplot LIBRARY DESTINATION flowplot)

flowplotpy-0.9.0/PKG-INFO

@@ -0,0 +1,336 @@
+Metadata-Version: 2.2
+Name: FlowPlotPy
+Version: 0.9.0
+Summary: Python bindings for the FlowPlot plotting library
+Author: FlowPlot contributors
+License: MIT License
+         
+         Copyright (c) 2026 Manwe314
+         
+         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.
+         
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.10
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.23; extra == "numpy"
+Description-Content-Type: text/markdown
+
+# FlowPlot
+
+FlowPlot is a header-only plotting library that:
+
+- compiles a JSON template into an internal spec
+- binds runtime data (`withData("dataset.field", ...)`)
+- resolves layout/axes/layers into a render command stream
+- optionally rasterizes to PNG with the built-in CPU renderer
+
+It supports scatter and histogram layers, automatic axis-domain inference, legends/titles, and pluggable text measurement/layout through `ITextEngine`.
+Text styling supports font family, numeric weight, and style (`normal`, `italic`, `oblique`).
+
+## Quick Start
+
+### 1. Create a template (`ScatterTemplate.json`)
+
+```json
+{
+  "version": "1.0",
+  "fonts": [
+    {
+      "family": "Inter",
+      "weight": 400,
+      "style": "normal",
+      "path": "/absolute/path/to/Inter-Regular.ttf"
+    },
+    {
+      "family": "Inter",
+      "weight": 700,
+      "style": "normal",
+      "path": "/absolute/path/to/Inter-Bold.ttf"
+    }
+  ],
+  "figure": {
+    "width": 1200,
+    "height": 800,
+    "title": {
+      "visible": true,
+      "text": "Scatter Plot",
+      "fontFamily": "Inter",
+      "fontWeight": 700,
+      "fontStyle": "normal"
+    }
+  },
+  "datasets": [
+    {
+      "name": "main",
+      "schema": {
+        "x": "number",
+        "y": "number"
+      }
+    }
+  ],
+  "panels": [
+    {
+      "layers": [
+        {
+          "type": "scatter",
+          "dataset": "main",
+          "mapping": {
+            "x": { "field": "x" },
+            "y": { "field": "y" }
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+### 2. Render from C++
+
+```cpp
+#define FLOW_PLOT_RENDERER
+#define FLOW_PLOT_IMPLEMENTATION
+#define FLOW_PLOT_DEFAULT_FONT_PATH "./FacultyGlyphic-Regular.ttf"
+#include "FlowPlot_Mega.hpp"
+
+#include <vector>
+
+int main()
+{
+    std::vector<int> x{1, 2, 3, 4, 5};
+    std::vector<int> y{3, 4, 1, 4, 6};
+
+    FlowPlot::plot("./ScatterTemplate.json")
+        .withData("main.x", x)
+        .withData("main.y", y)
+        .writePng("./out.png");
+}
+```
+
+### 3. Compile
+
+```bash
+g++ -std=c++20 -I. -IFlowPlot main.cpp -o plot
+```
+
+## Public API
+
+- `FlowPlot::plot(path)` loads template JSON (`.json` extension optional).
+- `PlotBuilder::set("path.to.prop", value)` mutates template JSON before compile.
+  - `value` supports: `int`, `float`, `double`, `bool`, `const char*`, `std::string`, `std::string_view`.
+- `PlotBuilder::setJsonRaw("path.to.prop", jsonText)` sets a property from raw JSON text (object/array/primitive).
+- `PlotBuilder::withData("dataset.field", std::span<const T>)`
+- `PlotBuilder::withData("dataset.field", const std::vector<T>&)`
+- `PlotBuilder::useTextEngine(engine)` injects a custom text engine.
+- `PlotBuilder::getCommands()` returns `RenderPlot` (resolved command stream).
+- `PlotBuilder::writePng(path)` (only when `FLOW_PLOT_RENDERER` is enabled).
+- `FlowPlot::registerFonts(textEngine, templateJsonText)` registers every root-level `fonts[]` entry with an `ITextEngine`.
+- `FlowPlot::getCompleteJson(templateJsonText, pretty = true)` (only when `FLOW_PLOT_COMPLETE_JSON` is enabled).
+
+## Defines
+
+### Required in specific modes
+
+- `FLOW_PLOT_RENDERER`
+  - Enables renderer integration (`CpuRenderer`, `StbTextEngine`, `PlotBuilder::writePng`).
+  - Define before including headers (or pass as compiler define).
+
+- `FLOW_PLOT_IMPLEMENTATION`
+  - Required in exactly one translation unit if you use built-in stb implementations.
+  - Without this (and without external stb implementation), renderer builds can compile but will fail to link when stb symbols are needed.
+
+### Optional
+
+- `FLOW_PLOT_DEFAULT_FONT_PATH`
+  - String literal path to a default TTF file auto-registered by `StbTextEngine`.
+  - `PlotBuilder::writePng` and renderer-enabled `PlotBuilder::getCommands` auto-create a fallback `StbTextEngine` if none is set; this default font path makes that work out of the box.
+
+- `FLOW_PLOT_COMPLETE_JSON`
+  - Enables full-template normalization helper: `getCompleteJson(templateJsonText, pretty)`.
+
+- `FLOW_PLOT_STB_EXTERNAL_IMPLEMENTATION`
+  - Use when you provide stb implementations externally.
+  - Disables FlowPlot’s internal stb implementation emission.
+
+### Internal (do not set manually)
+
+Examples: `FLOW_PLOT_HPP_INCLUDED`, `FLOW_PLOT_RENDERER_HPP_INCLUDED`, `FLOW_PLOT_DEFINED_STBTT_IMPLEMENTATION`, etc.
+
+## Template Schema (Overview)
+
+Root object:
+
+- `version` (`"1.0"`)
+- `fonts` optional array of font variants
+- `figure`
+- `datasets`
+- `layout`
+- `panels`
+
+### `fonts`
+
+Optional root-level font manifest. Each entry describes one concrete font face:
+
+```json
+{
+  "family": "Inter",
+  "weight": 400,
+  "style": "normal",
+  "path": "/absolute/path/to/Inter-Regular.ttf"
+}
+```
+
+- `family`: family name referenced by text specs.
+- `weight`: numeric font weight, usually `100..900`.
+- `style`: `normal`, `italic`, or `oblique`.
+- `path`: absolute path to a `.ttf`/`.ttc` font file.
+
+The built-in fallback `StbTextEngine` automatically registers these entries for `writePng()` and renderer-enabled `getCommands()`. Custom text engines can opt in by calling `FlowPlot::registerFonts(engine, templateJsonText)`.
+
+### `figure`
+
+Includes width/height/dpi/background/padding/title/legends.
+
+### `datasets`
+
+Each dataset has:
+
+- `name`
+- `schema` map where values are `number`, `string`, or `boolean`
+
+Runtime data binding uses:
+
+- `withData("datasetName.fieldName", data)`
+
+### `panels`
+
+Each panel has:
+
+- style/frame/title
+- axes: `xAxis`, `yAxis`, `xSecondary`, `ySecondary`
+- `layers`
+
+### `layers`
+
+Common layer fields:
+
+- `type`: `scatter` or `histogram`
+- `dataset`: dataset name
+- `axisData`: `{ "x": "primary|secondary|null", "y": "primary|secondary|null" }`
+- `mapping`, `style`, `stats`, `config`
+
+Scatter mapping (important fields):
+
+- `mapping.x.field` (required)
+- `mapping.y.field` (required)
+- optional: `mapping.color.field`, `mapping.size.field`, `mapping.label.field`
+
+Histogram mapping (important fields):
+
+- `mapping.data.field` (required)
+- `mapping.data.axis`: `"x"` or `"y"` (which axis receives input data)
+- optional color field/mapping
+
+Notes:
+
+- If no layer contributes data to an axis and no explicit `min/max` is provided, axis domain falls back to `0..1`.
+- You must define panels/layers/mappings if you want automatic domain inference from data.
+
+## Renderer Pipeline
+
+High-level flow:
+
+1. Template JSON -> compiled spec
+2. Spec + data views -> bound IR
+3. Bound IR + text metrics -> resolved IR
+4. Resolved IR -> `RenderPlot` command stream
+5. `CpuRenderer` rasterizes commands to RGBA8 image / PNG
+
+Command variants include:
+
+- `BoxCommand`
+- `PolylineCommand`
+- `TextCommand`
+- `MarkersCommand`
+- clip stack commands (`PushClipRectCommand`, `PopClipRectCommand`)
+
+## Text Engine Pluggability
+
+`ITextEngine` is pluggable for text metrics/layout:
+
+- `registerFont(...)`
+- `hasFont(...)`
+- `measureText(...)`
+- `layoutText(...)`
+
+Built-in `StbTextEngine` provides UTF-8 layout and glyph bitmap raster support used by the CPU renderer.
+
+Important current behavior:
+
+- `resolvePlotIR` needs a text engine for auto-sized text boxes.
+- `PlotBuilder::writePng` and renderer-enabled `PlotBuilder::getCommands` auto-fall back to `StbTextEngine` when no engine is explicitly set.
+- The fallback `StbTextEngine` automatically registers root `fonts[]` entries before resolving text.
+- If no default font is available, `writePng` throws with guidance (`useTextEngine(...)` or set `FLOW_PLOT_DEFAULT_FONT_PATH`).
+- Font lookup uses `family + weight + style`, with fallback to normal style/default weight/default family where possible.
+- Non-`StbTextEngine` custom engines can drive measurement/layout, but glyph rasterization in the built-in renderer is currently specialized for `StbTextEngine`.
+
+## Header Options
+
+You can use modular headers (`FlowPlot/FlowPlot.hpp`) or one of four generated amalgamated headers.
+
+Regenerate all amalgamated variants with:
+
+```bash
+python3 tools/generate_flowplot_mega.py
+```
+
+Generated outputs:
+
+- `FlowPlot_Mega_Core.hpp`
+  - Inlines FlowPlot headers only.
+  - Leaves RapidJSON and stb external (`-IFlowPlot` needed for bundled deps).
+- `FlowPlot_Mega_Stb.hpp`
+  - Inlines FlowPlot + stb headers.
+  - Leaves RapidJSON external (`-IFlowPlot` needed for bundled deps).
+- `FlowPlot_Mega_Json.hpp`
+  - Inlines FlowPlot + used RapidJSON subset.
+  - Leaves stb external (`-IFlowPlot` needed only if renderer/stb paths are used).
+- `FlowPlot_Mega.hpp`
+  - Inlines FlowPlot + used RapidJSON subset + stb.
+  - Fully self-contained single header (copy one file and include it).
+
+All variants support the same feature macros and runtime API.
+
+## JSON Backend
+
+FlowPlot uses RapidJSON. The JSON-inlined mega variants include only the RapidJSON subset reachable from FlowPlot's actual include usage.
+
+## Documentation Status
+
+This is a temporary README. FlowPlot will get full documentation and a pre-v1.0.0 release soon.

flowplotpy-0.9.0/flowplot_py.cpp

@@ -0,0 +1,421 @@
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "FlowPlot_Mega.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <filesystem>
+#include <optional>
+#include <span>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace py = pybind11;
+
+namespace
+{
+	py::tuple colorToTuple(const FlowPlot::Color& color)
+	{
+		return py::make_tuple(color.r, color.g, color.b, color.a);
+	}
+
+	py::tuple pointToTuple(const FlowPlot::PointF& point)
+	{
+		return py::make_tuple(point.x, point.y);
+	}
+
+	py::tuple rectToTuple(const FlowPlot::RectF& rect)
+	{
+		return py::make_tuple(rect.x, rect.y, rect.w, rect.h);
+	}
+
+	const char* horizontalAlignName(FlowPlot::HorizontalAlign align) noexcept
+	{
+		switch (align)
+		{
+		case FlowPlot::HorizontalAlign::Left:
+			return "left";
+		case FlowPlot::HorizontalAlign::Center:
+			return "center";
+		case FlowPlot::HorizontalAlign::Right:
+			return "right";
+		}
+		return "left";
+	}
+
+	const char* verticalAlignName(FlowPlot::VerticalAlign align) noexcept
+	{
+		switch (align)
+		{
+		case FlowPlot::VerticalAlign::Top:
+			return "top";
+		case FlowPlot::VerticalAlign::Middle:
+			return "middle";
+		case FlowPlot::VerticalAlign::Bottom:
+			return "bottom";
+		}
+		return "top";
+	}
+
+	const char* markerShapeName(FlowPlot::MarkerShape shape) noexcept
+	{
+		switch (shape)
+		{
+		case FlowPlot::MarkerShape::Circle:
+			return "circle";
+		case FlowPlot::MarkerShape::Square:
+			return "square";
+		case FlowPlot::MarkerShape::Diamond:
+			return "diamond";
+		case FlowPlot::MarkerShape::Triangle:
+			return "triangle";
+		}
+		return "circle";
+	}
+
+	const char* lineCapName(FlowPlot::LineCap cap) noexcept
+	{
+		switch (cap)
+		{
+		case FlowPlot::LineCap::Butt:
+			return "butt";
+		case FlowPlot::LineCap::Square:
+			return "square";
+		case FlowPlot::LineCap::Round:
+			return "round";
+		}
+		return "butt";
+	}
+
+	const char* lineJoinName(FlowPlot::LineJoin join) noexcept
+	{
+		switch (join)
+		{
+		case FlowPlot::LineJoin::Miter:
+			return "miter";
+		case FlowPlot::LineJoin::Bevel:
+			return "bevel";
+		case FlowPlot::LineJoin::Round:
+			return "round";
+		}
+		return "bevel";
+	}
+
+	py::list pointsToList(const std::vector<FlowPlot::PointF>& points)
+	{
+		py::list out;
+		for (const FlowPlot::PointF& point : points)
+			out.append(pointToTuple(point));
+		return out;
+	}
+
+	py::list colorsToList(const std::vector<FlowPlot::Color>& colors)
+	{
+		py::list out;
+		for (const FlowPlot::Color& color : colors)
+			out.append(colorToTuple(color));
+		return out;
+	}
+
+	py::list floatsToList(const std::vector<float>& values)
+	{
+		py::list out;
+		for (float value : values)
+			out.append(value);
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::BoxCommand& command)
+	{
+		py::dict out;
+		out["type"] = "box";
+		out["rect"] = rectToTuple(command.rect);
+		out["fill"] = colorToTuple(command.fill);
+		out["stroke"] = colorToTuple(command.stroke);
+		out["stroke_width"] = command.strokeWidth;
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::PolylineCommand& command)
+	{
+		py::dict out;
+		out["type"] = "polyline";
+		out["points"] = pointsToList(command.points);
+		out["color"] = colorToTuple(command.color);
+		out["width"] = command.width;
+		out["cap"] = lineCapName(command.cap);
+		out["join"] = lineJoinName(command.join);
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::TextCommand& command)
+	{
+		py::dict out;
+		out["type"] = "text";
+		out["box"] = rectToTuple(command.box);
+		out["text"] = command.text;
+		out["color"] = colorToTuple(command.color);
+		out["font_family"] = command.fontFamily;
+		out["font_size"] = command.fontSize;
+		out["font_weight"] = command.fontWeight;
+		out["font_style"] = FlowPlot::fontStyleName(command.fontStyle);
+		out["h_align"] = horizontalAlignName(command.hAlign);
+		out["v_align"] = verticalAlignName(command.vAlign);
+		out["clip_to_box"] = command.clipToBox;
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::MarkersCommand& command)
+	{
+		py::dict out;
+		out["type"] = "markers";
+		out["shape"] = markerShapeName(command.shape);
+		out["positions"] = pointsToList(command.positions);
+		out["fills"] = colorsToList(command.fills);
+		out["stroke"] = colorToTuple(command.stroke);
+		out["sizes"] = floatsToList(command.sizes);
+		out["stroke_width"] = command.strokeWidth;
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::PushClipRectCommand& command)
+	{
+		py::dict out;
+		out["type"] = "push_clip_rect";
+		out["rect"] = rectToTuple(command.rect);
+		return out;
+	}
+
+	py::dict commandToDict(const FlowPlot::PopClipRectCommand&)
+	{
+		py::dict out;
+		out["type"] = "pop_clip_rect";
+		return out;
+	}
+
+	py::dict renderPlotToDict(const FlowPlot::RenderPlot& plot)
+	{
+		py::list commands;
+		for (const FlowPlot::RenderCommand& command : plot.commands)
+		{
+			commands.append(std::visit(
+				[](const auto& concreteCommand)
+				{
+					return commandToDict(concreteCommand);
+				},
+				command));
+		}
+
+		py::dict out;
+		out["width"] = plot.width;
+		out["height"] = plot.height;
+		out["background"] = colorToTuple(plot.background);
+		out["commands"] = std::move(commands);
+		return out;
+	}
+
+	class PyPlot
+	{
+	public:
+		explicit PyPlot(const std::string& path)
+			: builder_(FlowPlot::makePlot(path))
+		{
+		}
+
+		PyPlot& set(const std::string& property, py::object value)
+		{
+			if (py::isinstance<py::bool_>(value))
+				builder_.set(property, value.cast<bool>());
+			else if (py::isinstance<py::int_>(value))
+				builder_.set(property, value.cast<int>());
+			else if (py::isinstance<py::float_>(value))
+				builder_.set(property, value.cast<double>());
+			else if (py::isinstance<py::str>(value))
+				builder_.set(property, value.cast<std::string>());
+			else if (value.is_none())
+				throw py::type_error("set() does not accept None; use set_json_raw(property, \"null\")");
+			else
+				throw py::type_error("set() value must be bool, int, float, or str");
+
+			return *this;
+		}
+
+		PyPlot& setJsonRaw(const std::string& property, const std::string& jsonText)
+		{
+			builder_.setJsonRaw(property, jsonText);
+			return *this;
+		}
+
+		PyPlot& setDefaultFont(const std::string& fontPath)
+		{
+			textEngine_.emplace(std::filesystem::path(fontPath));
+			builder_.useTextEngine(*textEngine_);
+			return *this;
+		}
+
+		PyPlot& withData(const std::string& datasetField, py::object data)
+		{
+			if (py::isinstance<py::array>(data))
+				return withNumpyData(datasetField, data);
+
+			if (py::isinstance<py::sequence>(data) && !py::isinstance<py::str>(data))
+				return withSequenceData(datasetField, data.cast<py::sequence>());
+
+			throw py::type_error("with_data() expects a 1D sequence or NumPy array");
+		}
+
+		py::dict getCommands() const
+		{
+			prepareTextEngine("get_commands()");
+			return renderPlotToDict(builder_.getCommands());
+		}
+
+		void writePng(const std::string& outputPath) const
+		{
+			prepareTextEngine("write_png()");
+			builder_.writePng(outputPath);
+		}
+
+	private:
+		void prepareTextEngine(const char* caller) const
+		{
+			if (!textEngine_.has_value())
+			{
+				throw py::value_error(
+					std::string(caller)
+					+ " requires a default font in Python; call set_default_font(path_to_ttf) first");
+			}
+
+			builder_.registerTemplateFonts(*textEngine_);
+		}
+
+		PyPlot& withNumpyData(const std::string& datasetField, py::object data)
+		{
+			using DoubleArray = py::array_t<double, py::array::c_style | py::array::forcecast>;
+
+			DoubleArray array = DoubleArray::ensure(data);
+			if (!array)
+				throw py::type_error("with_data() NumPy arrays must contain numeric data");
+
+			py::buffer_info info = array.request();
+			if (info.ndim != 1)
+				throw py::value_error("with_data() NumPy arrays must be 1D");
+
+			keptArrays_.push_back(array);
+			builder_.withData(
+				datasetField,
+				std::span<const double>(
+					static_cast<const double*>(info.ptr),
+					static_cast<std::size_t>(info.shape[0])));
+			return *this;
+		}
+
+		PyPlot& withSequenceData(const std::string& datasetField, py::sequence sequence)
+		{
+			if (sequence.empty())
+			{
+				ownedDoubles_.emplace_back();
+				builder_.withData(datasetField, ownedDoubles_.back());
+				return *this;
+			}
+
+			py::object first = sequence[0];
+			if (py::isinstance<py::str>(first))
+				return withStringSequenceData(datasetField, sequence);
+
+			if (py::isinstance<py::bool_>(first))
+				throw py::type_error("with_data() boolean sequences are not supported yet");
+
+			if (py::isinstance<py::int_>(first) || py::isinstance<py::float_>(first))
+				return withNumericSequenceData(datasetField, sequence);
+
+			throw py::type_error("with_data() sequence items must be numbers or strings");
+		}
+
+		PyPlot& withNumericSequenceData(const std::string& datasetField, py::sequence sequence)
+		{
+			std::vector<double>& values = ownedDoubles_.emplace_back();
+			values.reserve(static_cast<std::size_t>(sequence.size()));
+
+			for (py::handle item : sequence)
+			{
+				if (py::isinstance<py::bool_>(item) || !(py::isinstance<py::int_>(item) || py::isinstance<py::float_>(item)))
+					throw py::type_error("numeric data sequences cannot contain non-numeric values");
+
+				values.push_back(py::cast<double>(item));
+			}
+
+			builder_.withData(datasetField, values);
+			return *this;
+		}
+
+		PyPlot& withStringSequenceData(const std::string& datasetField, py::sequence sequence)
+		{
+			std::vector<std::string>& values = ownedStrings_.emplace_back();
+			values.reserve(static_cast<std::size_t>(sequence.size()));
+
+			for (py::handle item : sequence)
+			{
+				if (!py::isinstance<py::str>(item))
+					throw py::type_error("string data sequences cannot contain non-string values");
+
+				values.push_back(py::cast<std::string>(item));
+			}
+
+			builder_.withData(datasetField, values);
+			return *this;
+		}
+
+		FlowPlot::PlotBuilder builder_;
+		mutable std::optional<FlowPlot::StbTextEngine> textEngine_{};
+		std::vector<py::array> keptArrays_{};
+		std::vector<std::vector<double>> ownedDoubles_{};
+		std::vector<std::vector<std::string>> ownedStrings_{};
+	};
+
+	PyPlot plot(const std::string& path)
+	{
+		return PyPlot(path);
+	}
+} // namespace
+
+PYBIND11_MODULE(_flowplot, module)
+{
+	module.doc() = "Python bindings for FlowPlot";
+
+	py::class_<PyPlot>(module, "Plot")
+		.def("set", &PyPlot::set, py::arg("property"), py::arg("value"), py::return_value_policy::reference_internal)
+		.def("set_json_raw", &PyPlot::setJsonRaw, py::arg("property"), py::arg("json"), py::return_value_policy::reference_internal)
+		.def("setJsonRaw", &PyPlot::setJsonRaw, py::arg("property"), py::arg("json"), py::return_value_policy::reference_internal)
+		.def("set_default_font", &PyPlot::setDefaultFont, py::arg("font_path"), py::return_value_policy::reference_internal)
+		.def("setDefaultFont", &PyPlot::setDefaultFont, py::arg("font_path"), py::return_value_policy::reference_internal)
+		.def("with_data", &PyPlot::withData, py::arg("dataset_field"), py::arg("data"), py::return_value_policy::reference_internal)
+		.def("withData", &PyPlot::withData, py::arg("dataset_field"), py::arg("data"), py::return_value_policy::reference_internal)
+		.def("get_commands", &PyPlot::getCommands)
+		.def("getCommands", &PyPlot::getCommands)
+		.def("write_png", &PyPlot::writePng, py::arg("output_path"))
+		.def("writePng", &PyPlot::writePng, py::arg("output_path"));
+
+	module.def("plot", &plot, py::arg("path"));
+	module.def(
+		"get_complete_json",
+		[](const std::string& templateJson, bool pretty)
+		{
+			return FlowPlot::getCompleteJson(templateJson, pretty);
+		},
+		py::arg("template_json"),
+		py::arg("pretty") = true);
+	module.def(
+		"getCompleteJson",
+		[](const std::string& templateJson, bool pretty)
+		{
+			return FlowPlot::getCompleteJson(templateJson, pretty);
+		},
+		py::arg("template_json"),
+		py::arg("pretty") = true);
+}

flowplotpy-0.9.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["scikit-build-core>=0.10", "pybind11>=2.12"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "FlowPlotPy"
+version = "0.9.0"
+description = "Python bindings for the FlowPlot plotting library"
+readme = "../README.md"
+requires-python = ">=3.10"
+license = { file = "../LICENSE" }
+authors = [
+  { name = "FlowPlot contributors" }
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Intended Audience :: Science/Research",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: C++",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Visualization",
+]
+
+[project.optional-dependencies]
+numpy = ["numpy>=1.23"]
+
+[tool.scikit-build]
+cmake.version = ">=3.18"
+build-dir = "build/{wheel_tag}"
+
+[tool.scikit-build.wheel]
+packages = ["src/flowplot"]

flowplotpy-0.9.0/src/flowplot/__init__.py

@@ -0,0 +1,22 @@
+from importlib import resources
+
+from . import _flowplot
+from ._flowplot import Plot, getCompleteJson, get_complete_json
+
+
+def _default_font_resource():
+    return resources.files(__package__).joinpath("fonts", "Inter.ttf")
+
+
+def plot(path):
+    plot_obj = _flowplot.plot(path)
+    with resources.as_file(_default_font_resource()) as font_path:
+        plot_obj.set_default_font(str(font_path))
+    return plot_obj
+
+__all__ = [
+    "Plot",
+    "getCompleteJson",
+    "get_complete_json",
+    "plot",
+]