semvec/pypi-packages huggingface dataset:
comfy-commander 0.1.2
A package for programmatically running ComfyUI workloads either locally or remotely
License: MIT
Requires Python: >=3.8
Keywords: comfyui, workflow, automation, ai, image-generation

Comfy Commander is a package for programmatically running ComfyUI workloads either locally or remotely
 - Edit any node and its values from Python
 - Supports Local and RunPod ComfyUI instances
 - Convert standard ComfyUI workflows to API format
 - Execute workflows on local ComfyUI servers

## Quickstart

### Basic Workflow Usage
```python
from comfy_commander import Workflow

# Load an API format workflow
workflow = Workflow.from_file("./image_workflow.json")

# Modify node parameters
sampler_node = workflow.node(id="31")
sampler_node.param("seed").set(1234567890)
sampler_node.param("steps").set(8)

# Access node properties
print(f"Current seed: {sampler_node.param('seed').value}")
```

### Direct Execution
```python
import asyncio
from comfy_commander import ComfyUIServer, Workflow

server = ComfyUIServer("http://localhost:8188")
workflow = Workflow.from_file("./workflow.json")

result = server.execute(workflow)
for i, image in enumerate(result.media):
    image.save(f"./image_{i}.png")

```

### Queue for Later Processing
```python
from comfy_commander import ComfyUIServer, Workflow

server = ComfyUIServer("http://localhost:8188")
workflow = Workflow.from_file("./workflow.json")

# Queue workflow and get prompt ID immediately
prompt_id = server.queue(workflow)
print(f"Workflow queued with ID: {prompt_id}")

# Later, check status or get results
history = server.get_history(prompt_id)
```

## Requirements

### For Standard Workflow Conversion
To convert standard ComfyUI workflows to API format, you need:

1. **ComfyUI running locally** on `http://localhost:8188`
2. **Workflow Converter Extension** installed:
   ```bash
   cd ComfyUI/custom_nodes
   git clone https://github.com/SethRobinson/comfyui-workflow-to-api-converter-endpoint
   ```
   Then restart ComfyUI.

## Testing

### Unit Tests (Default)
```bash
# Runs all unit tests by default (e2e tests are in separate files)
pytest tests/ -v
```

### End-to-End Tests
```bash
# Make sure ComfyUI is running with the converter extension
python run_e2e_tests.py
```

Or run e2e tests directly:
```bash
pytest tests/e2e_test_local_server.py -v
```

### All Tests (Including E2E)
```bash
# Run all tests including e2e (requires running ComfyUI instance)
pytest tests/ tests/e2e_test_local_server.py -v
```
termagent 0.1.0
A Python package for terminal agent functionality
License: MIT
Requires Python: >=3.11

# TermAgent

An AI-powered terminal assistant that seamlessly combines shell commands with AI capabilities.

## Features

- **AI Command Execution** - Natural language commands powered by Claude
- **Shell Integration** - Execute shell commands directly
- **Command History** - Navigate and search previous commands
- **Shell Aliases** - Automatic alias resolution from your shell
- **Permissions System** - Fine-grained control over file system access
- **Message Caching** - Replay previous AI interactions
- **Autonomy Levels** - Control when permission prompts appear

## Installation

```bash
git clone <repository-url>
cd termagent
uv sync
```

## Usage

Start the agent:

```bash
make run
```

Or with debug mode:

```bash
make debug
```

Check version:

```bash
termagent --version
```

### Commands

- Type shell commands directly: `ls -la`, `git status`, etc.
- Ask AI questions: "what files changed recently?"
- Type `config` to view current settings
- Type `exit`, `quit`, or `q` to exit

## Configuration

Configuration is stored in `~/.termagent/config.json`:

```json
{
  "autonomy_level": "manual",
  "debug_mode": false,
  "max_context_length": 200000,
  "model": "claude-3-5-sonnet-20241022"
}
```

### Autonomy Levels

- **manual** - Ask permission for all operations
- **semi** - Ask only for dangerous operations
- **full** - Never ask for permission

## Environment

Set your Anthropic API key:

```bash
export ANTHROPIC_API_KEY=your_key_here
```

## Development

Run tests:

```bash
make test
```

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
msigen 0.3.1
A package for converting spectrometry imaging line scan data files to a visualizable format
License: MIT
Requires Python: <3.12,>=3.9.0

# MSIGen
MSIGen is designed for converting mass spectrometry imaging (MSI) data from the raw line-scan data to a visualizable format and is designed with nano-DESI MSI in mind. It has premade files for converting to images using a GUI, jupyter notebook, or from the command line.

