semvec/pypi-packages huggingface dataset:
airoh 0.1.4
A lightweight task library for reproducible workflows
License: MIT
Requires Python: >=3.8

# 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
* `ensure-dir-exist`: Creates a directory listed in `invoke.yaml` if it doesn't already exist.
* `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
basicParallelize 1.1.3
Wrappers for multiprocessing's Pool and ThreadPool classes.
License: MIT
Requires Python: >=3.8
Keywords: parallel

# basicParallelize: A Basic Wrapper for Multiprocessing
[![pypi](http://img.shields.io/pypi/v/basicParallelize.png)](https://pypi.python.org/pypi/basicParallelize)
[![Supported Python Versions](https://img.shields.io/pypi/pyversions/basicParallelize.svg)](https://pypi.python.org/pypi/basicParallelize/)
[![PyPI Downloads](https://static.pepy.tech/badge/basicparallelize)](https://pepy.tech/projects/basicparallelize)
[![License](https://img.shields.io/pypi/l/basicParallelize.svg)](https://pypi.python.org/pypi/basicParallelize/)
![Tests Status](https://raw.githubusercontent.com/jBeale23/parallelize/refs/heads/stable/reports/tests/tests-badge.svg?dummy=8484744)
![Coverage Status](https://raw.githubusercontent.com/jBeale23/parallelize/refs/heads/stable/reports/coverage/coverage-badge.svg?dummy=8484744)
[![Nox](https://img.shields.io/badge/%F0%9F%A6%8A-Nox-D85E00.svg)](https://github.com/wntrblm/nox)
***

``basicParallelize`` is designed to provide a user friendly wrapper for Python's multiprocessing library, including support for progress bars from [tqdm](https://github.com/tqdm/tqdm).

```python
    # Wrapper for multiprocessing.pool.ThreadPool
    from basicParallelize import multiThread
    output = multiThread(function, parameters)
```


```python
    # Wrapper for multiprocessing.Pool
    from basicParallelize import parallelProcess
    output = multiProcess(function, parameters)
```

Both core functions can be run with a built in progress bars by instead using `multiThreadTQDM` or `parallelProcessTQDM` respectively.

# Installation
------------
A recent version of Python 3 (3.8 or above) is required. You can probably run it or easily adapt it for older versions of Python, but I don't support any end-of-life Python versions. Beyond that, the only dependency is the `tqdm` library.

## Latest stable version on PyPi
`pip install basicParallelize`

## Latest stable version on GitHub
`pip install git+https://github.com/jBeale23/parallelize.git@stable`

## Latest development version on GitHub
`pip install git+https://github.com/jBeale23/parallelize.git@dev`
bdvr 0.12.0
customized report generated from set of blackduck reports that gives 'color coded vulnerabilities', and 'source paths' including 'direct' and 'indirect dependencies' details all in one report
License: MIT
Requires Python: <4.0,>=3.8

# bdvr, an Customized Blackduck_Vulnerability_report

# Use case:

Project stakeholders want to know which files are affected with vulnerabilities after a Blackduck HUB scan.

# Drawbacks:

The current blackduck generates multiple reports. To fulfill above requirement once has to refer 2 different reports to really able to trace the source files affected.

# Features

1. Produces customized report where we can see vulnerability, OSS name, affected source path details all in one report
2. Color coded

   low risk = no color

   medium risk = Yellow

   High risk = Red

3. Omits all other files which has no vulnerabilities.

### Prerequiites:

Export your environment variable (in linux)
```sh
export BD_URL="https://www.your_blackduck.com" && export BD_TOKEN="YOUR_API_TOKEN"
```

## How to install

```sh

pip install bdvr
```

## Command to run

