cpp-pd-code-simplify-interface 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

cpp_pd_code_simplify_interface/_worker.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+from .main import _run_one_direct
+
+
+def main() -> int:
+    try:
+        request: dict[str, Any] = json.loads(sys.stdin.read())
+        result = _run_one_direct(
+            str(request.get("pd_text", "")),
+            max_paths=int(request.get("max_paths", -1)),
+            ban_heuristic=bool(request.get("ban_heuristic", False)),
+            reduction_round=int(request.get("reduction_round", -1)),
+            max_thread=int(request.get("max_thread", -1)),
+            timeout=int(request.get("timeout", -1)),
+            verbose=bool(request.get("verbose", False)),
+            known_crossingless_components=int(
+                request.get("known_crossingless_components", 0)
+            ),
+            remove_crossings=request.get("remove_crossings") or [],
+        )
+        print(json.dumps({"ok": True, "result": result}, separators=(",", ":")))
+        return 0
+    except KeyboardInterrupt:
+        print(
+            json.dumps(
+                {"ok": False, "error": "interrupted by Ctrl+C"},
+                separators=(",", ":"),
+            )
+        )
+        return 130
+    except BaseException as exc:  # noqa: BLE001 - return errors through JSON.
+        print(
+            json.dumps(
+                {"ok": False, "error": str(exc)},
+                separators=(",", ":"),
+            )
+        )
+        return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <array>
+#include <chrono>
 #include <cstddef>
 #include <functional>
 #include <iosfwd>
