semvec/pypi-packages huggingface dataset:
ei-cli 0.16.0
aws cli for human
Requires Python: >=3.13

# A`[ei]`WS CLI

AWS CLI for humans. [![PyPI version](https://badge.fury.io/py/ei-cli.svg)](https://badge.fury.io/py/ei-cli)

[![codecov](https://codecov.io/gh/Ashon/ei/branch/main/graph/badge.svg?token=HSW2NN23BY)](https://codecov.io/gh/Ashon/ei)
[![CI-Python-3.12](https://github.com/Ashon/ei/actions/workflows/ci-py312.yml/badge.svg)](https://github.com/Ashon/ei/actions/workflows/ci-py312.yml)
[![CI-Python-3.13](https://github.com/Ashon/ei/actions/workflows/ci-py313.yml/badge.svg)](https://github.com/Ashon/ei/actions/workflows/ci-py313.yml)

## Installation

Install via [pypi](https://pypi.org/project/ei-cli/)

``` sh
pip install ei-cli
```

Install via github

``` sh
pip install git+https://github.com/ashon/ei
```

## Configuration

``` sh
# set environment variables

# comma seperated account ids
EI_ACCOUNT_IDS='000000000000,111111111111'

# comma seperated region list
EI_REGIONS='ap-northeast-1,ap-northeast-2,ca-central-1,eu-west-2'

# sts assume role pattern for cross account
EI_ASSUME_ROLE_ARN_PATTERN='arn:aws:iam::{account_id}:role/my-awesome-role'
EI_ASSUME_ROLE_SESSION_NAME='AssumeRoleEi'

# use aws-vault for resolve aws environment vars
AWS_REGION=None
AWS_ACCESS_KEY_ID=None
AWS_SECRET_ACCESS_KEY=None
AWS_SECURITY_TOKEN=None
AWS_SESSION_EXPIRATION=None
```

## Run

![ei](https://github.com/Ashon/ei/raw/main/assets/ei.png)

Using aws-vault for cross account, region resource retrieving.

```
# list vpcs across all regions, and all accounts ($EI_REGIONS, $EI_ACCOUNT_IDS)
$ aws-vault exec {aws-vault-profile} -- ei ec2 vpc list --all-regions --all-accounts

# same as ec2
$ aws-vault exec {aws-vault-profile} -- ei ec2 instance list --all-regions --all-accounts

...
```

## Development

This project controlled by [Hatch](https://github.com/pypa/hatch).

``` sh
$ pip install hatch

# install package as editable mode
$ pip install -e .

# testing commands
$ hatch run lint
$ hatch run test
$ hatch run typecheck
```
monitor-gitlab-jobs 0.2.0
monitor Gitlab job statuses on the CLI
Requires Python: >=3.10

# monitor-gitlab-jobs
Script to observe the status of all jobs in your latest Gitlab pipeline

## Installation
```bash
pip install monitor-gitlab-jobs
```

## Usage

```bash
usage: monitor-gitlab-jobs [-h] [--token TOKEN] [--ref REF] [--gitlab_url GITLAB_URL] project_id

monitor Gitlab job statuses on the CLI

positional arguments:
  project_id

options:
  -h, --help            show this help message and exit
  --token TOKEN
  --ref REF
  --gitlab_url GITLAB_URL
```

## Features
- print a pretty table of all jobs of the latest pipeline (optionally given a ref) and their statuses
- groups jobs by stage
- update the table until all jobs are finished
- returns 0 if all jobs are either successful or skipped, 1 otherwise

## Example outputs
```bash
$ monitor-gitlab-jobs 1234 --token $GITLAB_ACCESS_TOKEN --gitlab_url $GITLAB_URL --ref 0.6.4
┏━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
┃ Stage ┃ Job                      ┃ Status     ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
│ test  │ run_tests                │ ✅ success │
├───────┼──────────────────────────┼────────────┤
│ build │ build_docker             │ ✅ success │
└───────┴──────────────────────────┴────────────┘
No jobs failed
```

```bash
$ monitor-gitlab-jobs 5678 --token $GITLAB_ACCESS_TOKEN --gitlab_url $GITLAB_URL
┏━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
┃ Stage ┃ Job                       ┃ Status     ┃
┡━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
│ test  │ unit_test                 │ 🏃 running │
│       │ integration_test          │ 🕓 pending │
├───────┼───────────────────────────┼────────────┤
│ lint  │ lint                      │ ✅ success │
├───────┼───────────────────────────┼────────────┤
│ build │ build                     │ ✅ success │
└───────┴───────────────────────────┴────────────┘
⠹ waiting for jobs to finish...
```
polymcsim 0.8.0
A high-performance Python library for Monte Carlo polymer graph generation
Requires Python: >=3.11

# PolyMCsim

A high-performance Python library for computational chemists to generate polymer graph structures through Monte Carlo simulations. The library models polymerization reactions using monomers as nodes and chemical bonds as edges, enabling emergent generation of diverse polymer architectures.

## Features

- Monte Carlo simulation of polymer growth
- Numba-optimized performance
- JSON/Pydantic configuration
- Batch simulation capabilities
- Support for complex monomer structures
- Parallel processing for large-scale simulations

## Installation

PolyMCsim requires Python 3.8 or later. To install, run:

```bash
# Using Poetry (recommended)
poetry install

# Using pip
pip install .
```

## Development Setup

1. Install Poetry (if not already installed):
   ```bash
   curl -sSL https://install.python-poetry.org | python3 -
   ```

2. Clone the repository:
   ```bash
   git clone <repository-url>
   cd polymcsim
   ```

3. Install dependencies:
   ```bash
   poetry install
   ```

4. Install pre-commit hooks:
   ```bash
   poetry run pre-commit install
   ```

## Usage

Basic example of polymer generation:

```python
from polymcsim import PolymerSimulation

# Configure simulation
sim = PolymerSimulation(
    monomers_config="path/to/monomers.json",
    n_steps=1000
)

# Run simulation
result = sim.run()

# Export results
result.export_graph("polymer.graphml")
```

## Testing

Run the test suite:

```bash
poetry run pytest
```

## License

[License Type] - See LICENSE file for details

## Contributing

Contributions are welcome! Please read our Contributing Guidelines for details on how to submit pull requests, report issues, and contribute to the project.

*   **High Performance:** Built with `Numba` for C-like speed in computationally intensive parts.
*   **Extensible:** Easily define new monomer types, reactions, and simulation parameters.
*   **Rich Visualization:** Generate insightful plots and analyses right out of the box.

For detailed information, visit the full documentation at [juliankimmig.github.io/polymcsim/](https://juliankimmig.github.io/polymcsim/).

## Installation

You can install `polymcsim` via pip:

```bash
pip install polymcsim
```

Alternatively, you can use `uv`:

```bash
uv pip install polymcsim
```

## Quick Start

Here's a minimal example of how to simulate the formation of a branched polymer and visualize its structure:

```python
from polymcsim import PolymerSimulation

# 1. Define monomers and reactions
monomers = [
    # ... existing code ...
    # 4. Run the simulation
    sim = PolymerSimulation(simulation_input)
    polymer_graph = sim.run()

    # 5. Visualize the largest polymer structure
    sim.visualize_polymer(polymer_graph)
```

This will produce an image of the largest polymer's network structure. `polymcsim` also offers more advanced visualizations, such as molecular weight distribution plots and comprehensive analysis dashboards.
notes-app-cli 0.1.1
A CLI tool for adding and reviewing notes
Requires Python: >=3.7

# NOTES CLI App

A CLI tool to add, review, and manage notes and todos.

## Semantic Search & Vector Database

This uses a vector database (ChromaDB) and a machine learning model (MiniLM) to enable semantic search:

- When you add a note, its meaning is converted into a vector (embedding) and stored in ChromaDB.
- When you use semantic search, your query is also converted to a vector, and the app finds notes with similar meaning (not just exact words).
- If no semantic match is found, the app automatically falls back to a keyword search for robust results.
- The vector database is stored locally in the `.chroma_db` directory (auto-created).
- Find notes by meaning, not just keywords (e.g., searching "remind mom" can find "call mom").

## Installation

1. **Clone the repository:**
   ```bash
   git clone <repo name>
   cd review_and_append
   ```
2. **Create and activate a virtual environment (recommended):**
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. **Install dependencies and the CLI tool:**
   ```bash
   pip install -e .
   ```

## Usage

### Command Line

Add a note:
```bash
notes "Remember to call mom"
```

Add a todo:
```bash
notes "Buy groceries" --tag todo
```

View today's notes:
```bash
notes today
```

View all todos:
```bash
notes todo
```

View notes for a period:
```bash
notes "this week"
notes "15 days"
notes "a month"
notes all
```

### Interactive Menu
Just run:
```bash
notes
```
And use the arrow keys to select actions:
- **Add TODO**: Add a new todo
- **Add Note**: Add a regular note
- **View Notes**: See all notes (except todos) in a beautiful table
- **View TODOs**: See all todos in a beautiful table
- **Semantic Search**: Find notes by meaning, with keyword fallback if no semantic match
- **Delete All TODOs**: Delete all todos (with confirmation)
- **Delete All Notes**: Delete all notes (with confirmation)
- **Other**: Run a custom SQL query on your notes database
- **Exit**: Quit the app

## Data Storage
- Notes are stored in a local SQLite database file: `notes.db`

## Uninstall
```bash
pip uninstall notes-app
```
tamuwhisper 0.1.4
A Utility to Initiate the Generation of Transcripts, Subtitles, and Closed Captions
Requires Python: >=3.12

# tamuwhisper

Tool for initializing subtitle, caption, and transcript files and embedding metadata about the process according to
[FADGI Metadata Guidelines](https://www.digitizationguidelines.gov/guidelines/FADGI_WebVTT_embed_guidelines_v0.1_2024-04-18.pdf).

## Requires

* Python ~3.9 - Python ~3.12
* ffmpeg

## Running

`tamuwhisper` is designed to run as a cli program versus a directory of media files like:

```shell
tamuwhisper transcribe -d path/to/files -m turbo -c "Surname, Given name " -o path/to/where/to/write/vtts
```

## Arguments

```shell
Usage: tamuwhisper transcribe [OPTIONS]

  Create VTTs with FADGI Embedded Metadata and Whisper JSON

Options:
  -d, --directory TEXT            The path to your media files
  -o, --output TEXT               The output directory to write your generated
                                  vtts and json to
  -m, --model [tiny|base|small|medium|large|turbo]
                                  Which Whisper model to use
  -l, --language TEXT             Specify language of media file
  -f, --fp16                      Use FP16 instead of FP32
  -i, --ignore-existing           Skip A/V files that already have a
                                  transcription
  -c, --creator TEXT              Name of person using the tool. Used for
                                  embedded metadata.
  --check_silence                 Run a check if files are silent first.
  -t, --temperature FLOAT         Controls randomness in text decoding. Lower
                                  values (e.g., 0.0) make output more
                                  deterministic and accurate; higher values
                                  (e.g., 1.0) increase diversity and may
                                  improve results on noisy or ambiguous audio.
  --help                          Show this message and exit.
```