```sh


bdvr -h
usage: A program to create vulnerability reports for a given project-version [-h] [-z ZIP_FILE_NAME] [-r REPORTS] [--format {CSV}] [-t TRIES] [-s SLEEP_TIME] [--no-verify]
                                                                             [-o]
                                                                             project_name version_name

positional arguments:
  project_name
  version_name

options:
  -h, --help            show this help message and exit
  -z ZIP_FILE_NAME, --zip_file_name ZIP_FILE_NAME
  -r REPORTS, --reports REPORTS
                        Comma separated list (no spaces) of the reports to generate - ['version', 'scans', 'components', 'vulnerabilities', 'source', 'cryptography',
                        'license_terms', 'component_additional_fields', 'project_version_additional_fields', 'vulnerability_matches', 'upgrade_guidance',
                        'license_conflicts']. Default is all reports.
  --format {CSV}        Report format - only CSV available for now
  -t TRIES, --tries TRIES
                        How many times to retry downloading the report, i.e. wait for the report to be generated
  -s SLEEP_TIME, --sleep_time SLEEP_TIME
                        The amount of time to sleep in-between (re-)tries to download the report
  --no-verify           disable TLS certificate verification
  -o                    (Optional) To automatically open the file

#To automatically open the file add -o option
bdvr BD_PROJECT_NAME BD_PROJECT_VERSION

```

## Dependenceis

```sh

Thanks to all authors. As this library uses below modules
pandas = "^1.4.3"
quo = "^2022.8.2"
universal-startfile = "^0.1.3"

```

## Issues

Please send your bugs to dineshr93@gmail.com

## License

[MIT](LICENSE)
sphinx-autodocgen 1.4
Sphinx AutoDocGen extension
License: MIT
Requires Python: >=3.6
Keywords: sphinx, autodoc

Sphinx autodocgen extension
===========================

A free extension for Sphinx (the documentation generator) that automatically generates .rst files for 
Python modules. Each module is a page with ``autodoc`` and navigation subheadings for each class, and 
each package has an autosummary with links and description for each of the the modules it contains. 

The project this was originally developed for the PySys test framework. To see what the documentation for a typical 
module looks like, `see here <https://pysys-test.github.io/pysys-test/autodocgen/pysys.writer.html>`_. 

Current supported Sphinx version is v8.

Features include:

- A strong emphasis on extensibility by writing simple Python callbacks. The extension takes care of walking the 
  Python hierarchy (the tricky bit), but lets you choose exactly what you want the rst to look like, using the 
  full power of Python rather than the (sometimes) restrictive templating library approach taken by other plugins. 
  
- Nice defaults that give an autosummary table for each package so users know what each of the contained modules 
  is for, and for each module a single page listing all the classes (and other members) with a navbar-visible 
  subheading for each class. 

- Skipping of modules (e.g. internal modules) controlled by a regular expression. 

- Ability to customize the autodoc configuration for individual modules. 

- Ability to choose the title of each topic using a Python callback. 

- Automatic generation of .rst files as part of conf.py without the need to separately run a tool like autogen 
  first. 

Sample
------

To use it, just add a few lines to your ``conf.py``::

	extensions = [
		...
		'sphinx.ext.autodoc',
		'sphinx.ext.autosummary',
		'sphinxcontrib_autodocgen',
	]

	autodocgen_config = [{
		'modules':['mymodule'], # (assumes you've added the parent dir of your module to sys.path)
		'generated_source_dir': DOC_SOURCE_DIR+'/autodocgen-output/',
		
		# if module matches this then it and any of its submodules will be skipped
		'skip_module_regex': '(.*[.]__|myskippedmodule)', 
		
		# produce a text file containing a list of everything documented. you can use this in a test to notice when you've 
		# intentionally added/removed/changed a documented API
		'write_documented_items_output_file': 'autodocgen_documented_items.txt',
		
		# customize autodoc on a per-module basis
		'autodoc_options_decider': { 
			'mymodule.FooBar':    { 'inherited-members':True },
		},
		
		# choose a different title for specific modules, e.g. the toplevel one
		'module_title_decider': {'mymodule': 'API Reference'},
	}]