openscad-cpp-evaluator 1.0.1__tar.gz → 1.1.0__tar.gz

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/.github/workflows/wheels.yml

@@ -165,9 +165,13 @@ jobs:
   publish-pypi:
     needs: [publish-testpypi]
     runs-on: ubuntu-latest
-    # Requires a "pypi" GitHub Environment with a required-reviewer
-    # protection rule, so this job pauses for manual approval after the
-    # TestPyPI publish above has been verified.
+    # The "pypi" environment carries no protection rules, so a tag runs
+    # straight through TestPyPI to PyPI with nothing to stop it -- and a
+    # PyPI upload cannot be undone or replaced at the same version. Adding
+    # a required reviewer to the environment reinstates that brake; GitHub
+    # permits approving your own deployment unless "Prevent self-review"
+    # is ticked. Kept regardless of rules: token auth aside, the
+    # environment is where a publishing credential would be scoped.
     environment: pypi
     steps:
       - uses: actions/download-artifact@v8

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/bindings/module.cpp

@@ -373,7 +373,8 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
 }
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
-                     std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile) {
+                     std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
+                     bool generate) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -391,9 +392,12 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
             oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp, generate));
             collectIdSpans(ev, idSpans);
-            csgTree = std::move(ev.csgTree);
+            // Only moved out when it will actually be converted below --
+            // csgTreeToPy() walks the whole tree building Python objects,
+            // which a resolve-only caller has no use for.
+            if (generate) csgTree = std::move(ev.csgTree);
             profileResult = std::move(ev.profileResult);
             {
                 nb::gil_scoped_acquire g; // building Python objects needs the GIL back
@@ -792,8 +796,11 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "rather than restated here, so the Python side cannot drift from what can actually be written.");
 
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
-          nb::arg("profile") = false,
-          "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");
+          nb::arg("profile") = false, nb::arg("generate") = true,
+          "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).\n"
+          "generate=False stops after the resolve pass: the script runs and reports everything "
+          "it normally would, but no Manifold geometry is built, and neither bodies nor csg_tree "
+          "are populated.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -178,15 +178,24 @@ public:
     // forcing it to expose a separate `_root_ctx` escape hatch for this)
     // this port's `ctx` is always caller-owned already. Mirrors the
     // reference's `evaluate(nodes, root_scope, viewport_params=None)`.
+    //
+    // `generate = false` stops after the resolve pass: the CSG tree is built
+    // and stashed in `csgTree` as usual, but no Manifold work happens and an
+    // empty body list comes back. For a caller that only wants to know
+    // whether a script RUNS -- a docs check, a syntax/semantics smoke test --
+    // that skips the geometry without skipping the language. Mirrors what the
+    // reference does for `openscad -o out.term`.
     std::vector<ColoredBody> evaluate(const std::vector<std::unique_ptr<oscad::ASTNode>>& nodes, EvalContext& ctx,
-                                       const std::unordered_map<std::string, Value>& viewportParams = {});
+                                       const std::unordered_map<std::string, Value>& viewportParams = {},
+                                       bool generate = true);
     // Same, but over a non-owning pointer list -- needed by `use <file>`
     // resolution (eval_use.hpp/.cpp), whose "processed nodes" list combines
     // declarations owned by more than one independently-owned AST vector,
     // so it can't be represented as a single vector<unique_ptr<ASTNode>>.
     // Mirrors evalChildren's existing dual-overload shape.
     std::vector<ColoredBody> evaluate(const std::vector<const oscad::ASTNode*>& nodes, EvalContext& ctx,
-                                       const std::unordered_map<std::string, Value>& viewportParams = {});
+                                       const std::unordered_map<std::string, Value>& viewportParams = {},
+                                       bool generate = true);
 
     // Resolve pass: resets idToNode/idToColor and the tree-build stack,
     // then walks `nodes` via evalChildren(), returning the completed (but
@@ -654,7 +663,8 @@ private:
     std::vector<std::unique_ptr<CSGNode>> resolveTreeImpl(const NodeList& nodes, EvalContext& ctx);
     template <typename NodeList>
     std::vector<ColoredBody> evaluateImpl(const NodeList& nodes, EvalContext& ctx,
-                                           const std::unordered_map<std::string, Value>& viewportParams);
+                                           const std::unordered_map<std::string, Value>& viewportParams,
+                                           bool generate);
 
     // Shared bottom-up generate walk behind generateTree()/generatePartialTree()
     // -- see generatePartialTree()'s own doc comment and this function's

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/python/openscad_cpp_evaluator/__init__.py

@@ -492,7 +492,19 @@ class Evaluator:
         self.dyn = {}
         self.dyn_explicit = set()
 
