semvec/pypi-packages huggingface dataset:
jsonthat 0.4.0
Transform plain text to JSON
Requires Python: <4.0,>=3.12

# json that

transform any raw text to json, using LLM.

Provider:
- OpenAI
- Claude AI
- Mistral AI
- Ollama (local)

## installation

```bash
pip install jsonthat
```

```bash
jt --setup
```

## usage

```bash
echo 'my name is jay' | jt
{
  "name": "Jay"
}
```

```bash
options:
    --schema   <json_schema_file> Pass a json schema to format the output
    --provider <provider>         Specify the LLM provider to use
    --stream                      Stream the output
```
returncache 1.0.0
A decorator for wrapping any function in an expiring cache. Supports coroutines!
Requires Python: >=3.12

# returncache

A very, very small Python utility library for caching the return value of a function until a given `datetime` has passed.

## example

```python
from time import sleep
from datetime import datetime, timedelta

from returncache import returncache

# This only has to be recomputed every ten minutes
@returncache()
def cached_square(value) -> tuple[datetime, float]:
    print("squaring!!")
    return datetime.now() + timedelta(minutes=10), value ** 2


# only the first call will cause the body of cached_square() to run
first = cached_square(42)  # prints "squaring!!"
second = cached_square(42) # does not print anything

# wait for a bit...
sleep(60 * 15)
third = cached_square(42)  # prints "squaring!!"

# by default, the internal cache is keyed by a hash of the parameters.
# this does require all parameters to be hashable.
# you can opt out of this behavior by passing keyed_by_parameters=False to @returncache()
# because the parameter is different, cached_square() _will_ run here!
fourth = cached_square(69) # prints "squaring!!"
```

Coroutines are also supported:
```py
from asyncio import run
from aiohttp import ClientSession
from returncache import returncache
from datetime import datetime, timedelta

@returncache()
async def cached_network_request(url) -> bytes:
    async with ClientSession() as session:
        async with session.get(url) as response:
            return datetime.now() + timedelta(minutes=10), await response.json()

async def main():
    # only makes one network request
    first = await cached_network_request("https://httpbin.org/get")
    second = await cached_network_request("https://httpbin.org/get")

asyncio.run(main())
```
qt-ble-discovery-widget 1.0.0
A Qt widget for BLE device discovery
Requires Python: >=3.10

# QT Ble discovery widget
[![PyPI version](https://badge.fury.io/py/qt-ble-discovery-widget.svg)](https://pypi.org/project/qt-ble-discovery-widget)

A QT widget for discovering BLE devices.

## Installation

### From PyPI

Install the package directly from PyPI using pip:

```bash
pip install qt-ble-discovery-widget
```

### From Source

Clone the repository and install dependencies:

```bash
git clone https://github.com/fvsolutions-common/qt-ble-discovery-widget
pip install -e qt-ble-discovery-widget
```

## Development

This project depends on UV for managing dependencies.
Make sure you have UV installed and set up in your environment.

You can find more information about UV [here](https://docs.astral.sh/uv/getting-started/installation/).

```bash
uv venv
```

```bash
uv sync --all-extras --dev
```