semvec/pypi-packages huggingface dataset:
querybuilder-llm 0.2.0
A pip package to generate SQL/Mongo queries from natural language using an LLM API
Requires Python: >=3.8

# querybuilder-llm

A simple pip package that lets you generate **SQL** or **MongoDB** queries from natural language using your deployed **LLM API**.  
Schema is passed in, and the LLM figures out the correct query.  
All responses are wrapped with a `success` flag for safety.

---

## Installation

```bash
pip install querybuilder-llm
```

## Usage
```python
from querybuilder_llm.client import build_query

# Example schema
schema = {
    "users": ["id", "name", "email", "age"]
}

result = build_query(schema, "Find all gmail users", "postgresql")

if result["success"]:
    print("SQL Query:", result["response"])
else:
    print("Error:", result["error"])

# --- Mongo Example ---
result = build_query(schema, "Find users older than 30", "mongodb")

if result["success"]:
    print("Mongo Query:", result["response"])
else:
    print("Error:", result["error"])
```

## Response Format
```json
{
  "success": True/False,
  "response": str | dict | None,
  "db_type": postgress|mongodb
  "error": str | None
}

```
```success```: Whether query generation was successful

```response```: SQL string or MongoDB JSON dict (if success)

```error```: Error details if failed
tstrings-backport 0.1.5
Backport of t-strings (PEP 750)
Requires Python: >=3.9

# tstrings: PEP 750-style Template Strings for Python < 3.14

This package provides a backport of the new [PEP 750](https://peps.python.org/pep-0750/) "t-string" template string syntax, for use with Python versions **before 3.14**.

## Usage

Install from [PyPI](https://pypi.org/project/tstrings-backport/) with `uv add tstrings-backport` or `python -m pip install tstrings-backport`.

Instead of the new syntax `t"..."` (which is only available in Python 3.14+), use the function call form:

```python
from tstrings import t

name = "World"
tpl = t("Hello, {name}!")
print(tpl.strings)         # ("Hello, ", "!")
print(tpl.interpolations)  # (Interpolation(value="World", expression="name", ...),)
```

The returned object is a `Template` with `.strings` and `.interpolations` attributes,
which should be a drop-in replacement for the built-in t-strings.

## Features

- **String interpolation**: Supports `{expr}` expressions, including complex expressions.
- **Debug specifier**: `{var=}` and `{var=:.2f}` forms, as in f-strings.
- **Conversion specifiers**: `{val!r}`, `{val!s}`, `{val!a}`.
- **Format specifiers**: `{num:.2f}`.
- **Multiline expressions**: Supported.
- **Error handling**: Raises `NameError` or `SyntaxError` for invalid expressions, as in f-strings (but at runtime, not at compile time).
- **PEP 750 API**: Returns `Template` and `Interpolation` dataclasses matching the PEP.

## Limitations

- **No t-string literal syntax**: You must use `t("...")`, not `t"..."`.
- **No support for all edge cases**: Some advanced t-string edge cases may not be fully supported.

## Examples

```python
from tstrings import t

name = ""
value = 1
num = 3.1415
obj = {}
data = [1, 2, 3]

# Simple
tpl = t("Hello, {name}!")
# Debug
tpl = t("{value=}")
# Format
tpl = t("{num:.2f}")
# Conversion
tpl = t("{obj!r}")
# Multiline
tpl = t("""
    {sum(data)}
""")
```

## Development & Testing

Install with `uv sync` and activate the virtualenv (`. .venv/bin/activate` or similar).

Run the test suite with:

```sh
make test
```

or just:

```sh
uv run --python 3.13 pytest
```

See `tests/test_all.py` for coverage of all supported features.

Tests also include the tdom source code (modified for pre-3.14 syntax) and test suite.

## How to help

This was (initially) hacked together in less than 2 hours. If you find it useful, please consider contributing fixes, improvements, or documentation!

Pull requests and issues are welcome.
unitwise 0.0.1
A Python library for unit conversions!
Requires Python: >=3.10
Keywords: app, macOS, windows, linux, flatpak

# unitwise
What is `unitwise`? Unitwise is a library created by `@devs_des1re` which can be used to convert different types of units between them. We are planning to add more in the future including physics and chemistry.

# Installation
For the installation, you'll need to have pip

Run this pip command

```
pip install unitwise
```

# Snippets
Converting distance

```py
"""Converting Distance"""
from unitwise import distances, convert_distance
from unitwise import InvalidUnit

print(convert_distance(15, distances.KILOMETERS, distances.MILES))
```

Converting mass

```py
"""Converting Mass"""
from unitwise import mass, convert_mass
from unitwise import InvalidUnit

print(convert_distance(15, mass.KILOGRAMS, mass.STONE))
```

Converting temperature

```py
"""Converting Temperature"""
from unitwise import temperature, convert_temperature
from unitwise import InvalidUnit

print(convert_distance(15, temperature.CELSIUS, temperature.RANKINE))
```

Converting volume

```py
"""Converting Volume"""
from unitwise import volume, convert_volume
from unitwise import InvalidUnit

print(convert_distance(15, volume.CUBIC_CENTIMETER, volume.CUP))
```

Converting Area

```py
"""Converting Area"""
from unitwise import area, convert_area
from unitwise import InvalidUnit

print(convert_distance(15, area.ACRE, area.SQUARE_KILOMETER))
```

# Want to contribute?
If you have any suggestions that are appropriate that you want to share, create a issue and we will let you know as soon as possible. Thanks for using `unitwise`!
pybakong 0.1.0
Python SDK for Cambodia Bakong Open API
Requires Python: >=3.7


# pybakong

Python SDK for Cambodia Bakong Open API.

## Installation

```bash
pip install pybakong
```

## Usage

```python
from pybakong import BakongClient

client = BakongClient()

# Step 1: Request token
client.request_token("your@email.com", "MyOrg", "MyProject")

# Step 2: Verify token with code from email
client.verify_token("123456")

# Step 3: Generate deeplink
link = client.generate_deeplink(
    qr="QR_STRING",
    app_icon_url="https://example.com/icon.png",
    app_name="MyApp",
    app_deep_link_callback="myapp://callback"
)
print("Payment Link:", link)
```
manipy 0.1.9
Latent-space manipulation utilities and models (StyleGAN, flow matching, ratings).
Requires Python: >=3.9
Keywords: stylegan, latent-space, flow-matching, pytorch, computer-vision

# manipy

Latent-space manipulation utilities and models for StyleGAN-based workflows:

- Flow models for manipulating W-space along psychometric dimensions
- Rating models trained on human ratings
- Utilities for visualization and StyleGAN interaction

Install from source:

```bash
pip install .
```

Build locally:

```bash
python -m build
```

Optional extras: `viz`, `stylegan`, `train`.

```bash
pip install "manipy[viz,stylegan,train]"
```