semvec/pypi-packages huggingface dataset:
liteai-sdk 0.6.0
A wrapper of LiteLLM
Requires Python: >=3.10

# LiteAI-SDK

LiteAI-SDK is a wrapper of LiteLLM which provides a more intuitive API and [AI SDK](https://github.com/vercel/ai) like DX.

## Installation

```
pip install liteai-sdk
```

### Develop with coding agent

You can access the complete usage guidance with [llms.txt](https://raw.githubusercontent.com/BHznJNs/liteai/refs/heads/main/llms.txt), just give it to your coding agent to tell it how to use LiteAI-SDK.

## Examples

Below is a simple example of just a API call:

```python
import os
from dotenv import load_dotenv
from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage

load_dotenv()

llm = LLM(provider=LlmProviders.OPENAI,
          api_key=os.getenv("API_KEY", ""),
          base_url=os.getenv("BASE_URL", ""))

response = llm.generate_text_sync( # sync API of generate_text
    LlmRequestParams(
        model="deepseek-v3.1",
        messages=[UserMessage(content="Hello.")]))
print(response)
```

Below is an example that shows the automatically tool call:

```python
import os
from dotenv import load_dotenv
from liteai_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage

load_dotenv()

def example_tool():
    """
    This is a test tool that is used to test the tool calling functionality.
    """
    print("The example tool is called.")
    return "Hello World"

llm = LLM(provider=LlmProviders.OPENAI,
          api_key=os.getenv("API_KEY", ""),
          base_url=os.getenv("BASE_URL", ""))

params = LlmRequestParams(
        model="deepseek-v3.1",
        tools=[example_tool],
        execute_tools=True,
        messages=[UserMessage(content="Please call the tool example_tool.")])

print("User: ", "Please call the tool example_tool.")
messages = llm.generate_text_sync(params)
for message in messages:
    match message.role:
        case "assistant":
            print("Assistant: ", message.content)
        case "tool":
            print("Tool: ", message.result)
```
tket 0.12.16
Quantinuum's TKET Quantum Compiler
Requires Python: >=3.10

# tket

[![pypi][]](https://pypi.org/project/tket/)
[![codecov][]](https://codecov.io/gh/quantinuum/tket2)
[![py-version][]](https://pypi.org/project/tket/)

  [codecov]: https://img.shields.io/codecov/c/gh/quantinuum/tket2?logo=codecov
  [py-version]: https://img.shields.io/pypi/pyversions/tket
  [pypi]: https://img.shields.io/pypi/v/tket

TKET is an open source quantum compiler developed by Quantinuum. Central to
TKET's design is its hardware agnosticism which allows researchers and quantum
software developers to take advantage of its powerful compilation for many
different quantum architectures.

This is the Python front-end for TKET, providing a high-level interface for working with quantum circuits.
See also the Rust library with the same name on [crates.io](https://crates.io/crates/tket).


## Install

TKET can be installed via `pip`. Requires Python >= 3.10.

```sh
pip install tket
```

## Usage

See the [Getting Started][getting-started] guide and the other [examples].

  [getting-started]: https://github.com/quantinuum/tket2/blob/main/tket-py/examples/1-Getting-Started.ipynb
  [examples]: https://github.com/quantinuum/tket2/tree/main/tket-py/examples

The API documentation for `tket-py` can be found at https://quantinuum.github.io/tket2/.

## Development

This package uses [pyo3](https://pyo3.rs/latest/) and
[maturin](https://github.com/PyO3/maturin) to bind TKET functionality to
python as the `tket` package.

Recommended:

A clean python 3.10 environment with `maturin` installed. At which point running
`maturin develop` in this directory should build and install the package in the
environment. Run `pytest` in this directory to test everything is working.

Don't forget to use the `--release` flag when using Badger and other heavy
computational workloads.

See [DEVELOPMENT.md] for more information.

  [DEVELOPMENT.md]: https://github.com/quantinuum/tket2/blob/main/DEVELOPMENT.md


## License

This project is licensed under Apache License, Version 2.0 ([LICENCE][] or http://www.apache.org/licenses/LICENSE-2.0).

  [LICENCE]: https://github.com/quantinuum/tket2/blob/main/LICENCE
paddleocr-haystack 1.1.0
An integration of PaddleOCR with Haystack
Requires Python: >=3.10

# paddleocr-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/paddleocr-haystack.svg)](https://pypi.org/project/paddleocr-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/paddleocr-haystack.svg)](https://pypi.org/project/paddleocr-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/paddleocr)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/paddleocr/CHANGELOG.md)

---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

To run integration tests locally, you need to export the `PADDLEOCR_VL_API_URL` and `AISTUDIO_ACCESS_TOKEN` environment variables.
ds-event-stream-py-sdk 0.1.0a1
A Python package from the DS library collection
Requires Python: >=3.10
Keywords: ds, kafka, python

# ds-event-stream-py-sdk

A Python package from the DS Event Stream Python SDK.

## Installation

Install the package using pip:

```bash
pip install ds-event-stream-py-sdk
```

Or using uv (recommended):

```bash
uv pip install ds-event-stream-py-sdk
```

## Quick Start

```python
from ds_event_stream_py_sdk import __version__

print(f"ds-event-stream-py-sdk version: {__version__}")
```

## Features

- Kafka producer
- Kafka consumer
- Event stream model

## Usage

```python
import logging
from uuid import uuid4

from ds_common_logger_py_lib import Logger
from ds_event_stream_py_sdk.errors import ProducerError
from ds_event_stream_py_sdk.models.v1 import EventStream
from ds_event_stream_py_sdk.producer import KafkaProducer

Logger.configure(level=logging.DEBUG)
logger = Logger.get_logger(__name__)


producer = KafkaProducer(
    bootstrap_servers="b0.dev.kafka.ds.local:9095",
    sasl_username="ds.test.producer.v1",
    sasl_password="",
    timeout=5.0,
)

event = EventStream(
    session_id=uuid4(),
    tenant_id=uuid4(),
    event_type="example.event",
    event_source="examples",
    created_by="John Doe",
    payload={"hello": "world"},
)
producer.send_message(
    topic="ds.test.message.created.v1",
    message=event,
    key=str(event.session_id),
    timeout=5.0,
)
```

## Requirements

- Python 3.10 or higher
- ds-common-logger-py-lib
- ds-common-serde-py-lib
- confluent-kafka

## Documentation

Full documentation is available at:

- [GitHub Repository](https://github.com/grasp-labs/ds-event-stream-py-sdk)
- [Documentation Site](https://grasp-labs.github.io/ds-event-stream-py-sdk/)

## Development

To contribute or set up a development environment:

```bash
# Clone the repository
git clone https://github.com/grasp-labs/ds-event-stream-py-sdk.git
cd ds-event-stream-py-sdk

# Install development dependencies
uv sync --all-extras --dev

# Run tests
make test
```

See the [README](https://github.com/grasp-labs/ds-event-stream-py-sdk#readme)
for more information.

## License

This package is licensed under the Apache License 2.0.
See the [LICENSE-APACHE](https://github.com/grasp-labs/ds-event-stream-py-sdk/blob/main/LICENSE-APACHE)
file for details.

## Support

- **Issues**: [GitHub Issues](https://github.com/grasp-labs/ds-event-stream-py-sdk/issues)
- **Releases**: [GitHub Releases](https://github.com/grasp-labs/ds-event-stream-py-sdk/releases)
nanobind 2.11.0
nanobind: tiny and efficient C++/Python bindings

![nanobind logo](
https://github.com/wjakob/nanobind/raw/master/docs/images/logo.jpg?raw=True)

_nanobind_ is a small binding library that exposes C++ types in Python and
vice versa. It is reminiscent of
[Boost.Python](https://www.boost.org/doc/libs/1_64_0/libs/python/doc/html)
and [pybind11](http://github.com/pybind/pybind11) and uses near-identical
syntax. In contrast to these existing tools, nanobind is more efficient:
bindings compile in a shorter amount of time, produce smaller binaries, and
have better runtime performance.

More concretely,
[benchmarks](https://nanobind.readthedocs.io/en/latest/benchmark.html) show up
to **~4× faster** compile time, **~5× smaller** binaries, and **~10× lower**
runtime overheads compared to pybind11. nanobind also outperforms Cython in
important metrics (**3-12×** binary size reduction, **1.6-4×** compilation time
reduction, similar runtime performance).

Please see the following links for tutorial and reference documentation in
[HTML](https://nanobind.readthedocs.io/en/latest/) and
[PDF](https://nanobind.readthedocs.io/_/downloads/en/latest/pdf/) formats.
pandaflex 1.0.0
PandaFlex (PFX) - A new efficient data format for pandas
Requires Python: >=3.7

# PandaFlex (PFX) - The Next-Generation Data Format

[![PyPI version](https://badge.fury.io/py/pandaflex.svg)](https://badge.fury.io/py/pandaflex)
[![Python versions](https://img.shields.io/pypi/pyversions/pandaflex.svg)](https://pypi.org/project/pandaflex/)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/yourusername/pandaflex/blob/main/LICENSE)
[![Downloads](https://pepy.tech/badge/pandaflex)](https://pepy.tech/project/pandaflex)

PandaFlex (PFX) is a revolutionary new data format designed specifically for pandas that combines the best features of JSON, CSV, and Parquet while adding unique advantages:

✅ **Human-readable** like JSON and CSV
✅ **Schema-aware** like Parquet
✅ **Columnar storage** for efficient processing
✅ **Type preservation** with automatic inference
✅ **Metadata support** for rich dataset documentation
✅ **Compression-ready** for storage efficiency
✅ **Fast random access** to data
✅ **Pandas native** with seamless integration

## Why PandaFlex?

| Feature          | PFX | JSON | CSV  | Parquet |
|------------------|-----|------|------|---------|
| Human-readable   | ✅  | ✅   | ✅   | ❌      |
| Schema-aware     | ✅  | ❌   | ❌   | ✅      |
| Type preservation| ✅  | ✅   | ❌   | ✅      |
| Columnar storage | ✅  | ❌   | ❌   | ✅      |
| Metadata         | ✅  | ❌   | ❌   | ✅      |
| Compression      | ✅  | ❌   | ❌   | ✅      |
| Random access    | ✅  | ❌   | ❌   | ✅      |
| Pandas native    | ✅  | ❌   | ✅   | ✅      |

## Installation

```bash
pip install pandaflex
rodeo-bufr-tools 0.3.3
Tools for working with JSON-BUFR conversion in the E-SOH proejct.
Requires Python: >=3.11

# E-SOH

## EURODEO

The RODEO project develops a user interface and Application Programming Interfaces (API) for accessing meteorological datasets declared as High Value Datasets (HVD) by the EU Implementing Regulation (EU) 2023/138 under the EU Open Data Directive (EU) 2019/1024. The project also fosters the engagement between data providers and data users for enhancing the understanding of technical solutions being available for sharing and accessing the HVD datasets.
This project provides a sustainable and standardized system for sharing real-time surface weather observations in line with the HVD regulation and WMO WIS 2.0 strategy. The real-time surface weather observations are made available through open web services, so that they can be accessed by anyone.

## Near real-time observational data

E-SOH is part of the RODEO project. The goal for this project is to make near real-time weather observations from land based station easily available. The data will be published on both a message queue using [MQTT](https://mqtt.org/) and [EDR](https://ogcapi.ogc.org/edr/) compliant APIs. Metadata will also be made available through [OGC Records](https://ogcapi.ogc.org/records/) APIs. The system architecture is portable, scalable and modular for taking into account possible future extensions to existing networks and datasets (e.g. 3rd party surface observations).

## RODEO BUFR Tools

This tool handles the BUFR messages:
* ecoding the messages for E-SOH/openradardata ingestion
* providing E-SOH API output in BUFR format

The library suports [ECMWF ecCodes](https://confluence.ecmwf.int/display/ECC), [WMO](https://github.com/wmo-im/BUFR4/) and [OPERA](https://www.eumetnet.eu/observations/weather-radar-network/) BUFR tables.

## Installation

Create virtual environment
```shell
python3 -m venv bufr-venv
```
Activate
```shell
source bufr-venv/bin/activate
```
Install rodeo-bufr-tools
```shell
pip install rodeo-bufr-tools
```
Install BUFR table files:
* WMO(for example version 44)
    ```shell
    wget https://github.com/wmo-im/BUFR4/archive/refs/tags/v44.zip
    unzip v44.zip
    export BUFR_TABLE_DIR=./BUFR4-44/txt/
    ```
* ECMWF Eccodes
    ```shell
    sudo apt install libeccodes-data
    export BUFR_TABLE_DIR=/usr/share/eccodes/definitions/bufr/tables/0/wmo
    ```

## Usage

### Dump BUFR content
```python
from bufr_tools import bufr2tx
msg = bufr2txt.bufr2text(bufr_file_name)
print(msg)

```

### Create E-SOH message(s)

Print E-SOH message
```python
import create_mqtt_message_from_bufr
msg = create_mqtt_message_from_bufr.bufr2mqtt(bufr_file_name)
for m in msg:
  print(m)

```

#### Encode BUFR content from Coverage json
TBD
flask-tabler-icons 3.36.1.20260129
a collection of jinja macros for tabler icons
Requires Python: >=3.8
Keywords: flask_tabler, flask_tabler_icons

# flask-tabler-icons

flask-tabler-icons is a collection of Jinja macros for [tabler-icons](https://tabler-icons.io/) and Flask.

## Installation

```bash
pip install -U flask-tabler-icons
```

## Example (check examples folder for details)

Register the extension:

```python
from flask import Flask
from flask_tabler_icons import TablerIcons

app = Flask(__name__)
tabler_icons = TablerIcons(app)
```

```html

{% from "tabler_icons/helper.html" import render_icon %}

<html>
  <head>
    <!-- css area -->
    <style>
        .custom-css {
          color: red;
        }
    </style>
  </head>
  <body>
    <h2>tabler icon</h2>
    {{ render_icon("helicopter", class="custom-css") }}
    {{ render_icon("helicopter", animation="pulse", color="blue") }}
    {{ render_icon("helicopter", animation="tada", color="blue") }}
    {{ render_icon("helicopter", animation="rotate", color="blue") }}
  </body>
</html>
```
ect 1.2.3
A python package for computing the Euler Characteristic Transform
Requires Python: >=3.10

# `ect`: A python package for computing the Euler Characteristic Transform

Python computation tools for computing the Euler Characteristic Transform of embedded complexes. 

## Description

The package provides fast tools for computing the Euler Characteristic Transform (ECT) on embedded cell complexes in any ambient dimension. You build a complex (vertices, edges, and optional higher‑dimensional cells), choose a set of directions and thresholds, and compute either the exact ECT or its smoothed/differentiable variants. Results come back as NumPy arrays with metadata, plotting helpers, and distance utilities, making it straightforward to visualize transforms and compare shapes. The core is implemented with NumPy and Numba, with optional validation of geometric and structural constraints when constructing complexes.

- `EmbeddedComplex`: convert point clouds into complexes with vertices, edges, and higher‑dimensional cells with embedded coordinates.
- `ECT`, `SECT`, `DECT` : ECT calculations along with the smooth and differentiable variants over sampled directions and transforms.
- `Directions`: uniform, random, or custom directions (angles in 2D; vectors in any dimension)
- Results as `ECTResult`: behaves like a NumPy array, with plotting and distance helpers
- Optional geometric/structural validation when building complexes

For more information on the ECT, see:

>  Munch, Elizabeth. An Invitation to the Euler Characteristic Transform. The American Mathematical Monthly, 132(1), 15-25. [doi:10.1080/00029890.2024.2409616](https://doi.org/10.1080/00029890.2024.2409616). 2024.

## Getting Started

### Documentation and tutorials

- The documentation is available at: [munchlab.github.io/ect](https://munchlab.github.io/ect/)
- A tutorial jupyter notebook can be found [here](https://munchlab.github.io/ect/notebooks/Tutorial-EmbeddedComplex.html)


### Installing

Requires Python 3.10+.

Install from PyPI:

```{bash}
pip install ect
```

Alternatively, you can clone the repo and install directly

```{bash}
git clone git@github.com:MunchLab/ect.git
cd ect
pip install .
```

### Quickstart

Compute an ECT for a simple embedded triangle and plot it.

```python
from ect import ECT, EmbeddedComplex

G = EmbeddedComplex()
G.add_node("a", [0.0, 0.0])
G.add_node("b", [1.0, 0.0])
G.add_node("c", [0.5, 0.8])
G.add_edge("a", "b")
G.add_edge("b", "c")
G.add_edge("c", "a")

ect = ECT(num_dirs=32, num_thresh=128)
result = ect.calculate(G)
result.plot()
```



## Authors

This code was written by [Liz Munch](https://elizabethmunch.com/) along with her research group and collaborators. People who have contributed to `ect` include:

- [Sarah McGuire](https://www.sarah-mcguire.com/)
- [Yemeen Ayub](https://yemeen.com/)
- [Dan Chitwood](https://github.com/DanChitwood)

## License

This project is licensed under the GPLv3 License - see the License file for details

## Contact Information

- Liz Munch: [Website](http://www.elizabethmunch.com), [Email](mailto:muncheli@msu.edu)