semvec/pypi-packages huggingface dataset:
stache-ai-qdrant 0.1.1
Qdrant provider for Stache AI
License: MIT
Requires Python: >=3.10
Keywords: stache, rag, ai, qdrant

# stache-ai-qdrant

Qdrant provider for [Stache AI](https://github.com/stache-ai/stache-ai).

## Installation

```bash
pip install stache-ai-qdrant
```

## Usage

Install the package and configure the provider in your settings:

```python
from stache_ai.config import Settings

settings = Settings(
    vectordb_provider: "qdrant"
)
```

The provider will be automatically discovered via entry points.

## Requirements

- Python >= 3.10
- stache-ai >= 0.1.0
- qdrant-client>=1.7.3
stache-ai-pinecone 0.1.1
Pinecone provider for Stache AI
License: MIT
Requires Python: >=3.10
Keywords: stache, rag, ai, pinecone

# stache-ai-pinecone

Pinecone provider for [Stache AI](https://github.com/stache-ai/stache-ai).

## Installation

```bash
pip install stache-ai-pinecone
```

## Usage

Install the package and configure the provider in your settings:

```python
from stache_ai.config import Settings

settings = Settings(
    vectordb_provider: "pinecone"
)
```

The provider will be automatically discovered via entry points.

## Requirements

- Python >= 3.10
- stache-ai >= 0.1.0
- pinecone-client>=3.0.0
stache-ai-mongodb 0.1.1
Mongodb provider for Stache AI
License: MIT
Requires Python: >=3.10
Keywords: stache, rag, ai, mongodb

# stache-ai-mongodb

Mongodb provider for [Stache AI](https://github.com/stache-ai/stache-ai).

## Installation

```bash
pip install stache-ai-mongodb
```

## Usage

Install the package and configure the provider in your settings:

```python
from stache_ai.config import Settings

settings = Settings(
    namespace_provider: "mongodb"
)
```

The provider will be automatically discovered via entry points.

## Requirements

- Python >= 3.10
- stache-ai >= 0.1.0
- pymongo>=4.6.0
stache-ai-enrichment 0.1.1
AI-powered metadata enrichment for Stache (standard features)
License: MIT
Requires Python: >=3.10
Keywords: stache, rag, ai, enrichment, metadata

# stache-ai-enrichment

AI-powered metadata enrichment for Stache (standard features).

## Features

Automatically enriches document metadata with:

- **Summary**: 2-3 sentence summary of document content and purpose
- **Document Type**: Classification (article, guide, tutorial, reference, etc.)
- **Chunking Strategy**: Recommended chunking strategy based on document structure

## Installation

```bash
pip install stache-ai-enrichment
```

The enricher automatically registers via entry points - no configuration needed.

## Cost

Approximately $0.0005 per document using Nova Lite (default model).

## Requirements

- `stache-ai>=0.1.6` (includes BaseAIEnricher and LLM structured output support)
- Bedrock LLM provider with Nova or Claude models

## Coexistence with Enterprise Plugin

This plugin can coexist with `stache-ai-enrichment-enterprise`:

- Standard plugin: priority=80, extracts basic fields
- Enterprise plugin: priority=85, extracts advanced fields (concepts, entities, relationships)
- Enterprise plugin detects standard plugin and avoids duplicate LLM calls

## License

MIT
PySwitchbot 1.0.0
A library to communicate with Switchbot
License: MIT
Requires Python: >=3.11

# pySwitchbot [![codecov](https://codecov.io/gh/sblibs/pySwitchbot/graph/badge.svg?token=TI027U5ISQ)](https://codecov.io/gh/sblibs/pySwitchbot)

Library to control Switchbot IoT devices https://www.switch-bot.com/bot

## Obtaining encryption key for Switchbot Locks

Using the script `scripts/get_encryption_key.py` you can manually obtain locks encryption key.

Usage:

```shell
$ python3 get_encryption_key.py MAC USERNAME
Key ID: XX
Encryption key: XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```

Where `MAC` is MAC address of the lock and `USERNAME` is your SwitchBot account username, after that script will ask for your password.
If authentication succeeds then script should output your key id and encryption key.

## Examples:

#### WoLock (Lock-Pro)

Unlock:

```python
import asyncio
from switchbot.discovery import GetSwitchbotDevices
from switchbot.devices import lock
from switchbot.const import SwitchbotModel

BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
KEY_ID="XX" # The key-ID of your encryption-key for your lock
ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)


async def main():
    wolock = await GetSwitchbotDevices().get_locks()
    await lock.SwitchbotLock(
        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
    ).unlock()


asyncio.run(main())
```

Lock:

```python
import asyncio
from switchbot.discovery import GetSwitchbotDevices
from switchbot.devices import lock
from switchbot.const import SwitchbotModel

BLE_MAC="XX:XX:XX:XX:XX:XX" # The MAC of your lock
KEY_ID="XX" # The key-ID of your encryption-key for your lock
ENC_KEY="XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" # The encryption-key with key-ID "XX"
LOCK_MODEL=SwitchbotModel.LOCK_PRO # Your lock model (here we use the Lock-Pro)


async def main():
    wolock = await GetSwitchbotDevices().get_locks()
    await lock.SwitchbotLock(
        wolock[BLE_MAC].device, KEY_ID, ENCRYPTION_KEY, model=LOCK_MODEL
    ).lock()


asyncio.run(main())
```

#### WoCurtain (Curtain 3)

```python
import asyncio
from pprint import pprint
from switchbot import GetSwitchbotDevices
from switchbot.devices import curtain


async def main():
    # get the BLE advertisement data of all switchbot devices in the vicinity
    advertisement_data = await GetSwitchbotDevices().discover()

    for i in advertisement_data.values():
        pprint(i)
        print()  # print newline so that devices' data is separated visually

    # find your device's BLE address by inspecting the above printed debug logs, example below
    ble_address = "9915077C-C6FD-5FF6-27D3-45087898790B"
    # get the BLE device (via its address) and construct a curtain device
    ble_device = advertisement_data[ble_address].device
    curtain_device = curtain.SwitchbotCurtain(ble_device, reverse_mode=False)

    pprint(await curtain_device.get_device_data())
    pprint(await curtain_device.get_basic_info())
    await curtain_device.set_position(100)


if __name__ == "__main__":
    asyncio.run(main())
```
whywhytools 0.6.2
A lightweight Python package for easy reading and writing of JSON, JSONL, and Pickle files.
License: MIT
Requires Python: >=3.7

# whywhytools

whywhytools is a lightweight Python package for reading and writing JSON, JSON Lines (`.jsonl`), and Pickle files. It provides simple and intuitive APIs for handling these common data formats.

## Installation

You can install this package using pip:

```bash
pip install whywhytools
```

## Quickstart

### JSON Lines (`.jsonl`)

Handle `.jsonl` files, supporting read, write, and append operations.

##### Write JSONL File

```python
from whywhytools import write_jsonl

data = [
    {'id': 'data-1', 'text': 'hello world'},
    {'id': 'data-2', 'text': 'whywhytools is awesome'}
]

# Write to file
write_jsonl(data, 'output.jsonl') # [INFO] save to output.jsonl

# If file exists
write_jsonl(data, 'output.jsonl') # [INFO] output.jsonl already exists.

# Force overwrite existing file
write_jsonl(data, 'output.jsonl', force=True) # [INFO] save to output.jsonl

# Silent mode (not print any message)
write_jsonl(data, 'output.jsonl', force=True, silent=True)
```

##### Append to JSONL File

```python
from whywhytools import append_jsonl

new_data = [{'id': 'data-3', 'text': 'new line'}]
append_jsonl(new_data, 'output.jsonl')
```

##### Read JSONL File

```python
from whywhytools import read_jsonl

data = read_jsonl('output.jsonl')
print(data)
# [{'id': 'data-1', 'text': 'hello world'}, {'id': 'data-2', 'text': 'whywhytools is awesome'}, {'id': 'data-3', 'text': 'new line'}]
```

### JSON (`.json`)

Handle standard `.json` files.

##### Write JSON File

```python
from whywhytools import write_json

data = {'project': 'whywhytools', 'version': '0.1.0'}

# Write to file
write_json(data, 'config.json')
```

##### Read JSON File

```python
from whywhytools import read_json

config = read_json('config.json')
print(config)
```

### Pickle (`.pkl`)

Handle Python's pickle serialization format.

##### Save Pickle File

```python
from whywhytools import save_pickle

model_data = {'weights': [0.1, 0.5, 0.9], 'bias': 0.01}
save_pickle(model_data, 'model.pkl')
```

##### Load Pickle File

```python
from whywhytools import load_pickle

data = load_pickle('model.pkl')
print(data)
```

## License

MIT
my-reposmith-bootstrap 0.1.0
Bootstrap installer for reposmith toolchain (core + extensions + cli).
License: MIT
Requires Python: >=3.10

# my-reposmith-bootstrap

Bootstrap runner package for **RepoSmith**.

This project provides a **governed installer** for the RepoSmith toolchain.
It is intentionally lightweight and does **not** expose RepoSmith as Python
dependencies. Instead, it installs locked versions explicitly at runtime.

> This is a **runner package**, not a framework or library.

---

## What this package does

When executed, `my-reposmith-bootstrap` will:

- Install **reposmith-core** (locked version)
- Install **reposmith-extensions** (locked version)
- Install **reposmith-cli** (locked version, without dependency resolution)
- Use explicit package indexes (Forgejo + PyPI)
- Avoid modifying global `pip` configuration

All decisions about versions and order are enforced by the bootstrap itself.

---

## Install

```bash
pip install -U my-reposmith-bootstrap
```

---

## Setup RepoSmith

After installation, run:

```bash
my-reposmith-setup
```

Once completed, RepoSmith will be available:

```bash
reposmith --help
reposmith version
```

---

## Governed installation model

This package intentionally:

- ❌ Does **not** list `reposmith-*` packages in `dependencies`
- ❌ Does **not** rely on `pip` dependency resolution
- ❌ Does **not** modify global `pip config`
- ✅ Pins exact versions internally
- ✅ Uses explicit `--index-url` and `--extra-index-url`
- ✅ Acts as a single authoritative installation contract

This ensures:
- Reproducible installs
- No hidden upgrades
- No accidental dependency drift

---

## Package indexes

The bootstrap installs packages from:

- **Primary**: RepoSmith Forgejo PyPI  
- **Fallback**: Public PyPI

Indexes are passed explicitly per install command and are never persisted.

---

## Supported platforms

- Windows (PowerShell)
- Linux
- macOS

> On Windows, restart the shell if the `reposmith` command is not found
> immediately after running the bootstrap.

---

## What this package is NOT

- ❌ Not a RepoSmith SDK
- ❌ Not a library to import
- ❌ Not a dependency manager
- ❌ Not a virtual environment manager

Its only responsibility is **bootstrapping RepoSmith correctly**.

---

## Versioning

This package follows semantic versioning:

- Patch: internal bootstrap fixes
- Minor: controlled upgrade of locked RepoSmith versions
- Major: change in bootstrap contract

---

## License

MIT License © 2026 TamerOnLine