semvec/pypi-packages huggingface dataset:
elizaos-plugin-gmail-watch 2.0.0a4
Gmail Pub/Sub watcher plugin for elizaOS - spawns gog gmail watch serve and auto-renews
Requires Python: >=3.11
Keywords: agents, ai, elizaos, gmail, google, pubsub, watch

# elizaos-plugin-gmail-watch (Python)

Gmail Pub/Sub watcher plugin for elizaOS. Spawns `gog gmail watch serve` and auto-renews the watch periodically.

## Installation

```bash
pip install elizaos-plugin-gmail-watch
```

## Development

```bash
pip install -e ".[dev]"
pytest
```
elizaos-plugin-github 2.0.0a4
GitHub plugin for elizaOS - Python implementation
Requires Python: >=3.11
Keywords: agent, ai, elizaos, git, github

# elizaos-plugin-github (Python)

Python implementation of the GitHub plugin for elizaOS.

## Installation

```bash
pip install elizaos-plugin-github
```

## Usage

```python
from elizaos_plugin_github import GitHubConfig, GitHubService

# Create configuration
config = GitHubConfig(
    api_token="ghp_your_token_here",
    owner="my-org",
    repo="my-repo",
)

# Create service
service = GitHubService(config)

# Start service
await service.start()

# Create an issue
from elizaos_plugin_github.types import CreateIssueParams

issue = await service.create_issue(
    CreateIssueParams(
        owner="my-org",
        repo="my-repo",
        title="Bug: Something is broken",
        body="Description of the bug...",
        labels=["bug"],
    )
)
print(f"Created issue #{issue.number}")

# Create a pull request
from elizaos_plugin_github.types import CreatePullRequestParams

pr = await service.create_pull_request(
    CreatePullRequestParams(
        owner="my-org",
        repo="my-repo",
        title="Fix the bug",
        head="fix/bug-123",
        base="main",
    )
)
print(f"Created PR #{pr.number}")

# Stop service
await service.stop()
```

## Configuration

The plugin can be configured via environment variables:

- `GITHUB_API_TOKEN` (required): GitHub personal access token
- `GITHUB_OWNER`: Default repository owner
- `GITHUB_REPO`: Default repository name
- `GITHUB_BRANCH`: Default branch (defaults to "main")
- `GITHUB_WEBHOOK_SECRET`: Secret for webhook verification
- `GITHUB_APP_ID`: GitHub App ID for app authentication
- `GITHUB_APP_PRIVATE_KEY`: GitHub App private key
- `GITHUB_INSTALLATION_ID`: GitHub App installation ID

## Features

### Repository Operations

- Get repository information
- List repositories

### Issue Operations

- Create issues
- Get issue details
- Update issues
- List issues
- Close/reopen issues

### Pull Request Operations

- Create pull requests
- Get PR details
- Update pull requests
- List pull requests
- Merge pull requests

### Review Operations

- Create reviews (approve, request changes, comment)
- List reviews

### Comment Operations

- Create comments on issues/PRs
- List comments

### Branch Operations

- Create branches
- Delete branches
- List branches

### File Operations

- Get file content
- List directory contents

### Commit Operations

- Create commits with file changes

## Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Type checking
mypy elizaos_plugin_github

# Linting
ruff check .
ruff format .
```

## License

MIT
elizaos-plugin-feishu 2.0.0a4
Feishu/Lark plugin for elizaOS - Python implementation for bot integration
Requires Python: >=3.11
Keywords: agents, ai, bot, bytedance, chat, elizaos, feishu, lark

# Feishu/Lark Plugin for ElizaOS (Python)

Python implementation of the Feishu/Lark plugin for elizaOS agents.

## Installation

```bash
pip install elizaos-plugin-feishu
```

## Usage

```python
from elizaos_plugin_feishu import FeishuService, FeishuConfig

# Create configuration
config = FeishuConfig.from_env()

# Or create manually
config = FeishuConfig(
    app_id="cli_xxx",
    app_secret="your-app-secret",
    domain="feishu",  # or "lark" for global
)

# Create and start service
service = FeishuService(config)
await service.start()

# Send a message
await service.send_message(
    chat_id="oc_xxx",
    content=FeishuContent(text="Hello from ElizaOS!")
)