@@ -51,10 +52,14 @@ struct GreenCrossing {
 struct SimplifierOptions {
     int max_paths = -1;
     int max_threads = -1;
+    int timeout_seconds = -1;
+    bool has_timeout_deadline = false;
+    std::chrono::steady_clock::time_point timeout_deadline{};
     bool ban_heuristic = false;
     bool require_applicable = false;
     bool verbose = false;
     std::function<void(const std::string&)> progress;
+    std::function<bool()> should_cancel;
 };
 
 struct LinkComponentSummary {
@@ -121,6 +126,7 @@ struct ReductionResult {
     std::size_t tested_green_paths = 0;
     std::string last_path_search_mode;
     bool stopped_by_round_limit = false;
+    bool timed_out = false;
 };
 
 PDCODE_SIMPLIFY_API PDCode parse_pd_code(const std::string& text);

cpp_pd_code_simplify_interface/data/src/native_interface.cpp

@@ -106,7 +106,8 @@ std::string result_to_json(
     out << "\"tested_green_paths\":" << result.tested_green_paths << ",";
     out << "\"last_path_search_mode\":\"" << json_escape(result.last_path_search_mode) << "\",";
     out << "\"stopped_by_round_limit\":"
-        << (result.stopped_by_round_limit ? "true" : "false");
+        << (result.stopped_by_round_limit ? "true" : "false") << ",";
+    out << "\"timed_out\":" << (result.timed_out ? "true" : "false");
     out << "}";
     return out.str();
 }
@@ -133,6 +134,7 @@ char* pdcode_simplify_run_json(
     int ban_heuristic,
     int reduction_round,
     int max_thread,
+    int timeout_seconds,
     int verbose,
     unsigned long long known_crossingless_components,
     const int* removed_crossings,
@@ -146,6 +148,7 @@ char* pdcode_simplify_run_json(
         pdcode_simplify::SimplifierOptions options;
         options.max_paths = max_paths;
         options.max_threads = max_thread;
+        options.timeout_seconds = timeout_seconds;
         options.ban_heuristic = ban_heuristic != 0;
         options.verbose = verbose != 0;
         options.progress = [](const std::string& message) {

cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp

@@ -1,6 +1,7 @@
 #include "pdcode_simplify/pdcode_simplify.hpp"
 
 #include <algorithm>
+#include <chrono>
 #include <cctype>
 #include <cstdlib>
 #include <deque>
@@ -987,7 +988,10 @@ std::set<int> normalized_removed_crossings(const PDCode& code, const std::vector
 std::vector<int> heuristic_distances_to_target(
     const DualGraph& graph,
     int target,
-    int cutoff);
+    int cutoff,
+    const SimplifierOptions& options);
+
+void check_timeout(const SimplifierOptions& options);
 
 void collect_simple_paths_dfs(
     const DualGraph& graph,
@@ -999,7 +1003,9 @@ void collect_simple_paths_dfs(
     const std::vector<int>& distance,
     std::vector<char>& visited,
     std::vector<int>& current_path,
-    std::vector<std::vector<int>>& paths) {
+    std::vector<std::vector<int>>& paths,
+    const SimplifierOptions& options) {
+    check_timeout(options);
     const int infinity = std::numeric_limits<int>::max() / 4;
     if (static_cast<int>(current_path.size()) - 1 >= cutoff) {
         return;
@@ -1045,7 +1051,8 @@ void collect_simple_paths_dfs(
                 distance,
                 visited,
                 current_path,
-                paths);
+                paths,
+                options);
             if (max_paths != -1 && static_cast<int>(paths.size()) > max_paths) {
                 visited[next] = false;
                 current_path.pop_back();
@@ -1063,18 +1070,24 @@ std::vector<std::vector<int>> collect_simple_paths(
     int source,
     int target,
     int cutoff,
-    int max_paths) {
+    int max_paths,
+    const SimplifierOptions& options) {
+    check_timeout(options);
     std::vector<std::vector<int>> paths;
-    if (source == target || source < 0 || target < 0 ||
+    if (source < 0 || target < 0 ||
         source >= static_cast<int>(graph.faces.size()) ||
         target >= static_cast<int>(graph.faces.size()) ||
         cutoff <= 0) {
         return paths;
     }
+    if (source == target) {
+        paths.push_back(std::vector<int>{source});
+        return paths;
+    }
 
     std::vector<char> visited(graph.faces.size(), false);
     std::vector<int> current_path{source};
-    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff);
+    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff, options);
     visited[source] = true;
     collect_simple_paths_dfs(
         graph,
@@ -1086,14 +1099,16 @@ std::vector<std::vector<int>> collect_simple_paths(
         distance,
         visited,
         current_path,
-        paths);
+        paths,
+        options);
     return paths;
 }
 
 std::vector<int> heuristic_distances_to_target(
     const DualGraph& graph,
     int target,
-    int cutoff) {
+    int cutoff,
+    const SimplifierOptions& options) {
     const int face_count = static_cast<int>(graph.faces.size());
     const int infinity = std::numeric_limits<int>::max() / 4;
     std::vector<int> distance(face_count, infinity);
@@ -1102,6 +1117,7 @@ std::vector<int> heuristic_distances_to_target(
     queue.push_back(target);
 
     while (!queue.empty()) {
+        check_timeout(options);
         const int current = queue.front();
         queue.pop_front();
         for (int edge_index : graph.adjacency[current]) {
@@ -1179,15 +1195,21 @@ std::vector<std::vector<int>> collect_heuristic_paths(
     const DualGraph& graph,
     int source,
     int target,
-    int cutoff) {
+    int cutoff,
+    const SimplifierOptions& options) {
+    check_timeout(options);
     std::vector<std::vector<int>> paths;
     const int face_count = static_cast<int>(graph.faces.size());
-    if (source == target || source < 0 || target < 0 ||
+    if (source < 0 || target < 0 ||
         source >= face_count || target >= face_count || cutoff <= 0) {
         return paths;
     }
+    if (source == target) {
+        paths.push_back(std::vector<int>{source});
+        return paths;
+    }
 
-    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff);
+    const std::vector<int> distance = heuristic_distances_to_target(graph, target, cutoff, options);
     const int infinity = std::numeric_limits<int>::max() / 4;
     if (distance[source] == infinity || distance[source] >= cutoff) {
         return paths;
@@ -1215,6 +1237,7 @@ std::vector<std::vector<int>> collect_heuristic_paths(
     int popped_states = 0;
     while (!queue.empty() && popped_states < state_budget &&
            static_cast<int>(paths.size()) < path_budget) {
+        check_timeout(options);
         HeuristicState state = queue.top();
         queue.pop();
         ++popped_states;
@@ -1823,6 +1846,41 @@ std::string search_mode_for_options(const SimplifierOptions& options) {
     return "bounded";
 }
 
+void validate_timeout_options(const SimplifierOptions& options) {
+    if (options.timeout_seconds < -1 || options.timeout_seconds == 0) {
+        throw std::invalid_argument("timeout must be -1 or a positive integer");
+    }
+}
+
+class TimeoutError : public std::runtime_error {
+public:
+    explicit TimeoutError(const std::string& message) : std::runtime_error(message) {}
+};
+
+SimplifierOptions with_timeout_deadline(SimplifierOptions options) {
+    validate_timeout_options(options);
+    if (options.timeout_seconds > 0 && !options.has_timeout_deadline) {
+        options.has_timeout_deadline = true;
+        options.timeout_deadline =
+            std::chrono::steady_clock::now() + std::chrono::seconds(options.timeout_seconds);
+    }
+    return options;
+}
+
+void check_timeout(const SimplifierOptions& options) {
+    if (options.should_cancel && options.should_cancel()) {
+        throw std::runtime_error("interrupted by Ctrl+C");
+    }
+    if (!options.has_timeout_deadline) {
+        return;
+    }
+    if (std::chrono::steady_clock::now() >= options.timeout_deadline) {
+        std::ostringstream message;
+        message << "timeout after " << options.timeout_seconds << " seconds";
+        throw TimeoutError(message.str());
+    }
+}
+
 }  // namespace
 
 PDCode parse_pd_code(const std::string& text) {
@@ -2213,6 +2271,7 @@ RedPathSearchOutcome search_single_red_path(
     const std::string& path_search_mode,
     int red_index,
     const std::atomic<int>* best_found_index) {
+    check_timeout(options);
     RedPathSearchOutcome outcome;
     outcome.witness.path_search_mode = path_search_mode;
     if (should_skip_parallel_red_path(red_index, best_found_index)) {
@@ -2231,6 +2290,7 @@ RedPathSearchOutcome search_single_red_path(
     const std::array<int, 2> destinations{end_face, end_opposite_face};
 
     for (std::size_t i = 1; i + 1 < red_path.size(); ++i) {
+        check_timeout(options);
         const Endpoint endpoint = red_path[i];
         const int right_region = graph.edge_to_face[endpoint_key(endpoint)];
         const int left_region = graph.edge_to_face[endpoint_key(diagram.opposite(endpoint))];
@@ -2243,15 +2303,17 @@ RedPathSearchOutcome search_single_red_path(
     const int cutoff = static_cast<int>(red_path.size()) - 1;
     for (int source : sources) {
         for (int destination : destinations) {
+            check_timeout(options);
             if (should_skip_parallel_red_path(red_index, best_found_index)) {
                 outcome.skipped = true;
                 return outcome;
             }
             std::vector<std::vector<int>> found_paths;
             if (options.max_paths == -1 && !options.ban_heuristic) {
-                found_paths = collect_heuristic_paths(graph, source, destination, cutoff);
+                found_paths = collect_heuristic_paths(graph, source, destination, cutoff, options);
             } else {
-                found_paths = collect_simple_paths(graph, source, destination, cutoff, options.max_paths);
+                found_paths = collect_simple_paths(
+                    graph, source, destination, cutoff, options.max_paths, options);
             }
             paths.insert(paths.end(), found_paths.begin(), found_paths.end());
             if (options.max_paths != -1 && static_cast<int>(paths.size()) > options.max_paths) {
@@ -2261,6 +2323,7 @@ RedPathSearchOutcome search_single_red_path(
     }
 
     for (const auto& green_path : paths) {
+        check_timeout(options);
         if (should_skip_parallel_red_path(red_index, best_found_index)) {
             outcome.skipped = true;
             return outcome;
@@ -2401,36 +2464,49 @@ SimplificationResult find_simplification_parallel_bruteforce(
 SimplificationResult find_simplification(
     const PDCode& code,
     const SimplifierOptions& options) {
+    const SimplifierOptions run_options = with_timeout_deadline(options);
+    check_timeout(run_options);
     SimplificationResult result;
-    result.path_search_mode = search_mode_for_options(options);
+    result.path_search_mode = search_mode_for_options(run_options);
     Diagram diagram(code);
+    check_timeout(run_options);
     DualGraph base_graph(diagram);
+    check_timeout(run_options);
     const auto red_lines = possible_red_lines(diagram);
-    const bool brute_force_mode = options.max_paths == -1 && options.ban_heuristic;
+    check_timeout(run_options);
+    const bool brute_force_mode = run_options.max_paths == -1 && run_options.ban_heuristic;
     const int worker_count = brute_force_mode
         ? selected_bruteforce_worker_count(
-              options.max_threads,
+              run_options.max_threads,
               static_cast<int>(red_lines.size()))
         : 1;
+    if (brute_force_mode && run_options.max_threads == -1) {
+        std::ostringstream message;
+        message << "bruteforce_threads max_thread=-1"
+                << " actual_threads=" << worker_count
+                << " red_paths=" << red_lines.size();
+        emit_progress(run_options, message.str());
+    }
     if (worker_count > 1) {
         return find_simplification_parallel_bruteforce(
             code,
             diagram,
             base_graph,
             red_lines,
-            options,
+            run_options,
             result.path_search_mode,
             worker_count);
     }
 
     for (const auto& red_path : red_lines) {
+        check_timeout(run_options);
         ++result.tested_red_paths;
         const RedPathSearchOutcome outcome = search_single_red_path(
             code,
             diagram,
             base_graph,
             red_path,
-            options,
+            run_options,
             result.path_search_mode,
             -1,
             nullptr);
@@ -2452,125 +2528,155 @@ ReductionResult reduce_pd_code(
     std::size_t known_crossingless_components,
     const SimplifierOptions& options,
     int reduction_round) {
-    {
-        std::ostringstream message;
-        message << "start input_crossings=" << code.size()
-                << " known_crossingless_components=" << known_crossingless_components
-                << " reduction_round=" << reduction_round
-                << " max_paths=" << options.max_paths
-                << " max_thread=" << options.max_threads
-                << " heuristic=" << (options.ban_heuristic ? "off" : "on");
-        emit_progress(options, message.str());
-    }
-
-    const PDSimplificationResult prepared = simplify_pd_code(code, known_crossingless_components);
+    const SimplifierOptions run_options = with_timeout_deadline(options);
     ReductionResult output;
-    output.code = prepared.code;
-    output.crossingless_components = prepared.crossingless_components;
-    output.reidemeister_i_moves = prepared.reidemeister_i_moves;
-    output.nugatory_crossing_moves = prepared.nugatory_crossing_moves;
-    {
-        std::ostringstream message;
-        message << "pre_simplify input_crossings=" << code.size()
-                << " output_crossings=" << output.code.size()
-                << " crossingless_components=" << output.crossingless_components
-                << " r1_moves=" << prepared.reidemeister_i_moves
-                << " nugatory_moves=" << prepared.nugatory_crossing_moves;
-        emit_progress(options, message.str());
-    }
+    output.code = code;
+    output.crossingless_components = known_crossingless_components;
 
-    while (reduction_round < 0 || output.mid_simplification_rounds < reduction_round) {
-        SimplifierOptions search_options = options;
-        search_options.require_applicable = true;
-        const int round = output.mid_simplification_rounds + 1;
+    try {
+        check_timeout(run_options);
         {
             std::ostringstream message;
-            message << "round " << round
-                    << " search_start crossings=" << output.code.size()
-                    << " mode=" << search_mode_for_options(search_options)
-                    << " max_thread=" << search_options.max_threads;
-            emit_progress(options, message.str());
-        }
-        SimplificationResult search = find_simplification(output.code, search_options);
-        output.tested_red_paths += search.tested_red_paths;
-        output.tested_green_paths += search.tested_green_paths;
-        output.last_path_search_mode = search.path_search_mode;
+            message << "start input_crossings=" << code.size()
+                    << " known_crossingless_components=" << known_crossingless_components
+                    << " reduction_round=" << reduction_round
+                    << " max_paths=" << run_options.max_paths
+                    << " max_thread=" << run_options.max_threads
+                    << " timeout=" << run_options.timeout_seconds
+                    << " heuristic=" << (run_options.ban_heuristic ? "off" : "on");
+            emit_progress(run_options, message.str());
+        }
+
+        const PDSimplificationResult prepared =
+            simplify_pd_code(code, known_crossingless_components);
+        output.code = prepared.code;
+        output.crossingless_components = prepared.crossingless_components;
+        output.reidemeister_i_moves = prepared.reidemeister_i_moves;
+        output.nugatory_crossing_moves = prepared.nugatory_crossing_moves;
+        check_timeout(run_options);
         {
             std::ostringstream message;
-            message << "round " << round
-                    << " search_done found=" << (search.found ? "yes" : "no")
-                    << " mode=" << search.path_search_mode
-                    << " tested_red=" << search.tested_red_paths
-                    << " tested_green=" << search.tested_green_paths;
-            emit_progress(options, message.str());
-        }
-
-        if (!search.found && reduction_round < 0 &&
-            options.max_paths == -1 && !options.ban_heuristic) {
-            SimplifierOptions brute_options = options;
-            brute_options.max_paths = -1;
-            brute_options.ban_heuristic = true;
-            brute_options.require_applicable = true;
+            message << "pre_simplify input_crossings=" << code.size()
+                    << " output_crossings=" << output.code.size()
+                    << " crossingless_components=" << output.crossingless_components
+                    << " r1_moves=" << prepared.reidemeister_i_moves
+                    << " nugatory_moves=" << prepared.nugatory_crossing_moves;
+            emit_progress(run_options, message.str());
+        }
+
+        while (reduction_round < 0 || output.mid_simplification_rounds < reduction_round) {
+            check_timeout(run_options);
+            SimplifierOptions search_options = run_options;
+            search_options.require_applicable = true;
+            output.last_path_search_mode = search_mode_for_options(search_options);
+            const int round = output.mid_simplification_rounds + 1;
             {
                 std::ostringstream message;
                 message << "round " << round
-                        << " brute_fallback_start crossings=" << output.code.size()
-                        << " max_thread=" << brute_options.max_threads;
-                emit_progress(options, message.str());
-            }
-            SimplificationResult brute = find_simplification(output.code, brute_options);
-            output.tested_red_paths += brute.tested_red_paths;
-            output.tested_green_paths += brute.tested_green_paths;
-            output.last_path_search_mode = brute.path_search_mode;
+                        << " search_start crossings=" << output.code.size()
+                        << " mode=" << output.last_path_search_mode
+                        << " max_thread=" << search_options.max_threads;
+                emit_progress(run_options, message.str());
+            }
+            SimplificationResult search = find_simplification(output.code, search_options);
+            output.tested_red_paths += search.tested_red_paths;
+            output.tested_green_paths += search.tested_green_paths;
+            output.last_path_search_mode = search.path_search_mode;
             {
                 std::ostringstream message;
                 message << "round " << round
-                        << " brute_fallback_done found=" << (brute.found ? "yes" : "no")
-                        << " tested_red=" << brute.tested_red_paths
-                        << " tested_green=" << brute.tested_green_paths;
-                emit_progress(options, message.str());
+                        << " search_done found=" << (search.found ? "yes" : "no")
+                        << " mode=" << search.path_search_mode
+                        << " tested_red=" << search.tested_red_paths
+                        << " tested_green=" << search.tested_green_paths;
+                emit_progress(run_options, message.str());
+            }
+
+            if (!search.found && reduction_round < 0 &&
+                run_options.max_paths == -1 && !run_options.ban_heuristic) {
+                SimplifierOptions brute_options = run_options;
+                brute_options.max_paths = -1;
+                brute_options.ban_heuristic = true;
+                brute_options.require_applicable = true;
+                output.last_path_search_mode = search_mode_for_options(brute_options);
+                {
+                    std::ostringstream message;
+                    message << "round " << round
+                            << " brute_fallback_start crossings=" << output.code.size()
+                            << " max_thread=" << brute_options.max_threads;
+                    emit_progress(run_options, message.str());
+                }
+                SimplificationResult brute = find_simplification(output.code, brute_options);
+                output.tested_red_paths += brute.tested_red_paths;
+                output.tested_green_paths += brute.tested_green_paths;
+                output.last_path_search_mode = brute.path_search_mode;
+                {
+                    std::ostringstream message;
+                    message << "round " << round
+                            << " brute_fallback_done found=" << (brute.found ? "yes" : "no")
+                            << " tested_red=" << brute.tested_red_paths
+                            << " tested_green=" << brute.tested_green_paths;
+                    emit_progress(run_options, message.str());
+                }
+                if (brute.found) {
+                    ++output.heuristic_failover_rounds;
+                    search = std::move(brute);
+                }
             }
-            if (brute.found) {
-                ++output.heuristic_failover_rounds;
-                search = std::move(brute);
+
+            if (!search.found) {
+                {
+                    std::ostringstream message;
+                    message << "round " << round
+                            << " stop_no_path crossings=" << output.code.size();
+                    emit_progress(run_options, message.str());
+                }
+                break;
             }
-        }
 
-        if (!search.found) {
+            const std::size_t before_apply_crossings = output.code.size();
+            check_timeout(run_options);
+            const MidSimplificationApplyResult applied =
+                apply_simplification_witness(output.code, search, output.crossingless_components);
+            ++output.mid_simplification_rounds;
+            output.code = applied.code;
+            output.crossingless_components = applied.crossingless_components;
+            check_timeout(run_options);
+            const PDSimplificationResult simplified =
+                simplify_pd_code(output.code, output.crossingless_components);
+            output.code = simplified.code;
+            output.crossingless_components = simplified.crossingless_components;
+            output.reidemeister_i_moves += simplified.reidemeister_i_moves;
+            output.nugatory_crossing_moves += simplified.nugatory_crossing_moves;
+            check_timeout(run_options);
             {
                 std::ostringstream message;
                 message << "round " << round
-                        << " stop_no_path crossings=" << output.code.size();
-                emit_progress(options, message.str());
+                        << " applied crossings=" << before_apply_crossings
+                        << " -> " << applied.code.size()
+                        << " -> " << output.code.size()
+                        << " crossingless_components=" << output.crossingless_components
+                        << " r1_moves=" << simplified.reidemeister_i_moves
+                        << " nugatory_moves=" << simplified.nugatory_crossing_moves;
+                emit_progress(run_options, message.str());
             }
-            break;
         }
-
-        const std::size_t before_apply_crossings = output.code.size();
-        const MidSimplificationApplyResult applied =
-            apply_simplification_witness(output.code, search, output.crossingless_components);
-        ++output.mid_simplification_rounds;
-        const PDSimplificationResult simplified =
-            simplify_pd_code(applied.code, applied.crossingless_components);
-        output.code = simplified.code;
-        output.crossingless_components = simplified.crossingless_components;
-        output.reidemeister_i_moves += simplified.reidemeister_i_moves;
-        output.nugatory_crossing_moves += simplified.nugatory_crossing_moves;
+    } catch (const TimeoutError& error) {
+        output.timed_out = true;
         {
             std::ostringstream message;
-            message << "round " << round
-                    << " applied crossings=" << before_apply_crossings
-                    << " -> " << applied.code.size()
-                    << " -> " << output.code.size()
+            message << error.what()
+                    << "; returning_current_best crossings=" << output.code.size()
                     << " crossingless_components=" << output.crossingless_components
-                    << " r1_moves=" << simplified.reidemeister_i_moves
-                    << " nugatory_moves=" << simplified.nugatory_crossing_moves;
-            emit_progress(options, message.str());
+                    << " mid_rounds=" << output.mid_simplification_rounds;
+            emit_progress(run_options, message.str());
         }
     }
 
     output.stopped_by_round_limit =
-        reduction_round >= 0 && output.mid_simplification_rounds >= reduction_round;
+        !output.timed_out &&
+        reduction_round >= 0 &&
+        output.mid_simplification_rounds >= reduction_round;
     {
         std::ostringstream message;
         message << "done final_crossings=" << output.code.size()
@@ -2578,8 +2684,9 @@ ReductionResult reduce_pd_code(
                 << " mid_rounds=" << output.mid_simplification_rounds
                 << " heuristic_failover_rounds=" << output.heuristic_failover_rounds
                 << " stopped_by_round_limit="
-                << (output.stopped_by_round_limit ? "yes" : "no");
-        emit_progress(options, message.str());
+                << (output.stopped_by_round_limit ? "yes" : "no")
+                << " timed_out=" << (output.timed_out ? "yes" : "no");
+        emit_progress(run_options, message.str());
     }
     return output;
 }

cpp_pd_code_simplify_interface/main.py

@@ -762,6 +762,7 @@ def _load_library() -> ctypes.CDLL:
         ctypes.c_int,
         ctypes.c_int,
         ctypes.c_int,
+        ctypes.c_int,
         ctypes.c_ulonglong,
         ctypes.POINTER(ctypes.c_int),
         ctypes.c_ulonglong,
@@ -774,13 +775,14 @@ def _load_library() -> ctypes.CDLL:
     return library
 
 
-def _run_one(
+def _run_one_direct(
     pd_text: str,
     *,
     max_paths: int = -1,
     ban_heuristic: bool = False,
     reduction_round: int = -1,
     max_thread: int = -1,
+    timeout: int = -1,
     verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
@@ -789,6 +791,8 @@ def _run_one(
         raise ValueError("reduction_round must be -1 or a non-negative integer")
     if max_thread < -1 or max_thread == 0:
         raise ValueError("max_thread must be -1 or a positive integer")
+    if timeout < -1 or timeout == 0:
+        raise ValueError("timeout must be -1 or a positive integer")
     library = _load_library()
     removed_count = 0 if remove_crossings is None else len(remove_crossings)
     removed_array = None
@@ -801,6 +805,7 @@ def _run_one(
         1 if ban_heuristic else 0,
         int(reduction_round),
         int(max_thread),
+        int(timeout),
         1 if verbose else 0,
         int(known_crossingless_components),
         removed_array,
@@ -822,6 +827,93 @@ def _run_one(
     return result
 
 
+def _terminate_process(proc: subprocess.Popen[str]) -> None:
+    if proc.poll() is not None:
+        return
+    proc.terminate()
+    try:
+        proc.wait(timeout=2.0)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        proc.wait()
+
+
+def _run_one(
+    pd_text: str,
+    *,
+    max_paths: int = -1,
+    ban_heuristic: bool = False,
+    reduction_round: int = -1,
+    max_thread: int = -1,
+    timeout: int = -1,
+    verbose: bool = False,
+    known_crossingless_components: int = 0,
+    remove_crossings: Optional[Sequence[int]] = None,
+) -> dict[str, Any]:
+    if reduction_round < -1:
+        raise ValueError("reduction_round must be -1 or a non-negative integer")
+    if max_thread < -1 or max_thread == 0:
+        raise ValueError("max_thread must be -1 or a positive integer")
+    if timeout < -1 or timeout == 0:
+        raise ValueError("timeout must be -1 or a positive integer")
+
+    request = {
+        "pd_text": pd_text,
+        "max_paths": int(max_paths),
+        "ban_heuristic": bool(ban_heuristic),
+        "reduction_round": int(reduction_round),
+        "max_thread": int(max_thread),
+        "timeout": int(timeout),
+        "verbose": bool(verbose),
+        "known_crossingless_components": int(known_crossingless_components),
+        "remove_crossings": [int(value) for value in remove_crossings or []],
+    }
+    env = os.environ.copy()
+    project_root = str(pathlib.Path(__file__).resolve().parents[1])
+    env["PYTHONPATH"] = project_root + os.pathsep + env.get("PYTHONPATH", "")
+    proc = subprocess.Popen(
+        [
+            sys.executable,
+            "-m",
+            "cpp_pd_code_simplify_interface._worker",
+        ],
+        cwd=str(pathlib.Path.cwd()),
+        text=True,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=None if verbose else subprocess.PIPE,
+        env=env,
+    )
+    try:
+        stdout, stderr = proc.communicate(json.dumps(request))
+    except KeyboardInterrupt:
+        _terminate_process(proc)
+        raise
+
+    if proc.returncode != 0:
+        detail = (stderr or "").strip()
+        raise PdCodeSimplifyInterfaceError(
+            f"C++ interface worker failed with exit code {proc.returncode}"
+            + (f": {detail}" if detail else "")
+        )
+    try:
+        envelope = json.loads(stdout)
+    except json.JSONDecodeError as exc:
+        raise PdCodeSimplifyInterfaceError(
+            f"invalid interface worker JSON output: {stdout!r}"
+        ) from exc
+    if not isinstance(envelope, dict):
+        raise PdCodeSimplifyInterfaceError(
+            f"invalid interface worker response type: {type(envelope)!r}"
+        )
+    if not envelope.get("ok", False):
+        raise PdCodeSimplifyInterfaceError(str(envelope.get("error", "unknown worker error")))
+    result = envelope.get("result")
+    if not isinstance(result, dict):
+        raise PdCodeSimplifyInterfaceError("interface worker did not return a JSON object result")
+    return result
+
+
 def simplify(
     pd_code: PdInput,
     *,
@@ -829,6 +921,7 @@ def simplify(
     ban_heuristic: bool = False,
     reduction_round: int = -1,
     max_thread: int = -1,
+    timeout: int = -1,
     verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
@@ -841,6 +934,7 @@ def simplify(
         ban_heuristic=ban_heuristic,
         reduction_round=reduction_round,
         max_thread=max_thread,
+        timeout=timeout,
         verbose=verbose,
         known_crossingless_components=known_crossingless_components,
         remove_crossings=remove_crossings,
@@ -854,6 +948,7 @@ def simplify_many(
     ban_heuristic: bool = False,
     reduction_round: int = -1,
     max_thread: int = -1,
+    timeout: int = -1,
     verbose: bool = False,
     known_crossingless_components: int = 0,
     remove_crossings: Optional[Sequence[int]] = None,
@@ -867,6 +962,7 @@ def simplify_many(
             ban_heuristic=ban_heuristic,
             reduction_round=reduction_round,
             max_thread=max_thread,
+            timeout=timeout,
             verbose=verbose,
             known_crossingless_components=known_crossingless_components,
             remove_crossings=remove_crossings,
@@ -884,6 +980,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     parser.add_argument("--ban-heuristic", action="store_true")
     parser.add_argument("--reduction-round", type=int, default=-1)
     parser.add_argument("--max-thread", type=int, default=-1)
+    parser.add_argument("--timeout", type=int, default=-1)
     parser.add_argument("--verbose", action="store_true")
     parser.add_argument("--known-crossingless-components", type=int, default=0)
     parser.add_argument("--remove-crossings", help="comma-separated zero-based crossing indices")
@@ -892,6 +989,8 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
         parser.error("--reduction-round must be -1 or a non-negative integer")
     if args.max_thread < -1 or args.max_thread == 0:
         parser.error("--max-thread must be -1 or a positive integer")
+    if args.timeout < -1 or args.timeout == 0:
+        parser.error("--timeout must be -1 or a positive integer")
     if args.pd_code and args.pd_code_option:
         parser.error("pass either a positional PD code or --pd-code, not both")
     pd_code_text = args.pd_code_option or args.pd_code
@@ -916,6 +1015,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                     ban_heuristic=args.ban_heuristic,
                     reduction_round=args.reduction_round,
                     max_thread=args.max_thread,
+                    timeout=args.timeout,
                     verbose=args.verbose,
                     known_crossingless_components=args.known_crossingless_components,
                     remove_crossings=remove_crossings,
@@ -923,6 +1023,15 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 if show_labels:
                     item = {"label": label, **item}
                 batch_payload.append(item)
+                if item.get("timed_out"):
+                    exit_code = 2
+            except KeyboardInterrupt:
+                exit_code = 130
+                item = {"error": "interrupted by Ctrl+C"}
+                if show_labels:
+                    item = {"label": label, **item}
+                batch_payload.append(item)
+                break
             except Exception as exc:
                 exit_code = 2
                 item = {"error": str(exc)}
@@ -931,16 +1040,26 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
                 batch_payload.append(item)
         payload: Any = batch_payload
     else:
-        payload = simplify(
-            pd_code_text or "",
-            max_paths=args.max_paths,
-            ban_heuristic=args.ban_heuristic,
-            reduction_round=args.reduction_round,
-            max_thread=args.max_thread,
-            verbose=args.verbose,
-            known_crossingless_components=args.known_crossingless_components,
-            remove_crossings=remove_crossings,
-        )
+        try:
+            payload = simplify(
+                pd_code_text or "",
+                max_paths=args.max_paths,
+                ban_heuristic=args.ban_heuristic,
+                reduction_round=args.reduction_round,
+                max_thread=args.max_thread,
+                timeout=args.timeout,
+                verbose=args.verbose,
+                known_crossingless_components=args.known_crossingless_components,
+                remove_crossings=remove_crossings,
+            )
+            if isinstance(payload, dict) and payload.get("timed_out"):
+                exit_code = 2
+        except KeyboardInterrupt:
+            exit_code = 130
+            payload = {"error": "interrupted by Ctrl+C"}
+        except Exception as exc:
+            exit_code = 2
+            payload = {"error": str(exc)}
 
     print(json.dumps(payload, indent=2))
     return exit_code

{cpp_pd_code_simplify_interface-0.1.11.dist-info → cpp_pd_code_simplify_interface-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpp-pd-code-simplify-interface
-Version: 0.1.11
+Version: 0.1.13
 Summary: Python interface for cpp-pd-code-simplify with runtime C++ compilation.
 License-Expression: MIT
 Author: GGN_2015
@@ -69,8 +69,14 @@ The default `max_paths=-1` uses deterministic heuristic green-path sampling in
 the C++ backend. Use `ban_heuristic=True` to request exhaustive green-path
 enumeration for a manageable input. Use `reduction_round=K` to cap applied
 mid-simplification rounds; the default `-1` runs until stable. Use
-`verbose=True` to forward timestamped C++ progress logs to stderr. Verbose log
-lines use local wall-clock time in `YYYY-MM-DD HH:MM:SS` format.
+`timeout=K` to cap a call at `K` seconds; the default `-1` has no timeout. Use
+`verbose=True` to forward timestamped C++ progress logs to stderr. If a call
+times out, the returned dictionary still contains the best PD code found so far
+and sets `timed_out` to `True`. Verbose log lines use local wall-clock time in
+`YYYY-MM-DD HH:MM:SS` format. When `max_thread=-1` reaches a brute-force search
+phase, verbose logs also include `actual_threads`, the worker count selected by
+the C++ backend for that phase. The backend call runs in a helper process, so
+`Ctrl+C` can terminate active C++ work and its worker threads cleanly.
 
 Batch use:
 

cpp_pd_code_simplify_interface-0.1.13.dist-info/RECORD

@@ -0,0 +1,12 @@
+cpp_pd_code_simplify_interface/__init__.py,sha256=aaNwD--zgQX13xiU1hpuvgXy8vVTFGRk-r5zLm8zIRY,447
+cpp_pd_code_simplify_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
+cpp_pd_code_simplify_interface/_worker.py,sha256=pgvL3zlAZkUVM033YKAT1geXxcI8TxTUXLp83sgrZgw,1477
+cpp_pd_code_simplify_interface/main.py,sha256=QkhR_2Cq9Ep_8hT5qpFKML7bhq99SuQSKO0jePJHp3U,37007
+cpp_pd_code_simplify_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+cpp_pd_code_simplify_interface-0.1.13.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
+cpp_pd_code_simplify_interface-0.1.13.dist-info/METADATA,sha256=-uQyhNQjhrKxBj2_HaRqkrWhF50ojY878shH3kafxaE,4553
+cpp_pd_code_simplify_interface-0.1.13.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
+cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=ZWZVWuSXN9HgCYd88pfURgLqs-3_0xGDi_ZEPZrYUyY,5135
+cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=-X9ztIyCl5y27Yhj2vCyC4bHCeDpFlcKm6ACPMDoxHs,6708
+cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=xQd5-tirH-Mk4dLZpXAAZo6qHP4mpAFO94Z8GFCPJbg,95788
+cpp_pd_code_simplify_interface-0.1.13.dist-info/RECORD,,

cpp_pd_code_simplify_interface-0.1.11.dist-info/RECORD

@@ -1,11 +0,0 @@
-cpp_pd_code_simplify_interface/__init__.py,sha256=aaNwD--zgQX13xiU1hpuvgXy8vVTFGRk-r5zLm8zIRY,447
-cpp_pd_code_simplify_interface/__main__.py,sha256=fdA1QWBe5LNX0fbtaJXa1-dwEhrg_4sS_5UnjaajcMo,80
-cpp_pd_code_simplify_interface/main.py,sha256=4t-6xvjQjsuEWP_oiwedGtgrLYu3316uATrl9t4Q8zs,32778
-cpp_pd_code_simplify_interface/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-cpp_pd_code_simplify_interface-0.1.11.dist-info/entry_points.txt,sha256=ThorC4Enxp317TKITsXm9pE0gUp7pt-pP6Dl5mEPUR8,91
-cpp_pd_code_simplify_interface-0.1.11.dist-info/METADATA,sha256=XtZebJNhEOhA9lHFiGYYHFQJUF5DXS7ItsG0AhOALv8,4073
-cpp_pd_code_simplify_interface-0.1.11.dist-info/WHEEL,sha256=eY7nduwzv-ldUxpzbRlxwvC693Hg6PX8bWDjEHjZ_dk,88
-cpp_pd_code_simplify_interface/data/include/pdcode_simplify/pdcode_simplify.hpp,sha256=0WflWW2MB2EAK8GbcKKr9SbnoByMV3hFxt4m4mAerzQ,4917
-cpp_pd_code_simplify_interface/data/src/native_interface.cpp,sha256=16HbKJBPA_EGdbyom4sSoQ7lisDBwaKrl7NsphmlA-k,6555
-cpp_pd_code_simplify_interface/data/src/pdcode_simplify.cpp,sha256=n5rvqpHcUqS87O2AV9duSMAmrh7KUI0HwGHYd5UkMFY,91309
-cpp_pd_code_simplify_interface-0.1.11.dist-info/RECORD,,