pytractoviz 0.2.14__py3-none-any.whl

pytractoviz/__init__.py

@@ -0,0 +1,11 @@
+"""pyTractoViz package.
+
+Python tools for diffusion tractography visualization
+"""
+
+from __future__ import annotations
+
+from pytractoviz._internal.cli import get_parser, main
+from pytractoviz.html import create_quality_check_html
+
+__all__: list[str] = ["create_quality_check_html", "get_parser", "main"]

pytractoviz/__main__.py

@@ -0,0 +1,14 @@
+"""Entry-point module, in case you use `python -m pytractoviz`.
+
+Why does this file exist, and why `__main__`? For more info, read:
+
+- https://www.python.org/dev/peps/pep-0338/
+- https://docs.python.org/3/using/cmdline.html#cmdoption-m
+"""
+
+import sys
+
+from pytractoviz._internal.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

pytractoviz/_internal/cli.py

@@ -0,0 +1,59 @@
+# Why does this file exist, and why not put this in `__main__`?
+#
+# You might be tempted to import things from `__main__` later,
+# but that will cause problems: the code will get executed twice:
+#
+# - When you run `python -m pytractoviz` python will execute
+#   `__main__.py` as a script. That means there won't be any
+#   `pytractoviz.__main__` in `sys.modules`.
+# - When you import `__main__` it will get executed again (as a module) because
+#   there's no `pytractoviz.__main__` in `sys.modules`.
+
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import Any
+
+from pytractoviz._internal import debug
+
+
+class _DebugInfo(argparse.Action):
+    def __init__(self, nargs: int | str | None = 0, **kwargs: Any) -> None:
+        super().__init__(nargs=nargs, **kwargs)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ARG002
+        debug._print_debug_info()
+        sys.exit(0)
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Return the CLI argument parser.
+
+    Returns
+    -------
+        An argparse parser.
+    """
+    parser = argparse.ArgumentParser(prog="pytractoviz")
+    parser.add_argument("-V", "--version", action="version", version=f"%(prog)s {debug._get_version()}")
+    parser.add_argument("--debug-info", action=_DebugInfo, help="Print debug information.")
+    return parser
+
+
+def main(args: list[str] | None = None) -> int:
+    """Run the main program.
+
+    This function is executed when you type `pytractoviz` or `python -m pytractoviz`.
+
+    Parameters
+    ----------
+        args: Arguments passed from the command line.
+
+    Returns
+    -------
+        An exit code.
+    """
+    parser = get_parser()
+    opts = parser.parse_args(args=args)
+    print(opts)
+    return 0

pytractoviz/_internal/debug.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from dataclasses import dataclass
+from importlib import metadata
+
+
+@dataclass
+class _Variable:
+    """Dataclass describing an environment variable."""
+
+    name: str
+    """Variable name."""
+    value: str
+    """Variable value."""
+
+
+@dataclass
+class _Package:
+    """Dataclass describing a Python package."""
+
+    name: str
+    """Package name."""
+    version: str
+    """Package version."""
+
+
+@dataclass
+class _Environment:
+    """Dataclass to store environment information."""
+
+    interpreter_name: str
+    """Python interpreter name."""
+    interpreter_version: str
+    """Python interpreter version."""
+    interpreter_path: str
+    """Path to Python executable."""
+    platform: str
+    """Operating System."""
+    packages: list[_Package]
+    """Installed packages."""
+    variables: list[_Variable]
+    """Environment variables."""
+
+
+def _interpreter_name_version() -> tuple[str, str]:
+    if hasattr(sys, "implementation"):
+        impl = sys.implementation.version
+        version = f"{impl.major}.{impl.minor}.{impl.micro}"
+        kind = impl.releaselevel
+        if kind != "final":
+            version += kind[0] + str(impl.serial)
+        return sys.implementation.name, version
+    return "", "0.0.0"
+
+
+def _get_version(dist: str = "pytractoviz") -> str:
+    """Get version of the given distribution.
+
+    Parameters
+    ----------
+        dist: A distribution name.
+
+    Returns
+    -------
+        A version number.
+    """
+    try:
+        return metadata.version(dist)
+    except metadata.PackageNotFoundError:
+        return "0.0.0"
+
+
+def _get_debug_info() -> _Environment:
+    """Get debug/environment information.
+
+    Returns
+    -------
+        Environment information.
+    """
+    py_name, py_version = _interpreter_name_version()
+    packages = ["pytractoviz"]
+    variables = ["PYTHONPATH", *[var for var in os.environ if var.startswith("PYTRACTOVIZ")]]
+    return _Environment(
+        interpreter_name=py_name,
+        interpreter_version=py_version,
+        interpreter_path=sys.executable,
+        platform=platform.platform(),
+        variables=[_Variable(var, val) for var in variables if (val := os.getenv(var))],  # ty: ignore[invalid-argument-type]
+        packages=[_Package(pkg, _get_version(pkg)) for pkg in packages],
+    )
+
+
+def _print_debug_info() -> None:
+    """Print debug/environment information."""
+    info = _get_debug_info()
+    print(f"- __System__: {info.platform}")
+    print(f"- __Python__: {info.interpreter_name} {info.interpreter_version} ({info.interpreter_path})")
+    print("- __Environment variables__:")
+    for var in info.variables:
+        print(f"  - `{var.name}`: `{var.value}`")
+    print("- __Installed packages__:")
+    for pkg in info.packages:
+        print(f"  - `{pkg.name}` v{pkg.version}")
+
+
+if __name__ == "__main__":
+    _print_debug_info()