openscad-cpp-evaluator 1.31.0__tar.gz → 1.32.0__tar.gz

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/.github/workflows/wheels.yml

@@ -119,6 +119,9 @@ jobs:
           # C:\msys64 (not on PATH); its bison/flex satisfy the parser
           # submodule's grammar version requirement.
           CIBW_BEFORE_ALL_WINDOWS: 'C:\msys64\usr\bin\bash.exe -lc "pacman -Sy --noconfirm bison flex"'
+          # The binding tests run under pytest (the file's own entry point
+          # hands over to it): most of them take tmp_path or use pytest.raises.
+          CIBW_TEST_REQUIRES: "pytest"
           CIBW_TEST_COMMAND: "python {package}/tests/test_python_bindings.py"
 
       - uses: actions/upload-artifact@v7
@@ -128,6 +131,9 @@ jobs:
 
   publish-testpypi:
     needs: [sdist, build_wheels]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     environment: testpypi
     steps:
@@ -164,6 +170,9 @@ jobs:
 
   publish-pypi:
     needs: [publish-testpypi]
+    # Tags only: a manual dispatch builds and tests every wheel, and must
+    # never publish whatever branch it was run on.
+    if: startsWith(github.ref, 'refs/tags/v')
     runs-on: ubuntu-latest
     # The "pypi" environment carries no protection rules, so a tag runs
     # straight through TestPyPI to PyPI with nothing to stop it -- and a

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/CLAUDE.md

