semvec/pypi-packages huggingface dataset:
pylepcc 0.1.0
Python bindings to Esri's Limited-Error Point Cloud Compression library.
Requires Python: >=3.10

# pylepcc

Minimal Python bindings to Esri's Limited-Error Point Cloud Compression (LEPCC) Library.

## Installation

Using pip:

```shell
pip install pylepcc
```

## Usage

Compress some positions:

```python
compressed, order = pylepcc.compress_xyz(positions)
```

Note that LEPCC may reorder points during compression. The permutation is described in the returned order array. Let's compress some corresponding colors:

```python
compressed = pylepcc.compress_rgb(colors[np.argsort(order)])
```

In order to preserve the mapping of positions to colors, the colors must be sorted according to the reordering done during position compression.

### Development

Hacking on `pylepcc` is as easy as installing in editable mode:

```shell
pip install -e .
```
casambi-bt 0.3.2
A minimal, unofficial implementation of a bluetooth client for casambi devices
Requires Python: >=3.11

![PyPI](https://img.shields.io/pypi/v/casambi-bt)
[![Discord](https://img.shields.io/discord/1186445089317326888)](https://discord.gg/jgZVugfx)

# A bluetooth based Python library for controlling Casambi networks

This library provides a currently **alpha quality** interface to Casambi-based lights over Bluetooth.
The author is not associated with Casambi and the implementation is based on his own analysis of the protocol.
This interface is not feature complete and was only tested with a very small network.

If you want to check out my (slow) progress in writing a integration for Home Assistant using this library you can take a look at [https://github.com/lkempf/casambi-bt-hass/](https://github.com/lkempf/casambi-bt-hass/).

For a more mature solution using a gateway and the official Casambi API have a look at [https://github.com/hellqvio86/aiocasambi](https://github.com/hellqvio86/aiocasambi).

## Getting started

This library is available on PyPi:

```
pip install casambi-bt
```

Have a look at `demo.py` for a small example.

### MacOS

MacOS [does not expose the Bluetooth MAC address via their official API](https://github.com/hbldh/bleak/issues/140),
if you're running this library on MacOS, it will use an undocumented IOBluetooth API to get the MAC Address.
Without the real MAC address the integration with Casambi will not work.
If you're running into problems fetching the MAC address on MacOS, try it on a Raspberry Pi.

### Casambi network setup

If you have problems connecting to the network please check that your network is configured appropriately before creating an issue. The network I test this with uses the **Evoultion firmware** and is configured as follows (screenshots are for the iOS app but the Android app should look very similar):

![Gateway settings](/doc/img/gateway.png)
![Network settings](/doc/img/network.png)
![Performance settings](/doc/img/perf.png)
ml-ralph 0.4.0
Autonomous ML agent with cognitive loop
Requires Python: >=3.10
Keywords: ml, agent, workflow, cli, automation

# ML-Ralph

![ML-Ralph](https://raw.githubusercontent.com/pentoai/ml-ralph/main/ml-ralph.webp)

An autonomous ML agent that thinks like an experienced MLE. It works through a cognitive loop: ORIENT → RESEARCH → HYPOTHESIZE → EXECUTE → ANALYZE → VALIDATE → DECIDE.

## Requirements

- [Claude Code](https://docs.anthropic.com/en/docs/claude-code) or [Codex CLI](https://developers.openai.com/codex/cli/)
- A git repo for your ML project

## Install

```bash
pip install ml-ralph
```

Or with uv:

```bash
uv tool install ml-ralph
```

## Quick Start

### 1. Initialize Ralph in your project

```bash
ml-ralph init
```

### 2. Create a PRD with Claude Code

Open Claude Code and use the `/ml-ralph` skill:

```
/ml-ralph
```

Ralph will ask clarifying questions to understand your ML problem and create a PRD.

### 3. Run the Autonomous Loop

```bash
ml-ralph run
```

Ralph works through the cognitive loop until success criteria are met.

## Project Structure

After running Ralph, your project will have:

```
your-project/
├── .ml-ralph/
│   ├── RALPH.md           # Agent instructions
│   ├── prd.json           # PRD (the contract)
│   ├── ralph.json         # Execution state
│   ├── backlog.json       # Hypotheses queue
│   ├── log.jsonl          # Thinking log (research, learnings, analysis)
├── .claude/skills/ml-ralph/
├── .codex/skills/ml-ralph/
├── CLAUDE.md
└── AGENTS.md
```

## Commands

| Command         | Purpose                             |
| --------------- | ----------------------------------- |
| `ml-ralph init` | Initialize Ralph in current project |
| `ml-ralph run`  | Run autonomous execution loop       |

## Options

```bash
# Use Claude Code (default)
ml-ralph run --tool claude

# Use OpenAI Codex
ml-ralph run --tool codex

# Codex with custom sandbox mode (default: workspace-write)
ml-ralph run --tool codex --sandbox danger-full-access

# Set max iterations (default: 100)
ml-ralph run --max-iterations 200

# Force overwrite on init
ml-ralph init --force
```

### Codex Sandbox Modes

When using `--tool codex`, you can control the sandbox policy:

| Mode | Description |
|------|-------------|
| `read-only` | Agent can only read files, not modify |
| `workspace-write` | Agent can modify files in workspace (default) |
| `danger-full-access` | Full system access (use with caution) |

## The Cognitive Loop

```
ORIENT → RESEARCH → HYPOTHESIZE → EXECUTE → ANALYZE → VALIDATE → DECIDE
                         ↑                                         │
                         └─────────────────────────────────────────┘
```

- **ORIENT**: Understand the problem, constraints, failure modes
- **RESEARCH**: Learn from existing knowledge, find SOTA approaches
- **HYPOTHESIZE**: Form testable bets with expected outcomes
- **EXECUTE**: Implement minimal changes, run experiments
- **ANALYZE**: Understand results, examine failures, find patterns
- **VALIDATE**: Check for leakage, ensure results are trustworthy
- **DECIDE**: Keep/revert/pivot based on evidence
dqlite-client 0.1.0
Async Python client for dqlite with connection pooling and leader detection
Requires Python: >=3.13
Keywords: async, asyncio, database, distributed, dqlite, sqlite

# dqlite-client

Async Python client for [dqlite](https://dqlite.io/), following asyncpg patterns.

## Installation

```bash
pip install dqlite-client
```

## Usage

```python
import asyncio
from dqliteclient import connect

async def main():
    conn = await connect("localhost:9001")
    async with conn.transaction():
        await conn.execute("CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY, name TEXT)")
        await conn.execute("INSERT INTO test (name) VALUES (?)", ["hello"])
        rows = await conn.fetch("SELECT * FROM test")
        for row in rows:
            print(row)
    await conn.close()

asyncio.run(main())
```

## Connection Pooling

```python
from dqliteclient import create_pool

pool = await create_pool(["localhost:9001", "localhost:9002", "localhost:9003"])
async with pool.acquire() as conn:
    rows = await conn.fetch("SELECT 1")
```

## Development

See [DEVELOPMENT.md](DEVELOPMENT.md) for setup and contribution guidelines.

## License

MIT