dv-solve 0.2.3__py3-none-win_amd64.whl

dv_solve/__init__.py

@@ -0,0 +1,253 @@
+"""""" # start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import ctypes
+    import os
+    import platform
+    import sys
+    libs_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'dv_solve.libs'))
+    is_conda_cpython = platform.python_implementation() == 'CPython' and (hasattr(ctypes.pythonapi, 'Anaconda_GetVersion') or 'packaged by conda-forge' in sys.version)
+    if sys.version_info[:2] >= (3, 8) and not is_conda_cpython or sys.version_info[:2] >= (3, 10):
+        if os.path.isdir(libs_dir):
+            os.add_dll_directory(libs_dir)
+    else:
+        load_order_filepath = os.path.join(libs_dir, '.load-order-dv_solve-0.2.3')
+        if os.path.isfile(load_order_filepath):
+            import ctypes.wintypes
+            with open(os.path.join(libs_dir, '.load-order-dv_solve-0.2.3')) as file:
+                load_order = file.read().split()
+            kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
+            kernel32.LoadLibraryExW.restype = ctypes.wintypes.HMODULE
+            kernel32.LoadLibraryExW.argtypes = ctypes.wintypes.LPCWSTR, ctypes.wintypes.HANDLE, ctypes.wintypes.DWORD
+            for lib in load_order:
+                lib_path = os.path.join(os.path.join(libs_dir, lib))
+                if os.path.isfile(lib_path) and not kernel32.LoadLibraryExW(lib_path, None, 8):
+                    raise OSError('Error loading {}; {}'.format(lib, ctypes.FormatError(ctypes.get_last_error())))
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch
+
+import os
+import platform
+
+from . import _resolve
+
+# The same file setup.py exec()s to supply the wheel's version, so an
+# installed dv_solve and its distribution metadata cannot disagree. Importing
+# it here is safe: the constraint that ruled out a dynamic attr: is a
+# BUILD-time one (the package is not importable while the wheel is being
+# built), and by the time this runs the package is installed.
+from .__version__ import _pkg_version as __version__
+
+
+def _pkg_dir():
+    # Delegated so that ``_resolve`` is the ONE place either location is
+    # decided. Keeping a second copy here meant the fallback paths below could
+    # name a different installation than the search itself had considered.
+    return _resolve._pkg_dir()
+
+
+def _src_root():
+    # packages/dv-solve/  (up from src/dv_solve/) in a source tree.
+    return _resolve._src_root()
+
+
+def get_libs():
+    """Names of the libraries a C consumer links against."""
+    return ["dv_solve"]
+
+
+def _lib_filename(stem):
+    """The platform's file name for shared library *stem* (no directory)."""
+    return _resolve.lib_filename(stem)
+
+
+def _lib_search_dirs():
+    """Every directory a dv-solve shared library may live in, best first.
+
+    Now just the shared contract in :mod:`dv_solve._resolve`. This list used to
+    be maintained here independently of the ctypes loader's, and the two had
+    drifted: the loader also honoured ``DVS_SOLVER_PATH``, the package's
+    ``lib/`` subdirectory and three alternate build-directory names, none of
+    which this function knew about. On a host using any of them the solver ran
+    out of one installation and generated C linked against another.
+    """
+    return _resolve.lib_search_dirs()
+
+
+def get_libdirs():
+    """Directories containing the dv-solve shared libraries.
+
+    Returning only the package directory described a layout a *source tree* does
+    not have, so a consumer that compiled against a checkout failed to link:
+
+        /usr/bin/ld: cannot find -ldv_solve
+
+    which is how pssc's generated ``libpssc_scenario.so`` failed once dv-solve
+    was installed editable rather than from a wheel. The same reasoning, and the
+    same fix, as ``get_incdirs()`` -- see its docstring.
+
+    Probes for the library rather than the directory: in a source tree
+    ``build/lib`` exists as soon as CMake configures, well before anything is
+    linked into it.
+
+    Only the UNVERSIONED library name counts here, because that is the one
+    ``-ldv_solve`` resolves. It is sought in the SAME installation the ctypes
+    loader opens (see :mod:`dv_solve._resolve`). If that installation holds
+    only ``libdv_solve.so.1`` -- loadable, not linkable -- this raises
+    ``RuntimeError`` naming it. It used to carry on searching and report a
+    different installation's library, so the Python API ran one solver build
+    while generated C linked another.
+
+    Raises ``RuntimeError`` likewise when ``DVS_SOLVER_PATH`` is set but holds
+    no library: an explicit override is never silently replaced.
+    """
+    if _resolve.select_installation() is not None:
+        return [os.path.dirname(_resolve.require_library("dv_solve",
+                                                         linkable=True))]
+    # Nothing built anywhere. The package directory is the installed-wheel
+    # answer and keeps the failure identical to what a missing wheel library
+    # already produces, rather than naming a build tree that does not exist.
+    return [_pkg_dir()]
+
+
+def get_deps():
+    return []
+
+
+def get_incdirs():
+    """Directories containing the public dv-solve C headers.
+
+    The wheel case returns BOTH ``share/include`` and ``share/include/dv_solve``
+    because the two trees disagree on layout and only the nested one actually
+    holds headers:
+
+      * source tree -- headers sit FLAT in ``src/c``, so ``#include
+        "dvs_ctx.h"`` resolves;
+      * installed wheel -- CMake puts them in ``include/dv_solve``
+        (CMakeLists.txt: ``DESTINATION include/dv_solve``), so that same
+        unqualified include does NOT resolve against the base directory, and
+        the base directory on its own contains no headers at all.
+
+    Returning only the base therefore described a layout the wheel does not
+    have. A consumer following this API could compile against a checkout and
+    then fail against the released wheel with
+
+        fatal error: dvs_block_alloc.h: No such file or directory
+
+    which is exactly how pssc's generated ``pssc_solve.c`` fails, since it emits
+    unqualified includes.
+
+    NOTE ON NAMESPACING: these headers are installed under ``dv_solve/`` so
+    they cannot shadow another project's headers of the same name. Before the
+    ``dvs_`` prefix, dv-solve and zuspec-be-sw both shipped a ``zsp_alloc.h``
+    defining ``struct zsp_alloc_s`` incompatibly; the prefix removes that clash,
+    and the install layout keeps internal header names out of a consumer's
+    include path.
+
+    Probes for an actual header rather than testing ``isdir``. A staging bug
+    that creates ``share/include`` but populates nothing under it used to pass
+    the directory test and then fail deep inside a consumer's compile.
+
+    Taken from the installation the solver library is loaded from; raises
+    ``RuntimeError`` if that installation has no headers rather than pairing
+    its library with another installation's headers.
+    """
+    if _resolve.select_installation() is not None:
+        return _resolve.require_incdirs()
+    found = _resolve.find_incdirs()
+    if found is not None:
+        return found
+    # Nothing found: name the installed-wheel location, so the failure is the
+    # same "no headers here" a missing wheel already produces.
+    return [os.path.join(_pkg_dir(), "share", "include")]
+
+
+def get_svdirs():
+    """SystemVerilog package search dir (dvs_dpi_pkg.sv, dvs_randomizer_pkg.sv).
+
+    From the selected installation, like :func:`get_incdirs`; raises
+    ``RuntimeError`` if that installation has none.
+    """
+    if _resolve.select_installation() is not None:
+        return _resolve.require_svdirs()
+    found = _resolve.find_svdirs()
+    if found is not None:
+        return found
+    return [os.path.join(_pkg_dir(), "share", "sv")]
+
+
+def get_dpi_lib():
+    """Absolute path to the DPI shared library for an SV simulator's -sv_lib.
+
+    Searches the same places as :func:`get_libdirs` -- this library is staged
+    into the wheel alongside ``libdv_solve`` and built into the same
+    ``build/<libdir>`` in a checkout, so it had the same source-tree gap.
+
+    Resolved by its OWN filename rather than by appending to whatever directory
+    the core library was found in: the two are staged together today, but a
+    ``-sv_lib`` pointed at a path that merely ought to exist fails inside the
+    simulator's elaborator, a long way from anything that names dv-solve.
+
+    Taken from the installation the core library is loaded from, never from
+    another one: the DPI shim calls into the core library and must match it.
+    Raises ``RuntimeError`` if that installation has no DPI library.
+    """
+    if _resolve.select_installation() is not None:
+        return _resolve.require_library("dv_solve_dpi")
+    return os.path.join(_pkg_dir(), _lib_filename("dv_solve_dpi"))
+
+
+def get_smt2_exe():
+    """Absolute path to the ``dv-solve-smt2`` SMT-LIB2 command-line tool.
+
+    The wheel installs it into the environment's scripts directory, so in an
+    activated environment it is also simply ``dv-solve-smt2`` on PATH. Use
+    this when PATH may hold a different copy, or when the environment is not
+    activated (for example, to set ``VERILATOR_SOLVER`` from a script).
+
+    Order: ``DVS_SOLVER_PATH`` (alone, when set), this package's own wheel
+    install, a built source checkout (``build/bin``, then ``build``), PATH.
+    The tool is statically linked, so any copy found is self-contained.
+
+    Raises ``RuntimeError`` naming every location searched when none is found
+    -- always the case on Windows today, whose wheel does not include it.
+    """
+    return _resolve.require_smt2_exe()
+
+
+def resolve_report():
+    """What this installation actually resolved to, for diagnostics.
+
+    Deployment problems in this area are all of the form "which installation
+    did it pick?", and answering that from the outside means replicating the
+    search. Returns a dict of plain strings/lists, safe to print or assert on.
+
+    Never raises: an artifact the selected installation lacks is ``None``
+    here, with the reason under ``errors``.
+    """
+    inst = _resolve.select_installation()
+    errors = {}
+    for key, fn in (("link_dirs", get_libdirs), ("dpi_lib", get_dpi_lib),
+                    ("incdirs", get_incdirs), ("svdirs", get_svdirs),
+                    ("smt2_exe", get_smt2_exe)):
+        try:
+            fn()
+        except RuntimeError as e:
+            errors[key] = str(e)
+    link = _resolve.find_library("dv_solve", linkable=True)
+    return {
+        "package_dir": _pkg_dir(),
+        "override": _resolve.override_root(),
+        "search_dirs": list(_lib_search_dirs()),
+        "installation": ({"kind": inst.kind, "root": inst.root}
+                         if inst is not None else None),
+        "core_lib": _resolve.find_library("dv_solve"),
+        "link_dirs": [os.path.dirname(link)] if link else None,
+        "dpi_lib": _resolve.find_library("dv_solve_dpi"),
+        "incdirs": _resolve.find_incdirs(),
+        "svdirs": _resolve.find_svdirs(),
+        "smt2_exe": _resolve.find_smt2_exe(),
+        "errors": errors,
+    }

