semvec/pypi-packages huggingface dataset:
parquet-lf 1.0.0
A lingua franca utility for converting between data formats (JSON, CSV) and Parquet.
Requires Python: >=3.13
Keywords: cli, conversion, csv, data, json, parquet

# parquet-lf

A lingua franca utility for converting between data formats (NDJSON, CSV) and Parquet.

## Installation

```bash
uv tool install parquet-lf
```

## Usage

### Convert to Parquet

```bash
# Convert CSV to Parquet
parquet-lf to-parquet csv input.csv -o output.parquet

# Convert NDJSON to Parquet
parquet-lf to-parquet ndjson input.ndjson -o output.parquet

# jsonl is an alias for ndjson
parquet-lf to-parquet jsonl input.jsonl -o output.parquet
```

### Convert from Parquet

```bash
# Convert Parquet to CSV
parquet-lf from-parquet csv input.parquet -o output.csv

# Convert Parquet to NDJSON
parquet-lf from-parquet ndjson input.parquet -o output.ndjson

# jsonl is an alias for ndjson
parquet-lf from-parquet jsonl input.parquet -o output.jsonl
```

### Output to stdout

When the `-o/--output` flag is omitted, output is written to stdout:

```bash
# Output CSV to stdout
parquet-lf from-parquet csv input.parquet

# Pipe to another command
parquet-lf from-parquet csv input.parquet | head -10

# Output Parquet to stdout (binary) and redirect to file
parquet-lf to-parquet csv input.csv > output.parquet
```

Note: Logs are written to stderr, so they won't interfere with piped data.

### Inspect Files

Use the `info` command to view file metadata and schema without loading the entire dataset:

```bash
# Show file info (schema, row count, size)
parquet-lf info examples/sample.parquet

# Show file info with preview of first N rows
parquet-lf info --head 5 examples/sample.parquet
parquet-lf info -n 5 examples/sample.csv
```

The `info` command supports all formats (Parquet, CSV, NDJSON) and auto-detects the format from the file extension.

### Help

```bash
parquet-lf --help
parquet-lf to-parquet --help
parquet-lf from-parquet --help
parquet-lf info --help
```

## Supported Formats

### NDJSON (Newline Delimited JSON)

NDJSON is a format where each line is a valid JSON object. It's a true tabular peer to CSV, making it ideal for data interchange.

Example NDJSON file:
```json
{"name": "alice", "value": 10}
{"name": "bob", "value": 20}
{"name": "charlie", "value": 30}
```

Both `ndjson` and `jsonl` commands are supported as synonyms.

### CSV

Standard comma-separated values format with a header row.

Example CSV file:
```csv
name,value
alice,10
bob,20
charlie,30
```

## Example Files

The `examples/` directory contains sample data files for experimenting with the CLI:

- `examples/sample.parquet` - Parquet format
- `examples/sample.csv` - CSV format
- `examples/sample.ndjson` - NDJSON format

These files contain the same 5-row dataset with columns: id, name, age, city, score.

## Development

See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.

## License

MIT License - see [LICENSE](LICENSE) for details.
epist-mcp-server 0.1.0
MCP Server for Epist.ai Audio Knowledge Base
Requires Python: >=3.10

# Epist MCP Server

This is the official Model Context Protocol (MCP) server for Epist.ai, allowing you to connect Claude Desktop to your Audio Knowledge Base.

## Installation

```bash
pip install epist-mcp-server
```

## Configuration

Configure your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "epist": {
      "command": "epist-mcp",
      "env": {
        "EPIST_API_KEY": "your_api_key_here"
      }
    }
  }
}
```

## Features

- **Ingest Audio**: Submit audio URLs for transcription and indexing directly from Claude.
- **Search Knowledge Base**: Semantically search your audio transcripts.
- **Check Status**: Monitor the status of your transcription jobs.
- **Access Transcripts**: Use `transcript://{id}` resources to read full transcripts.
gkbus 0.4.85
GKBus: High level automotive protocol library

# GKBus

High level automotive protocol library

```
from gkbus.hardware import CanHardware, KLineHardware
from gkbus.protocol import kwp2000
from gkbus.transport import Kwp2000OverKLineTransport

print('available KLineHardware ports')
ports = KLineHardware.available_ports()
for port in ports:
	print(f'    {port.description()}')

print('available CanHardware ports')
can_ports = CanHardware.available_ports()
for port in can_ports:
	print(f'    {port.description()}')

print('creating hardware')
hardware = KLineHardware(ports[0].port)
transport = Kwp2000OverKLineTransport(hardware, tx_id=0x11, rx_id=0xf1)
kwp = kwp2000.Kwp2000Protocol(transport)
	
print('fast init')
init_success = kwp.init(kwp2000.commands.StartCommunication())
print('fast init : {}'.format(init_success))

print('requesting security access seed')
response = kwp.execute(kwp2000.commands.SecurityAccess().request_seed())
print(response.get_data())

print('starting flash reprogramming diagnostic session')
response = kwp.execute(
	kwp2000.commands.StartDiagnosticSession(
		kwp2000.enums.DiagnosticSession.FLASH_REPROGRAMMING
		)
	)
print(response)
```

## Supported protocols

- Kwp2000 (ISO14230) - over CAN and K-Line

- CCP (Can Calibration Protocol)

## Installing 

GKBus is available on PyPi:

```console
$ python -m pip install gkbus
```

## API Reference available on [Read the Docs](https://gkbus.readthedocs.io)
micro-http-server 0.1.1
a simple HTTP server using functional principles for Micropython and CPython
Requires Python: >=3.8
Keywords: httpserver, functional, asyncio


# micro_http_server

## a simple http server for micropython and CPython which also happens to be fast


### examples

```
def my_post_handler(url, data) -> tuple:
    code, hdrs = 404, {}
    if url == "/users":
        for k, v in data.items():
            DB[k] = v
        code = 200
    return code, "", hdrs

def my_get_handler(url, data) -> tuple:
    return 200, "hello world!", {}

async def my_handle_client(reader, writer):
    handlers = {
        "get": my_get_handler,
        "post": my_post_handler,
    }
    await userver.handle_client(reader, writer, handlers)
    await userver.finalise_client(reader, writer)
    
async def main():
    loop.create_task(asyncio.start_server(my_handle_client, "0.0.0.0", 3000))

```



### speed

Not a design consideration, but.
Benchmarking a simple GET request handler, one request takes ~200 usec user time.
Running on a Macbook M1, a single core can serve approx 6000 requests/sec.