semvec/pypi-packages huggingface dataset:
pygitx 0.2.2
Cross-platform Git history access via Rust with a Python API
Requires Python: >=3.11

<img src="https://github.com/zangjiucheng/pygitx/blob/main/.github/icon.png?raw=true" alt="PyGitX icon" width="60%" />

[![pypi](https://img.shields.io/pypi/v/pygitx.svg)](https://pypi.org/project/pygitx/)
[![coverage](https://img.shields.io/codecov/c/github/zangjiucheng/pygitx)](https://codecov.io/gh/zangjiucheng/pygitx)
[![support-version](https://img.shields.io/pypi/pyversions/pygitx)](https://img.shields.io/pypi/pyversions/pygitx)
[![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
[![build](https://img.shields.io/github/actions/workflow/status/zangjiucheng/pygitx/publish-to-pypi.yml?label=build)](https://github.com/zangjiucheng/pygitx/actions)
[![commit](https://img.shields.io/github/last-commit/zangjiucheng/pygitx.svg)](https://github.com/jiucheng-xie/pygitx/commits/main)

Cross-platform Git history access implemented in Rust with a Python API via PyO3 and libgit2.

## Highlights
- Fast Git history access via libgit2 with a lightweight Python wrapper.
- Repo helpers for HEAD info, revision parsing, commit listing, and branch/tag lookup.
- History rewriting tools: amend messages, rewrite author/committer, reword arbitrary commits, squash, rebase (pick-only), drop commits, and purge paths.
- All rewrites return a `RewriteResult` with mappings and ref updates.

## Install
```bash
pip install pygitx
```

## Python usage
```python
import pygitx
from pathlib import Path

repo = pygitx.open_repo(Path("."))
head = repo.head()
print("HEAD:", head.id if head else "None")

# Resolve a revision (branch/tag/oid) to a hex id
print("main ->", repo.rev_parse("main"))

for c in repo.list_commits(max=5):
    print(f"{c.id[:7]} {c.author} <{c.email}> {c.summary}")

# Quick repo summary (also printed by str(repo))
print(repo.summary())

# Graph helpers
print("Branches:", repo.list_branches(local=True, remote=False))
print("Tags:", repo.list_tags())
print("Current branch:", repo.current_branch())
print("Merge base of main and feature:", repo.merge_base("main", "feature"))
print("Ahead/behind main vs feature:", repo.ahead_behind("main", "feature"))
print("Diff HEAD~1..HEAD:", repo.diff_stat("HEAD~1", "HEAD").files_changed, "files")
```

Example script: `examples/demo.py` (run with `--help` to see options).

## Documentation
Full API and usage docs live in `docs/` (Sphinx). Build locally with:
```bash
make docs
```
Or browse the published docs if available in your environment.

## Development
- Run Rust and Python checks: `make test`
- Pytest for Python wrappers: `pytest`
- Make targets: `make venv`, `make install`, `make develop`, `make release`, `make docs`, `make test`
- Optional pre-commit prompt: set `git config core.hooksPath .githooks` and `chmod +x .githooks/pre-commit` to be prompted to run `make develop`, `make test`, and `pytest` before each commit.
ezmsg-peripheraldevice 0.3.0
Modules to stream data from peripheral devices into ezmsg
Requires Python: >=3.10

# ezmsg-peripheraldevice

Short description of your ezmsg package.

## Installation

```bash
pip install ezmsg-peripheraldevice
```

## Dependencies

- `ezmsg`
- `ezmsg-baseproc`
- `numpy`
- `pynput`

## Usage

### Mouse Examples

**Event-driven mouse listener** - captures every mouse movement event:

```bash
python examples/mouse_listen.py
```

**Polling mouse position** - reads mouse position at a fixed rate:

```bash
python examples/mouse_poll.py --rate 60
```

### Programmatic Usage

```python
import ezmsg.core as ez
from ezmsg.peripheraldevice import MouseListener, MouseListenerSettings
from ezmsg.peripheraldevice import MousePoller, MousePollerSettings
```

> Note: MouseListener requires extra permissions.

## Development

We use [`uv`](https://docs.astral.sh/uv/getting-started/installation/) for development.

1. Install [`uv`](https://docs.astral.sh/uv/getting-started/installation/) if not already installed.
2. Fork this repository and clone your fork locally.
3. Open a terminal and `cd` to the cloned folder.
4. Run `uv sync` to create a `.venv` and install dependencies.
5. (Optional) Install pre-commit hooks: `uv run pre-commit install`
6. After making changes, run the test suite: `uv run pytest tests`

## License

MIT License - see [LICENSE](LICENSE) for details.
evokernel 0.8.0
CUDA kernel optimization agent powered by OpenEvolve
Requires Python: <3.14,>=3.10

# EvoKernel

CUDA kernel optimization agent powered by OpenEvolve.

## Quick Start

```bash
# Install as CLI tool (requires Python 3.10-3.13)
pipx install evokernel
# or with uv
uv tool install evokernel

# Setup Modal (GPU evaluator)
modal setup

# Configure OpenRouter API key
evokernel setup

# Run in any project directory
evokernel
```

### Development Install

```bash
git clone https://github.com/haladir-ai/EvoKernel.git
cd EvoKernel
uv tool install .
```

## Usage

Just run `evokernel` in a directory with CUDA kernels and chat with the agent:

```
> optimize my_kernel.cu

> check status

> show the best result

> apply changes
```

## Current Features

- **Speedup optimization**: Maximizes kernel throughput via evolutionary search
- **EVOLVE markers**: Define which code regions to optimize
- **Modal GPU evaluation**: Compile and benchmark on cloud A100 (default)
- **Local GPU evaluation**: Run benchmarks on your own GPU (for codebases with dependencies)
- **LLM ensemble**: Uses Gemini, Claude, GPT via OpenRouter

## Evaluator Modes

| Mode | Use Case |
|------|----------|
| `modal` (default) | Self-contained kernels, no local GPU needed |
| `local` | Kernels with custom headers/dependencies |

## Roadmap (Not Yet Implemented)

- **Memory optimization goal**: Minimize memory usage instead of speedup
- **Target hardware selection**: Optimize for specific GPUs (A100, H100, V100)
- **Energy efficiency goal**: Minimize power consumption
ucache 0.1.5
lightweight and efficient caching library

![](http://media.charlesleifer.com/blog/photos/ucache-logo-0.png)

ucache is a lightweight and efficient caching library for python.

* [Kyoto Tycoon](https://fallabs.com/kyototycoon/) via [ukt](https://github.com/coleifer/ukt)
* [Redis](https://redis.io) via [redis-py](https://github.com/andymccurdy/redis-py)
* [Sqlite](https://www.sqlite.org/) via [peewee](https://github.com/coleifer/peewee)
* [Kyoto Cabinet](https://fallabs.com/kyotocabinet/) via [kyotocabinet-python bindings](https://fallabs.com/kyotocabinet/pythondoc/)
* [DBM](https://en.wikipedia.org/wiki/DBM_(computing)) via [dbm module from standard library](https://docs.python.org/3/library/dbm.html)
* Simple in-memory cache using Python dictionary.

Features:

* Pickle serialization by default, msgpack also supported
* Optional (transparent) compression using `zlib`
* Efficient bulk-operations.
* Preload context manager for efficient pre-loading of cached data