-    def evaluate(self, source_path: str, viewport_params: Optional[dict] = None):
+    def evaluate(self, source_path: str, viewport_params: Optional[dict] = None,
+                 generate: bool = True):
+        """Run `source_path` and return (bodies, id_to_node).
+
+        `generate=False` stops after the resolve pass. The script still runs
+        in full, so everything it echoes, warns or errors about is reported
+        exactly as usual -- but no Manifold geometry is built, and `bodies`
+        and `csg_tree` both come back empty. For a caller that only wants to
+        know whether a script RUNS (a docs check, a smoke test) that skips
+        the geometry without skipping the language.
+
+        Ignored on the debugger path, which has no geometry handle anyway.
+        """
         vp = viewport_params or {}
         try:
             if self._debug_hook is not None:
@@ -512,7 +524,7 @@ class Evaluator:
             else:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry) = _ext.evaluate(
-                    source_path, vp, self._manifold_cache, self._profile)
+                    source_path, vp, self._manifold_cache, self._profile, generate)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/src/csg_resolve.cpp

@@ -244,7 +244,8 @@ std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTree(const std::vector<c
 
 template <typename NodeList>
 std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalContext& ctx,
-                                                  const std::unordered_map<std::string, Value>& viewportParams) {
+                                                  const std::unordered_map<std::string, Value>& viewportParams,
+                                                  bool generate) {
     // Seeds ctx.dyn directly, deliberately not touching ctx.dynExplicit --
     // see this method's own doc comment in evaluator.hpp for why that
     // distinction matters to a caller.
@@ -260,7 +261,10 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     std::vector<std::unique_ptr<CSGNode>> tree = resolveTreeImpl(nodes, ctx);
     rerootAtShowOnly(tree);
     const Clock::time_point resolveEnd = profiling_ ? Clock::now() : Clock::time_point{};
-    std::vector<ColoredBody> result = generateTree(tree);
+    // generate = false is the resolve-only path: the language has run and
+    // the tree is built, so anything the script itself gets wrong has already
+    // been reported -- only the Manifold work is skipped.
+    std::vector<ColoredBody> result = generate ? generateTree(tree) : std::vector<ColoredBody>{};
     const Clock::time_point generateEnd = profiling_ ? Clock::now() : Clock::time_point{};
     csgTree = std::move(tree); // stash for caller inspection -- see the member's own doc comment
 
@@ -332,13 +336,15 @@ void Evaluator::rerootAtShowOnly(std::vector<std::unique_ptr<CSGNode>>& tree) {
 }
 
 std::vector<ColoredBody> Evaluator::evaluate(const std::vector<std::unique_ptr<oscad::ASTNode>>& nodes, EvalContext& ctx,
-                                              const std::unordered_map<std::string, Value>& viewportParams) {
-    return evaluateImpl(nodes, ctx, viewportParams);
+                                              const std::unordered_map<std::string, Value>& viewportParams,
+                                              bool generate) {
+    return evaluateImpl(nodes, ctx, viewportParams, generate);
 }
 
 std::vector<ColoredBody> Evaluator::evaluate(const std::vector<const oscad::ASTNode*>& nodes, EvalContext& ctx,
-                                              const std::unordered_map<std::string, Value>& viewportParams) {
-    return evaluateImpl(nodes, ctx, viewportParams);
+                                              const std::unordered_map<std::string, Value>& viewportParams,
+                                              bool generate) {
+    return evaluateImpl(nodes, ctx, viewportParams, generate);
 }
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/tests/test_python_bindings.py

@@ -405,3 +405,47 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+
+def test_evaluate_generate_false_skips_geometry(tmp_path):
+    """generate=False runs the script but builds no Manifold geometry.
+
+    The point of the flag is a docs/smoke check that answers "does this
+    script run?" without paying for the solids, matching what the reference
+    does for `openscad -o out.term`.
+    """
+    from openscad_cpp_evaluator import Evaluator
+
+    src = tmp_path / "m.scad"
+    src.write_text("echo(\"ran\");\ndifference() { cube(10, center=true); sphere(6.4); }\n")
+
+    echoes = []
+    ev = Evaluator(echo_fn=echoes.append)
+    bodies, _ids = ev.evaluate(str(src), {}, generate=False)
+
+    # The language ran: the echo came out.
+    assert any("ran" in e for e in echoes)
+    # The geometry did not.
+    assert list(bodies) == []
+    assert ev.csg_tree == []
+
+    # And the same file with generate left alone still produces geometry,
+    # so the flag is what made the difference, not the script.
+    echoes2 = []
+    ev2 = Evaluator(echo_fn=echoes2.append)
+    bodies2, _ids2 = ev2.evaluate(str(src), {})
+    assert any("ran" in e for e in echoes2)
+    assert len(list(bodies2)) > 0
+    assert ev2.csg_tree != []
+
+
+def test_evaluate_generate_false_still_reports_script_errors(tmp_path):
+    """Resolve-only is still a real check: a script that fails, fails."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    src = tmp_path / "bad.scad"
+    src.write_text("assert(false, \"nope\");\ncube(1);\n")
+
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {}, generate=False)

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.1.0}/uv.lock

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