semvec/pypi-packages huggingface dataset:
platega 0.1.5
A comprehensive Python library for the Platega.io API
Requires Python: >=3.8
Keywords: api, async, httpx, payments, platega

# Platega API Library

A comprehensive Python library for interacting with the Platega.io API.

## Features

- Full support for all Platega API endpoints (Payments, Rates, etc.)
- Synchronous and Asynchronous clients
- Pydantic models for request/response validation
- Webhook handler with decorator support
- Type hinting

## Installation

```bash
pip install platega
```

## Usage

### Synchronous Client

```python
from platega import PlategaClient

client = PlategaClient(merchant_id="your-uuid", secret_key="your-secret")

status = client.check_invoice("transaction-uuid")
print(status)
```

### Asynchronous Client

```python
import asyncio
from platega import AsyncPlategaClient

async def main():
    client = AsyncPlategaClient(merchant_id="your-uuid", secret_key="your-secret")
    async with client:
        status = await client.check_invoice("transaction-uuid")
        print(status)

asyncio.run(main())
```

### Webhooks

```python
from platega import PlategaWebhookHandler, PaymentStatus

handler = PlategaWebhookHandler()

@handler.on(PaymentStatus.CONFIRMED)
async def handle_confirmed(payload):
    print(f"Payment confirmed: {payload.id}")

# In your web framework (e.g., FastAPI/Flask)
# handler.process_webhook(request_json)
```
QualysPy 0.5.10.7
A Python wrapper for the Qualys API.
Requires Python: >=3.10

# QualysPy

A Python wrapper for the Qualys API.  Qualys data can be interacted with using a Python model,
loaded into a PostgreSQL database, and queryed from that database with the same model.

The Python models are intended to be a 1:1 mapping of the objects returned by the Qualys API.

This is a work in progress.  The currently supported API calls are:

-  VMDR
    - host_list_detection

## Requirements

- Python >= 3.10
- A supported version of Linux (tested on Ubuntu 22.04)
- A supported version of PostgreSQL, if you want to use the ORM features.

## Installation

```shell
python -m venv .venv
source .venv/bin/activate
pip install qualyspy
```

Then, create a config file to indicate the Qualys API URLS and credentials and, optionally,
PostgreSQL database information.  See `.qualyspy-example` for an example configuration file.  By
default, QualysPy will search for this file at ~/.qualyspy, but a different file path
can be supplied.

## Usage

Documentation is located at <https://qualyspy.readthedocs.io>.

Each Qualys API has class subclassed from QualysAPIBase.  For example, to connect to the VMDR API:

```python
from qualyspy.vmdr import VmdrAPI

api = VmdrAPI()
```

The API object has methods corresponding to the Qualys API's endpoints.

```python

host_vulns = api.host_list_detection(ids=12345)
```

To load the data into a database, use the ORM class corresponding to the API endpoint.  For the
host_list_detection endpoint:

```python
from qualyspy.vmdr import HostListDetectionORM
# Tip: You can pass echo=True to an ORM class to write the SQL commands to stdout
orm = HostListDetectionORM()
orm.load() # This may take some time, depending on how much data there is to load.
```

Finally, the data can be queryed and will be outputted in the same form as with VmdrAPI.

```python
from qualyspy.models.vmdr.host_list_vm_detection_orm import Host

# Get all hosts from the database
with orm.Session(vmdr_orm.engine) as session:
    stmt = session.query(Host)
    host_list = vmdr_orm.query(stmt)[0]
    host = host_list.host[0]
```
societal-costs-pipeline-2026-02-02 0.1.0
Societal costs pipeline CLI.
Requires Python: >=3.9

# societal_costs

Workspace for the societal costs study.

## Crates

- `crates/costs_core` — core domain types, aggregation, pricing, and validation.
- `crates/costs_models` — two-part, Tweedie, and log-normal models + selection tools.
- `crates/costs_matching` — matching + balance diagnostics.
- `crates/costs_cohort` — cohort assignment + diagnostics.
- `crates/costs_components` — register-derived component builders (LMDB volume so far).
- `crates/costs_pipeline` — configuration, orchestration, and report outputs.

## LMDB example

See `crates/costs_pipeline/README.md` for the LMDB ingestion example.

## Pipeline config

Start from `pipeline.example.toml` and update the register file paths to match
your local dataset layout. Most SAS7BDAT paths accept either a single file
or a directory (all `.sas7bdat` files are loaded, sorted by name). You can
also set `base_path` in the config to prefix all relative register paths.

## Additional docs

- `crates/costs_core/README.md` — core domain and aggregation usage.
- `crates/costs_models/README.md` — model APIs and examples.
- `crates/costs_models/examples/README.md` — runnable model examples.
- `crates/costs_components/README.md` — LMDB note (missing price fields).
- `crates/costs_pipeline/README.md` — pipeline usage and LMDB example.
qutePandas 1.1.4
A pandas-like library for kdb+/q using pykx
Requires Python: >=3.7
Keywords: kdb+, q, pandas, data analysis, timeseries, finance

# qutePandas

A pandas-like library for kdb+/q powered by [PyKX](https://github.com/KxSystems/pykx).

While Pandas is the gold standard for data manipulation in Python, it often struggles with memory overhead and execution speed when handling multi-gigabyte datasets or complex time-series operations. `qutePandas` addresses these limitations by offloading compute-intensive operations to the kdb+/q engine, leveraging its columnar architecture and high-performance vector processing. By providing a familiar pandas-like API, it allows Python engineers to achieve kdb+ speeds without leaving the Python ecosystem.

## Installation

```bash
pip install qutePandas
```

*Note: Requires a kdb+ license and the PyKX library.*

## Quick Start

```python
import qutePandas as qpd
import pandas as pd

# Convert a pandas DataFrame to a qutePandas table
df = pd.DataFrame({
    "time": pd.date_range("2023-01-01", periods=1000000, freq="ms"),
    "price": pd.Series(range(1000000))
})
q_table = qpd.DataFrame(df)

# Perform high-performance aggregation
# Computation happens in kdb+
res = qpd.apply(q_table, "sum", axis=0, return_type="p")
print(res)
```

## Documentation

Full documentation, including API reference and performance benchmarks, is available at:
[https://ishapatro.github.io/qutePandas/](https://ishapatro.github.io/qutePandas/)

## GitHub

The source code for this project is available on GitHub at:
[https://github.com/ishapatro/qutePandas](https://github.com/ishapatro/qutePandas)

## Contributing

Contributions are welcome! Please read our [CONTRIBUTING.md](https://github.com/IshaPatro/qutePandas/blob/main/CONTRIBUTING.md) for more information.

## License
MIT License

## Author

Created by [Isha Patro](https://ishapatro.in)