# Stop service
await service.stop()
```

## Configuration

Environment variables:

- `FEISHU_APP_ID`: Application ID (required)
- `FEISHU_APP_SECRET`: Application secret (required)
- `FEISHU_DOMAIN`: "feishu" or "lark" (default: "feishu")
- `FEISHU_ALLOWED_CHATS`: JSON array of allowed chat IDs

## License

MIT
ibm-metrics-plugin 3.0.21
IBM Watson OpenScale Metrics library
Requires Python: <3.14,>=3.10

******************************************
## Welcome to `ibm_metrics_plugin`
******************************************

`ibm_metrics_plugin` is a python API for computing llm, fairness metrics and explaining transactions using notebooks. For more information, look at [documentation](https://www.ibm.com/docs/en/cloud-paks/cp-data/4.0?topic=tutorials-metrics-computation-using-python-sdk)

## Important Notice:

- If you are using **IBM watsonx.governance** or **IBM Watson OpenScale** on Cloud, please install [ibm-metrics-plugin v3.0.x](https://pypi.org/project/ibm-metrics-plugin/).
- If you are using **IBM watsonx.governance** or **IBM Watson OpenScale** on CPD, please install the version with the CPD version as prefix Eg: [ibm-metrics-plugin v5.0.x.x](https://pypi.org/project/ibm-metrics-plugin/).
- IBM is not responsible for any existing vulnerabilities within the third-party dependencies that are required to install the ibm-metrics-plugin python package.

### License

This library is delivered under the [International License Agreement for Non-Warranted Programs](https://www14.software.ibm.com/cgi-bin/weblap/lap.pl?li_formnum=L-AMCU-CCTQDV).
tasksets 0.1.0
Utilities for working with task sets.
Requires Python: >=3.10

# tasksets

Initial PyPI package scaffold for `tasksets`, using `uv` for build and publish.

## Local workflow

```bash
uv build
uv publish
```

`uv publish` reads `UV_PUBLISH_TOKEN` automatically.

If your token is stored as `PYPI_TOKEN`, run:

```bash
export UV_PUBLISH_TOKEN="$PYPI_TOKEN"
uv publish
```

## TestPyPI

```bash
uv publish --publish-url https://test.pypi.org/legacy/
```
autoform 0.2.0
Composable function transformations for LLM programs
Requires Python: >=3.12

<div align="center">

# `autoform`

**Trace once. Transform freely.**

Composable function transformations for LM programs.

*Think [JAX](https://github.com/jax-ml/jax), but for LM programs.*

[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
[![CI](https://github.com/ASEM000/autoform/actions/workflows/ci.yml/badge.svg)](https://github.com/ASEM000/autoform/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/ASEM000/autoform/graph/badge.svg?token=Z0JBHSC3ZK)](https://codecov.io/gh/ASEM000/autoform)

[Quickstart](#quickstart) - [Transforms](#transforms) - [Concurrency](#concurrency) - [Debugging](#debugging) - [Docs](https://autoform.readthedocs.io)

</div>

```bash
pip install git+https://github.com/ASEM000/autoform.git
```

## Quickstart
```python
import autoform as af

def explain(topic: str) -> str:
    prompt = af.format("Explain {} in one paragraph.", topic)
    msg = dict(role="user", content=prompt)
    return af.lm_call([msg], model="gpt-5.2")

ir = af.trace(explain)("...")  # capture structure, no execution
```

Now transform it:
```python
# execute
output = ir.call("quantum entanglement")

# batch: n inputs
outputs = af.batch(ir).call(["DNA", "gravity", "recursion"])

# pushforward: propagate input perturbations forward
output, tangent = af.pushforward(ir).call(("quantum entanglement", "add more examples"))

# pullback: propagate output feedback backward
output, grad = af.pullback(ir).call(("quantum entanglement", "too technical"))

# compose: batched differentiation
topics = ["DNA", "gravity", "recursion"]
critiques = ["too technical", "too brief", "too abstract"]
outputs, hints = af.batch(af.pullback(ir)).call((topics, critiques))
```

The last line is the point: `batch(pullback(ir))`, transformations compose.

## Transforms

| Transform | What it does |
|-----------|--------------|
| `batch` | Vectorize over inputs |
| `pushforward` | Forward-mode AD |
| `pullback` | Reverse-mode AD |
| `sched` | Auto-concurrent execution |

## Concurrency

`sched` finds independent LM calls. `acall` runs them concurrently.
```python
scheduled = af.sched(ir)
result = await scheduled.acall("input") # acall for async
```

## Debugging

Checkpoint intermediate values. Substitute on re-execution.
```python
def pipeline(x: str) -> str:
    msg1 = dict(role="user", content=x)
    step1 = af.lm_call([msg1], model="gpt-5.2")
    step1 = af.checkpoint(step1, key="step1", collection="debug")
    
    msg2 = dict(role="user", content=step1)
    step2 = af.lm_call([msg2], model="gpt-5.2")
    return step2

ir = af.trace(pipeline)("...")

# capture
with af.collect(collection="debug") as captured:
    result = ir.call("input")

# substitute step1 value
with af.inject(collection="debug", values=dict(step1=["modified"])):
    result = ir.call("input")
```

---

> ⚠️ **Early development**: API may change.
iflow-mcp_stephentth-chatty-mcp 0.1.0
An MCP server that adds voice output to your AI editor
Requires Python: >=3.10

# Chatty MCP

Oh, hello there! Meet **Chatty MCP**, your new best buddy who *loves* to chat out loud! After every request in Cursor, Cline, or any MCP-supported editor, it will speak up and summarize what was just done. Not only will you know when your long request has completed, but you can also use another sense to quickly understand what the editor produced, integrating deeply with your workflow for a better coding experience.

Check out our main website for documentation, demos, and configuration: https://chatty-mcp.vercel.app/

![Chatty MCP Demo](documentation-site/static/videos/chatty-mcp-demo.gif)

## Why?

1. Waiting for Cursor to complete your requests can be tedious - you're just staring at a black screen. With Chatty MCP, you can Alt+Tab to another window while Cursor is thinking, and return when you hear the voice announcement.
2. You don't need to read everything produced by your AI - just listen to the summary and quickly decide if it's going in the right direction, then make adjustments as needed.
3. Having your computer interact with you by voice is an interesting coding experience.

Additionally, this gives you the ability to customize the voice. Use your system's built-in TTS for convenience, Kokoro TTS for smooth and natural voice output, or even Fish TTS for anime-style voices in the future.

## How to Get and Configure Chatty

I don't like extremely long READMEs as documentation, so visit our site for everything you need to know: https://chatty-mcp.vercel.app/docs/welcome

## Note

For Kokoro ONNX model to work, you must download the Kokoro model and place it in the correct directory. Check the documentation's Speech Engine section for more information.

*Made with 💖 by folks who believe every computer needs a voice!*