semvec/pypi-packages huggingface dataset:
test-ipa-sdk 0.0.1
template python project with necessary configurations
Requires Python: >=3.10

# pyproject-tmpl

## features

2. pytest
3. pre-commit
4. darker for code format
5. ruff for lint
6. commitlint for commit message format

## 使用方式

- 初始化环境：`./setup`

- 执行测试：`uv run -m pytest`

- 启动服务：`uv run main.py`

- 构建发布：`./publish`
pi 1.0.0.dev2
Python Intelligence
Requires Python: ==3.13.*

# pi

Python Intelligence -- a better ✨ tool chain for humans and agents.


## Configuration

1. Add `PI_LLM_API_KEY=` env var with your OpenRouter, OpenAI, or Anthropic
   API key.

2. Add `PI_LLM_MODEL=` with the name of the model you want to use.


E.g.:

```shell
export PI_LLM_API_KEY="vck_jlasdfkjajkfhieu..."
export PI_LLM_MODEL="anthropic/claude-sonnet-4.5"
```


## Development

1. Clone the repo `git clone --recursive git@github.com:geldata/pi.git`

2. `cd pi`

3. `uv sync`

4. `uv run pre-commit install`

5. `uv run pi`

6. Run `realpath $(uv run which pi)` and use the path it returned to create an
   alias in your shell: `alias pi="<relpath output>"`. Now you are able to run
   `pi` from anywhere in your system.


## Running tests

1. `uv run pytest` will do the job.
harlequin-wherobots 0.9.0
Harlequin adapter for Wherobots' Spatial SQL API
Requires Python: <3.14,>=3.9

# Wherobots Adapter for Harlequin

This repository provides the Harlequin adapter for WherobotsDB, using
the Wherobots Spatial SQL API and its
[wherobots-python-dbapi-driver](https://github.com/wherobots/wherobots-python-dbapi-driver).

## Installation

```
$ pip install harlequin-wherobots
```

## Usage

Procure an API key from Wherobots, and start Harlequin with the
required parameters:

```
$ harlequin -a wherobots --api-key <key>
```

Alternatively, you can use your session token:

```
$ harlequin -a wherobots --token <token>
```

The Harlequin adapter for Wherobots will automatically start a Wherobots
SQL session with the default runtime (Tiny, 4 executors) in the
default Wherobots public compute region (AWS `us-west-2`). You can
override those defaults with the `--runtime` and `--region` options,
respectively:

```
$ harlequin -a wherobots --api-key <key> --runtime MEDIUM --region AWS_US_WEST_2
```

> [!NOTE]
> Community Edition users of Wherobots Cloud are restricted to the
> "Tiny" runtime size. See our [Pricing](https://www.wherobots.com/pricing)
> for more information.

## Advanced options

If your SQL session is already provisioned and running, you can force
the driver to directly connect to it via its WebSocket URL (without
protocol version):

```
$ harlequin -a wherobots --api-key <key> --ws-url <session-url>
```

You can also specify the base hostname of the Wherobots stack to
interact with as the first positional parameter. By default, the driver
connects to `cloud.wherobots.com`, the official public Wherobots
service.

```
$ harlequin -a wherobots --api-key <key> [host]
```
anthos 1.0.4
Make waveform widgets beautifully.

# **Anthos**

A Tkinter-based waveform visualization widget using `Canvas` and `librosa`.

A fork of ostcrom’s *python-tkinter-waveform-widget*, with a simpler API and customizable waveform display options.

---

## **Usage**

```python
import tkinter as tk
import anthos

# Create main Tkinter window
main_window = tk.Tk()

# Standard Tkinter Canvas options
cnf = {
    "height": 100,
    "width": 500,
    "bg": "green"
}

# Waveform display options
wave_cnf = {
    "x_scale": 1,
    "y_scale": 5
}

path_to_audio = "test.mp3"

# Create waveform widget
widget = anthosWidget(
    master=main_window,
    path(path_to_audio)
    cnf=cnf,
    wave_cnf=wave_cnf
)

# Draw the waveform
widget.draw()

# The widget inherits from tkinter.Canvas, so you can use standard geometry methods
widget.place(x=10, y=10)

# Update standard canvas configuration dynamically
widget.config({"bg": "black", "width": 600})
```

---
basejump-llama-index-core 0.12.35.post1
Interface between LLMs and your data
Requires Python: <4.0,>=3.9
Keywords: LLM, NLP, RAG, data, devtools, index, retrieval

# LlamaIndex Core

The core python package to the LlamaIndex library. Core classes and abstractions
represent the foundational building blocks for LLM applications, most notably,
RAG. Such building blocks include abstractions for LLMs, Vector Stores, Embeddings,
Storage, Callables and several others.

We've designed the core library so that it can be easily extended through subclasses.
Building LLM applications with LlamaIndex thus involves building with LlamaIndex
core as well as with the LlamaIndex [integrations](https://github.com/run-llama/llama_index/tree/main/llama-index-integrations) needed for your application.
bqredis 0.0.8
A Redis-backed cache for BigQuery
Requires Python: >=3.11

# bqredis

This library provides functionality to cache calls to bigquery with redis.

The use case which drove creation of this library was a web-based dashboard
which pulled data from bigquery. Often queries were inexplicably slow. Even
worse, a slow loading page would prompt users to refresh, would would saturate
the available threadpools, further slowing the experience.

This is the result: a library which uses redis to cache bigquery results and
prevents more than one inflight request from going out from a given cache
instance at a time. Enough talking, let's cut to an example:

```python
import bqredis

_QUERY = "SELECT * FROM `bigquery-public-data.country_codes.country_codes` ORDER BY alpha_3_code DESC LIMIT 10"

redis_client = redis.Redis.from_url("redis://localhost:6379")
cache = bqredis.BQRedis(redis_client, redis_cache_ttl_sec=300, redis_background_refresh_ttl_sec=5)
# Subsequent calls to this for the next 300 seconds will be cached.
cache.query_sync(_QUERY)
# Start a background refresh for this query.
promise = cache.submit_background_refresh(_QUERY)
promise.result()
# More calls for refreshing the background cache for the next 5 seconds will
# not start.
```

## Return type
By default, this library will parse results as a `pyarrow.RecordBatch`. To
instead use a different format, override the `convert_arrow_to_output` method.
For example, to have results as a `polars.DataFrame` do the following:

```
import polars
import pyarrow

class BQRedisPolars(bqredis.BQRedis):
    def convert_arrow_to_output_format(self, records: pyarrow.RecordBatch) -> polars.DataFrame:
        return polars.from_arrow(records)

pl_cache = BQRedisPolars(redis_client, redis_cache_ttl_sec=300, redis_background_refresh_ttl_sec=5)
pl_cache.query_sync(_QUERY)
```

We use arrow as the underlying format because it is the direct format being
sent by BigQuery. This can be converted with 0-copy to polars as show above.
django-api-gate 0.0.7
A middleware to monetize Django APIs with Stripe and the 402 Error Code
Requires Python: >=3.9

# Django API Gate 🏦

Monetize your Django API in minutes.
django-api-gate is a drop-in middleware that turns your API into a metered, paid service.
It connects to the API Gate Hub protocol to handle API keys, credit balances, and billing automatically.

# 🚀 Features

Instant Paywall: Protects your API routes with one line of code.

Metered Billing: Deducts credits per request automatically.

Zero-Config Banking: No need to set up Stripe or Ledger logic yourself—API Gate Hub handles the backend.

High Performance: Uses persistent connection pooling for minimal latency impact (~20ms).

# 📦 Installation

pip install django-api-gate

# ⚙️ Configuration

1. Add into your settings.py:

MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

    'django.middleware.common.CommonMiddleware',

    # ...

    'django_api_gate.middleware.ApiGateMiddleware', # <--- Add this

    # ...

]


2. Go to API Gate Hub and create an account.

3. Copy your API Key from the dashboard.

4. Add your API Key to settings.py:

API_GATE_API_KEY = "your-merchant-uuid-here"

OPTIONAL VARIABLES:

Change which URLS are protected (Default: '/api/'):

API_GATE_URL_PREFIX = "/v1/"

Change the cost per request (Default: 1 credit):

API_GATE_PRICE = 5


# 🛠️ Usage

Once installed, any request to your protected URL prefix (e.g., /api/data) will require an API Gate Key in the header:

curl -H "X-Api-Key: 'customer-uuid-here'" [https://yoursite.com/api/data](https://yoursite.com/api/data)

If a user runs out of credits, they receive a standard 402 Payment Required response:

{
    "error": "Insufficient Credits",
    "balance": 0,
    "top_up_url": "[https://api-gate-hub.onrender.com](https://api-gate-hub.onrender.com)"
}

If a user is missing a key, they receive a standard 401 Unauthorized response:

{
    "error": "Unauthorized",
    "message": "Access requires a prepaid API Key in header 'X-Api-Key'.",
    "portal_url": "[https://api-gate-hub.onrender.com](https://api-gate-hub.onrender.com)"
}

# 🏗️ Architecture

This library operates as a Spoke in a Hub-and-Spoke financial model.

The Hub: The API Gate Hub (Ledger, Stripe Processing, User Accounts).

The Spoke: Your Django App (Product, Logic, Value).

When a request comes in, this middleware pings the Hub to verify funds and transfer credits from the Consumer to the Merchant.
tylereq 0.1.4
A simple equations module made by Tyler
Requires Python: >=3.8

# tylereq

A simple equations module made by Tyler, providing geometry-related formulas for perimeters, areas, surface areas, and volumes.

## Installation

```bash
pip install tylereq
```

## Usage

```python
from tylereq import shapes

# Calculate area of a rectangle
area = tylereq.shapes.a_rectangle(5, 3)  # Returns 15.0

# Calculate volume of a sphere
volume = tylereq.shapes.v_sphere(2)  # Returns 33.510321638291124

# Calculate perimeter of a square
perimeter = tylereq.shapes.p_square(10)  # Returns 40
```

## Available Functions

### Perimeter/Circumference
- `tylereq.shapes.p_rectangle(l, w)`: Rectangle perimeter
- `tylereq.shapes.p_square(s)`: Square perimeter
- `tylereq.shapes.p_triangle(a, b, c)`: Triangle perimeter
- `tylereq.shapes.c_circle(r)`: Circle circumference

### Area
- `tylereq.shapes.a_rectangle(l, w)`: Rectangle area
- `tylereq.shapes.a_square(s)`: Square area
- `tylereq.shapes.a_triangle(b, h)`: Triangle area
- `tylereq.shapes.a_circle(r)`: Circle area

### Surface Area
- `tylereq.shapes.sa_box(l, w, h)`: Box surface area
- `tylereq.shapes.sa_sphere(r)`: Sphere surface area
- `tylereq.shapes.sa_cylinder(r, h)`: Cylinder surface area

### Volume
- `tylereq.shapes.v_box(l, w, h)`: Box volume
- `tylereq.shapes.v_sphere(r)`: Sphere volume
- `tylereq.shapes.v_cylinder(r, h)`: Cylinder volume

## Documentation

Full documentation is available at the project's GitHub Pages site.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
igvf-utils 3.1.1
Client and tools for IGVF data submitters.
Requires Python: >=3.8
Keywords: genomics, IGVF, data-submission, bioinformatics

© 2019 The Board of Trustees of the Leland Stanford Junior University.

# igvf_utils
Tools that are useful to any IGVF Consortium submitting group, as well as the general community working with IGVF data.  Library and scripts are coded in Python.

See the [wiki](https://github.com/IGVF-DACC/igvf_utils/wiki) to get started. 

API and script documentation are available on [Read the Docs](http://igvf-utils.readthedocs.io/).

# Installation
Please clone this repository (e.g. `git clone https://github.com/IGVF-DACC/igvf_utils.git`) and then refer to instructions on the [Installation wiki page](https://github.com/IGVF-DACC/igvf_utils/wiki/Installation).

# Latest news

2022-04-27

Forked from https://github.com/StanfordBioinformatics/encode_utils.