airoh 0.1.2__tar.gz

airoh-0.1.2/.gitignore

@@ -0,0 +1,194 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the enitre vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

airoh-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SIMEXP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

airoh-0.1.2/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: airoh
+Version: 0.1.2
+Summary: A lightweight task library for reproducible workflows
+Project-URL: Homepage, https://github.com/simexp/airoh
+Project-URL: Issues, https://github.com/SIMEXP/airoh/issues
+Author-email: Lune Bellec <lune.bellec@umontreal.ca>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.8
+Requires-Dist: invoke>=2.0
+Description-Content-Type: text/markdown
+
+# airoh
+_Because reproducible science takes clean tasks. And why don't you have a cup of relaxing jasmin tea?_
+
+**airoh** is a lightweight Python task library built with [`invoke`](https://www.pyinvoke.org/), designed for reproducible research workflows. It provides pre-written, modular task definitions that can be easily reused in your own `tasks.py` file — no boilerplate, just useful automation.
+
+## Installation
+Installation through PIP:
+```bash
+pip install airoh
+```
+
+For local deployment:
+
+```bash
+git clone https://github.com/simexp/airoh.git
+cd airoh
+pip install -e .
+```
+
+## Usage
+
+You can use `airoh` in your project simply by importing tasks in your `tasks.py` file.
+
+### Minimal Example
+
+```python
+# tasks.py
+from airoh.utils import run_figures, setup_env_python
+```
+
+Now you can call:
+
+```bash
+invoke run-figures
+invoke setup-env-python
+```
+
+## Available Tasks
+
+### From `containers.py`
+
+* `docker-build` — Build a Docker image from a Dockerfile
+* `docker-archive` — Archive the Docker image to `.tar.gz`
+* `docker-setup` — Download and load a Docker image from URL
+* `docker-run` — Run an `invoke` task inside Docker
+* `apptainer-archive` — Build an Apptainer image from Docker
+* `apptainer-run` — Run an `invoke` task inside Apptainer
+
+### From `utils.py`
+
+* `ensure_submodule` — Ensure a git submodule is present and up to date
+* `install_local` — Install a local Python package in editable mode using pip 
+* `setup-env-python` — Install Python dependencies from a file
+* `run-figures` — Run Jupyter notebooks to generate figures
+* `clean_folder` — Remove an entire directory recursively. Use with caution!!!
+
+### From `datalad.py`
+* `get-data` — Install and retrieve a subdataset listed in `invoke.yaml`
+* `import-archive` — Download a remote archive (e.g. from Zenodo), extract its contents with `datalad`, and optionally drop the original file
+* `import-file` — Download a remote file (e.g. from Zenodo), using `datalad`
+
+## Requirements
+
+* Python ≥ 3.8
+* [`invoke`](https://www.pyinvoke.org/) ≥ 2.0
+* Docker (for container tasks)
+* Apptainer (optional, for `.sif` support)
+* `jupyter` (if using `run-figures`)
+
+## Philosophy
+
+Inspired by Uncle Iroh from *Avatar: The Last Airbender*, `airoh` aims to bring simplicity, reusability, and clarity to research infrastructure — one well-structured task at a time. It is meant to support a concrete implementation of the [YODA principles](https://handbook.datalad.org/en/latest/basics/101-127-yoda.html).
+
+## License
+
+MIT © Lune Bellec

airoh-0.1.2/README.md

@@ -0,0 +1,76 @@
+# airoh
+_Because reproducible science takes clean tasks. And why don't you have a cup of relaxing jasmin tea?_
+
+**airoh** is a lightweight Python task library built with [`invoke`](https://www.pyinvoke.org/), designed for reproducible research workflows. It provides pre-written, modular task definitions that can be easily reused in your own `tasks.py` file — no boilerplate, just useful automation.
+
+## Installation
+Installation through PIP:
+```bash
+pip install airoh
+```
+
+For local deployment:
+
+```bash
+git clone https://github.com/simexp/airoh.git
+cd airoh
+pip install -e .
+```
+
+## Usage
+
+You can use `airoh` in your project simply by importing tasks in your `tasks.py` file.
+
+### Minimal Example
+
+```python
+# tasks.py
+from airoh.utils import run_figures, setup_env_python
+```
+
+Now you can call:
+
+```bash
+invoke run-figures
+invoke setup-env-python
+```
+
+## Available Tasks
+
+### From `containers.py`
+
+* `docker-build` — Build a Docker image from a Dockerfile
+* `docker-archive` — Archive the Docker image to `.tar.gz`
+* `docker-setup` — Download and load a Docker image from URL
+* `docker-run` — Run an `invoke` task inside Docker
+* `apptainer-archive` — Build an Apptainer image from Docker
+* `apptainer-run` — Run an `invoke` task inside Apptainer
+
+### From `utils.py`
+
+* `ensure_submodule` — Ensure a git submodule is present and up to date
+* `install_local` — Install a local Python package in editable mode using pip 
+* `setup-env-python` — Install Python dependencies from a file
+* `run-figures` — Run Jupyter notebooks to generate figures
+* `clean_folder` — Remove an entire directory recursively. Use with caution!!!
+
+### From `datalad.py`
+* `get-data` — Install and retrieve a subdataset listed in `invoke.yaml`
+* `import-archive` — Download a remote archive (e.g. from Zenodo), extract its contents with `datalad`, and optionally drop the original file
+* `import-file` — Download a remote file (e.g. from Zenodo), using `datalad`
+
+## Requirements
+
+* Python ≥ 3.8
+* [`invoke`](https://www.pyinvoke.org/) ≥ 2.0
+* Docker (for container tasks)
+* Apptainer (optional, for `.sif` support)
+* `jupyter` (if using `run-figures`)
+
+## Philosophy
+
+Inspired by Uncle Iroh from *Avatar: The Last Airbender*, `airoh` aims to bring simplicity, reusability, and clarity to research infrastructure — one well-structured task at a time. It is meant to support a concrete implementation of the [YODA principles](https://handbook.datalad.org/en/latest/basics/101-127-yoda.html).
+
+## License
+
+MIT © Lune Bellec

airoh-0.1.2/airoh/containers.py

@@ -0,0 +1,160 @@
+# src/airoh/containers.py
+import os
+import shutil
+import tempfile
+import gzip
+from pathlib import Path
+from invoke import task
+
+def _set_image(c, image=None):
+    """
+    Resolve the Docker image name from parameter or invoke.yaml.
+    """
+    image = image or c.config.get("docker_image")
+    if not image:
+        raise ValueError("No Docker image specified. Please set docker_image in invoke.yaml or pass it explicitly.")
+    return image
+
+@task
+def docker_build(c, image=None):
+    """
+    Build the Docker image from the Dockerfile in the project root.
+    """
+    image = _set_image(c, image)
+    print(f"🐳 Building Docker image: {image}")
+    c.run(f"docker build -t {image} .")
+
+@task
+def docker_archive(c, image=None):
+    """
+    Save the Docker image to a compressed archive for Zenodo or transport.
+    """
+    image = _set_image(c, image)
+    output = f"{image}.tar.gz"
+    print(f"📦 Archiving Docker image '{image}' to {output}...")
+    c.run(f"docker save {image} | gzip > {output}")
+    print("🪦 Archive complete.")
+
+@task
+def docker_setup(c, url=None, image=None):
+    """
+    Download and load the prebuilt Docker image from Zenodo.
+    """
+    image = _set_image(c, image)
+    if not url:
+        url = c.config.get("docker_archive")
+        if not url:
+            raise ValueError("No archive URL provided. Set docker_archive in invoke.yaml or pass --url.")
+
+    output = f"{image}.tar.gz"
+    if not os.path.exists(output):
+        print(f"📥 Downloading container from {url}...")
+        c.run(f"wget -O {output} '{url}'")
+    else:
+        print(f"📦 Container archive already exists: {output}")
+
+    print("🐳 Loading Docker image...")
+    c.run(f"gunzip -c {output} | docker load")
+    print("✨ Container setup complete.")
+
+def _ensure_docker_image_loaded(c, image, image_tar):
+    """
+    Ensure the specified Docker image is available. If not, try to load it from a .tar or .tar.gz.
+    """
+    if not shutil.which("docker"):
+        raise RuntimeError("❌ Docker is not installed or not in PATH. Please install Docker.")
+
+    result = c.run(f"docker images -q {image}", hide=True, warn=True)
+    if result.stdout.strip():
+        c.run(f"docker tag {image} {image}:latest", warn=True)
+        return
+
+    print(f"📦 Docker image '{image}' not found. Attempting to load from {image_tar}...")
+
+    image_tar = Path(image_tar)
+    if not image_tar.exists():
+        raise FileNotFoundError(f"❌ Docker image file not found: {image_tar}")
+
+    if image_tar.suffixes[-2:] == ['.tar', '.gz']:
+        print(f"🖜️ Extracting {image_tar}...")
+        with tempfile.NamedTemporaryFile(suffix=".tar", delete=False) as temp_tar:
+            with gzip.open(image_tar, "rb") as f_in:
+                shutil.copyfileobj(f_in, temp_tar)
+            temp_tar_path = temp_tar.name
+        c.run(f"docker load -i {temp_tar_path}")
+        os.remove(temp_tar_path)
+    elif image_tar.suffix == ".tar":
+        c.run(f"docker load -i {image_tar}")
+    else:
+        raise ValueError("❌ Unsupported container format. Use .tar or .tar.gz")
+
+    c.run(f"docker tag {image} {image}:latest", warn=True)
+
+@task
+def docker_run(c, task, args=""):
+    """
+    Run an invoke task inside the Docker container.
+
+    Args:
+        task (str): the invoke task to run
+        args (str): any additional CLI args to pass to the task
+    """
+    image = c.config.get("docker_image")
+    image_tar = f"{image}.tar.gz"
+
+    _ensure_docker_image_loaded(c, image, image_tar)
+
+    hostdir = os.getcwd()
+    workdir = "/home/jovyan/work"
+    cmd = f"invoke {task} {args}"
+    docker_cmd = f'docker run --rm -v {hostdir}:{workdir} -w {workdir} {image} {cmd}'
+
+    print(f"🐳 Running inside container: {cmd}")
+    c.run(docker_cmd)
+
+@task
+def apptainer_archive(c, image=None):
+    """
+    Archive the Apptainer (Singularity) image from a Docker image using Docker daemon.
+    Builds the .sif file if not present.
+    """
+    image = _set_image(c, image)
+    sif_path = Path(f"{image}.sif")
+
+    if not shutil.which("apptainer"):
+        raise RuntimeError("❌ Apptainer is not installed or not in PATH. Please install it.")
+
+    if sif_path.exists():
+        print(f"✅ Apptainer image already exists at {sif_path}. Skipping build.")
+        return
+
+    if not shutil.which("docker"):
+        raise RuntimeError("❌ Docker is required to build from Docker image. Please install it.")
+
+    _ensure_docker_image_loaded(c, image, f"{image}.tar.gz")
+    print(f"🧪 Building Apptainer image {sif_path} from Docker image {image}:latest...")
+    c.run(f"apptainer build {sif_path} docker-daemon:{image}:latest")
+    print("✅ Apptainer image build complete.")
+
+@task
+def apptainer_run(c, task, args=""):
+    """
+    Run an invoke task inside the Apptainer container.
+
+    Args:
+        task (str): the invoke task to run
+        args (str): any additional CLI args to pass to the task
+    """
+    docker_image = c.config.get("docker_image")
+    sif_path = Path(f"{docker_image}.sif")
+
+    if not sif_path.exists():
+        raise FileNotFoundError(f"❌ Apptainer image not found: {sif_path}")
+
+    hostdir = os.getcwd()
+    workdir = "/home/jovyan/work"
+    cmd = f"invoke {task} {args}"
+    apptainer_cmd = f"apptainer exec --cleanenv --bind {hostdir}:{workdir} {sif_path} {cmd}"
+
+    print(f"🧪 Running inside Apptainer: {cmd}")
+    c.run(apptainer_cmd)

airoh-0.1.2/airoh/datalad.py

@@ -0,0 +1,82 @@
+# src/airoh/datalad.py
+from invoke import task
+import os
+import shlex
+import shutil
+from pathlib import Path
+
+@task
+def get_data(c, name):
+    """
+    Ensure a Datalad subdataset is installed and retrieved.
+
+    Parameters:
+        name (str): Name of the dataset as defined in invoke.yaml under 'datasets'.
+    """
+    datasets = c.config.get("datasets", {})
+    if name not in datasets:
+        raise ValueError(f"❌ Dataset '{name}' not found in invoke.yaml under 'datasets'.")
+
+    path = datasets[name]
+    print(f"📦 Checking dataset '{name}' at: {path}")
+
+    if not os.path.exists(path):
+        print(f"📥 Installing subdataset '{name}'...")
+        c.run(f"datalad install --recursive {path}")
+
+    print(f"📥 Retrieving data for '{name}'...")
+    c.run(f"datalad get {path}")
+    print("✅ Done.")
+
+@task
+def import_file(c, name):
+    """
+    Download a file using its name from invoke.yaml -> files.<name>.
+
+    Parameters:
+        name (str): Key from the 'files' section in invoke.yaml.
+    """
+    files = c.config.get("files", {})
+    if name not in files:
+        raise ValueError(f"❌ No file config found for '{name}' in invoke.yaml.")
+
+    entry = files[name]
+    url = entry.get("url")
+    output_file = entry.get("output_file")
+
+    if not url or not output_file:
+        raise ValueError(f"❌ Entry for '{name}' must define both 'url' and 'output_file'.")
+
+    c.run(f"datalad download-url -O {shlex.quote(output_file)} {shlex.quote(url)}")
+    print(f"✅ Downloaded {name} to {output_file}")
+
+@task
+def import_archive(c, url, archive_name=None, target_dir=".", drop_archive=False):
+    """
+    Download a remote archive (e.g. from Zenodo or Figshare) and extract its content with Datalad.
+
+    Parameters:
+        url (str): URL to the archive (e.g. .zip, .tar.gz). For Figshare-style links, explicitly provide
+                   `archive_name` if the URL does not end with the actual filename.
+        archive_name (str): Optional filename (default: basename of URL).
+        target_dir (str): Directory to extract into (default: current dir).
+        drop_archive (bool): Whether to drop the original archive from annex after extraction.
+    """
+    archive_name = archive_name or os.path.basename(url)
+    archive_path = os.path.join(target_dir, archive_name)
+
+    import_file(c, url, archive_path)
+
+    archive_exts = ['.zip', '.tar', '.tar.gz', '.tgz', '.tar.bz2', '.7z']
+    if not any(archive_path.endswith(ext) for ext in archive_exts):
+        print("⚠️ Skipping extraction — file does not appear to be a supported archive.")
+        return
+
+    print(f"📦 Extracting archive content into {target_dir}...")
+    c.run(f"datalad add-archive-content --delete --extract {shlex.quote(archive_path)} -d {shlex.quote(target_dir)}")
+
+    if drop_archive:
+        print(f"🧹 Dropping archive from annex: {archive_path}")
+        c.run(f"datalad drop {shlex.quote(archive_path)}")
+
+    print("✅ Archive import complete.")

airoh-0.1.2/airoh/utils.py

@@ -0,0 +1,95 @@
+# src/airoh/utils.py
+import os
+import shutil
+from pathlib import Path
+from invoke import task
+
+@task
+def setup_env_python(c, reqs="requirements.txt"):
+    """
+    Set up Python environment by installing from a requirements file.
+    """
+    if not os.path.exists(reqs):
+        raise FileNotFoundError(f"⚠️ Requirements file not found: {reqs}")
+
+    print(f"🐍 Installing Python requirements from {reqs}...")
+    c.run(f"pip install -r {reqs}")
+
+@task
+def ensure_submodule(c, path):
+    """
+    Ensure a git submodule is present and up to date.
+
+        Parameters:
+            path (str): Path to the submodule directory 
+    """
+    if not os.path.exists(path) or not os.path.exists(os.path.join(path, ".git")):
+        print(f"📦 Initializing submodule at {path}...")
+        c.run(f"git submodule update --init --recursive {path}")
+    else:
+        print(f"🔄 Updating submodule at {path}...")
+        c.run(f"git submodule update --remote {path}")
+
+@task
+def install_local(c, path):
+    """
+    Install a local Python package in editable mode using pip.
+
+    Parameters:
+        path (str): Path to the package directory
+    """
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"❌ Package path not found: {path}")
+
+    print(f"🔧 Installing package from {path} in editable mode...")
+    c.run(f"pip install -e {path}")
+    print("✅ Editable install complete.")
+
+@task
+def clean_folder(c, dir_name, label=None):
+    """
+    Remove an entire directory recursively. Use with caution!!!
+    Parameters: 
+        dir_name (str): Path to be removed 
+        label (str, optional): label to use for path in the verbose
+    """
+    label = label or dir_name
+    if os.path.exists(dir_name):
+        shutil.rmtree(dir_name)
+        print(f"💥 Removed {label} at {dir_name}")
+    else:
+        print(f"🫧 Nothing to clean: {label}")
+
+@task
+def run_figures(c, notebooks_path=None, figures_base=None):
+    """
+    Run figure notebooks, skipping any that already have output folders.
+    Notebooks directory and output location pulled from invoke.yaml.
+    """
+    import pathlib as lib
+
+    notebooks_path = Path(notebooks_path or c.config.get("notebooks_dir", "code/figures"))
+    figures_base = Path(figures_base or c.config.get("figures_dir", "output_data/Figures"))
+
+    if not notebooks_path.exists():
+        print(f"⚠️ Notebooks directory not found: {notebooks_path}")
+        return
+
+    notebooks = sorted(notebooks_path.glob("*.ipynb"))
+
+    if not notebooks:
+        print(f"⚠️ No notebooks found in {notebooks_path}/")
+        return
+
+    for nb in notebooks:
+        fig_name = nb.stem
+        fig_output_dir = figures_base / fig_name
+
+        if fig_output_dir.exists():
+            print(f"✅ Skipping {nb.name} (output exists at {fig_output_dir})")
+            continue
+
+        print(f"📈 Running {nb.name}...")
+        c.run(f"jupyter nbconvert --to notebook --execute --inplace {nb}")
+
+    print("🎉 All figure notebooks processed.")

airoh-0.1.2/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "airoh"
+version = "0.1.2"
+description = "A lightweight task library for reproducible workflows"
+authors = [{ name = "Lune Bellec", email = "lune.bellec@umontreal.ca" }]
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+dependencies = ["invoke>=2.0"]
+
+[project.urls]
+Homepage = "https://github.com/simexp/airoh"
+Issues = "https://github.com/SIMEXP/airoh/issues"
+
+[tool.ruff]
+line-length = 100
+target-version = "py38"
+select = ["I"]  # E = pycodestyle, F = pyflakes, I = isort
+
+[tool.hatch.envs.dev]
+dependencies = [
+"invoke>=2.0",
+"ruff>=0.1.0",
+"pytest>=7.0"
+]

airoh-0.1.2/requirements.txt

@@ -0,0 +1 @@
+invoke>=2.0

airoh-0.1.2/requirements_dev.txt

@@ -0,0 +1,5 @@
+hatchling>=1.18
+invoke>=2.0
+pytest>=7.0
+ruff>=0.1.0
+twine>=0.4