semvec/pypi-packages huggingface dataset:
hugedict 2.14.6
A dictionary-like object that is friendly with multiprocessing and uses key-value databases (e.g., RocksDB) as the underlying storage.
Requires Python: >=3.8

# hugedict ![PyPI](https://img.shields.io/pypi/v/hugedict) ![Documentation](https://readthedocs.org/projects/hugedict/badge/?version=latest&style=flat)

hugedict provides a drop-in replacement for dictionary objects that are too big to fit in memory. hugedict's dictionary-like objects implement `typing.Mapping` and `typing.MutableMapping` interfaces using key-value databases (e.g., RocksDB) as the underlying storage. Moreover, they are friendly with Python's multiprocessing.

- [Documentation](https://hugedict.readthedocs.io/)

## Installation

From PyPI (using pre-built binaries):

```bash
pip install hugedict
```

To compile the source, run: `maturin build -r` inside the project directory. You need [Rust](https://www.rust-lang.org/), [Maturin](https://github.com/PyO3/maturin), CMake and CLang (to build [Rust-RocksDB](https://github.com/rust-rocksdb/rust-rocksdb)).

## Features

1. Create a mutable mapping backed by RocksDB

```python
from functools import partial
from hugedict.prelude import RocksDBDict, RocksDBOptions

# replace [str, str] for the types of keys and values you want
# as well as deser_key, deser_value, ser_value
mapping: MutableMapping[str, str] = RocksDBDict(
    path=dbpath,  # path (str) to db file
    options=RocksDBOptions(create_if_missing=create_if_missing),  # whether to create database if missing, check other options
    deser_key=partial(str, encoding="utf-8"),  # decode the key from memoryview
    deser_value=partial(str, encoding="utf-8"),  # decode the value from memoryview
    ser_value=str.encode,  # encode the value to bytes
    readonly=False,  # open database in read only mode
    secondary_mode=False,  # open database in secondary mode
    secondary_path=None,  # when secondary_mode is True, it's a string pointing to a directory for storing data required to operate in secondary mode
)
```

2. Load huge data from files into RocksDB in parallel: `from hugedict.prelude import rocksdb_load`. This function creates SST files in parallel, ingests into the db and (optionally) compacts them.

3. Cache a function when doing parallel processing

```python
from hugedict.prelude import Parallel

pp = Parallel()

@pp.cache_func("/tmp/test.db")
def heavy_computing(seconds: float):
    time.sleep(seconds)
    return seconds * 2


output = pp.map(heavy_computing, [0.5, 1, 0.7, 0.3, 0.6], n_processes=3)
```

4. Create dictionary backed by Sqlite: `hugedict.sqlite.SqliteDict`
5. Chain multiple dictionaries: `hugedict.chained_mapping.ChainedMapping`
6. Cache a dictionary so previously accessed keys are stored in memory: `hugedict.cachedict.CacheDict` or called `hugedict.types.HugeMapping.cache`
rctv 0.1.2
Quick CLI for displaying Recurse Center TV in fullscreen
Requires Python: >=3.12

# rctv

[![PyPI Version](https://img.shields.io/pypi/v/rctv.svg)](https://pypi.org/project/rctv/)
[![Python Versions](https://img.shields.io/pypi/pyversions/rctv.svg)](https://pypi.org/project/rctv/)
[![License](https://img.shields.io/github/license/fcjr/rctv.py.svg)](https://github.com/fcjr/rctv.py/blob/main/LICENSE)
[![UV Friendly](https://img.shields.io/badge/uv-friendly-blue)](https://github.com/astral-sh/uv)

Quick CLI for displaying Recurse Center TV in fullscreen.

## Install

Recommended (fast, reproducible):

```bash
uv tool install rctv
```

Run without installing:

```bash
uvx rctv
```

With pip:

```bash
pip install rctv
```

## Usage

```bash
# Basic usage with token
RCTV_TOKEN=your_token_here rctv

# Or set the token once
export RCTV_TOKEN=your_token_here
rctv
```

The app will:
- Fetch apps from the RCTV API
- Display each page in fullscreen
- Rotate through pages based on timing from the API
- Automatically reload and loop continuously

Press `Cmd+Q` (macOS) or `Alt+F4` (Linux/Windows) to exit.

## Development

```bash
uv sync
uv run rctv                          # run the CLI using local code

# optional: editable install
uv pip install -e .

./scripts/release.sh                 # release a new version
```

## Notes

- Requires `RCTV_TOKEN` environment variable with your Recurse Center TV token
- Uses pywebview for cross-platform fullscreen display
- Automatically reloads apps after each complete rotation
- On Linux, requires GTK, Qt, or CEF for webview backend
- On macOS, uses native WebKit
- On Windows, uses Edge WebView2