semvec/pypi-packages huggingface dataset:
babylab 0.8.1
A GUI for the SJD Babylab REDCap database
Requires Python: >=3.10

# babylab-redcap

![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/NeuroDevComp/babylab-redcap/lint-test.yml)
![GitHub Issues or Pull Requests](https://img.shields.io/github/issues/NeuroDevComp/babylab-redcap)
![PyPI - License](https://img.shields.io/pypi/l/babylab)
![PyPI - Status](https://img.shields.io/pypi/status/babylab)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/babylab)
[![PyPI - Version](https://img.shields.io/pypi/v/babylab)](https://pypi.org/project/babylab/)
![GitHub Tag](https://img.shields.io/github/v/tag/NeuroDevComp/babylab-redcap)
![GitHub Release](https://img.shields.io/github/v/release/NeuroDevComp/babylab-redcap)

---

## Table of Contents

- [Installation](#installation)
- [Launch](#launch)
- [Updating](#updating)
- [Feed-back](#feed-back)
- [License](#license)

## Installation

Python >=3.10 is needed. Python 3.12.7 is recommended (installation available at the [official website](https://www.python.org/downloads/release/python-3127/)). Depending on your OS, you may have to download one of these files:

- **Windows**: `Windows installer (64-bit)` file
- **macOS**: `macOS 64-bit universal2 installer` file

Once Python is installed, [open your terminal](https://www.youtube.com/watch?v=8Iyldhkrh7E) and run this command to install the necessary Python modules:

- **Windows**: `python -m pip install flask pywin32 python-dotenv babylab`
- **Linux/macOS**: `python3 -m pip install flask pywin32 python-dotenv babylab`

## Launch

To run the app in your browser, run the following command in your terminal:

- **Windows**: `python -m flask --app babylab.app run`
- **Linux/macOS**: `python3 -m flask --app babylab.app run`

Open your browser and go to [http://127.0.0.1:5000](http://127.0.0.1:5000). Log in with your API authentication token (and maybe your email), and you should be ready to go!

## Updating

To update the app, run the following line of code in your terminal:

- **Windows**: `python -m pip install --upgrade babylab`
- **Linux/macOS**: `python3 -m pip install --upgrade babylab`


## Feed-back

Please, report any issues or feeb-back by opening a [GitHub issue](https://github.com/NeuroDevComp/babylab-redcap/issues/new/choose), or getting in touch at [gonzalo.garcia[at]sjd.es](mailto:gonzalo.garcia@sjd.es).


## License

`babylab-redcap` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
sphinxext-photofinish 0.1.12
Sphinx Extension that creates responsive images.
Requires Python: >=3.8

# sphinxext-photofinish

Photofinish is a sphinx extension for creating [responsive](https://developer.mozilla.org/en-US/docs/Learn/HTML/Multimedia_and_embedding/Responsive_images) images to your Sphinx site. This has several benefits:

- Lower bandwidth cost for browsers and devices that don't need the higher resolution version
- Higher resolution images for higher resolution devices

Photofinish can dramatically increase the loading time of your Sphinx website.

## Installation

`python -m pip install sphinxext-photofinish`

## Usage
Just add `sphinxext-photofinish` to your extensions list in your `conf.py`

```python
extensions = [
    "sphinxext.photofinish",
]
```

## Configuration

Photofinish adds several `conf.py` options that you can optionally configure:

`max_viewport_width` - This is maximum "viewable" size of images in your documentation. Typically, it's set to the width of your body. Responsive images are generated up to double of this value. Default is 1000.

`width_min` - Minimum width of images to generate. Default is 500.

`width_step` - The resolution to iterate over for generating images. EX: 500, 800, 1100. Default is 300.

`photofinish_ci_only` - Should this extension only run if the `CI` environment variable is set? Default is False.
dissect.evidence 3.13.dev3
A Dissect module implementing a parsers for various forensic evidence file containers, currently: AD1, ASDF and EWF
Requires Python: >=3.10

# dissect.evidence

A Dissect module implementing parsers for various forensic evidence file containers, currently: AD1, ADCRYPT, ASDF and EWF. For
more information, please see [the documentation](https://docs.dissect.tools/en/latest/projects/dissect.evidence/index.html).

## Requirements

This project is part of the Dissect framework and requires Python.

Information on the supported Python versions can be found in the Getting Started section of [the documentation](https://docs.dissect.tools/en/latest/index.html#getting-started).

## Installation

`dissect.evidence` is available on [PyPI](https://pypi.org/project/dissect.evidence/).

```bash
pip install dissect.evidence
```

This module is also automatically installed if you install the `dissect` package.

## Build and test instructions

This project uses `tox` to build source and wheel distributions. Run the following command from the root folder to build
these:

```bash
tox -e build
```

The build artifacts can be found in the `dist/` directory.

`tox` is also used to run linting and unit tests in a self-contained environment. To run both linting and unit tests
using the default installed Python version, run:

```bash
tox
```

For a more elaborate explanation on how to build and test the project, please see [the
documentation](https://docs.dissect.tools/en/latest/contributing/tooling.html).

## Contributing

The Dissect project encourages any contribution to the codebase. To make your contribution fit into the project, please
refer to [the development guide](https://docs.dissect.tools/en/latest/contributing/developing.html).

## Copyright and license

Dissect is released as open source by Fox-IT (<https://www.fox-it.com>) part of NCC Group Plc
(<https://www.nccgroup.com>).

Developed by the Dissect Team (<dissect@fox-it.com>) and made available at <https://github.com/fox-it/dissect>.

License terms: AGPL3 (<https://www.gnu.org/licenses/agpl-3.0.html>). For more information, see the LICENSE file.
pve-cli 0.10.2
CLI Tool to manage VMs and more on proxmox clusters
Requires Python: <4.0.0,>=3.10

# pve-cli

CLI Tool to manage VMs and more on proxmox clusters

## Features

### Prevent migration

Migration of a VM by pve-cli can be prevented if the tag `do-not-migrate` is added to the VM. The migration of VMs with this tags can be forced with `--force`.
This is implemented for the commands `pve-cli vm VM migrate`, `pve-cli cluster reboot` and `pve-cli cluster vm-mapping restore`.

## Config

For config option reference see `config.example.toml`.
The config file path can be provided via command line option `--config`/`-c` and is searched by default in the following
paths:

* Linux (Unix): `~/.config/pve-cli/config.toml`
* MacOS: `~/Library/Application Support/pve-cli/config.toml`
* Windows: `C:\Users\<user>\AppData\Local\pve-cli\config.toml`

This leverages the [`get_app_dir`](https://click.palletsprojects.com/en/8.1.x/api/#click.get_app_dir) method
from [`click`](https://click.palletsprojects.com).

## Required PVE Permissions

For full functionallity following permissions are required:
* `Sys.Audit`
* `Sys.PowerMgmt`
* `VM.Audit`
* `VM.GuestAgent.Unrestricted`
* `VM.Migrate`
* `VM.PowerMgmt`

With the following line in `/etc/pve/user.cfg` you can create a role `CLI-Tool`:
```
role:CLI-Tool:Sys.Audit,Sys.PowerMgmt,VM.Audit,VM.GuestAgent.Unrestricted,VM.Migrate,VM.PowerMgmt:
```

Until PVE 9 instead of `VM.GuestAgent.Unrestricted` the permission `VM.Monitor` was needed.
weather-dashboard-jl 0.1.3
A Rich-powered weather dashboard CLI using WeatherAPI.com, with favorites and interactive mode.
Requires Python: >=3.12

# 🌤️ Weather Dashboard CLI

A Python command-line weather dashboard built with Typer and Rich.
Fetch current weather and forecasts, manage favorite cities, and explore weather data via an interactive CLI.

## ✨ Features

- 🌤️ Current weather for any city
- ⭐ Manage favorite cities (add, list, remove, clear)
- 🧭 Interactive menu-based mode
- 🌡️ Celsius / Fahrenheit support
- 📊 Rich-formatted terminal output
- ⚠️ Basic weather alerts (rain, etc.)

## 📦 Installation (from PyPI)

### Using pip
```bash
pip install weather-dashboard-jl
```

### Using uvx (no project needed)
```bash
uvx --from weather-dashboard-jl weather --help
```

## 🔑 API Key Setup

This CLI uses **WeatherAPI.com**.

**1) Get an API key**

Create an account and generate a key at:
https://www.weatherapi.com/

**2) Set the environment variable**

macOS / Linux
```bash
export WEATHER_API_KEY="YOUR_API_KEY"
```

Windows (PowerShell)
```bash
$env:WEATHER_API_KEY="YOUR_API_KEY"
```

## 🧪 Development Setup

```bash
git clone https://github.com/<your-username>/weather-dashboard.git
cd weather-dashboard
uv sync
```

## 🚀 Usage

### Help
```bash
weather --help
```

### Current weather
```bash
weather current Singapore
weather current "New York" --units f
```

### Interactive mode
```bash
weather interactive
```

### Favorites
```bash
weather fav add London
weather fav list
weather fav remove London
weather fav clear
```

## 📁 Project Structure
```text
weather_dashboard/
├── cli_weather.py        # Typer CLI commands
├── client.py             # WeatherAPI HTTP client
├── conditions.py         # Weather condition mappings
├── models.py             # View models
├── ui.py                 # Rich UI helpers
├── weather_service.py    # Domain logic
├── favorites.py          # Favorites persistence
├── units.py              # Unit handling (C/F)
├── alerts.py             # Alert logic
└── data/
    └── weather_conditions.json
```
ashaxiom 2.4.4
Intelligent Math & Financial Framework with Parallel Expert Consilium
Requires Python: >=3.7

# AshAxiom: Intelligent Math & Financial Ecosystem (v.2.4.4) (Consolidated Global Edition)

AshAxiom is a high-performance Python framework designed as a **Living Library**. It unifies academic mathematical rigor with modern financial analysis and decentralized AI integration.

## 🚀 Key Innovation: The Golden Standard
AshAxiom uses a unified argument system across all expert books. You no longer need to guess variable names:
- **`expr`**: For formulas and equations.
- **`var`**: For symbols like 'x', 't', or 'n'.
- **`val`**: For numeric values (points, orders, periods).
- **`ticker`**: For assets (e.g., 'AAPL', 'BTC-USD').
- **`data`**: For collections (lists, matrices, arrays).

## 🧠 Parallel Intelligence (The Consilium)
When you call `.solve()`, AshAxiom triggers a **Parallel Consilium**. It searches through thousands of pages from Zorich, Krasnov, Murphy, and others, executing their logic simultaneously in background threads to provide instant results without hanging the UI.

## 🎓 Interactive Academy
AshAxiom includes a built-in learning server. You can launch the interactive courses directly from Jupyter:

```python
import ashaxiom
# Initialize the Brain and start the Academy
ashaxiom.Axiom.think().lesson().go()


Note: The Academy server provides localized training on math and financial principles.
📊 Visualization Engine
Synchronized '2D': Automatically aligns assets with different trading dates.
'3D' Projections: Visualizes the mathematical complexity spectrum with highlighted prediction vectors.
Lazy Styling: Apply colors and gradients via .color() before rendering.
github-haystack 2.0.0
Haystack components for interacting with GitHub repositories
Requires Python: >=3.10

# github-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/github-haystack.svg)](https://pypi.org/project/github-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/github-haystack.svg)](https://pypi.org/project/github-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/github)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/github/CHANGELOG.md)
 
---
## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
geneea-nlp-client 1.5.2
The SDK library and command-line interface to Geneea Interpretor, an NLP REST API.
Keywords: geneea python interpretor nlp nlu api cli

# Geneea Interpretor Client

Interpretor is a Natural Language Processing platform which helps the users leverage their text data. Features include 

- language detection
- entity recognition
- semantic tagging
- sentiment analysis

This package contains Python SDK which enables easy integration of Interpretor [General NLP REST API](https://help.geneea.com/api_general/index.html#api-general) with your code.

For detailed information, please [read the docs](https://help.geneea.com/sdk/index.html).
roche-datachapter-team-lib 0.0.13
Modular Python library designed for building and managing robust ETL processes. Includes database connectors, Google Sheets/Drive integration, AppSheet API support, job scheduling via SQL Server Agent, Excel generation, and logging utilities.
Requires Python: >=3.12

# Roche Data Chapter Team Library

## Description

Una biblioteca modular en Python desarrollada para estandarizar y simplificar la creación de procesos ETL y automatizaciones. Pensada para equipos de datos que requieren integraciones con múltiples fuentes, soporte de logs y trazabilidad, y herramientas de administración de jobs SQL.

## Características principales

### 🔌 Conectores de Base de Datos
- Conexiones automáticas a SQL Server, Oracle, SAP HANA, MySQL, Snowflake y Redshift utilizando variables de entorno para parametrización segura.
- Soporte de ejecución de consultas personalizadas y procedimientos almacenados.
- Lectura directa a `pandas.DataFrame` o listas JSON.

### 📊 Transformaciones de Datos
- Conversión robusta de fechas, números, nulos y tipos de datos desde hojas de cálculo o APIs externas.
- Estándares predefinidos para Google Sheets y Excel.

### 📤 Google API Services
- Lectura/escritura en hojas de Google Sheets.
- Carga y descarga de archivos desde Google Drive.
- Manejo de credenciales OAuth2 y reintentos automáticos.

### 📩 Email Automation con AppSheet
- Gestión automatizada del envío de emails usando AppSheet como backend.
- Soporte para archivos adjuntos en Google Drive (PDF, Excel, TXT).

### 📁 Generación de Excel
- Creación de archivos Excel multiformato con estilo, desde múltiples `DataFrame`.
- Ancho de columnas y formatos aplicados automáticamente.

### 📅 SQL Server Agent Job Manager
- Creación, actualización y administración de SQL Jobs directamente desde Python.
- Utilidad especialmente útil para entornos corporativos que ejecutan ETLs como tareas programadas.

### 📑 Logging persistente
- Sistema de log en archivos `.log` y persistencia opcional en base de datos.
- Integrado con `JobExecution` y `JobExecutionLog`.

## Usage
Está pensada para ser utilizado como requisito en cualquier proyecto ETL en Python.

## Support
- Ignacio Castillo (ignacio.castillo@roche.com)
- Sara Fernandez (sara.fernandez.sf1@roche.com)
- Diego Pedro (diego.pedro@contractors.roche.com)

## Authors and acknowledgment
Lucas Frías (lucas.frias@roche.com)
Uciel Bustamante (uciel.bustamante@contractors.roche.com)
glomar_gridding 1.1.0
National Oceanography Centre library for performing gridding.
Requires Python: >=3.11
Keywords: covariance, gridding, interpolation, kriging, observations, ordinary, simple

# GloMar Gridding

Library for performing Gridding as used by the GloMar datasets produced by the National Oceanography
Centre.

Part of the NOC Surface Processes _GloMar_ suite of libraries and datasets.

## Installation

`GloMarGridding` is available on [PyPI](https://pypi.org/project/glomar_gridding/), as
`glomar_gridding`:

```bash
pip install glomar_gridding
```

Or using uv:

```bash
uv add glomar_gridding
```

### Development

Clone the repository

```bash
git clone https://github.com/NOCSurfaceProcesses/GloMarGridding.git /path/to/glomar_gridding
```

Create virtual environment and install dependencies. We recommend using
[uv](https://docs.astral.sh/uv/) for python as an alternative to `pip`.

```bash
cd /path/to/glomar_gridding
uv sync --all-extras --python 3.11  # Install dependencies, recommended python version
```

#### `pip` instructions

For development:

```bash
cd /path/to/glomar_gridding
python -m venv .venv
source .venv/bin/activate
pip install -e .
```

## Documentation

Documentation PDF can be found in the docs directory. Or
[here](https://github.com/NOCSurfaceProcesses/GloMarGridding/blob/main/docs/Documentation.pdf).

An example workflow can be found in the documentation PDF, or in the notebooks directory.

## Citation

Richard C. Cornes, Steven. C. Chan, Archie Cable et al. GloMarGridding: A Python Package for Spatial
Interpolation to Support Structural Uncertainty Assessment of Climate Datasets, 22 August 2025,
PREPRINT (Version 1) available at Research Square
[https://doi.org/10.21203/rs.3.rs-7427869/v1](https://doi.org/10.21203/rs.3.rs-7427869/v1)

## Acknowledgements

Supported by the Natural Environmental Research Council through National Capability funding
(AtlantiS: NE/Y005589/1)
swanhub 1.0.10
Custom SWAN templates and handlers for JupyterHub
Requires Python: >=3.8
Keywords: CERN, JupyterHub, SWAN

# SwanHub

JupyterHub wrapper that automatically configures the SWAN templates and handlers.

These handlers replace the default ones with slightly modified versions (for example, the user info api endpoint provides information about the auth state, which is hidden in the default implementation).

## Requirements

This module requires and installs JupyterHub.

## Installation

Install the package

```bash
pip install swanhub
```

To have the proper css, it is necessary to download a release from https://github.com/swan-cern/common into the folder `/usr/local/share/jupyterhub/static/swan/`.

## Usage

Start SwanHub as you would for JupyterHub, and with the same configurations. Example:

```bash
swanhub --config /path/to/my/jupyterhub_config.py
```
makefile-generator 1.0.2
Generate makefiles with a function.
Keywords: c++, python, typescript, makefile, makefile-generator

# Makefile Generator Module

## Usage
Heads up: This is a Python-only module.

1. Install the module with pip:
```bash
pip install makefile-generator
```
2. Use the module by importing it:
```py
from mk_generator import create_write_mk
```
3. Call the function (`create_write_mk()`):
```py
create_write_mk("makefile", "main.cpp")
```

- Example usage file: [example.py](/example.py)

## Supported Languages
* C++
* Python
* TypeScript

## Features
- Self documented module
- The parameters of `create_write_mk()` can be autocompleted:
![Makefile name parameter](./autocomplete_images/mk_name.png)
![Target file name parameter](./autocomplete_images/target_file_name.png)
discover-with-mahdi 1.0.0
Automated Exploratory Data Analysis Library for JSON Data
Requires Python: >=3.7
Keywords: eda, data analysis, json, exploratory data analysis, pandas, tabulate

# discover_with_mahdi

![PyPI Version](https://img.shields.io/pypi/v/discover_with_mahdi)
![Python Versions](https://img.shields.io/pypi/pyversions/discover_with_mahdi)
![License](https://img.shields.io/pypi/license/discover_with_mahdi)

**Automated Exploratory Data Analysis Library for JSON Data**

## Features

- 🔍 **Comprehensive Analysis**: Automatic detection of data types, missing values, outliers, and correlations
- 📊 **Interactive Reports**: Beautiful table-formatted reports using tabulate
- 🌐 **HTML Export**: Generate interactive HTML reports
- 📁 **Multiple Input Formats**: Support for JSON files, strings, and dictionaries
- 🚀 **Easy to Use**: Simple API for quick EDA
- 📈 **Statistical Insights**: Descriptive statistics and correlation analysis

## Installation

```bash
pip install discover_with_mahdi
platon-cli 1.3.1
Unified CLI tool for managing Vault secrets and Kubernetes resources for Sikt GitLab repositories
Requires Python: >=3.8
Keywords: platon, vault, kubernetes, kubectl, cli

# Platon CLI

a command-line tool for managing Vault secrets and Kubernetes resources for Sikt repos.

includes...

- vault secret management
- kubernetes resource operations
- auto-detection of repository configuration
- interactive tui menu
- shell completion for bash and zsh

## Installation

Install Vault CLI:

```bash
# macOS
brew tap hashicorp/tap
brew install hashicorp/tap/vault

# Linux (Ubuntu/Debian)
wget -O- https://apt.releases.hashicorp.com/gpg | sudo gpg --dearmor -o /usr/share/keyrings/hashicorp-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list
sudo apt update && sudo apt install vault

# Windows
choco install vault

# for other platforms, see: https://developer.hashicorp.com/vault/install
```

### Install Platon CLI

```bash
# Using uv tool (recommended)
uv tool install platon-cli

# Using pip
pip install platon-cli
```

### Vault Login

login to vault using oidc:

```bash
vault login -method=oidc mount=microsoft
```

## Quick Start

navigate to a local repo and run:

```bash
platon

platon --help

platon status
```

For detailed usage, configuration, and examples, see [docs.md](docs.md).

## Development

This project includes a Makefile for common tasks:

```bash
make help              # Show all available commands
make run               # Run the CLI
make build             # Build the package
make test              # Run tests
make install           # Install globally
make vault-login       # Login to Vault
make release-patch     # Bump version and create release
```

For full development documentation, see [CLAUDE.md](CLAUDE.md).
run-ipynb 0.1.2
A tool to run Jupyter notebooks as Python scripts
Requires Python: >=3.7

## run-ipynb

Run Jupyter notebooks as plain Python scripts from the command line.

This tool converts a `.ipynb` to `.py`, removes IPython-only lines, ensures a non-interactive Matplotlib backend, optionally adjusts `sys.path` when `os.chdir(...)` is used, executes the script, and cleans up the generated file by default.

## Usage

You can directly use the tool with `uv`:
```bash
uvx run-ipynb path/to/notebook.ipynb [--keep] [--yes]
```

Optionally specify a Python interpreter:

```bash
uvx run-ipynb path/to/notebook.ipynb --python /path/to/python
```

You can also rely on your current shell's interpreter by setting `RUN_IPYNB_PYTHON`:

```bash
export RUN_IPYNB_PYTHON=$(which python)
uvx run-ipynb path/to/notebook.ipynb
```

Otherwise run:
```bash
pip install run-ipynb
```
and then:
```bash
run-ipynb path/to/notebook.ipynb [--keep] [--yes]
```

- **notebook_path**: Path to the `.ipynb` notebook to run
- **-k, --keep**: Keep the generated `.py` file after execution
- **-y, --yes**: Automatically overwrite an existing `.py` file without prompting
- **-p, --python**: Python interpreter to execute the generated script (defaults to the current interpreter)

If `--python` is not provided, `run-ipynb` checks in order:

- `RUN_IPYNB_PYTHON`
- `RUN_IPYNB_ENV_PYTHON`
- active virtual environments (`VIRTUAL_ENV`, `CONDA_PREFIX`, `MAMBA_PREFIX`, Pipenv, Poetry, etc.)
- `which python`
- the interpreter running the CLI

### Examples

```bash
# Basic: convert, run, and remove the temporary .py file
uvx run-ipynb notebooks/analysis.ipynb

# Keep the .py file for inspection and overwrite if it already exists
uvx run-ipynb notebooks/analysis.ipynb --keep --yes
```

### What it does

- Converts the notebook with `jupyter nbconvert --to script`
- Removes `get_ipython().run_line_magic` lines
- Sets Matplotlib backend to `Agg` for headless environments
- If `os.chdir(...)` is detected, appends `os.getcwd()` to `sys.path` right after the change
- Executes the resulting script with your current Python interpreter
- Deletes the generated `.py` file unless `--keep` is passed