## Installation on Windows
Using Anaconda (https://www.anaconda.com/download), create a new environment titled "MSIGen" with python >=3.9 and <3.12 and activate it. Then, MSIGen can be installed using the pip package manager.

Run the following in Anaconda Prompt one line at a time:
```
conda create --name MSIGen python=3.11 -y
conda activate MSIGen
pip install MSIGen
```
### For GUI tool:
Download "make GUI shortcut.py" from the other_files folder in the Github repository. Run this code from Anaconda Prompt.
```
conda activate MSIGen
python "C:/path/to/make GUI shortcut.py"
```
After running with the actual location of "make GUI shortcut.py", there should be a shortcut called "MSIGen GUI" on your desktop. This runs the GUI for MSIGen.

### For Jupyter Notebook Tool:
Download "MSIGen_jupyter.ipynb" from the other_files folder in the Github repository. Open Anaconda Navigator and run Jupyter Notebook in the MSIGen environment. Open "MSIGen_jupyter.ipynb" from Jupyter Notebook. <br><br>Alternatively, Jupyter Notebook can be run from Anaconda Prompt. For the first time opening MSIGen:

```
conda activate MSIGen
pip install notebook
jupyter notebook
```
After the first run:
```
conda activate MSIGen
jupyter notebook
```

### For Command Line Interface Tool:
Download "MSIGen_CLI.py" from the other_files folder in the Github repository. Create a configuration file for your experiment. An example can be found in the other_files folder. Run the following in Anaconda Prompt:
```
conda activate MSIGen
python "C:/Path/to/MSIGen_CLI.py" "C:/path/to/config_file1.json" "C:/path/to/config_file2.json"
```
Supply one configuration file for each dataset to be processed.

# Referencing
If MSIGen was used in your project, please reference it using the following:<br>
[1.] Hernly E, Hu H, Laskin J. MSIGen: An Open-Source Python Package for Processing and Visualizing Mass Spectrometry Imaging Data. J. Am. Soc. Mass Spectrom. 2024, 35, 10, 2315–2323; doi:[10.1021/jasms.4c00178](https://doi.org/10.1021/jasms.4c00178)
keyphrases-mcp 0.0.4
Keyphrases MCP server - Model Context Protocol server to extract keyphrases from a text using a BERT model
License: MIT
Requires Python: >=3.12
Keywords: keyphrases, keywords, metadata, mcp, model-context-protocol, ai, llm, bert, nlp, text-analysis

# 🔤 Keyphrases-MCP

*Empowering LLMs with authentic keyphrase Extraction*

mcp-name: io.github.IvanRublev/keyphrases-mcp

Please refer to the full description on [GitHub](https://github.com/IvanRublev/keyphrases-mcp).
monotonic-alignment-search 0.2.1
Monotonically align text and speech
License: MIT
Requires Python: >=3.10

<!--
SPDX-FileCopyrightText: Enno Hermann

SPDX-License-Identifier: MIT
-->

# Monotonic Alignment Search (MAS)

[![PyPI - License](https://img.shields.io/pypi/l/monotonic-alignment-search)](https://github.com/eginhard/monotonic_alignment_search/blob/main/LICENSE)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/monotonic-alignment-search)
[![PyPI - Version](https://img.shields.io/pypi/v/monotonic-alignment-search)](https://pypi.org/project/monotonic-alignment-search)
![GithubActions](https://github.com/eginhard/monotonic_alignment_search/actions/workflows/test.yml/badge.svg)
![GithubActions](https://github.com/eginhard/monotonic_alignment_search/actions/workflows/lint.yml/badge.svg)

Implementation of MAS from [Glow-TTS](https://github.com/jaywalnut310/glow-tts)
for easy reuse in other projects.

## Installation

```bash
pip install monotonic-alignment-search
```

Wheels are provided for Linux, Mac, and Windows. Pytorch is not installed by
default. You either first need to install it yourself, or install one of the
following extras with [uv](https://docs.astral.sh/uv/):

```bash
uv add monotonic-alignment-search[cpu]
uv add monotonic-alignment-search[cuda]
```

## Usage

MAS can find the most probable alignment between a text sequence `t_x` and a
speech sequence `t_y`.

```python
from monotonic_alignment_search import maximum_path

# value (torch.Tensor): [batch_size, t_x, t_y]
# mask  (torch.Tensor): [batch_size, t_x, t_y]
path = maximum_path(value, mask, implementation="cython")
```

The `implementation` argument allows choosing from one of the following
implementations:

- `cython` (default): Cython-optimised
- `numpy`: pure Numpy

## References

This implementation is taken from the original [Glow-TTS
repository](https://github.com/jaywalnut310/glow-tts). Consider citing the
Glow-TTS paper when using this project:

```bibtex
@inproceedings{kim2020_glowtts,
    title={Glow-{TTS}: A Generative Flow for Text-to-Speech via Monotonic Alignment Search},
    author={Jaehyeon Kim and Sungwon Kim and Jungil Kong and Sungroh Yoon},
    booktitle={Proceedings of Neur{IPS}},
    year={2020},
}
```