semvec/pypi-packages huggingface dataset:
deepset-mcp 0.0.13
Collection of MCP tools and Agents to work with the deepset AI platform. Create, debug or learn about pipelines on the platform. Useable from the CLI, Cursor, Claude Code, or other MCP clients.
Requires Python: >=3.11
Keywords: Agents, Haystack, LLM, MCP, deepset, pipelines

# deepset-mcp

**The official MCP server and Python SDK for the deepset AI platform**

deepset-mcp enables AI agents to build and debug pipelines on the [Haystack Enterprise AI platform](https://www.deepset.ai/products-and-services/deepset-ai-platform) through 30+ specialized tools. It also provides a Python SDK for programmatic access to many platform resources.

## Documentation

📖 **[View the full documentation](https://deepset-ai.github.io/deepset-mcp-server/)**

## Quick Links

- 🔗 **[Haystack Enterprise AI platform](https://www.deepset.ai/products-and-services/deepset-ai-platform)**
- 📚 **[Installation Guide](https://deepset-ai.github.io/deepset-mcp-server/installation/)**
- 🛠️ **[MCP Server Guide](https://deepset-ai.github.io/deepset-mcp-server/guides/mcp_server/)**
- 🐍 **[Python SDK Guide](https://deepset-ai.github.io/deepset-mcp-server/guides/api_sdk/)**

## Development

### Installation

Install the project using [uv](https://docs.astral.sh/uv/):

```bash
# Install uv first
pipx install uv

# Install project with all dependencies
uv sync --locked --all-extras --all-groups
```

### Code Quality & Testing

Run code quality checks and tests using the Makefile:

```bash
# Install dependencies
make install

# Code quality
make lint          # Run ruff linting
make format        # Format code with ruff
make types         # Run mypy type checking

# Testing
make test          # Run unit tests (default)
make test-unit     # Run unit tests only
make test-integration     # Run integration tests
make test-all      # Run all tests

# Clean up
make clean         # Remove cache files
```

### Documentation

Documentation is built using [MkDocs](https://www.mkdocs.org/) with the Material theme:

- Configuration: `mkdocs.yml`
- Content: `docs/` directory
- Auto-generated API docs via [mkdocstrings](https://mkdocstrings.github.io/)
- Deployed via GitHub Pages (automated via GitHub Actions on push to main branch)
tether-references 0.1.0
Tether creates bidirectionally entangled object references
Requires Python: >=3.14

# Tether
Tether is a small python library for managing bidirectionally related  object references.

Thanks to Jeff Kala for coming up with the name, Tether, for this project. I suck at naming things and after a brief description, Jeff came up with the name, and I liked it, so this is now known as Tether. Jeff wins a mention here in the README for his naming cleverness. I'm just glad it came from another "Jeff".

By example, if you have two classes, class A and class B, when you call tether's create_relation() with appropriate arguments, class A and class B will have attributes (actually properties) injected to reference one or more objects of the other type.

The cardinality of the references can be either "one" or "many". If the cardinality of the reference is "many", the resulting attribute will be represented by a set-like object.

More concretely, using one of the classic examples for OOP, if you have a class Car, and a class Engine, assuming a one-to-one relation, when you create_relation() specifying Car and Engine, class Car will gain an attribute engine that will return the associated Engine object, and class Engine will gain an attribute car that will return the associated Car object.

	>>> from tether import create_relation
	>>> 
	>>> class Car:
	...     single='car'
	...     plural='cars'
	...     
	>>> class Engine:
	...     single='engine'
	...     plural='engines'
	...     
	>>> rel_car_engine = create_relation(name='car_engine', a_type=Car,	a_cardinality='one', b_type=Engine, b_cardinality='one')
	>>> car1 = Car()
	>>> engine1 = Engine()
	
	>>> print(car1.engine)
	None
	>>> print(engine1.car)
	None
	
	>>> car1.engine = engine1
	
	>>> print(car1.engine)
	<__main__.Engine object at 0x7cc87a398980>
	>>> print(engine1.car)
	<__main__.Car object at 0x7cc87a398830>
	>>> 

Let's change the Engine to EVMotor, so it makes sense to have a cardinality of "many":

	>>> from tether import create_relation
	>>> class Car:
	...     single='car'
	...     plural='cars'
	...     
	>>> class EVMotor:
	...     single='evmotor'
	...     plural='evmotors'
	...     
	>>> rel_car_evmotor = create_relation(name='car_evmotor', a_type=Car, a_cardinality='one', b_type=EVMotor, b_cardinality='many')
	>>> 
	>>> car1 = Car()
	>>> evmotor1 = EVMotor()
	>>> evmotor2 = EVMotor()
	>>> 
	>>> print(car1.evmotors)
	set()
	>>> print(evmotor1.car)
	None
	>>> print(evmotor2.car)
	None

	>>> evmotor1.car = car1
	
	>>> print(car1.evmotors)
	{<__main__.EVMotor object at 0x7d60c059c980>}
	>>> car1.evmotors.add(evmotor2)
	>>> print(car1.evmotors)
	{<__main__.EVMotor object at 0x7d60c059c980>, 	<__main__.EVMotor object at 0x7d60c06e6ad0>
	>>> evmotor2.car
	<__main__.Car object at 0x7d60c059c830>

You can see that the "many" cardinality relation behaviors (mostly) as a set (at the time of this writing, not all set methods are implemented), but the bidirectional relationship is maintained.

## Motivation
See [Motivation.md](Motivation.md)
Glymur 0.14.7
Read and write JPEG 2000 files
Requires Python: >=3.11
Keywords: JPEG2000, JPEG, 2000, imagery

glymur: a Python interface for JPEG 2000
=========================================

**glymur** contains a Python interface to the OpenJPEG library which
allows one to read and write JPEG 2000 files.  **glymur** works on
Python 3.11, 3.12, and 3.13.

Please read the docs, https://glymur.readthedocs.org/en/latest/
polycubetools 1.1.2
Basic framework for working with polycubes in a 3-dimensional grid.
Requires Python: >=3.12

# polycube-framework

### Workflows

These are **only** available on github, not locally

1. lint workflow (runs automatically on PR, required for merging in main:
    - runs pyright with the config in pyproject.toml (pyright strict)
    - runs `black --check --line-length 120 "./src/polycubetools"`
2. format workflow (can be run manually)
    - runs `black --line-length 120 "./src/polycubetools"`
    - commits and push to the chosen branch

### Recommendations

1. PyCharm IDE
    - EAP (EARLY ACCESS PRODUCT) version: has pyright and black tools integrated
    - alternatively: `pip install pyright black`

### Getting started

1. Have a look at pyproject.toml
2. Configure a virtual environment (use python `>=3.12`)
3. For quick testing, feel free to create a script in `scripts/`
cli-todo-jd 0.3.0
Add your description here
Requires Python: >=3.10

# cli-todo-jd

A command line to do list with interactive menu

## What is`cli-todo-jd`?

This is a command line interface todo list. Once installed, there are two ways to interact 
with the list stored as a sqlite database 

### `todo menu`

Once installed use `todo menu` to launch into the interactive menu. From here you can add,
remove, list, or clear your todo list. Items in your list are stored (by default) as
`.todo_list.db`. The menu does also support optional filepaths using `-f` or `--filepath`.

### `todo web`

Once installed use `todo web` to launch into the interactive web UI. From here you can add,
remove, list, or clear your todo list. Items in your list are stored (by default) as
`.todo_list.db`. The menu does also support optional filepaths using `-f` or `--filepath`.


### interacting with todo list without menu

Alternately you can interact directly using the following commands (`--filepath can be substituted for -f`)

- `todo add text --filepath optional_path_to_json` used to add an item to your list
- `todo remove index --filepath optional_path_to_json` used to remove item number `index`
- `todo list --filepath optional_path_to_json` used to view list
- `todo clear --filepath optional_path_to_json` used to clear list (prompts y/n to confirm)

## Getting started

To start using this project, first make sure your system meets its
requirements.

It's suggested that you install this package and its requirements within
a virtual environment.

## Requirements

- Python 3.9+ installed

## Installing the package

Whilst in the root folder, in a terminal, you can install the package and its
Python dependencies using:

```shell
python -m pip install -U pip setuptools
pip install -e .
```

### Install for contributors/developers

To install the contributing requirements, use:
```shell
python -m pip install -U pip setuptools
pip install -e .[dev]
pre-commit install
```

This installs an editable version of the package. This means that when you update the
package code you do not have to reinstall it for the changes to take effect.
This saves a lot of time when you test your code.

Remember to update the setup and requirement files inline with any changes to your
package.


## Licence

Unless stated otherwise, the codebase is released under the MIT License. This covers
both the codebase and any sample code in the documentation.

## Contributing

If you want to help us build and improve `{{ cookiecutter.project_slug }}`, please take a look at our
[contributing guidelines][contributing].

## Acknowledgements

This project structure is based on the [`govcookiecutter` template project][govcookiecutter].

[contributing]: https://github.com/best-practice-and-impact/govcookiecutter/blob/main/%7B%7B%20cookiecutter.repo_name%20%7D%7D/docs/contributor_guide/CONTRIBUTING.md
[govcookiecutter]: https://github.com/best-practice-and-impact/govcookiecutter
py-jama-client 0.4.3
Python client library for Jama Connect
Requires Python: >=3.11

[![PyPI version](https://badge.fury.io/py/py-jama-client.svg)](https://badge.fury.io/py/py-jama-client)
# py_jama_client

A python Jama Connect REST API client library

## Acknowledgments

This client library is heavily inspired by, and even based on the client library created by the Jama team [py-jama-rest-client](https://github.com/jamasoftware-ps/py-jama-rest-client). However, due to inactivity I have taken it upon myself to create a distinct package for those who have a need for a more comprehensive client -- specifically for the use of embedded resources.

## Jama Software

Jama Software is the definitive system of record and action for product development. The company’s modern requirements and test management solution helps enterprises accelerate development time, mitigate risk, slash complexity and verify regulatory compliance. More than 600 product-centric organizations, including NASA, Boeing and Caterpillar use Jama to modernize their process for bringing complex products to market. The venture-backed company is headquartered in Portland, Oregon. For more information, visit jamasoftware.com.

Please visit dev.jamasoftware.com for additional resources and join the discussion in our community community.jamasoftware.com.

### Requirements

* [Python 3.11 or greater](https://www.python.org/downloads/release/python-372/)

### Installation

```bash
pip install py-jama-client
```

### Usage

#### Basic

```python
from py_jama_client.client import JamaClient # import client
from py_jama_client.apis.abstract_items_api import AbstractItemsAPI # import API

client = JamaClient(
    host="example.jamacloud.com", 
    credentials=("my_username", "my_password"),
) # create client instance

abstract_items_api = AbstractItemsAPI(client) # pass client instance to API

abstract_items = abstract_items_api.get_abstract_items() # use API methods to fetch resources

print(abstract_items.data)
```

#### With Links

```python
from py_jama_client.client import JamaClient # import client
from py_jama_client.apis.items_api import ItemsAPI # import API

client = JamaClient(
    host="example.jamacloud.com", 
    credentials=("my_username", "my_password"),
) # create client instance

items_api = ItemsAPI(client) # pass client instance to API

items = items_api.get_items(
    project_id=82, 
    params={'include': ('data.itemType', 'data.childItemType', )}, 
    # NOTE: 'params' must be a key-word argument
) # use API methods to fetch resources, include itemTypes, and childItemTypes in response

print(items.data, items.linked)
```

### Additional Notes

Please be aware that this package is a work-in-progress, and some API methods may be missing from the source code. Please open an issue, or submit a pull-request (see CONTRIBUTING.md for more).
clickhouse-orm 3.2.0
A simple ORM for working with the Clickhouse database. Maintainance fork of infi.clickhouse_orm.

A fork of [infi.clikchouse_orm](https://github.com/Infinidat/infi.clickhouse_orm) aimed at more frequent maintenance and bugfixes.

[![Tests](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml/badge.svg)](https://github.com/SuadeLabs/clickhouse_orm/actions/workflows/python-test.yml)
![PyPI](https://img.shields.io/pypi/v/clickhouse_orm)

Introduction
============

This project is simple ORM for working with the [ClickHouse database](https://clickhouse.yandex/).
It allows you to define model classes whose instances can be written to the database and read from it.

Let's jump right in with a simple example of monitoring CPU usage. First we need to define the model class,
connect to the database and create a table for the model:

```python
from clickhouse_orm import Database, Model, DateTimeField, UInt16Field, Float32Field, Memory, F

class CPUStats(Model):

    timestamp = DateTimeField()
    cpu_id = UInt16Field()
    cpu_percent = Float32Field()

    engine = Memory()

db = Database('demo')
db.create_table(CPUStats)
```

Now we can collect usage statistics per CPU, and write them to the database:

```python
import psutil, time, datetime

psutil.cpu_percent(percpu=True) # first sample should be discarded
while True:
    time.sleep(1)
    stats = psutil.cpu_percent(percpu=True)
    timestamp = datetime.datetime.now()
    db.insert([
        CPUStats(timestamp=timestamp, cpu_id=cpu_id, cpu_percent=cpu_percent)
        for cpu_id, cpu_percent in enumerate(stats)
    ])
```

Querying the table is easy, using either the query builder or raw SQL:

```python
# Calculate what percentage of the time CPU 1 was over 95% busy
queryset = CPUStats.objects_in(db)
total = queryset.filter(CPUStats.cpu_id == 1).count()
busy = queryset.filter(CPUStats.cpu_id == 1, CPUStats.cpu_percent > 95).count()
print('CPU 1 was busy {:.2f}% of the time'.format(busy * 100.0 / total))

# Calculate the average usage per CPU
for row in queryset.aggregate(CPUStats.cpu_id, average=F.avg(CPUStats.cpu_percent)):
    print('CPU {row.cpu_id}: {row.average:.2f}%'.format(row=row))
```

This and other examples can be found in the `examples` folder.

To learn more please visit the [documentation](docs/toc.md).
tinyercot 0.1.0
Tiny fully-typed ERCOT API
Requires Python: >=3.11

# tinyercot

Fully-typed Python client for the ERCOT Public API.

**Why tiny?** The entire hand-written codebase is ~420 lines. Everything else is auto-generated from ERCOT's OpenAPI spec.

## Install

```bash
uv add tinyercot
```

## Setup

```bash
export ERCOT_USERNAME="your-username"
export ERCOT_PASSWORD="your-password"
export ERCOT_SUBSCRIPTION_KEY="your-subscription-key"
```

## Usage

### Single Page

```python
from datetime import date
import tinyercot

# Returns typed response with .data, .meta, .links
response = tinyercot.np4_190_cd.dam_stlmnt_pnt_prices(
    deliveryDateFrom=date(2025, 12, 29),
    settlementPoint="HB_HOUSTON",
)

# Convert to pandas DataFrame
df = response.to_df()
```

### Pagination (Sync)

```python
# Iterator - yields typed rows from all pages
for row in tinyercot.np4_190_cd.dam_stlmnt_pnt_prices_iter(
    deliveryDateFrom=date(2025, 12, 29),
):
    print(row.settlementPoint, row.settlementPointPrice)

# DataFrame - fetches all pages, returns single DataFrame
df = tinyercot.np4_190_cd.dam_stlmnt_pnt_prices_df(
    deliveryDateFrom=date(2025, 12, 29),
)
```

### Pagination (Async + Rate Limited)

Async methods automatically rate-limit to 20 req/min with retry on 429:

```python
import asyncio
import tinyercot

async def main():
    # Async iterator - rate-limited, non-blocking
    async for row in tinyercot.np4_190_cd.dam_stlmnt_pnt_prices_iter_async(
        deliveryDateFrom=date(2025, 12, 29),
    ):
        print(row.settlementPoint, row.settlementPointPrice)

    # Async DataFrame - rate-limited, non-blocking
    df = await tinyercot.np4_190_cd.dam_stlmnt_pnt_prices_df_async(
        deliveryDateFrom=date(2025, 12, 29),
    )

asyncio.run(main())
```

## API Pattern

Every endpoint generates 5 methods:

| Method | Returns | Use Case |
|--------|---------|----------|
| `endpoint()` | `Response` | Single page |
| `endpoint_iter()` | `Iterator[Row]` | Stream all pages (sync) |
| `endpoint_df()` | `DataFrame` | All pages as DataFrame (sync) |
| `endpoint_iter_async()` | `AsyncIterator[Row]` | Stream all pages (async, rate-limited) |
| `endpoint_df_async()` | `DataFrame` | All pages as DataFrame (async, rate-limited) |

## Development

Create a `.env` file with your credentials, then run IPython with dev deps:

```bash
uv run --env-file .env --group dev -- ipython
```

## Regenerate

```bash
uv run python tools/generate_client.py
```

With fresh response field data (requires credentials):

```bash
uv run --env-file .env python tools/generate_client.py --refresh
```