zuspec-solver 0.1.1__py3-none-any.whl

zuspec/solver/__init__.py

@@ -0,0 +1,6 @@
+"""zuspec.solver -- Zuspec IR solve problems, translated for a solver.
+
+The translation lives in :mod:`zuspec.solver.translate`.
+"""
+
+from .__version__ import version as __version__

zuspec/solver/__version__.py

@@ -0,0 +1,20 @@
+
+#****************************************************************************
+# Copyright 2019-2025 Matthew Ballance and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#****************************************************************************
+BASE="0.1.1"
+SUFFIX=""
+VERSION="%s%s" % (BASE, SUFFIX)
+version=VERSION

zuspec/solver/translate/__init__.py

@@ -0,0 +1,31 @@
+"""
+zuspec.solver.translate -- Zuspec IR solve problems, translated for a solver.
+
+ir-core collects a solve problem (``xf.pss_lower.constraints`` ->
+``ScSolveProblem``); this package translates it, once, for whichever backend
+solves it. :func:`build_solve_blob` is the dv-solve form every in-process
+solver runs (be-bc's interpreter, its native engine, pssc's presolve).
+"""
+from __future__ import annotations
+
+from typing import Dict, Tuple
+
+from .errors import TranslateError
+from .sink import Sink, builder_sink
+from .walk import ProblemTranslator, slot_of, translate, writeback_slots
+
+__all__ = [
+    "TranslateError", "Sink", "builder_sink", "ProblemTranslator",
+    "slot_of", "translate", "writeback_slots", "build_solve_blob",
+]
+
+
+def build_solve_blob(problem) -> Tuple[bytes, Dict[int, int]]:
+    """*problem* as a relocatable dv-solve ``SolveProblem`` blob, with its
+    write-back map (object field slot -> solver var_id)."""
+    sp = builder_sink()
+    try:
+        wb = translate(problem, sp)
+        return sp.finalize_bytes(), wb
+    finally:
+        sp.destroy()

zuspec/solver/translate/errors.py

@@ -0,0 +1,14 @@
+"""Translation error type."""
+
+
+class TranslateError(Exception):
+    """A constraint the solver cannot take.
+
+    Carries an optional ``loc`` (source location). A backend re-raises it as
+    its own error type: be-bc as a ``LoweringError``, so a refusal reads the
+    same whichever package found it.
+    """
+
+    def __init__(self, message, loc=None):
+        super().__init__(message)
+        self.loc = loc

zuspec/solver/translate/sink.py

@@ -0,0 +1,56 @@
+"""
+sink.py -- what the constraint walk writes into.
+
+A sink is the subset of dv-solve's growable builder
+(``dv_solve.builder.SolveProblemBuilder``) that :mod:`.walk` calls. Each
+``expr_*`` returns a handle that a later call passes back; what a handle is is
+the sink's business (the builder's are node offsets in its blob, a C-source
+sink's would be the names of the C variables holding ``dvs_builder_*``
+results). So the builder is a sink as it stands, and a new output is a new
+class with these methods, not a second walk.
+"""
+from __future__ import annotations
+
+from typing import Dict, Iterable, List, Protocol, Sequence, Tuple
+
+
+class Sink(Protocol):
+    def add_var(self, var_id: int, width: int, is_signed: bool,
+                lo: int, hi: int) -> None: ...
+
+    def expr_const(self, value: int, is_signed: bool = ..., width: int = ...): ...
+
+    def expr_var(self, var_id: int): ...
+
+    def expr_binary(self, op: int, lhs, rhs): ...
+
+    def expr_unary(self, op: int, operand): ...
+
+    def expr_ite(self, cond, then, els): ...
+
+    def expr_cast(self, operand, width: int, is_signed: bool): ...
+
+    def expr_in_range(self, value, lo, hi): ...
+
+    def expr_in_ranges(self, value, pairs: Sequence[Tuple[object, object]]): ...
+
+    def add_constraint(self, expr) -> None: ...
+
+    def add_soft_constraint(self, expr, priority: int) -> None: ...
+
+    def add_dist(self, var_id: int, entries: List[Dict]) -> None: ...
+
+    def add_all_different(self, var_ids: Iterable[int]) -> None: ...
+
+
+def builder_sink():
+    """A fresh dv-solve growable builder. The caller ``finalize_bytes()``s it
+    and then ``destroy()``s it."""
+    try:
+        from dv_solve.builder import SolveProblemBuilder
+    except Exception as exc:  # pragma: no cover - environment-dependent
+        from .errors import TranslateError
+        raise TranslateError(
+            "dv-solve is required to build a solve blob "
+            "(cannot import dv_solve.builder): %s" % exc)
+    return SolveProblemBuilder()