dv_solve/__version__.py

@@ -0,0 +1,42 @@
+#****************************************************************************
+# 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.
+#****************************************************************************
+
+# The single source of this package's version, following the same shape as
+# pssparser's python/pssparser/__version__.py.
+#
+# BASE is the released version and is what a `v<BASE>` tag must match; the
+# publish job in .github/workflows/wheels.yml rejects a tag that disagrees
+# with it. SUFFIX is rewritten by CI for non-release builds so a development
+# wheel can never collide with a release.
+#
+# 0.1.0 rather than 0.0.1: PyPI already holds run-id-stamped dev releases of
+# sibling packages numbered 0.0.1.<run-id>, which sort ABOVE a bare 0.0.1.
+# The estate moves to 0.1.0 so that a real release outranks that stream.
+
+BASE = "0.2.3"
+SUFFIX = ""
+
+__version__ = (BASE, SUFFIX)
+
+# Read by setup.py for dynamic versioning. setup.py exec()s THIS FILE rather
+# than importing the package, which is the whole point of the arrangement:
+# a `[tool.setuptools.dynamic] version = {attr = ...}` was tried first and
+# reverted, because setuptools can only read an attr: statically when it is a
+# literal. BASE + SUFFIX is computed, so setuptools fell back to IMPORTING
+# dv_solve -- and the package is not importable during
+# get_requires_for_build_wheel under the ivpm_build backend. That failed only
+# inside the manylinux container, not under a local `uv build`.
+_pkg_version = BASE + SUFFIX