semvec/pypi-packages huggingface dataset:
otcdocstheme 1.14.2
T Cloud Public Docs Theme
Requires Python: >=3.6

========================
Team and repository tags
========================

.. image:: https://governance.openstack.org/tc/badges/openstackdocstheme.svg
    :target: https://governance.openstack.org/tc/reference/tags/index.html

.. Change things from this point on

T Cloud Public docs Sphinx Theme
================================

Theme and extension support for Sphinx documentation.

Intended for use by T Cloud Public `projects`.

..  `projects`: https://github.com/OpenTelekomCloud

* Free software: Apache License, Version 2.0
* Source: https://github.com/OpenTelekomCloud/otcdocstheme
binaryrain-helper-data-processing 1.1.1
Aims to simplify and help with commonly used functions in the data processing areas.
Requires Python: >=3.12
Keywords: binary rain, common, help, functions, data processing, dataframe

# Binary Rain Helper Toolkit: Data Processing

`binaryrain_helper_data_processing` is a python package that aims to simplify and help with common functions data processing areas. It builds on top of the `pandas` library and provides additional functionality to make data processing easier, reduces boilerplate code and provides clear error messages.

For further details, please refer to the [Binary Rain Helper Toolkit documentation](https://binaryrain-net.github.io/Binary-Rain-Helper-Toolkit/toolkits/dataframe/).

## Benefits

- Consistent interface for different file formats
- Simplified error handling with clear messages
- Optional format-specific configurations
- Built on pandas for robust data processing
- Type hints for better IDE support
binaryrain-helper-cloud-aws 1.0.13
Aims to simplify and help with commonly used functions in the aws cloud data areas.
Requires Python: >=3.12
Keywords: binary rain, common, help, functions, aws

# Binary Rain Helper Toolkit: AWS Cloud

`binaryrain_helper_cloud_aws` is a python package that aims to simplify and help with common functions in AWS Cloud areas. It builds on top of the `boto3` and `aws-lambda-powertools` libraries and provides additional functionality to make working with AWS Cloud easier, reduces boilerplate code and provides clear error messages.

For further details, please refer to the [Binary Rain Helper Toolkit documentation](https://binaryrain-net.github.io/Binary-Rain-Helper-Toolkit/toolkits/aws/).

## Benefits

- Consistent error handling with clear messages
- Input validation for all function parameters
- Simplified authentication and access to AWS services
- Secure handling of secrets and sensitive information
- Type hints for better IDE support
binaryrain-helper-cloud-dataverse 1.0.3
Aims to simplify and help with connecting to and using Microsoft Dataverse.
Requires Python: >=3.12
Keywords: binary rain, common, help, dataverse, microsoft dataverse

# Binary Rain Helper Toolkit: Dataverse Helper

`binaryrain_helper_cloud_dataverse` is a python package that aims to simplify and help with connecting to and using Microsoft Dataverse. It handles common operations like retrieving, creating, updating, and deleting records in a Dataverse environment. With the help of sessions it maintains a consistent connection to the Dataverse API, ensuring efficient and reliable data operations without the need for repetitive code when pagination is required.

For further details, please refer to the [Binary Rain Helper Toolkit documentation](https://binaryrain-net.github.io/Binary-Rain-Helper-Toolkit/toolkits/dataverse/).

## Benefits

- **Simplified API Interaction**: Provides a straightforward interface for common Dataverse operations.
- **Session Management**: Automatically handles session creation and management, reducing boilerplate code.
- **Error Handling**: Includes basic error handling for common issues like missing data or request failures.
- **Pagination Support**: Automatically handles pagination for GET requests, making it easier to work with large datasets.
binaryrain-helper-cloud-azure 1.0.10
Aims to simplify and help with commonly used functions in the azure cloud data areas.
Requires Python: >=3.12
Keywords: binary rain, common, help, functions, azure

# Binary Rain Helper Toolkit: Azure Cloud

`binaryrain_helper_cloud_azure` is a python package that aims to simplify and help with common functions in Azure Cloud areas. It builds on top of the `azure` library and provides additional functionality to make working with Azure Cloud easier, reduces boilerplate code and provides clear error messages.

For further information, please refer to the [Binary Rain Helper Toolkit documentation](https://binaryrain-net.github.io/Binary-Rain-Helper-Toolkit/toolkits/azure/).
django-treebeard 5.0.5
Efficient tree implementations for Django
Requires Python: >=3.10

# django-treebeard

**django-treebeard** is a library that implements efficient tree implementations for the Django Web Framework.

It was written by Gustavo Picón and licensed under the Apache License 2.0.

## Status

[![Documentation Status](https://readthedocs.org/projects/django-treebeard/badge/?version=latest)](https://django-treebeard.readthedocs.io/en/latest/?badge=latest)
[![Tests](https://github.com/django-treebeard/django-treebeard/actions/workflows/test.yml/badge.svg)]()
[![PyPI](https://img.shields.io/pypi/pyversions/django-treebeard.svg)]()
![PyPI - Django Version](https://img.shields.io/pypi/frameworkversions/django/django-treebeard.svg)
[![PyPI version](https://img.shields.io/pypi/v/django-treebeard.svg)](https://pypi.org/project/django-treebeard/)


## Features

django-treebeard is:

-   **Flexible**: Includes 3 different tree implementations with the
    same API:
    1.  Adjacency List
    2.  Materialized Path
    3.  Nested Sets
    4.  PostgreSQL ltree (experimental)
-   **Fast**: Optimized non-naive tree operations
-   **Easy**: Uses Django Model Inheritance with abstract classes to
    define your own models.
-   **Clean**: Testable and well tested code base. Code/branch test
    coverage is above 96%.

You can find the documentation at <https://django-treebeard.readthedocs.io/en/latest/>

### Supported versions

**django-treebeard** officially supports

-   Django 5.2 and higher
-   Python 3.10 and higher
-   PostgreSQL, MySQL, MSSQL, SQLite database back-ends.
laituri 0.5.0
Docker Toolkit for Python
Requires Python: >=3.8

# laituri — Docker Toolkit for Python

[![CI](https://github.com/valohai/laituri/actions/workflows/ci.yml/badge.svg)](https://github.com/valohai/laituri/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/valohai/laituri/branch/master/graph/badge.svg)](https://codecov.io/gh/valohai/laituri)

`laituri` is a set of Docker-related Python snippets used at [Valohai](https://valohai.com/).
You can use it with Python >= 3.8.

## Usage

### Configuration

You can configure your used Docker command if it is not the default `docker`, using laituri settings.

_Example:_

```
laituri.settings.DOCKER_COMMAND = 'docker'
```

### Docker Credential Manager

Laituri contains a docker credentials manager which can be used for example when pulling images.
It logs in and out using the Docker CLI.

_Example:_

```
from laituri.docker.credential_manager import get_credential_manager

my_credentials = {
    'username': 'SmolShark1',
    'password': 'sharksWithLazers',
}

with get_credential_manager(
    image='python:latest',
    registry_credentials=my_credentials,
    log_status=print  # Any callable
):
    # Do your docker things!
```

## Development

Installing editable library version in the current virtual environment.

```bash
# install this package and all development dependencies
pip install -e .[dev] pre-commit && pre-commit install

# manually run lint and type checks
pre-commit run --all-files

# manually run tests
pytest --cov

python
>>> import laituri; print(laituri.__version__)
```

## Making a Release

A new release build is released by the CI when a new tag is pushed to the repository:

```bash
# bump version number in "laituri/__init__.py"
vim laituri/__init__.py

# pushing a new tag will trigger a new release build
git add .
git commit -m "Become to X.Y.Z"
git tag -a vX.Y.Z -m "Version X.Y.Z"
git push --follow-tags
```

If a manual release is needed, you can follow up the above steps with:

```bash
pip install build twine
git clean -fdx -e .idea/
python -m build .
twine upload dist/*
```
chad-ai 0.11.0
Chad: YOLO AI
Requires Python: >=3.8

# Chad: YOLO AI

Coding agents need hand holding to implement complex features, but no one holds Chad's hand. 

Add one or more OpenAI Codex, Claude Code, Google Gemini, Alibaba Qwen, Mistral Vibe, Moonshot Kimi, or OpenCode coding 
agents, decide what happens when you reach a limit (wait for the reset and continue, switch provider), ask for a coding 
task, and Chad will ralph loop to deliver a one-shot result.

<p style="text-align: center;">
  <img src="docs/Chad.png" alt="Chad Code" width="80">
</p>

**The First Warning:** Chad was developed with...  Chad. Yes, this material writes itself. No, high quality robust code 
this is not. 

**World Warning II:** Chad is a risk-taker who knows no limits. Chad runs agents in YOLO mode and has access to 
everything on your hard drive and your internet connection.

### Blah blah how do I run it?
```bash
pip install chad-ai
chad 
```

### How is this better than $Grug?

Chad provides a Gradio UI to switch between coding agents (tokens encrypted with a master password you create and 
provide for each session), monitors usage quotas, switches between providers, is able to communicate via slack, 
and runs multiple tasks in parallel with result merging from their worktrees:
<details open>
<summary><b>Screenshots</b></summary>

#### Select coding and verification agents for a task
<img src="docs/screenshot-task-input.png" width="800" alt="Task input panel">

#### Monitor provider accounts with usage tracking
<img src="docs/screenshot-providers.png" width="800" alt="Providers tab with usage">

#### Configure rules to switch providers or wait for usage resets
<img src="docs/screenshot-settings.png" width="800" alt="Action rules configuration">

</details>

### Is this satire? What are you even doing here?

¯\_(ツ)_/¯
wagtail-content-import 0.13.2
A module for Wagtail that provides functionality for importing page content from third-party sources.
Requires Python: >=3.9
Keywords: Wagtail, Django, content import, Google Docs, OneDrive, SharePoint, docx

![Wagtail Content Import](docs/img/wagtail_content_import_logo_with_text.svg)

[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD--3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![PyPI version](https://img.shields.io/pypi/v/wagtail-content-import.svg?style=flat)](https://pypi.org/project/wagtail-content-import)
[![Build status](https://img.shields.io/github/actions/workflow/status/torchbox/wagtail-content-import/test.yml?branch=main)](https://github.com/torchbox/wagtail-content-import/actions)

Wagtail Content Import is a module for importing page content into Wagtail from third-party sources.
Page content is imported into a StreamField, using a set of customisable mappings.
Currently, it supports:

### As sources:
- Google Docs
- OneDrive/SharePoint

### As files:
- Google Docs documents with:
    - Rich text
    - Tables
    - Images
    - Headings
- Docx files with:
    - Text with bold and italics
    - Headings

### Requirements:
* Python >= 3.9
* Django >= 4.2
* Wagtail >= 6.3

For the full documentation, see: https://torchbox.github.io/wagtail-content-import/

### Note for Google Import

If using Google Docs import, for users to authenticate with Google they must either allow third party cookies or add `accounts.google.com` to their allowed domains ([Settings/Privacy and Security/Cookies and other site data in Chrome](chrome://settings/cookies) or [Preferences/Privacy & Security in Firefox](about:preferences#privacy)).
pydantic-settings 2.13.1
Settings management using Pydantic
Requires Python: >=3.10

# pydantic-settings

[![CI](https://github.com/pydantic/pydantic-settings/actions/workflows/ci.yml/badge.svg?event=push)](https://github.com/pydantic/pydantic-settings/actions/workflows/ci.yml?query=branch%3Amain)
[![Coverage](https://codecov.io/gh/pydantic/pydantic-settings/branch/main/graph/badge.svg)](https://codecov.io/gh/pydantic/pydantic-settings)
[![pypi](https://img.shields.io/pypi/v/pydantic-settings.svg)](https://pypi.python.org/pypi/pydantic-settings)
[![license](https://img.shields.io/github/license/pydantic/pydantic-settings.svg)](https://github.com/pydantic/pydantic-settings/blob/main/LICENSE)
[![downloads](https://static.pepy.tech/badge/pydantic-settings/month)](https://pepy.tech/project/pydantic-settings)
[![versions](https://img.shields.io/pypi/pyversions/pydantic-settings.svg)](https://github.com/pydantic/pydantic-settings)

Settings management using Pydantic.

See [documentation](https://docs.pydantic.dev/latest/concepts/pydantic_settings/) for more details.
deen-api-client 1.1.0
Python client for Deen API from Imaniro- Access authentic hadith collections.
Requires Python: >=3.7
Keywords: islamic, sunnah, bukhari, api, hadiths, quran, dua, muslim, daily hadiths

# Deen API Python Client

A Python client for the Deen API, providing easy access to Islamic resources including Hadith, Quran verses, and Duas.

## Installation

```bash
pip install deen-api-client
```

# Quick Start

```python
from deen_api import ImaniroDeenAPIClient

# Initialize client with your API key
client = ImaniroDeenAPIClient(api_key="sk_12345")

# Get hadiths from Sahih al-Bukhari
hadiths = client.get_hadiths(book="Sahih al-Bukhari", max_limits=5)

for hadith in hadiths:
    print(f"Book: {hadith.book}")
    print(f"Chapter: {hadith.chapter}")
    print(f"Text: {hadith.text}")
    print(f"Translation: {hadith.translation}")
    print("---")

# Get Quran verses
verses = client.get_quran_verses(surah="Al-Fatiha", max_limits=3)

# Get Duas
duas = client.get_duas(category="morning", max_limits=5)
```

# Features

- Hadith Access: Retrieve hadiths from various books

- Quran Verses: Access Quranic verses with translations(under development)

- Islamic Duas: Get supplications for various occasions(under development)

- Error Handling: Comprehensive exception handling

# Error Handling

The client provides specific exception types:

```python
from deen_api import AuthenticationError, RateLimitError, NotFoundError

try:
    hadiths = client.get_hadiths(book="Sahih al-Bukhari")
except AuthenticationError:
    print("Invalid API key")
except RateLimitError:
    print("Rate limit exceeded")
except NotFoundError:
    print("Resource not found")
```

## Example Usage Files

### `examples/hadith_example.py`

```python
from deen_api import ImaniroDeenAPIClient

def hadith_example():
    client = ImaniroDeenAPIClient(api_key="sk_12345")

    try:
        # Get hadiths from Sahih al-Bukhari
        hadiths = client.get_hadiths(book="Sahih al-Bukhari", max_limits=3)

        print("Hadiths from Sahih al-Bukhari:")
        for i, hadith in enumerate(hadiths, 1):
            print(f"\n{i}. {hadith.hadith}")
            print(f"Translation: {hadith.translation}")
            print("-" * 50)

    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    hadith_example()
```
pym2v 0.2.0
Python wrapper to interact with the Eurogard m2v IoT platform
Requires Python: <3.14,>=3.12
Keywords: eurogard, m2v, iot, iiot, api

# pym2v

![CI](https://github.com/bytecaretech/pym2v/actions/workflows/ci.yml/badge.svg)
![Docs](https://github.com/bytecaretech/pym2v/actions/workflows/docs.yml/badge.svg)
![PyPI](https://img.shields.io/pypi/v/pym2v)

Python wrapper to interact with [m2v][1] industrial IoT platform from [Eurogard][2].

## Prerequisites

- Python 3.12+
- Programmatic access to the Eurogard API

## Installation

pym2v is available as a Python package and can be installed via pip or [uv][3].

### Via pip

1. Create a virtual environment: `python3 -m venv .venv`
1. Activate the virtual environment: `source .venv/bin/active`
1. Install pym2v via pip: `pip install pym2v`

### Via uv

1. Install pym2v via uv: `uv add pym2v`

## Configuration

To authenticate with the Eurogard API, you need to provide the following credentials:

- Username
- Password
- Client ID
- Client Secret

You can do this either by using an `.env` file or by setting environment variables directly.

### Using an .env file

Rename the `.env.example` at the root of the project to `.env`, and replace the placeholder values with your actual credentials.

```
EUROGARD_BASEURL=https://eurogard.cloud
EUROGARD_USERNAME=your_username_here
EUROGARD_PASSWORD=your_password_here
EUROGARD_CLIENT_ID=your_client_id_here
EUROGARD_CLIENT_SECRET=your_client_secret_here
```

## Usage

Import the `EurogardAPI` object and create an instance of it

```python
from datetime import datetime, timedelta

from pym2v.api import EurogardAPI


api = EurogardAPI()
```

Retrieve a list of machines

```python
machines = api.get_machines()
```

Get the UUID of the machine your are interested in

```python
MACHINE_NAME = "1337Machine"

machine_uuid = api.get_machine_uuid(MACHINE_NAME, machines)
```

Get the names of measurements for which you like to pull data

```python
result = api.get_machine_measurement_names(machine_uuid)
```

Turn the data returned by the API into a DataFrame for easier handling

```python
import polars as pl

measurement_names_df = pl.DataFrame(result["entities"])
```

Get actual data

```python
START_DATE = datetime(2025, 1, 1)
END_DATE = datetime(2025, 1, 13)
INTERVAL = timedelta(seconds=60)
MAX_FRAME_LENGTH = timedelta(days=30)
NAMES = [col.strip() for col in measurement_names_df.get_column("name").to_list()]

data_df = api.get_long_frame_from_names(
    machine_uuid=machine_uuid,
    names=NAMES,
    start=START_DATE,
    end=END_DATE,
    interval=INTERVAL,
    max_frame_length=MAX_FRAME_LENGTH,
)
```

## Contributing

Check out [CONTRIBUTING.md](CONTRIBUTING.md) for further information.


[1]: https://eurogard.de
[2]: https://eurogard.de/software/m2v/
[3]: https://docs.astral.sh/uv/
numgrids 0.4.0
Working with numerical grids made easy.
Requires Python: >=3.10

<h1 align="center">numgrids</h1>
<p align="center"> Working with numerical grids made easy.</p>

**Main Features**

- Quickly define numerical grids for any rectangular or curvilinear coordinate system
- Differentiation and integration
- Interpolation
- Easy manipulation of meshed functions
- Using high precision spectral methods (FFT + Chebyshev) wherever possible
- Fully compatible with *numpy*

## Installation

```shell
pip install numgrids
```

## Quick Start

To get started, have a look at the <a href="https://github.com/maroba/numgrids">quick start</a>.