pyausaxs 1.3.0__tar.gz

pyausaxs-1.3.0/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pyausaxs-1.3.0/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: pyausaxs
+Version: 1.3.0
+Summary: An efficient small-angle Debye scattering calculator.
+Author-email: Kristian Lytje <kristian.lytje@uni-saarland.de>
+License-Expression: LGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/AUSAXS/pyAUSAXS
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: py-cpuinfo>=8.0.0
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: plots
+Requires-Dist: matplotlib>=3.7; extra == "plots"
+Requires-Dist: scipy>=1.10; extra == "plots"
+Provides-Extra: gui
+Requires-Dist: pyausaxs[plots]; extra == "gui"
+Requires-Dist: tkinterdnd2>=0.3.0; extra == "gui"
+Provides-Extra: all
+Requires-Dist: pyausaxs[gui,plots]; extra == "all"
+Dynamic: license-file
+
+![title_light](../media/title_dark.png?raw=true#gh-light-mode-only)
+![title_dark](../media/title_light.png?raw=true#gh-dark-mode-only)
+
+[![pip install](https://img.shields.io/badge/pip%20install-pyausaxs-blue)](#installation)
+[![Python version](https://img.shields.io/badge/python-%3E%3D3.9-blue)](https://python.org/downloads)
+[![PyPI - Version](https://img.shields.io/pypi/v/pyausaxs)](https://pypi.org/project/pyausaxs)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/pyausaxs)](https://pypistats.org/packages/pyausaxs)
+
+Welcome to `pyAUSAXS`, the perhaps fastest Python tool for evaluating the scattering intensity of biological samples and crystals. 
+`pyAUSAXS` is a Python wrapper around [`AUSAXS`](https://github.com/AUSAXS/AUSAXS), the high-performance C++ backend, offering easy
+access to most of its features. 
+
+## Who is this for?
+`pyAUSAXS` offers highly efficient calculation of the expected scattering intensity of your structures. These calculations include
+form factors, and hydration shell & excluded volume modeling. Calculations without these solvent effects are also possible, if only
+the pure Debye calculation is of interest. For a full overview of how it works, see the `AUSAXS` article:
+[10.1107/S160057672500562X](https://doi.org/10.1107/S160057672500562X).
+
+## Installation
+To install, simply run:
+```bash
+pip install pyausaxs
+```
+and you are good to go!
+
+## Usage
+Proper documentation is currently being written. For now, please refer to the runnable examples [here](https://github.com/AUSAXS/pyAUSAXS/tree/master/examples).
+
+## Contributing
+Are you encountering problems, have feedback or suggestions, or are you considering contributing to the project? Please check out the [contributor guidelines](CONTRIBUTING.md).
+
+## Citation
+If you use `pyAUSAXS` in published work, please cite the following paper:
+Small-angle X-ray scattering profile calculation for high-resolution models of biomacromolecules  
+(doi: [10.1107/S160057672500562X](https://doi.org/10.1107/S160057672500562X))
+
+*This project is licenced under the GNU Lesser General Public Licence v3.0.*

pyausaxs-1.3.0/README.md

@@ -0,0 +1,37 @@
+![title_light](../media/title_dark.png?raw=true#gh-light-mode-only)
+![title_dark](../media/title_light.png?raw=true#gh-dark-mode-only)
+
+[![pip install](https://img.shields.io/badge/pip%20install-pyausaxs-blue)](#installation)
+[![Python version](https://img.shields.io/badge/python-%3E%3D3.9-blue)](https://python.org/downloads)
+[![PyPI - Version](https://img.shields.io/pypi/v/pyausaxs)](https://pypi.org/project/pyausaxs)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/pyausaxs)](https://pypistats.org/packages/pyausaxs)
+
+Welcome to `pyAUSAXS`, the perhaps fastest Python tool for evaluating the scattering intensity of biological samples and crystals. 
+`pyAUSAXS` is a Python wrapper around [`AUSAXS`](https://github.com/AUSAXS/AUSAXS), the high-performance C++ backend, offering easy
+access to most of its features. 
+
+## Who is this for?
+`pyAUSAXS` offers highly efficient calculation of the expected scattering intensity of your structures. These calculations include
+form factors, and hydration shell & excluded volume modeling. Calculations without these solvent effects are also possible, if only
+the pure Debye calculation is of interest. For a full overview of how it works, see the `AUSAXS` article:
+[10.1107/S160057672500562X](https://doi.org/10.1107/S160057672500562X).
+
+## Installation
+To install, simply run:
+```bash
+pip install pyausaxs
+```
+and you are good to go!
+
+## Usage
+Proper documentation is currently being written. For now, please refer to the runnable examples [here](https://github.com/AUSAXS/pyAUSAXS/tree/master/examples).
+
+## Contributing
+Are you encountering problems, have feedback or suggestions, or are you considering contributing to the project? Please check out the [contributor guidelines](CONTRIBUTING.md).
+
+## Citation
+If you use `pyAUSAXS` in published work, please cite the following paper:
+Small-angle X-ray scattering profile calculation for high-resolution models of biomacromolecules  
+(doi: [10.1107/S160057672500562X](https://doi.org/10.1107/S160057672500562X))
+
+*This project is licenced under the GNU Lesser General Public Licence v3.0.*

pyausaxs-1.3.0/pyausaxs/__init__.py

@@ -0,0 +1,19 @@
+from .wrapper.PDBfile import read_pdb
+from .wrapper.Datafile import read_data, create_datafile
+from .wrapper.Molecule import create_molecule
+from .wrapper.IterativeFit import manual_fit
+from .wrapper.Rigidbody import Rigidbody, prepare_rigidbody_refinement
+from .wrapper.BackendObject import advanced
+from .wrapper.ExactDebye import unoptimized
+from .wrapper.Models import ExvModel, ExvTable
+from .wrapper.FormFactor import form_factor
+from .wrapper.settings import settings
+from .wrapper.sasview import sasview
+from .wrapper.Output import set_output_callback, reset_output_callback
+
+__all__ = [
+    "read_pdb", "read_data", "create_datafile", "create_molecule", "sasview", "settings", "manual_fit",
+    "prepare_rigidbody_refinement", "ExvModel", "ExvTable", "unoptimized", "advanced", "form_factor", "Rigidbody",
+    "set_output_callback", "reset_output_callback"
+]
+__version__ = "1.3.0"

pyausaxs-1.3.0/pyausaxs/__main__.py

@@ -0,0 +1,218 @@
+import argparse
+import importlib.util
+import sys
+
+from .__init__ import __version__
+
+# tool name -> (backend C function name, program name passed as argv[0])
+_CLI_TOOLS = {
+    "fit":       ("cli_saxs_fitter", "ausaxs_fit"),
+    "em":        ("cli_em_fitter",   "ausaxs_em"),
+    "rigidbody": ("cli_rigidbody",   "ausaxs_rigidbody"),
+}
+
+# Optional CLI tools backed by pip extras: tool -> (extra name, modules that must be importable).
+# We check _tkinter (the C extension), not tkinter (whose pure-Python package ships even on no-Tk builds).
+_OPTIONAL_TOOLS = {
+    "plot": ("plots", ("matplotlib", "scipy")),
+    "gui":  ("gui",   ("matplotlib", "scipy", "_tkinter")),
+}
+
+
+def _extra_available(tool: str) -> bool:
+    """Check if the optional dependencies for a tool are available by trying to find their modules."""
+    _, modules = _OPTIONAL_TOOLS[tool]
+    for module in modules:
+        try:
+            if importlib.util.find_spec(module) is None:
+                return False
+        except ModuleNotFoundError:
+            return False
+    return True
+
+
+def _extra_missing_error(tool: str) -> int:
+    extra = _OPTIONAL_TOOLS[tool][0]
+    print(
+        f"Error: the '{extra}' extension is not installed."
+        f"\nPlease install it by running the command \"pip install pyausaxs[{extra}]\".",
+        file=sys.stderr,
+    )
+    return 1
+
+
+class _Formatter(argparse.HelpFormatter):
+    def _format_action(self, action):
+        result = super()._format_action(action)
+        if action.nargs == argparse.PARSER:
+            lines = result.splitlines(keepends=True)
+            return ''.join(
+                line for line in lines[1:] if argparse.SUPPRESS not in line
+            )
+        return result
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ausaxs",
+        description="An efficient small-angle Debye scattering calculator.",
+        formatter_class=_Formatter,
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"pyAUSAXS {__version__}")
+    parser.add_argument("--license", action="store_true", help="show license information and exit")
+    sub = parser.add_subparsers(dest="tool", title="tools")
+
+    # C CLI tools — argparse does not consume their flags; everything after the subcommand name is passed through to the backend as-is.
+    for name, desc in [
+        ("fit",       "validate structures against SAXS data"),
+        ("em",        "validate EM maps against SAXS data"),
+        ("rigidbody", "perform rigid-body refinements"),
+        ("plot",      "plot results from other tools"),
+        ("gui",       "start the graphical interface"),
+    ]:
+        if name in _OPTIONAL_TOOLS and not _extra_available(name):
+            desc += " (disabled)"
+        sub.add_parser(name, help=desc, add_help=False)
+
+    # 'setup' is unlisted and has its own structured flags.
+    setup = sub.add_parser(
+        "setup", help=argparse.SUPPRESS,
+        description="Configure the AUSAXS backend.",
+    )
+    grp = setup.add_mutually_exclusive_group()
+    grp.add_argument(
+        "--relink", metavar="PATH",
+        help="use the backend library at PATH instead of the bundled one",
+    )
+    grp.add_argument(
+        "--reset", action="store_true",
+        help="forget any relinked path and use the bundled library",
+    )
+    grp.add_argument(
+        "--show", action="store_true",
+        help="show which backend library is currently in use (default)",
+    )
+
+    # # Put the tools section above the options section in help output.
+    by_title = {g.title: g for g in parser._action_groups}
+    parser._action_groups[:] = [by_title["tools"], by_title["options"]]
+
+    return parser
+
+
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = _build_parser()
+    ns, remaining = parser.parse_known_args(argv)
+
+    if ns.license:
+        _print_licence()
+        return 0
+
+    if ns.tool is None:
+        parser.print_help()
+        return 0
+
+    match ns.tool:
+        case "setup":
+            return _run_setup(ns)
+        case "gui":
+            if not _extra_available("gui"):
+                return _extra_missing_error("gui")
+            print("Warning: The Python GUI is highly experimental. Use at your own risk.", file=sys.stderr)
+            from .gui import main as gui_main
+            return gui_main(remaining)
+        case "plot":
+            if not _extra_available("plot"):
+                return _extra_missing_error("plot")
+            from .plot.plot import main as plot_main
+            return plot_main(remaining)
+        case t if t in _CLI_TOOLS:
+            return _run_cli_tool(t, remaining)
+
+
+def _run_cli_tool(tool, args):
+    from .wrapper.AUSAXS import AUSAXS
+    func_name, prog = _CLI_TOOLS[tool]
+    lib = AUSAXS().lib()
+    if not lib.ready():
+        print("Error: AUSAXS library not ready", file=sys.stderr)
+        return 1
+    return _call_cli(getattr(lib.functions, func_name), [prog, *args])
+
+
+def _call_cli(cli_func, args):
+    import ctypes as ct
+    c_args = [arg.encode("utf-8") for arg in args]
+    c_argv = (ct.c_char_p * len(c_args))(*c_args)
+    return cli_func(len(c_args), c_argv)
+
+
+def _run_setup(ns):
+    from pathlib import Path
+    from . import loader
+    from .wrapper.AUSAXS import AUSAXS
+
+    if ns.relink:
+        previous = loader.get_relink_path()
+        try:
+            cache = loader.set_relink_path(ns.relink)
+        except (FileNotFoundError, ValueError) as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+
+        # validate the newly relinked library actually loads before committing to it
+        if not AUSAXS.ready():
+            error = AUSAXS.init_error()
+            if previous is not None:
+                loader.set_relink_path(previous)
+            else:
+                loader.clear_relink_path()
+            AUSAXS.reset_singleton()
+            print(f"Error: '{ns.relink}' failed to load as an AUSAXS backend: {error}", file=sys.stderr)
+            return 1
+
+        linked = loader.get_relink_path()
+        if "ausaxs" not in Path(linked).stem.lower():
+            print(
+                f"Warning: '{Path(linked).name}' does not look like an AUSAXS "
+                "library (its name should contain 'ausaxs').",
+                file=sys.stderr,
+            )
+        print(f"Relinked AUSAXS backend to: {linked}")
+        print(f"(stored in {cache})")
+        return 0
+
+    if ns.reset:
+        if loader.clear_relink_path():
+            print("Reset: now using the bundled AUSAXS backend.")
+        else:
+            print("No relink configured; already using the bundled backend.")
+        return 0
+
+    # default: --show
+    path, origin = loader.resolve_lib()
+    print(f"AUSAXS backend in use: {path}")
+    print({
+        "relink": "  (relinked; reset with: ausaxs setup --reset)",
+        "environment": "  (set via the AUSAXS_LIB environment variable)",
+        "bundled": "  (bundled)",
+        "prefix": "  (installed in the environment prefix)",
+    }[origin])
+    return 0
+
+
+def _print_licence():
+    import importlib.resources as pkg_resources
+    try:
+        ref = pkg_resources.files("pyausaxs").joinpath("../../LICENSE")
+        with pkg_resources.as_file(ref) as p:
+            print(p.read_text(encoding="utf-8"))
+    except Exception:
+        print("LGPL-3.0-or-later — see https://github.com/AUSAXS/pyAUSAXS/blob/master/LICENSE")
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pyausaxs-1.3.0/pyausaxs/__pyinstaller/hook-pyausaxs.py

@@ -0,0 +1,14 @@
+from PyInstaller.utils.hooks import collect_data_files
+from pyausaxs.loader import find_lib_path
+import os
+
+datas = collect_data_files('pyausaxs')
+hiddenimports = []
+binaries = []
+
+lib_path = find_lib_path()
+if os.path.exists(lib_path):
+    datas.append((lib_path, 'pyausaxs/resources'))
+    binaries.append((lib_path, '.'))
+else:
+    raise FileNotFoundError(f"Library not found at expected path: {lib_path}")

pyausaxs-1.3.0/pyausaxs/__pyinstaller/pyinstaller.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+
+def get_hook_dirs():
+    return [str(Path(__file__).parent)]

pyausaxs-1.3.0/pyausaxs/architecture.py

@@ -0,0 +1,114 @@
+from enum import Enum
+from pathlib import Path
+import os
+import platform
+import cpuinfo
+
+class OS(Enum):
+    WIN = 0
+    LINUX = 1
+    MAC = 2
+    UNKNOWN = 3
+
+class CPUFeatures:
+    """CPU feature detection for AUSAXS library compatibility."""
+    
+    @staticmethod
+    def get_cpu_info():
+        try:
+            return cpuinfo.get_cpu_info()
+        except:
+            return {}
+
+    @staticmethod
+    def has_sse_support():
+        cpu_info = CPUFeatures.get_cpu_info()
+        flags = cpu_info.get('flags', [])
+        return any('sse' in flag.lower() for flag in flags)
+
+    @staticmethod
+    def has_avx_support():
+        cpu_info = CPUFeatures.get_cpu_info()
+        flags = cpu_info.get('flags', [])
+        return 'avx' in [flag.lower() for flag in flags]
+
+    @staticmethod
+    def has_avx2_support():
+        cpu_info = CPUFeatures.get_cpu_info()
+        flags = cpu_info.get('flags', [])
+        return 'avx2' in [flag.lower() for flag in flags]
+
+    @staticmethod
+    def get_architecture():
+        return platform.machine().lower()
+
+    @staticmethod
+    def is_compatible_architecture():
+        def is_compatible_macos():
+            arch = CPUFeatures.get_architecture()
+            return arch in ['x86_64', 'amd64', 'arm64']
+        
+        def is_compatible_linux():
+            arch = CPUFeatures.get_architecture()
+            if arch in ['aarch64', 'arm64']: return True
+            return arch in ['x86_64', 'amd64'] and CPUFeatures.has_avx2_support()
+        
+        def is_compatible_windows():
+            arch = CPUFeatures.get_architecture()
+            return arch in ['x86_64', 'amd64'] and CPUFeatures.has_avx2_support()
+
+        match get_os():
+            case OS.MAC:   return is_compatible_macos()
+            case OS.LINUX: return is_compatible_linux()
+            case OS.WIN:   return is_compatible_windows()
+            case _:        return False
+
+def get_os():
+    if platform.system() == "Windows":  return OS.WIN
+    elif platform.system() == "Linux":  return OS.LINUX
+    elif platform.system() == "Darwin": return OS.MAC
+    return OS.UNKNOWN
+
+def get_cache_dir() -> Path:
+    """Return the AUSAXS cache directory, mirroring the C++ backend's path resolution."""
+    _os = get_os()
+    if _os == OS.WIN:
+        base = os.environ.get("LOCALAPPDATA")
+    elif _os == OS.MAC:
+        base = os.path.join(os.environ.get("HOME", "~"), "Library", "Caches")
+    else:
+        base = os.environ.get("XDG_CACHE_HOME") or os.path.join(os.environ.get("HOME", "~"), ".cache")
+    return Path(base or ".") / "ausaxs"
+
+def get_shared_lib_extension():
+    """
+    Get the shared library extension for the current operating system, including the dot.
+    If the operating system is unknown, return an empty string.
+    """
+    _os = get_os()
+    if _os == OS.WIN:
+        return ".dll"
+    elif _os == OS.LINUX:
+        return ".so"
+    elif _os == OS.MAC:
+        return ".dylib"
+    return ""
+
+def _compat_cache_file() -> Path:
+    return get_cache_dir() / "cpu_compatible"
+
+def is_architecture_compatible() -> bool:
+    """Return whether the current CPU is compatible with the AUSAXS backend."""
+    cache = _compat_cache_file()
+    if cache.is_file():
+        return True
+
+    if not CPUFeatures.is_compatible_architecture():
+        return False
+
+    try:
+        cache.parent.mkdir(parents=True, exist_ok=True)
+        cache.write_text("ok", encoding="utf-8")
+    except OSError:
+        pass  # caching is best-effort; we'll just re-check next time
+    return True

pyausaxs-1.3.0/pyausaxs/config.py

@@ -0,0 +1 @@
+architecture_runtime_validation = True

pyausaxs-1.3.0/pyausaxs/gui/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+# Author: Kristian Lytje
+
+from .gui import main
+
+__all__ = ["main"]