spin 0.0.1.dev0__tar.gz → 0.2__tar.gz

{spin-0.0.1.dev0 → spin-0.2}/LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2022, Danila Bredikhin
+Copyright (c) 2021--2022, Scientific Python project
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

spin-0.2/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: spin
+Version: 0.2
+Summary: Developer tool for scientific Python libraries
+Maintainer-email: Scientific Python <spin@discuss.scientific-python.org>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2021--2022, Scientific Python project
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: homepage, https://github.com/scientific-python/spin
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Provides-Extra: lint
+License-File: LICENSE

spin-0.2/README.md

@@ -0,0 +1,140 @@
+# 💫 Scientific Python INcantations (`spin`)
+
+## A developer tool for scientific Python libraries
+
+**NOTE:** If you are looking for `devpy`, this is it! We had to rename
+the package to publish it on PyPi.
+
+Developers need to memorize a whole bunch of magic command-line incantations.
+And these incantations change from time to time!
+Typically, their lives are made simpler by a Makefile, but Makefiles can be convoluted, are not written in Python, and are hard to extend.
+The rationale behind `spin` is therefore to provide a simple interface for common development tasks.
+It comes with a few common build commands out the box, but can easily be customized per project.
+
+As a curiosity: the impetus behind developing the tool was the mass migration of scientific Python libraries (SciPy, scikit-image, and NumPy, etc.) to Meson, after distutils was deprecated.
+When many of the build and installation commands changed, it made sense to abstract away the nuisance of having to re-learn them.
+
+## Installation
+
+`spin` is not yet available via PyPi (but soon!).
+
+Meanwhile, please install it directly from GitHub:
+
+```
+pip install git+https://github.com/scientific-python/spin
+```
+
+## Configuration
+
+Settings are in your project's `pyproject.toml`.
+As an example, see the `[tool.spin]` section of [an example `pyproject.toml`](https://github.com/scientific-python/spin/blob/main/example_pkg/pyproject.toml).
+
+The `[tool.spin]` section should contain:
+
+```
+package = "pkg_importname"  # name of your package
+commands = [
+  "spin.cmds.meson.build",
+  "spin.cmds.meson.test"
+]
+```
+
+See [the command selection](#built-in-commands) below.
+
+### Command sections
+
+Once you have several commands, it may be useful to organize them into sections.
+In `pyproject.toml`, instead of specifying the commands as a list, use the following structure:
+
+```toml
+[tool.spin.commands]
+"Build" = [
+  "spin.cmds.meson.build",
+  "spin.cmds.meson.test"
+]
+"Environments" = [
+  "spin.cmds.meson.shell",
+  "spin.cmds.meson.ipython",
+  "spin.cmds.meson.python"
+]
+```
+
+These commands will then be rendered as:
+
+```
+Build:
+  build  🔧 Build package with Meson/ninja and install
+  test   🔧 Run tests
+
+Environments:
+  shell    💻 Launch shell with PYTHONPATH set
+  ipython  💻 Launch IPython shell with PYTHONPATH set
+  python   🐍 Launch Python shell with PYTHONPATH set
+```
+
+## Running
+
+```
+python -m spin
+```
+
+On Unix-like systems, you can also copy the [`dev.py` script](https://github.com/scientific-python/spin/blob/main/example_pkg/dev.py) to the root of your project directory, and launch it as:
+
+```
+./dev.py
+```
+
+## Built-in commands
+
+### [Meson](https://meson-python.readthedocs.io)
+
+```
+  build    🔧 Build package with Meson/ninja and install to `build-install`
+  ipython  💻 Launch IPython shell with PYTHONPATH set
+  python   🐍 Launch Python shell with PYTHONPATH set
+  shell    💻 Launch shell with PYTHONPATH set
+  test     🔧 Run pytest
+```
+
+### [Build](https://pypa-build.readthedocs.io/en/stable/) (PEP 517 builder)
+
+`spin` was started with Meson in mind, but we're working on expanding commands for PEP 517 `build`.
+
+```
+  sdist    📦 Build a source distribution in `dist/`.
+```
+
+## 🧪 Custom commands
+
+`spin` can invoke custom commands. These commands define their own arguments, and have access to the `pyproject.toml` file for further configuration.
+
+See, e.g., the [example custom command](https://github.com/scientific-python/spin/blob/main/example_pkg/.spin/cmds.py).
+
+Add custom commands to the `commands` variable in the `[tool.spin]` section of `pyproject.toml` as follows:
+
+```
+commands = [..., '.spin/cmds.py:example']
+```
+
+Here, the command is stored in `.spin/cmds.py`, and the function
+is named `example`.
+
+### Configuration
+
+Custom commands can access the `pyproject.toml` as follows:
+
+```python
+from spin import util
+
+@click.command()
+def example():
+    """Command that accesses `pyproject.toml` configuration"""
+    config = util.get_config()
+    print(config["tool.spin"])
+```
+
+## History
+
+The `dev.py` tool was [proposed for SciPy](https://github.com/scipy/scipy/issues/15489) by Ralf Gommers and [implemented](https://github.com/scipy/scipy/pull/15959) by Sayantika Banik, Eduardo Naufel Schettino, and Ralf Gommers (also see [Sayantika's blog post](https://labs.quansight.org/blog/the-evolution-of-the-scipy-developer-cli)).
+Inspired by that implementation, `spin` (this package) is a minimal rewrite by Stéfan van der Walt, that aims to be easily extendable so that it can be used across ecosystem libraries.
+We thank Danila Bredikhin and Luca Marconato who kindly donated the `spin` name on PyPi.

spin-0.2/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "spin"
+version = "0.2"
+requires-python = ">=3.7"
+description = "Developer tool for scientific Python libraries"
+license = {file = "LICENSE"}
+maintainers = [
+  {name = "Scientific Python", email = "spin@discuss.scientific-python.org"}
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python"
+]
+dependencies = [
+  "click",
+  "toml",
+  "colorama; platform_system == 'Windows'"
+]
+
+[project.optional-dependencies]
+lint = ["pre-commit >= 3.1"]
+
+[project.urls]
+homepage = "https://github.com/scientific-python/spin"
+
+[tool.setuptools.packages.find]
+include = ["spin*"]
+
+[tool.pytest.ini_options]
+filterwarnings = [
+  "ignore:cannot collect 'test' because it is not a function:",
+]

spin-0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spin-0.2/spin/__init__.py

@@ -0,0 +1,9 @@
+"""
+`spin` is a developer tool for scientific Python libraries
+
+For usage information see `python -m spin`.
+
+Read more at https://github.com/scientific-python/spin
+"""
+
+from .cmds import util

spin-0.2/spin/__main__.py

@@ -0,0 +1,123 @@
+import collections
+import os
+import sys
+import importlib
+from glob import glob
+
+import click
+import toml
+
+from . import cmds
+from .cmds import util
+from .cmds import *
+from .sectioned_help import SectionedHelpGroup
+from .color_format import ColorHelpFormatter
+
+
+click.Context.formatter_class = ColorHelpFormatter
+
+
+class DotDict(collections.UserDict):
+    def __getitem__(self, key):
+        subitem = self.data
+        for subkey in key.split("."):
+            try:
+                subitem = subitem[subkey]
+            except KeyError:
+                raise KeyError(f"`{key}` not found in configuration") from None
+        return subitem
+
+
+if __name__ == "__main__":
+    if not os.path.exists("pyproject.toml"):
+        print("Error: cannot find [pyproject.toml]")
+        sys.exit(1)
+
+    with open("pyproject.toml") as f:
+        try:
+            toml_config = toml.load(f)
+        except:
+            print("Cannot parse [pyproject.toml]")
+            sys.exit(1)
+
+    project_config = toml_config.get("project", {})
+
+    try:
+        config = toml_config["tool"]["spin"]
+    except KeyError:
+        print("No configuration found in [pyproject.toml] for [tool.spin]")
+        sys.exit(1)
+
+    proj_name = project_config.get("name", config["package"])
+
+    @click.group(help=f"Developer tool for {proj_name}", cls=SectionedHelpGroup)
+    @click.pass_context
+    def group(ctx):
+        ctx.meta["config"] = DotDict(toml_config)
+        ctx.meta["commands"] = ctx.command.section_commands
+        ctx.show_default = True
+
+    config_cmds = config["commands"]
+    # Commands can be provided as a list, or as a dictionary
+    # so that they can be sorted into sections
+    if isinstance(config_cmds, list):
+        config_cmds = {"Commands": config_cmds}
+
+    # Backward compatibility workaround
+    # Originally, you could specify any of these commands as `spin.cmd`
+    # and we'd fetch it from util
+    commands = {
+        "spin.build": cmds.meson.build,
+        "spin.test": cmds.meson.test,
+        "spin.ipython": cmds.meson.ipython,
+        "spin.python": cmds.meson.python,
+        "spin.shell": cmds.meson.shell,
+    }
+
+    for section, cmds in config_cmds.items():
+        for cmd in cmds:
+            if cmd not in commands:
+                # First, see if we can directly import the command
+                if not ":" in cmd:
+                    path, func = cmd.rsplit(".", maxsplit=1)
+                    try:
+                        mod = importlib.import_module(path)
+                    except ImportError:
+                        print(
+                            f"!! Could not import module `{path}` to load command `{cmd}`"
+                        )
+                        continue
+                else:
+                    try:
+                        path, func = cmd.split(":")
+                        spec = importlib.util.spec_from_file_location(
+                            "custom_mod", path
+                        )
+                        mod = importlib.util.module_from_spec(spec)
+                        spec.loader.exec_module(mod)
+                    except FileNotFoundError:
+                        print(
+                            f"!! Could not find file `{path}` to load custom command `{cmd}`.\n"
+                        )
+                        continue
+                    except Exception as e:
+                        print(
+                            f"!! Could not import file `{path}` to load custom command `{cmd}`.\n"
+                        )
+                        raise e
+
+                try:
+                    cmd_func = getattr(mod, func)
+                except AttributeError:
+                    print(f"!! Could not load command `{func}` from file `{path}`.\n")
+                    continue
+
+                commands[cmd] = cmd_func
+
+            group.add_command(commands[cmd], section=section)
+
+    try:
+        group()
+    except Exception as e:
+        print(f"{e}; aborting.")
+        sys.exit(1)

spin-0.2/spin/cmds/__init__.py

@@ -0,0 +1,8 @@
+from . import meson
+
+# Backward compatibility with older versions
+build = meson.build
+test = meson.test
+ipython = meson.ipython
+python = meson.python
+shell = meson.shell

spin-0.2/spin/cmds/build.py

@@ -0,0 +1,9 @@
+import click
+
+from .util import run
+
+
+@click.command()
+def sdist():
+    """📦 Build a source distribution in `dist/`."""
+    run(["python", "-m", "build", ".", "--sdist"])

spin-0.2/spin/cmds/meson.py

@@ -0,0 +1,250 @@
+import os
+import sys
+import shutil
+import json
+
+import click
+
+from .util import run, get_config, get_commands
+
+
+install_dir = "build-install"
+
+
+def _set_pythonpath():
+    site_packages = _get_site_packages()
+    env = os.environ
+
+    if "PYTHONPATH" in env:
+        env["PYTHONPATH"] = f"{site_packages}{os.pathsep}{env['PYTHONPATH']}"
+    else:
+        env["PYTHONPATH"] = site_packages
+
+    return env["PYTHONPATH"]
+
+
+def _get_site_packages():
+    candidate_paths = []
+    for root, dirs, files in os.walk(install_dir):
+        for subdir in dirs:
+            if subdir == "site-packages" or subdir == "dist-packages":
+                candidate_paths.append(os.path.abspath(os.path.join(root, subdir)))
+
+    X, Y = sys.version_info.major, sys.version_info.minor
+
+    site_packages = None
+    if any(f"python{X}." in p for p in candidate_paths):
+        # We have a system that uses `python3.X/site-packages` or `python3.X/dist-packages`
+        site_packages = [p for p in candidate_paths if f"python{X}.{Y}" in p]
+        if len(site_packages) == 0:
+            raise FileNotFoundError(
+                f"No site-packages found in {install_dir} for Python {X}.{Y}"
+            )
+        else:
+            site_packages = site_packages[0]
+    else:
+        # A naming scheme that does not encode the Python major/minor version is used, so return
+        # whatever site-packages path was found
+        if len(candidate_paths) > 1:
+            raise FileNotFoundError(
+                f"Multiple `site-packages` found in `{install_dir}`, but cannot use Python version to disambiguate"
+            )
+        elif len(candidate_paths) == 1:
+            site_packages = candidate_paths[0]
+
+    if site_packages is None:
+        raise FileNotFoundError(
+            f"No `site-packages` or `dist-packages` found under `{install_dir}`"
+        )
+
+    return site_packages
+
+
+def _meson_version():
+    try:
+        p = run(["meson", "--version"], output=False, echo=False)
+        return p.stdout.decode("ascii").strip()
+    except:
+        pass
+
+
+def _meson_version_configured():
+    try:
+        meson_info_fn = os.path.join("build", "meson-info", "meson-info.json")
+        meson_info = json.load(open(meson_info_fn))
+        return meson_info["meson_version"]["full"]
+    except:
+        pass
+
+
+@click.command()
+@click.option("-j", "--jobs", help="Number of parallel tasks to launch", type=int)
+@click.option("--clean", is_flag=True, help="Clean build directory before build")
+@click.option(
+    "-v", "--verbose", is_flag=True, help="Print all build output, even installation"
+)
+@click.argument("meson_args", nargs=-1)
+def build(meson_args, jobs=None, clean=False, verbose=False):
+    """🔧 Build package with Meson/ninja and install
+
+    MESON_ARGS are passed through e.g.:
+
+    ./dev.py build -- -Dpkg_config_path=/lib64/pkgconfig
+
+    The package is installed to build-install
+
+    By default builds for release, to be able to use a debugger set CFLAGS
+    appropriately. For example, for linux use
+
+    CFLAGS="-O0 -g" ./dev.py build
+    """
+    build_dir = "build"
+    setup_cmd = ["meson", "setup", build_dir, "--prefix=/usr"] + list(meson_args)
+
+    if clean:
+        print(f"Removing `{build_dir}`")
+        if os.path.isdir(build_dir):
+            shutil.rmtree(build_dir)
+        print(f"Removing `{install_dir}`")
+        if os.path.isdir(install_dir):
+            shutil.rmtree(install_dir)
+
+    if not (os.path.exists(build_dir) and _meson_version_configured()):
+        p = run(setup_cmd, sys_exit=False)
+        if p.returncode != 0:
+            raise RuntimeError(
+                "Meson configuration failed; please try `dev.py build` again with the `--clean` flag."
+            )
+    else:
+        # Build dir has been configured; check if it was configured by
+        # current version of Meson
+
+        if _meson_version() != _meson_version_configured():
+            run(setup_cmd + ["--reconfigure"])
+
+        # Any other conditions that warrant a reconfigure?
+
+    p = run(["meson", "compile", "-C", build_dir], sys_exit=False)
+    p = run(
+        [
+            "meson",
+            "install",
+            "--only-changed",
+            "-C",
+            build_dir,
+            "--destdir",
+            f"../{install_dir}",
+        ],
+        output=verbose,
+    )
+
+
+@click.command()
+@click.argument("pytest_args", nargs=-1)
+@click.pass_context
+def test(ctx, pytest_args):
+    """🔧 Run tests
+
+    PYTEST_ARGS are passed through directly to pytest, e.g.:
+
+    ./dev.py test -- -v
+
+    By default, runs the full test suite. To skip "slow" tests, run
+
+    ./dev.py test -- -m "not slow"
+    """
+    cfg = get_config()
+
+    command_groups = get_commands()
+    commands = [cmd for section in command_groups for cmd in command_groups[section]]
+    build_cmd = next((cmd for cmd in commands if cmd.name == "build"), None)
+    if build_cmd:
+        click.secho(
+            f"Invoking `build` prior to running tests:", bold=True, fg="bright_green"
+        )
+        ctx.invoke(build_cmd)
+
+    if not pytest_args:
+        pytest_args = (cfg.get("tool.spin.package", None),)
+        if pytest_args == (None,):
+            print(
+                "Please specify `package = packagename` under `tool.spin` section of `pyproject.toml`"
+            )
+            sys.exit(1)
+
+    site_path = _get_site_packages()
+    _set_pythonpath()
+
+    print(f'$ export PYTHONPATH="{site_path}"')
+    run(
+        [sys.executable, "-m", "pytest", f"--rootdir={site_path}"] + list(pytest_args),
+        cwd=site_path,
+        replace=True,
+    )
+
+
+@click.command()
+@click.argument("ipython_args", nargs=-1)
+def ipython(ipython_args):
+    """💻 Launch IPython shell with PYTHONPATH set
+
+    IPYTHON_ARGS are passed through directly to IPython, e.g.:
+
+    ./dev.py ipython -- -i myscript.py
+    """
+    p = _set_pythonpath()
+    print(f'💻 Launching IPython with PYTHONPATH="{p}"')
+    run(["ipython", "--ignore-cwd"] + list(ipython_args), replace=True)
+
+
+@click.command()
+@click.argument("shell_args", nargs=-1)
+def shell(shell_args=[]):
+    """💻 Launch shell with PYTHONPATH set
+
+    SHELL_ARGS are passed through directly to the shell, e.g.:
+
+    ./dev.py shell -- -c 'echo $PYTHONPATH'
+
+    Ensure that your shell init file (e.g., ~/.zshrc) does not override
+    the PYTHONPATH.
+    """
+    p = _set_pythonpath()
+    shell = os.environ.get("SHELL", "sh")
+    cmd = [shell] + list(shell_args)
+    print(f'💻 Launching shell with PYTHONPATH="{p}"')
+    print(f"⚠  Change directory to avoid importing source instead of built package")
+    print(f"⚠  Ensure that your ~/.shellrc does not unset PYTHONPATH")
+    run(cmd, replace=True)
+
+
+@click.command()
+@click.argument("python_args", nargs=-1)
+def python(python_args):
+    """🐍 Launch Python shell with PYTHONPATH set
+
+    PYTHON_ARGS are passed through directly to Python, e.g.:
+
+    ./dev.py python -- -c 'import sys; print(sys.path)'
+    """
+    p = _set_pythonpath()
+    v = sys.version_info
+    if (v.major < 3) or (v.major == 3 and v.minor < 11):
+        print("We're sorry, but this feature only works on Python 3.11 and greater 😢")
+        print()
+        print(
+            "Why? Because we need the '-P' flag so the interpreter doesn't muck with PYTHONPATH"
+        )
+        print()
+        print("However! You can still launch your own interpreter:")
+        print()
+        print(f"  PYTHONPATH='{p}' python")
+        print()
+        print("And then call:")
+        print()
+        print("import sys; del(sys.path[0])")
+        sys.exit(-1)
+
+    print(f'🐍 Launching Python with PYTHONPATH="{p}"')
+
+    run(["/usr/bin/env", "python", "-P"] + list(python_args), replace=True)

spin-0.2/spin/cmds/util.py

@@ -0,0 +1,80 @@
+import os
+import sys
+import subprocess
+import shlex
+import sysconfig
+from pathlib import Path
+
+import click
+
+
+def run(
+    cmd, cwd=None, replace=False, sys_exit=True, output=True, echo=True, *args, **kwargs
+):
+    """Run a shell command.
+
+    Parameters
+    ----------
+    cwd : str
+        Change to this directory before execution.
+    replace : bool
+        Whether to replace the current process.
+    sys_exit : bool
+        Whether to exit if the shell command returns with error != 0.
+    output : bool
+        Whether to display output as the process runs.
+        If set to ``False``, can be accessed afterwards as
+        ``p.stdout``.
+        If `sys_exit` is True and the process fails, output is printed
+        regardless.
+    echo : bool
+        Whether or not to echo commands.
+
+    Other arguments and keywords are passed directly to `subprocess.run`.
+
+    """
+    if cwd:
+        if echo:
+            click.secho(f"$ cd {cwd}", bold=True, fg="bright_blue")
+        os.chdir(cwd)
+
+    cmdstr = " ".join(shlex.quote(arg) for arg in cmd)
+    if echo:
+        click.secho(f"$ {cmdstr}", bold=True, fg="bright_blue")
+
+    if output is False:
+        output_kwargs = {"stdout": subprocess.PIPE, "stderr": subprocess.STDOUT}
+        kwargs = {**output_kwargs, **kwargs}
+
+    if replace:
+        os.execvp(cmd[0], cmd)
+        print(f"Failed to launch `{cmd}`")
+        sys.exit(-1)
+    else:
+        p = subprocess.run(cmd, *args, **kwargs)
+        if p.returncode != 0 and sys_exit:
+            # Output was suppressed, but the process failed, so print it anyway
+            if output is False:
+                print(p.stdout.decode("utf-8"), end="")
+            sys.exit(p.returncode)
+        return p
+
+
+def get_config():
+    """Return the pyproject.toml as a dictionary."""
+    return click.get_current_context().meta["config"]
+
+
+def get_commands():
+    """Return a list of all commands.
+
+    Returns
+    -------
+    cmds : dict
+       The keys of the dictionary are the section names, the values
+       lists of commands.
+
+       If no sections are provided, all commands are listed under the
+       ``commands`` key.
+    """
+    return click.get_current_context().meta["commands"]

spin-0.2/spin/color_format.py

@@ -0,0 +1,51 @@
+import re
+import shutil
+
+import click
+
+
+class RegexpFormatter:
+    def __init__(self, rules, default=None):
+        if default is None:
+            default = {}
+        self.rules = {re.compile(expr): format for (expr, format) in rules.items()}
+        self.default_style = click.style("", **default, reset=False)
+        self.reset_style = click.style("", reset=True)
+
+    def __call__(self, txt):
+        for expr, format in self.rules.items():
+            txt = expr.sub(click.style("\\g<0>", **format) + self.default_style, txt)
+        txt = self.default_style + txt + self.reset_style
+        return txt
+
+
+class ColorHelpFormatter(click.formatting.HelpFormatter):
+    def __init__(self, *args, **kwargs):
+        kwargs["width"] = shutil.get_terminal_size()[0]
+        super().__init__(*args, **kwargs)
+
+    def write_heading(self, heading):
+        super().write_heading(click.style(heading, dim=True))
+
+    def write_dl(self, items):
+        """Print definition list"""
+        key_fmt = RegexpFormatter(
+            {
+                " [A-Z]+": {"bold": True, "fg": "yellow"},
+                r"\-[a-z]{1}(?=[ ,]{1})": {"fg": "green"},
+            },
+            default={"bold": True, "fg": "cyan"},
+        )
+        val_fmt = RegexpFormatter({r"\[default: .*?\]": {"dim": True}})
+        items = [(key_fmt(key), val_fmt(val)) for (key, val) in items]
+        super().write_dl(items)
+
+    def write_usage(self, prog, args="", prefix=None):
+        fmt = RegexpFormatter(
+            {r"(?<=\[)[A-Z_]+(?=\])": {"fg": "cyan"}}, default={"bold": True}
+        )
+        super().write_usage(
+            click.style(prog, bold=True, fg="white"),
+            click.style(fmt(args), bold=True),
+            prefix=click.style("Usage: ", bold=True, fg="yellow"),
+        )

spin-0.2/spin/sectioned_help.py

@@ -0,0 +1,21 @@
+import click
+import collections
+
+
+class SectionedHelpGroup(click.Group):
+    """Organize commands as sections"""
+
+    def __init__(self, *args, **kwargs):
+        self.section_commands = collections.defaultdict(list)
+        super().__init__(*args, **kwargs)
+
+    def add_command(self, cmd, name=None, section=None):
+        self.section_commands[section].append(cmd)
+        super().add_command(cmd, name=name)
+
+    def format_commands(self, ctx, formatter):
+        for group, cmds in self.section_commands.items():
+            with formatter.section(group):
+                formatter.write_dl(
+                    [(cmd.name, cmd.get_short_help_str() or "") for cmd in cmds]
+                )

spin-0.2/spin/tests/test_meson.py

@@ -0,0 +1,100 @@
+import tempfile
+import sys
+import os
+from os.path import join as pjoin, normpath
+
+import pytest
+
+from spin.cmds import meson
+
+
+def make_paths(root, paths):
+    for p in paths:
+        os.makedirs(pjoin(root, p.lstrip("/")))
+
+
+def test_path_discovery(monkeypatch):
+    version = sys.version_info
+    X, Y = version.major, version.minor
+
+    # With multiple site-packages, choose the one that
+    # matches the current Python version
+    with tempfile.TemporaryDirectory() as d:
+        with monkeypatch.context() as m:
+            install_dir = pjoin(d, "build-install")
+            m.setattr(meson, "install_dir", install_dir)
+
+            make_paths(
+                install_dir,
+                [
+                    f"/usr/lib64/python{X}.{Y}/site-packages",
+                    f"/usr/lib64/python{X}.{Y + 1}/site-packages",
+                    f"/usr/lib64/python{X}.{Y + 2}/site-packages",
+                ],
+            )
+            assert (
+                normpath(f"/usr/lib64/python{X}.{Y}/site-packages")
+                in meson._get_site_packages()
+            )
+
+    # Debian uses dist-packages
+    with tempfile.TemporaryDirectory() as d:
+        with monkeypatch.context() as m:
+            install_dir = pjoin(d, "build-install")
+            m.setattr(meson, "install_dir", install_dir)
+
+            make_paths(
+                install_dir,
+                [
+                    f"/usr/lib64/python{X}.{Y}/dist-packages",
+                ],
+            )
+            assert (
+                normpath(f"/usr/lib64/python{X}.{Y}/dist-packages")
+                in meson._get_site_packages()
+            )
+
+    # If there is no version information in site-packages,
+    # use whatever site-packages can be found
+    with tempfile.TemporaryDirectory() as d:
+        with monkeypatch.context() as m:
+            install_dir = pjoin(d, "build-install")
+            m.setattr(meson, "install_dir", install_dir)
+
+            make_paths(install_dir, ["/Python3/site-packages"])
+            assert normpath("/Python3/site-packages") in meson._get_site_packages()
+
+    # Raise if no site-package directory present
+    with tempfile.TemporaryDirectory() as d:
+        with monkeypatch.context() as m:
+            install_dir = pjoin(d, "build-install")
+            m.setattr(meson, "install_dir", install_dir)
+
+            with pytest.raises(FileNotFoundError):
+                meson._get_site_packages()
+
+    # If there are multiple site-package paths, but without version information,
+    # refuse the temptation to guess
+    with tempfile.TemporaryDirectory() as d:
+        install_dir = pjoin(d, "build-install")
+        make_paths(
+            install_dir, [f"/Python3/x/site-packages", f"/Python3/y/site-packages"]
+        )
+        with pytest.raises(FileNotFoundError):
+            meson._get_site_packages()
+
+    # Multiple site-package paths found, but none that matches our Python
+    with tempfile.TemporaryDirectory() as d:
+        with monkeypatch.context() as m:
+            install_dir = pjoin(d, "build-install")
+            m.setattr(meson, "install_dir", install_dir)
+
+            make_paths(
+                install_dir,
+                [
+                    f"/usr/lib64/python{X}.{Y + 1}/site-packages",
+                    f"/usr/lib64/python{X}.{Y + 2}/site-packages",
+                ],
+            )
+            with pytest.raises(FileNotFoundError):
+                meson._get_site_packages()

spin-0.2/spin.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.1
+Name: spin
+Version: 0.2
+Summary: Developer tool for scientific Python libraries
+Maintainer-email: Scientific Python <spin@discuss.scientific-python.org>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2021--2022, Scientific Python project
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+        
+Project-URL: homepage, https://github.com/scientific-python/spin
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Requires-Python: >=3.7
+Provides-Extra: lint
+License-File: LICENSE

spin-0.2/spin.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+spin/__init__.py
+spin/__main__.py
+spin/color_format.py
+spin/sectioned_help.py
+spin.egg-info/PKG-INFO
+spin.egg-info/SOURCES.txt
+spin.egg-info/dependency_links.txt
+spin.egg-info/requires.txt
+spin.egg-info/top_level.txt
+spin/cmds/__init__.py
+spin/cmds/build.py
+spin/cmds/meson.py
+spin/cmds/util.py
+spin/tests/test_meson.py

spin-0.2/spin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spin-0.2/spin.egg-info/requires.txt

@@ -0,0 +1,8 @@
+click
+toml
+
+[:platform_system == "Windows"]
+colorama
+
+[lint]
+pre-commit>=3.1

spin-0.2/spin.egg-info/top_level.txt

@@ -0,0 +1 @@
+spin

spin-0.0.1.dev0/PKG-INFO

@@ -1,83 +0,0 @@
-Metadata-Version: 2.1
-Name: spin
-Version: 0.0.1.dev0
-Summary: Spatial omics analysis
-Author: Danila Bredikhin
-Maintainer-email: Danila Bredikhin <danila.bredikhin@embl.de>
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: anndata
-Requires-Dist: bump2version ; extra == "dev"
-Requires-Dist: sphinx>=4 ; extra == "doc"
-Requires-Dist: furo ; extra == "doc"
-Requires-Dist: myst-parser ; extra == "doc"
-Requires-Dist: sphinxcontrib-bibtex>=1.0.0 ; extra == "doc"
-Requires-Dist: scanpydoc[typehints]>=0.7.4 ; extra == "doc"
-Requires-Dist: nbsphinx ; extra == "doc"
-Requires-Dist: ipython>=8.3.0 ; extra == "doc"
-Requires-Dist: pytest ; extra == "test"
-Requires-Dist: pytest-cov ; extra == "test"
-Project-URL: Documentation, https://spin.readthedocs.io/
-Project-URL: Home-page, https://github.com/gtca/spin
-Project-URL: Source, https://github.com/gtca/spin
-Provides-Extra: dev
-Provides-Extra: doc
-Provides-Extra: test
-
-# spin
-
-[![Tests][badge-tests]][link-tests]
-[![Documentation][badge-docs]][link-docs]
-
-[badge-tests]: https://img.shields.io/github/workflow/status/gtca/spin/Test/main
-[link-tests]: https://github.com/gtca/spin/actions/workflows/test.yml
-[badge-docs]: https://img.shields.io/readthedocs/spin
-
-Spatial omics analysis
-
-## Getting started
-
-Please refer to the [documentation][link-docs]. In particular, the
-
--   [API documentation][link-api].
-
-## Installation
-
-You need to have Python 3.8 or newer installed on your system. If you don't have
-Python installed, we recommend installing `Miniconda <https://docs.conda.io/en/latest/miniconda.html>`\_.
-
-There are several alternative options to install spin:
-
-<!--
-1) Install the latest release of `spin` from `PyPI <https://pypi.org/project/spin/>`_:
-
-```bash
-pip install spin
-```
--->
-
-1. Install the latest development version:
-
-```bash
-pip install git+https://github.com/gtca/spin.git@main
-```
-
-## Release notes
-
-See the [changelog][changelog].
-
-## Contact
-
-For questions and help requests, you can reach out in the [scverse discourse][scverse-discourse].
-If you found a bug, please use the [issue tracker][issue-tracker].
-
-## Citation
-
-> t.b.a
-
-[scverse-discourse]: https://discourse.scverse.org/
-[issue-tracker]: https://github.com/gtca/spin/issues
-[changelog]: https://spin.readthedocs.io/latest/changelog.html
-[link-docs]: https://spin.readthedocs.io
-[link-api]: https://spin.readthedocs.io/latest/api.html
-

spin-0.0.1.dev0/README.md

@@ -1,56 +0,0 @@
-# spin
-
-[![Tests][badge-tests]][link-tests]
-[![Documentation][badge-docs]][link-docs]
-
-[badge-tests]: https://img.shields.io/github/workflow/status/gtca/spin/Test/main
-[link-tests]: https://github.com/gtca/spin/actions/workflows/test.yml
-[badge-docs]: https://img.shields.io/readthedocs/spin
-
-Spatial omics analysis
-
-## Getting started
-
-Please refer to the [documentation][link-docs]. In particular, the
-
--   [API documentation][link-api].
-
-## Installation
-
-You need to have Python 3.8 or newer installed on your system. If you don't have
-Python installed, we recommend installing `Miniconda <https://docs.conda.io/en/latest/miniconda.html>`\_.
-
-There are several alternative options to install spin:
-
-<!--
-1) Install the latest release of `spin` from `PyPI <https://pypi.org/project/spin/>`_:
-
-```bash
-pip install spin
-```
--->
-
-1. Install the latest development version:
-
-```bash
-pip install git+https://github.com/gtca/spin.git@main
-```
-
-## Release notes
-
-See the [changelog][changelog].
-
-## Contact
-
-For questions and help requests, you can reach out in the [scverse discourse][scverse-discourse].
-If you found a bug, please use the [issue tracker][issue-tracker].
-
-## Citation
-
-> t.b.a
-
-[scverse-discourse]: https://discourse.scverse.org/
-[issue-tracker]: https://github.com/gtca/spin/issues
-[changelog]: https://spin.readthedocs.io/latest/changelog.html
-[link-docs]: https://spin.readthedocs.io
-[link-api]: https://spin.readthedocs.io/latest/api.html

spin-0.0.1.dev0/pyproject.toml

@@ -1,92 +0,0 @@
-[build-system]
-build-backend = "flit_core.buildapi"
-requires = [
-    "flit_core >=3.4,<4",
-    "importlib_metadata>=0.7; python_version < '3.8'",
-]
-
-
-[project]
-name = "spin"
-description = "Spatial omics analysis"
-authors = [
-    {name = "Danila Bredikhin"},
-]
-maintainers = [
-    {name = "Danila Bredikhin", email = "danila.bredikhin@embl.de"},
-]
-urls.Documentation = "https://spin.readthedocs.io/"
-urls.Source = "https://github.com/gtca/spin"
-urls.Home-page = "https://github.com/gtca/spin"
-version = "0.0.1.dev0"
-requires-python = ">=3.8"
-license = {file = "LICENSE"}
-readme = "README.md"
-dependencies = ["anndata"]
-
-[project.optional-dependencies]
-dev = [
-    # dev version generation
-    "bump2version",
-]
-doc = [
-    "sphinx>=4",
-    "furo",
-    "myst-parser",
-    "sphinxcontrib-bibtex>=1.0.0",
-    "scanpydoc[typehints]>=0.7.4",
-    # For notebooks
-    "nbsphinx",
-    "ipython>=8.3.0"
-]
-test = [
-    "pytest",
-    "pytest-cov",
-]
-
-[tool.coverage.run]
-source = ["spin"]
-omit = [
-    "**/test_*.py",
-]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-xfail_strict = true
-addopts = [
-    "-Werror",  # if 3rd party libs raise DeprecationWarnings, just use filterwarnings below
-    "--import-mode=importlib",  # allow using test files with same name
-]
-filterwarnings = [
-    # "ignore:.*U.*mode is deprecated:DeprecationWarning",
-]
-
-[tool.isort]
-include_trailing_comma = true
-multi_line_output = 3
-profile = "black"
-skip_glob = ["docs/*"]
-
-[tool.black]
-line-length = 120
-target-version = ['py38']
-include = '\.pyi?$'
-exclude = '''
-(
-  /(
-      \.eggs
-    | \.git
-    | \.hg
-    | \.mypy_cache
-    | \.tox
-    | \.venv
-    | _build
-    | buck-out
-    | build
-    | dist
-  )/
-)
-'''
-
-[tool.jupytext]
-formats = "ipynb,md"

spin-0.0.1.dev0/spin/__init__.py

@@ -1,7 +0,0 @@
-from importlib.metadata import version
-
-from . import pl, pp, tl
-
-__all__ = ["pl", "pp", "tl"]
-
-__version__ = version("spin")

spin-0.0.1.dev0/spin/pl/__init__.py

@@ -1 +0,0 @@
-from .basic import basic_plot

spin-0.0.1.dev0/spin/pl/basic.py

@@ -1,7 +0,0 @@
-from anndata import AnnData
-
-
-def basic_plot(adata: AnnData) -> int:
-    """Generate a basic plot for an AnnData object."""
-    print("Import matplotlib and implement a plotting function here.")
-    return 0

spin-0.0.1.dev0/spin/pp/__init__.py

@@ -1 +0,0 @@
-from .basic import basic_preproc

spin-0.0.1.dev0/spin/pp/basic.py

@@ -1,7 +0,0 @@
-from anndata import AnnData
-
-
-def basic_preproc(adata: AnnData) -> int:
-    """Run a basic preprocessing on the AnnData object."""
-    print("Implement a preprocessing function here.")
-    return 0

spin-0.0.1.dev0/spin/tl/__init__.py

@@ -1 +0,0 @@
-from .basic import basic_tool

spin-0.0.1.dev0/spin/tl/basic.py

@@ -1,7 +0,0 @@
-from anndata import AnnData
-
-
-def basic_tool(adata: AnnData) -> int:
-    """Run a tool on the AnnData object."""
-    print("Implement a tool to run on the AnnData object.")
-    return 0