@@ -1091,8 +1091,8 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all ten
-  formats `exportExtensions()` lists: 3MF, AMF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eleven
+  formats `exportExtensions()` lists: 3MF, AMF, DXF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
   `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
   which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
   restating the list, because three hand-written copies had already drifted far enough that `.off`
@@ -1120,6 +1120,16 @@ grep for `ponytail:`.
   binary's, vertex order and 6-vertex line wrap included. A 3D body in the list throws
   ("Current top level object is not a 2D object"), as OpenSCAD refuses too: there is no projection
   to fall back on. `ExportOptions::svg` carries OpenSCAD's five `-O export-svg/...` settings.
+  **`writeDxf` is the third 2D writer**, also on `collect2d()`: OpenSCAD's own `export_dxf.cc`
+  layout verbatim (AC1006 header with the extents, one CONTINUOUS linetype, layer 0, every contour
+  a closed `LWPOLYLINE` on layer 0 with holes as ordinary contours; 1- and 2-vertex contours as
+  `POINT`/`LINE`), pinned byte-for-byte by `ExportDxf.MatchesRealOpenscadByteForByte`. Two
+  deliberate differences: coordinates are the **shortest text that round-trips the double**
+  (`dxfNum`), not OpenSCAD's 6 significant digits -- a DXF feeds a cutter, and its circles do not
+  survive a re-import otherwise; and `$EXTMAX` is right for a model below zero (OpenSCAD seeds its
+  maxima with `numeric_limits<double>::min()`, the smallest POSITIVE double). Every number goes
+  through the classic locale, the file stream included: Qt sets the process locale, and a grouping
+  locale writes a 1500-vertex count as `1.500`.
   **`writePdf` is the other 2D writer**, and shares `collect2d()` with `writeSvg` so the all-2D
   rule and its refusal have one implementation. Everything else differs from SVG: the drawing is
   **centred on a fixed paper size** rather than the page being cut to fit, and **PDF user space is

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.31.0
+Version: 1.32.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/include/openscad_cpp_evaluator/export.hpp

@@ -158,6 +158,17 @@ struct ExportSvgOptions {
 void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
               const ExportSvgOptions& opts = {});
 
+// DXF, the third 2D writer: OpenSCAD's own export_dxf.cc layout (an AC1006
+// header with the model's extents, one CONTINUOUS linetype, layer 0) and
+// every contour of every body a closed LWPOLYLINE on layer 0 -- holes are
+// contours like any other, as in OpenSCAD. A 1-vertex contour is a POINT
+// and a 2-vertex one a LINE, again as OpenSCAD writes them. Shares
+// collect2d() with writeSvg/writePdf, so a 3D model is refused the same
+// way. Coordinates are written at full round-trip precision, NOT OpenSCAD's
+// 6 significant digits: a DXF goes to a cutter, where 1234.567 written as
+// 1234.57 is a real error.
+void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies);
+
 // Options for the PDF writer, named and defaulted after OpenSCAD's own
 // `-O export-pdf/...` set.
 struct ExportPdfOptions {

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.31.0"
+version = "1.32.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/src/export.cpp

@@ -13,6 +13,8 @@
 #include <cstdio>
 #include <ctime>
 #include <fstream>
+#include <locale>
+#include <sstream>
 #include <optional>
 #include <stdexcept>
 
@@ -1155,6 +1157,105 @@ void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies, c
 
 namespace {
 
+// The shortest decimal that reads back as exactly `v`, in the classic
+// locale (Qt sets the process locale from the environment, so printf could
+// write "1,5" on a German system and no DXF reader would take it). -0 is
+// written as 0, and a non-finite value -- which no contour should hold --
+// as 0 rather than as text a reader would choke on.
+std::string dxfNum(double v) {
+    if (!std::isfinite(v) || v == 0.0) return "0";
+    for (int digits = 6; digits <= 17; ++digits) {
+        std::ostringstream o;
+        o.imbue(std::locale::classic());
+        o.precision(digits);
+        o << v;
+        std::istringstream in(o.str());
+        in.imbue(std::locale::classic());
+        double back = 0.0;
+        in >> back;
+        if (back == v) return o.str();
+    }
+    std::ostringstream o;  // unreachable: 17 digits always round-trips a double
+    o.imbue(std::locale::classic());
+    o.precision(17);
+    o << v;
+    return o.str();
+}
+
+// The header, tables and (empty) blocks sections, verbatim from OpenSCAD's
+// export_dxf.cc -- its comments record which readers each piece was needed
+// for (Inkscape, LibreCAD, Illustrator, sharecad.org, generic cutters).
+void writeDxfHeader(std::ostream& out, double xMin, double yMin, double xMax, double yMax) {
+    out << "999\nDXF from OpenSCAD\n"
+        << "  0\nSECTION\n  2\nHEADER\n"
+        << "  9\n$ACADVER\n  1\nAC1006\n"
+        << "  9\n$INSBASE\n 10\n0.0\n 20\n0.0\n 30\n0.0\n";
+    for (const char* name : {"$EXTMIN", "$EXTMAX", "$LINMIN", "$LINMAX"}) {
+        const bool isMin = std::string(name).find("MIN") != std::string::npos;
+        out << "  9\n" << name << "\n 10\n" << dxfNum(isMin ? xMin : xMax) << "\n 20\n"
+            << dxfNum(isMin ? yMin : yMax) << "\n";
+    }
+    out << "  0\nENDSEC\n"
+        << "  0\nSECTION\n  2\nTABLES\n"
+        << "  0\nTABLE\n  2\nLTYPE\n 70\n1\n"
+        << "  0\nLTYPE\n  2\nCONTINUOUS\n 70\n64\n  3\nSolid line\n 72\n65\n 73\n0\n 40\n0.000000\n"
+        << "  0\nENDTAB\n"
+        << "  0\nTABLE\n  2\nLAYER\n 70\n6\n"
+        << "  0\nLAYER\n  2\n0\n 70\n64\n 62\n7\n  6\nCONTINUOUS\n"
+        << "  0\nENDTAB\n"
+        << "  0\nTABLE\n  2\nSTYLE\n 70\n0\n  0\nENDTAB\n"
+        << "  0\nENDSEC\n"
+        << "  0\nSECTION\n  2\nBLOCKS\n  0\nENDSEC\n";
+}
+
+} // namespace
+
+void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies) {
+    const Flat2d flat = collect2d(bodies);
+
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+    // The vertex counts go through the stream itself, which otherwise takes
+    // the global C++ locale -- one with digit grouping writes 1500 as "1.500".
+    out.imbue(std::locale::classic());
+
+    // Extents from collect2d's own bounding box. OpenSCAD starts its maxima
+    // at numeric_limits<double>::min() -- the smallest POSITIVE double, not
+    // the most negative -- so a model lying entirely at negative x or y gets
+    // a wrong $EXTMAX there. That is a bug, not a format rule.
+    writeDxfHeader(out, flat.minx, flat.miny, flat.maxx, flat.maxy);
+
+    out << "  0\nSECTION\n  2\nENTITIES\n";
+    for (const manifold::Polygons& polys : flat.perBody) {
+        for (const manifold::SimplePolygon& contour : polys) {
+            const auto xy = [&](const char* xCode, const char* yCode, const manifold::vec2& p) {
+                out << xCode << "\n" << dxfNum(p.x) << "\n" << yCode << "\n" << dxfNum(p.y) << "\n";
+            };
+            switch (contour.size()) {
+            case 0:
+                break;
+            case 1:
+                out << "  0\nPOINT\n100\nAcDbEntity\n  8\n0\n100\nAcDbPoint\n";
+                xy(" 10", " 20", contour[0]);
+                break;
+            case 2:
+                // [X1 Y1 X2 Y2]: the order ezdxf and dxfgrabber can read.
+                out << "  0\nLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbLine\n";
+                xy(" 10", " 20", contour[0]);
+                xy(" 11", " 21", contour[1]);
+                break;
+            default:
+                out << "  0\nLWPOLYLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbPolyline\n"
+                    << " 90\n" << contour.size() << "\n 70\n1\n";  // 70 = 1: closed
+                for (const manifold::vec2& p : contour) xy(" 10", " 20", p);
+            }
+        }
+    }
+    out << "  0\nENDSEC\n  0\nEOF\n";
+}
+
+namespace {
+
 // PDF's own unit is 1/72 inch; models are millimetres.
 constexpr double kPtPerMm = 72.0 / 25.4;
 // Page margin the ruler is drawn on, in points. OpenSCAD's own MARGIN.
@@ -1497,7 +1598,7 @@ std::vector<std::string> writePdf(const std::string& path, const std::vector<Col
 }
 
 const std::vector<std::string>& exportExtensions() {
-    static const std::vector<std::string> exts = {".3mf", ".amf", ".pdf", ".stl", ".obj",
+    static const std::vector<std::string> exts = {".3mf", ".amf", ".dxf", ".pdf", ".stl", ".obj",
                                                   ".off", ".ply", ".svg", ".wrl", ".x3d"};
     return exts;
 }
@@ -1524,6 +1625,12 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         return writePdf(path, bodies, opts.pdf);
     }
 
+    if (ext == ".dxf") {
+        // 2D, outside the mesh pipeline like SVG and PDF.
+        writeDxf(path, bodies);
+        return warnings;
+    }
+
     if (ext == ".svg") {
         // 2D, and nothing the mesh pipeline below does applies: no merge,
         // no sliver strip, no manifoldness check. Contours are what they

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/tests/test_export.cpp

@@ -10,6 +10,7 @@
 #include <cstdio>
 #include <filesystem>
 #include <fstream>
+#include <locale>
 #include <gtest/gtest.h>
 #include <sstream>
 #include <stb_image.h>
@@ -444,6 +445,130 @@ M 18.0866,-7.3806 L 16.4645,-8.46447 L 15.3806,-10.0866 L 15,-12 L 15.3806,-13.9
               expected);
 }
 
+// -- DXF (2D) --------------------------------------------------------------
+
+namespace {
+
+std::string dxfOf(const std::string& code, const std::string& name) {
+    const std::string path = tempPath(name).string();
+    writeDxf(path, evalToBodies(code));
+    const std::string text = readText(path);
+    std::remove(path.c_str());
+    return text;
+}
+
+// The value on the line after the first `code` line following `header`
+// (DXF is group-code / value pairs, one per line).
+std::string dxfValueAfter(const std::string& text, const std::string& header, const std::string& code) {
+    size_t at = text.find("\n" + header + "\n");
+    if (at == std::string::npos) return "";
+    at = text.find("\n" + code + "\n", at + 1);
+    if (at == std::string::npos) return "";
+    const size_t start = at + code.size() + 2;
+    return text.substr(start, text.find('\n', start) - start);
+}
+
+} // namespace
+
+// Byte-for-byte against real OpenSCAD 2026.02.01's `-o out.dxf` for the same
+// script: header, tables, entity layout, contour order and vertex order. The
+// coordinates are chosen to need no more than 6 significant digits, the only
+// place ours deliberately differs (see FullPrecisionNotSixDigits).
+TEST(ExportDxf, MatchesRealOpenscadByteForByte) {
+    const std::string expected =
+        "999\nDXF from OpenSCAD\n  0\nSECTION\n  2\nHEADER\n  9\n$ACADVER\n  1\nAC1006\n"
+        "  9\n$INSBASE\n 10\n0.0\n 20\n0.0\n 30\n0.0\n"
+        "  9\n$EXTMIN\n 10\n0\n 20\n0\n  9\n$EXTMAX\n 10\n40\n 20\n25\n"
+        "  9\n$LINMIN\n 10\n0\n 20\n0\n  9\n$LINMAX\n 10\n40\n 20\n25\n"
+        "  0\nENDSEC\n  0\nSECTION\n  2\nTABLES\n  0\nTABLE\n  2\nLTYPE\n 70\n1\n"
+        "  0\nLTYPE\n  2\nCONTINUOUS\n 70\n64\n  3\nSolid line\n 72\n65\n 73\n0\n 40\n0.000000\n"
+        "  0\nENDTAB\n  0\nTABLE\n  2\nLAYER\n 70\n6\n  0\nLAYER\n  2\n0\n 70\n64\n 62\n7\n  6\nCONTINUOUS\n"
+        "  0\nENDTAB\n  0\nTABLE\n  2\nSTYLE\n 70\n0\n  0\nENDTAB\n  0\nENDSEC\n"
+        "  0\nSECTION\n  2\nBLOCKS\n  0\nENDSEC\n  0\nSECTION\n  2\nENTITIES\n"
+        "  0\nLWPOLYLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbPolyline\n 90\n4\n 70\n1\n"
+        " 10\n40\n 20\n25\n 10\n0\n 20\n25\n 10\n0\n 20\n0\n 10\n40\n 20\n0\n"
+        "  0\nLWPOLYLINE\n100\nAcDbEntity\n  8\n0\n100\nAcDbPolyline\n 90\n4\n 70\n1\n"
+        " 10\n10\n 20\n5\n 10\n10\n 20\n17.5\n 10\n30\n 20\n17.5\n 10\n30\n 20\n5\n"
+        "  0\nENDSEC\n  0\nEOF\n";
+    EXPECT_EQ(dxfOf("difference() { square([40,25]); translate([10,5]) square([20,12.5]); }", "parity.dxf"),
+              expected);
+}
+
+// OpenSCAD streams doubles at the default 6 significant digits, so 1234.5678
+// reaches the file as 1234.57 -- a 2 micron error on a cut part, from the
+// file format alone. Ours writes the shortest text that reads back exactly.
+TEST(ExportDxf, FullPrecisionNotSixDigits) {
+    const std::string text = dxfOf("square([1234.5678, 0.1]);", "precise.dxf");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMAX", " 10"), "1234.5678");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMAX", " 20"), "0.1");
+    EXPECT_EQ(countOf(text, "\n1234.5678\n"), 4u);  // $EXTMAX, $LINMAX and two vertices
+}
+
+// OpenSCAD starts its maxima at numeric_limits<double>::min(), the smallest
+// POSITIVE double, so a model entirely below zero reports $EXTMAX of ~0.
+TEST(ExportDxf, ExtentsOfAModelBelowZero) {
+    const std::string text = dxfOf("translate([-50,-30]) square(10);", "negative.dxf");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMIN", " 10"), "-50");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMIN", " 20"), "-30");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMAX", " 10"), "-40");
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMAX", " 20"), "-20");
+}
+
+TEST(ExportDxf, EveryContourIsAClosedPolylineHolesIncluded) {
+    const std::string text =
+        dxfOf("difference() { circle(10, $fn=12); circle(5, $fn=12); } translate([30,0]) square(4);", "multi.dxf");
+    EXPECT_EQ(countOf(text, "LWPOLYLINE"), 3u);           // outer, hole, and the separate square
+    EXPECT_EQ(countOf(text, " 90\n12\n 70\n1\n"), 2u);    // both circles: 12 vertices, closed
+    EXPECT_EQ(countOf(text, " 90\n4\n 70\n1\n"), 1u);
+}
+
+namespace {
+// A locale that writes 1500.5 as "1.500,5" -- what a German global locale
+// would do to any number that reaches a stream without the classic locale.
+struct GermanishPunct : std::numpunct<char> {
+    char do_decimal_point() const override { return ','; }
+    char do_thousands_sep() const override { return '.'; }
+    std::string do_grouping() const override { return "\3"; }
+};
+}  // namespace
+
+TEST(ExportDxf, NumbersIgnoreTheGlobalLocale) {
+    const std::locale previous = std::locale::global(std::locale(std::locale::classic(), new GermanishPunct));
+    std::string text;
+    try {
+        text = dxfOf("translate([0.5,0]) circle(1000, $fn=1500);", "locale.dxf");
+    } catch (...) {
+        std::locale::global(previous);
+        throw;
+    }
+    std::locale::global(previous);
+    EXPECT_NE(text.find(" 90\n1500\n"), std::string::npos);
+    EXPECT_EQ(dxfValueAfter(text, "$EXTMAX", " 10"), "1000.5");
+    EXPECT_EQ(text.find(','), std::string::npos);
+}
+
+TEST(ExportDxf, RefusesA3dModel) {
+    std::vector<ColoredBody> bodies = evalToBodies("cube(10);");
+    EXPECT_THROW(writeDxf(tempPath("solid.dxf").string(), bodies), std::runtime_error);
+}
+
+TEST(ExportDxf, NoGeometryThrows) {
+    std::vector<ColoredBody> empty;
+    EXPECT_THROW(writeDxf(tempPath("empty.dxf").string(), empty), std::runtime_error);
+}
+
+TEST(ExportDxf, ReachableThroughExportModelAndListedAsAnExtension) {
+    const std::vector<std::string>& exts = exportExtensions();
+    EXPECT_NE(std::find(exts.begin(), exts.end(), ".dxf"), exts.end());
+    const std::string path = tempPath("via_export_model.dxf").string();
+    const std::vector<std::string> warnings = exportModel(path, evalToBodies("square(5);"), ExportOptions{});
+    EXPECT_TRUE(warnings.empty());
+    const std::string text = readText(path);
+    EXPECT_EQ(countOf(text, "LWPOLYLINE"), 1u);
+    EXPECT_NE(text.find("  0\nEOF\n"), std::string::npos);
+    std::remove(path.c_str());
+}
+
 // -- PDF (2D) --------------------------------------------------------------
 
 namespace {

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/tests/test_python_bindings.py

@@ -6,12 +6,12 @@ test_debug_hooks.cpp, test_viewport_params.cpp); this file only exercises the
 nanobind plumbing that exposes them to Python, which has no coverage of its
 own otherwise.
 
-No test framework: plain functions + assert, run via `python
-tests/test_python_bindings.py`. This project has no existing Python test
-infrastructure (pure C++/gtest via CMake/ctest) -- adding pytest just for
-this would be a new dependency for a handful of checks; wired into
-wheels.yml's CIBW_TEST_COMMAND instead, which already builds+installs the
-package on every release platform.
+Run with `python tests/test_python_bindings.py` (what wheels.yml's
+CIBW_TEST_COMMAND does on every release platform) or pytest directly; the
+entry point hands the file to pytest. It started as plain functions with a
+hand-rolled runner, but the file outgrew that: most tests now take tmp_path
+or use pytest.raises, and the runner, sitting part-way down, never reached
+them in a wheel build at all.
 """
 import os
 import sys
@@ -20,6 +20,25 @@ from pathlib import Path
 
 from openscad_cpp_evaluator import Evaluator, ManifoldCache, format_csg_tree
 
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _scripts_are_utf8_with_lf(monkeypatch):
+    """Every .scad these tests write is UTF-8 with \\n line endings, as any
+    editor saves one. Path.write_text's own defaults are the platform's:
+    cp1252 and CRLF on Windows, which made "aé—z" undecodable and shifted
+    every source span after a line break by one character per line against
+    the test's own string -- failures of the test, not of the evaluator. An
+    explicit encoding or newline still wins."""
+    orig = Path.write_text
+
+    def write_text(self, data, encoding=None, errors=None, newline=None):
+        return orig(self, data, encoding=encoding or "utf-8", errors=errors,
+                    newline="\n" if newline is None else newline)
+
+    monkeypatch.setattr(Path, "write_text", write_text)
+
 
 def _write(src: str) -> str:
     f = tempfile.NamedTemporaryFile(suffix=".scad", mode="w", encoding="utf-8", delete=False)
@@ -389,25 +408,6 @@ def test_format_source_raises_parse_error_on_bad_input():
     raise AssertionError("expected ParseError")
 
 
-def main():
-    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)]
-    failures = []
-    for t in tests:
-        try:
-            t()
-            print(f"PASS {t.__name__}")
-        except Exception as e:
-            failures.append((t.__name__, e))
-            print(f"FAIL {t.__name__}: {e}")
-    print(f"\n{len(tests) - len(failures)}/{len(tests)} passed")
-    if failures:
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()
-
-
 def test_evaluate_generate_false_skips_geometry(tmp_path):
     """generate=False runs the script but builds no Manifold geometry.
 
@@ -702,6 +702,51 @@ def test_export_model_svg_refuses_a_3d_model(tmp_path):
         export_model(str(tmp_path / "solid.svg"), ev.geometry)
 
 
+def test_export_model_writes_dxf_that_imports_back_unchanged(tmp_path):
+    """.dxf through the facade, then back in through import(): exporting what
+    was imported must give the same file, which only holds if every
+    coordinate survived at full precision (OpenSCAD's own writer keeps 6
+    significant digits, so its circles do not round-trip)."""
+    from openscad_cpp_evaluator import Evaluator, export_extensions, export_model
+
+    assert ".dxf" in export_extensions()
+
+    def export(script, name):
+        src = tmp_path / (name + ".scad")
+        src.write_text(script)
+        ev = Evaluator()
+        ev.evaluate(str(src), {})
+        out = tmp_path / (name + ".dxf")
+        assert export_model(str(out), ev.geometry) == []
+        return out
+
+    first = export("difference() { square([40,25]); translate([20,12]) circle(5, $fn=16); }", "first")
+    text = first.read_text()
+    assert text.startswith("999\nDXF from OpenSCAD\n") and text.endswith("  0\nEOF\n")
+    assert text.count("LWPOLYLINE") == 2
+    # The circle's vertices carry more than 6 significant digits -- the ones
+    # OpenSCAD's writer would cut them to. (Their exact values are whatever
+    # Manifold's 2D kernel rounded them to, so no literal is pinned here.)
+    lines = text.split("\n")
+    coords = [lines[i + 1] for i, code in enumerate(lines[:-1]) if code in (" 10", " 20")]
+    assert max(len(c.lstrip("-").replace(".", "").lstrip("0")) for c in coords) > 6
+
+    second = export(f'import("{first.as_posix()}");', "second")
+    assert second.read_text() == text
+
+
+def test_export_model_dxf_refuses_a_3d_model(tmp_path):
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError, export_model
+
+    src = tmp_path / "solid.scad"
+    src.write_text("cube(10);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+    with pytest.raises(EvalError, match="not a 2D object"):
+        export_model(str(tmp_path / "solid.dxf"), ev.geometry)
+
+
 def test_export_model_writes_pdf_and_takes_its_options(tmp_path):
     """.pdf through the facade, plus the option dict. Same
     two-parameter-list trap as split_components and the svg_* set."""
@@ -1011,7 +1056,8 @@ def _svg_counts(tmp_path, args):
     svg = tmp_path / "f.svg"
     svg.write_text(SVG_FILTER)
     scad = tmp_path / "f.scad"
-    scad.write_text(f'echo(n = len(import("{svg}"{args})));\n')
+    # as_posix: a Windows path's backslashes would be escapes in a .scad string.
+    scad.write_text(f'echo(n = len(import("{svg.as_posix()}"{args})));\n')
     msgs = []
     Evaluator(echo_fn=msgs.append).evaluate(str(scad), generate=False)
     echoes = [m for m in msgs if m.startswith("ECHO:")]
@@ -1177,3 +1223,18 @@ def test_a_cancel_signal_stops_a_silent_script_from_another_thread(tmp_path):
     except EvalError as e:
         assert "Render cancelled" in str(e), e
     assert time.perf_counter() - t0 < 5
+
+
+def main():
+    """`python tests/test_python_bindings.py` -- how cibuildwheel runs this
+    file -- runs the whole file under pytest. It used to loop over the test_
+    functions itself, from a main() placed part-way down: every test defined
+    below that point (37 of them, every export test included) never ran in a
+    wheel build, and the ones that take tmp_path could not have."""
+    import pytest
+
+    sys.exit(pytest.main([__file__, "-q"]))
+
+
+if __name__ == "__main__":
+    main()

{openscad_cpp_evaluator-1.31.0 → openscad_cpp_evaluator-1.32.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.31.0"
+version = "1.32.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },