semvec/pypi-packages huggingface dataset:
kittycad 1.3.1
A client library for accessing KittyCAD
Requires Python: >=3.11

# kittycad.py

The Python API client for KittyCAD.

- [PyPI](https://pypi.org/project/kittycad/)
- [Python docs](https://python.api.docs.zoo.dev/)
- [KittyCAD API Docs](https://zoo.dev/docs/api?lang=python)

## Generating

You can trigger a build with the GitHub action to generate the client. This will
automatically update the client to the latest version based on the spec hosted
at [api.zoo.dev](https://api.zoo.dev/).

Alternatively, if you wish to generate the client locally, make sure you have
[Docker installed](https://docs.docker.com/get-docker/) and run:

```bash
$ just generate
```

## Contributing

Please do not change the code directly since it is generated. PRs that change
the code directly will be automatically closed by a bot.
kalshibook 0.1.0
Python SDK for the KalshiBook L2 orderbook data API
Requires Python: >=3.10

# KalshiBook

[![PyPI version](https://img.shields.io/pypi/v/kalshibook.svg)](https://pypi.org/project/kalshibook/)
[![Python versions](https://img.shields.io/pypi/pyversions/kalshibook.svg)](https://pypi.org/project/kalshibook/)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://opensource.org/licenses/MIT)

Python SDK for the KalshiBook L2 orderbook data API. Query historical orderbook snapshots, trades, OHLCV candles, market metadata, event hierarchies, and settlement records for Kalshi prediction markets.

## Installation

```bash
pip install kalshibook
```

With optional pandas support for `.to_df()` conversion:

```bash
pip install kalshibook[pandas]
```

## Quick Start

```python
from datetime import datetime, timezone
from kalshibook import KalshiBook

client = KalshiBook("kb-your-api-key")

# Reconstruct an orderbook at a point in time
book = client.get_orderbook(
    "KXBTC-25FEB14-T98250",
    timestamp=datetime(2025, 2, 14, 12, 0, tzinfo=timezone.utc),
)
for level in book.yes[:5]:
    print(f"YES {level.price}c x{level.quantity}")

client.close()
```

## Key Features

- **Typed responses** -- All API responses are frozen dataclasses with full type annotations
- **Sync and async** -- Use `KalshiBook(api_key, sync=True)` or `sync=False` for async workflows
- **Auto-pagination** -- `PageIterator` handles multi-page results transparently for deltas and trades
- **DataFrame support** -- Call `.to_df()` on any list response or paginated iterator
- **Comprehensive errors** -- Typed exceptions for auth, rate limits, credits, and missing data
- **Auto-retry** -- Rate-limited requests are retried with exponential backoff and jitter

## Usage Examples

### List markets

```python
markets = client.list_markets()
for m in markets.data:
    print(f"{m.ticker}: {m.title}")
```

### OHLCV candles

```python
candles = client.get_candles(
    "KXBTC-25FEB14-T98250",
    start_time=start,
    end_time=end,
    interval="1h",
)
df = candles.to_df()  # requires kalshibook[pandas]
```

### Paginated trades

```python
for trade in client.list_trades("KXBTC-25FEB14-T98250", start, end):
    print(f"{trade.yes_price}c x{trade.count}")
```

### Async

```python
async with KalshiBook("kb-your-api-key", sync=False) as client:
    markets = await client.alist_markets()
```

## Documentation

Full documentation with guides, examples, and API reference:

**[kalshibook.github.io/kalshibook](https://kalshibook.github.io/kalshibook/)**

- [Getting Started](https://kalshibook.github.io/kalshibook/getting-started/) -- Installation, first queries, DataFrames
- [Authentication](https://kalshibook.github.io/kalshibook/authentication/) -- API keys, environment variables, error handling
- [API Reference](https://kalshibook.github.io/kalshibook/reference/) -- Complete SDK reference from source

## License

MIT
vericorp 1.0.0
Python SDK for the VeriCorp API — European company verification
Requires Python: >=3.9
Keywords: api, company, europe, tax-id, validation, vat, vies

# VeriCorp Python SDK

Python SDK for the [VeriCorp API](https://rapidapi.com/vericorp/api/vericorp-api) — European company verification.

## Install

```bash
pip install vericorp
```

## Quick Start

```python
from vericorp import VeriCorp

client = VeriCorp("your-rapidapi-key")

# Look up a company
company = client.lookup("PT502011378")
print(company.name)       # UNIVERSIDADE DO MINHO
print(company.address)    # Address(street='LG DO PACO', city='BRAGA', ...)

# Validate a VAT number
result = client.validate("DE811871080")
print(result.vat_valid)   # True

# List supported countries
countries = client.countries()
print(countries.total)    # 29
```

## Async

```python
from vericorp import AsyncVeriCorp

async with AsyncVeriCorp("your-rapidapi-key") as client:
    company = await client.lookup("DK10150817")
    print(company.name)
```

## Methods

| Method | Description |
|--------|-------------|
| `lookup(tax_id)` | Look up company by tax ID |
| `lookup_gb(company_number)` | Look up UK company by number |
| `validate(tax_id)` | Validate a VAT number |
| `batch(tax_ids)` | Batch lookup (max 10) |
| `countries()` | List supported countries |
| `health()` | API health check |

## Error Handling

```python
from vericorp.errors import InvalidTaxIdError, NotFoundError, RateLimitError

try:
    company = client.lookup("INVALID")
except InvalidTaxIdError:
    print("Bad tax ID format")
except NotFoundError:
    print("Company not found")
except RateLimitError as e:
    print(f"Rate limited, retry after {e.retry_after}s")
```

## License

MIT
agentia 0.1.24
Ergonomic LLM Agents
Requires Python: >=3.12
Keywords: agent, ai-sdk, chatgpt, gpt, llm, mcp, openai, openrouter, skills, tools

# Agentia: Ergonomic LLM Agents

Ergonomic LLM Agents with MCP and Skills support.

# Getting Started

Run agents with tools, MCP, and Skills

```python
from agentia import Agent, MCP
from typing import Annotated

# Define a tool as a python function
def get_weather(location: Annotated[str, "The city name"]):
    """Get the current weather in a given location"""
    return { "temperature": 72 }

# Declare a MCP server:
calc = MCP(name="calculator", command="uvx", args=["mcp-server-calculator"])

# Create an agent
# This will load the function tool, the calculator MCP, and all skills under $CWD/.skills
agent = Agent(model="openai/gpt-5-nano", tools=[get_weather, calc], skills=True)

# Run the agent with the mcp
response = await agent.run("Calculate 234 ** 3")

print(response.text)

# Output: The result of 234 raised to the power of 3 is 12,812,904.
```

# The Magic Decorator

Create agent-powered magic functions.

Support both plain types and pydantic models as input and output.

```python
from agentia import magic
from pydantic import BaseModel

class Forcast(BaseModel):
    location: str
    temperature_celsius: int

@magic
async def get_weather(weather_forcast: str) -> Forcast:
    """Create weather forcase object based on the input string"""
    ...

forcast = await get_weather("The current temperature in Boston is 72°F")

print(forcast.location) # Output: Boston
print(forcast.temperature_celsius) # Output: 22
```

# Supported Parameter and Result Types

* Any types that can be passed to `pydantic.TypeAdaptor`:
    * Builtin types: `int`, `float`, `str`, `bool`, `tuple[_]`, `list[_]`, `dict[_, _]`
    * Enums: `Literal['A', 'B', ...]`, `StrEnum`, `IntEnum`, and `Enum`
    * dataclasses
* `pydantic.BaseModel` subclasses
arraylake 0.30.0
Python client for ArrayLake
Requires Python: <3.14,>=3.11

<p align="center">
<img src="https://earthmover-web-assets.s3.amazonaws.com/04-Arraylake-Lockup-Midnight-RGB-LARGE.png" width="80%" alt="Arraylake">
</p>

<p align="center">
  <a href="https://earthmover.io" rel="nofollow">earthmover.io</a> -
  <a href="https://docs.earthmover.io" rel="nofollow">documentation</a>
</p>

Arraylake is a cloud-based platform that understands a wide array of multidimensional scientific data. Organize, analyze, build, and collaborate—effortlessly.

Check out the [documentation](https://docs.earthmover.io) to get started.

## Install

```
# using pip
pip install arraylake

# using conda
conda install arraylake
```