semvec/pypi-packages huggingface dataset:
jinny 2.3.1
A practical templating tool for Jinja templates
Requires Python: >=3.6
Keywords: jinja, template, jinja2, kubernetes, cli

<p align="center">
  <img width="317" height="500" src="https://github.com/smashthings/jinny/blob/master/docs/img/logo.png?raw=true">
</p>

# jinny

Jinny is a templating tool for jinja templates. It can be used for a number of things but was created from a DevOps perspective to aid in configuration management for scaled deployments instead of using tools like Helm, Kustomize, jinja-cli, etc. These days jinny is still used for Ops work but is also used for live applications handling email templating, static HTML generation and more


## CLI Usage Examples

```

=> Templating multiple templates with a single input file:
$ jinny -t template-1.txt template-2.txt -i inputs.yml

=> Templating any number of templates with two input files where base-values.yml provides all the base values and any values in overrides.json acts as an override:
$ jinny -t template.yml -i base-values.yml overrides.json

=> Use an environment value file for templating
$ jinny -t template.yml -i ENVIRONMENT_VARIABLES.env

=> Add an explicit override via CLI argument -e
$ jinny -t template.yml -i base-values.yml -e 'image=smasherofallthings/flask-waitress:latest'

=> Add even more overrides via environment variables, so your pipelines can completely replace any bad value:
$ JINNY_overridden_value="top-priority" jinny -t template.yml -i base-values.yml overrides.json

=> Pump all your files to a single stdout stream with a separator so different files are clearly marked:
$ jinny -t template-1.yml template-2.yml -i inputs.json -s '---'

=> Dump all your templated files into a directory for capture, comparison and deployment
$ jinny -t template-1.yml template-2.yml -i inputs.json -d /path/to/directory
$ kubectl diff -f /path/to/directory
$ kubectl apply --server-dry-run -f /path/to/directory

=> Pipe jinny to kubectl directly
$ jinny -t template-1.yml -i inputs.json | kubectl apply -f -

```

## Documentation

Jinny has a lot of functionality, settings and more. You can review the documentation at - [https://jinny.southall.solutions](https://jinny.southall.solutions).

The documentation is a single HTML page built with Jinny. The source code for the site is at `docs/*` and contains:

- The main `index.html` page
- `docs/inputs/*` - containing `yml` files that cover separate content and configuration
- `docs/partials/*` - covering separate HTML parials which jinny collates into the single page
- `docs/css/*` && `docs/js/*` - static files that jinny dynamically loads in a build time with the templating provided at `index.html`
- `docs/img/*` - static images that jinny reads, base64 encodes and integrates directly into the HTML
- All the other frontend stuff

The directory tree is as standard as you can expect, but with jinny's features the whole functionality is compiled and deployed into a single HTML page.
supabase-functions 2.28.0
Library for Supabase Functions
Requires Python: >=3.9

# Functions-py

## Installation
The package can be installed using pip, uv or poetry:
### Pip
```bash
pip install supabase_functions
```
### UV
```bash
uv add supabase_functions
```
### Poetry
```bash
poetry add supabase_functions
```

## Usage

Deploy your Edge Function following the [Supabase Functions documentation](https://supabase.com/docs/guides/functions).


### Asynchronous Client

```python
import asyncio
from supabase_functions import AsyncFunctionsClient

async def run_func():
    # Initialize the client with your project URL and optional headers
    headers = {
        "Authorization": "Bearer your-anon-key",
        # Add any other headers you might need
    }
    
    fc = AsyncFunctionsClient("https://<project_ref>.functions.supabase.co", headers)
    
    try:
        # Invoke your Edge Function
        res = await fc.invoke("payment-sheet", {
            "responseType": "json",
            "body": {"amount": 1000, "currency": "usd"}
        })
        print("Response:", res)
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    asyncio.run(run_func())
```
### Synchronous Client
```python
from supabase_functions import SyncFunctionsClient

# Initialize the client
headers = {"Authorization": "Bearer your-anon-key"}
fc = SyncFunctionsClient("https://<project_ref>.functions.supabase.co", headers)

# Invoke your Edge Function
try:
    res = fc.invoke("payment-sheet", {
        "responseType": "json", 
        "body": {"amount": 1000, "currency": "usd"}
    })
    print("Response:", res)
except Exception as e:
    print(f"Error: {e}")
```
storage3 2.28.0
Supabase Storage client for Python.
Requires Python: >=3.9

# Storage-py

Python Client library to interact with Supabase Storage.

## How to use

As it takes some effort to get the headers. We suggest that you use the storage functionality through the main [Supabase Python Client](https://github.com/supabase-community/supabase-py)


```python3
from storage3 import AsyncStorageClient

url = "https://<your_supabase_id>.supabase.co/storage/v1"
key = "<your api key>"
headers = {"apiKey": key, "Authorization": f"Bearer {key}"}

storage_client = AsyncStorageClient(url, headers)

async def get_buckets():
  await storage_client.list_buckets()
```

### Uploading files
When uploading files, make sure to set the correct mimetype by using the `file_options` argument:
```py
async def file_upload():
  await storage_client.from_("bucket").upload("/folder/file.png", file_object, {"content-type": "image/png"})
```
If no mime type is given, the default `text/plain` will be used.
postgrest 2.28.0
PostgREST client for Python. This library provides an ORM interface to PostgREST.
Requires Python: >=3.9

# postgrest-py

[PostgREST](https://postgrest.org) client for Python. This library provides an "ORM-like" interface to PostgREST.

## INSTALLATION

### Requirements

- Python >= 3.9
- PostgreSQL >= 13
- PostgREST >= 11

### Local PostgREST server

If you want to use a local PostgREST server for development, you can use our preconfigured instance via Docker Compose.

```sh
docker-compose up
```

Once Docker Compose started, PostgREST is accessible at <http://localhost:3000>.

### Instructions

#### With uv (recommended)

```sh
uv add postgrest
```

#### With Pip

```sh
pip install postgrest
```

## USAGE

### Getting started

```py
import asyncio
from postgrest import AsyncPostgrestClient

async def main():
    async with AsyncPostgrestClient("http://localhost:3000") as client:
        r = await client.from_("countries").select("*").execute()
        countries = r.data

asyncio.run(main())
```

### Create

```py
await client.from_("countries").insert({ "name": "Việt Nam", "capital": "Hà Nội" }).execute()
```

### Read

```py
r = await client.from_("countries").select("id", "name").execute()
countries = r.data
```

### Update

```py
await client.from_("countries").update({"capital": "Hà Nội"}).eq("name", "Việt Nam").execute()
```

### Delete

```py
await client.from_("countries").delete().eq("name", "Việt Nam").execute()
```

### General filters

### Stored procedures (RPC)
```py
await client.rpc("foobar", {"arg1": "value1", "arg2": "value2"}).execute()
```

## CHANGELOG

Read more [here](https://github.com/supabase/postgrest-py/blob/main/CHANGELOG.md).

## SPONSORS

We are building the features of Firebase using enterprise-grade, open source products. We support existing communities wherever possible, and if the products don’t exist we build them and open source them ourselves. Thanks to these sponsors who are making the OSS ecosystem better for everyone.

[![Worklife VC](https://user-images.githubusercontent.com/10214025/90451355-34d71200-e11e-11ea-81f9-1592fd1e9146.png)](https://www.worklife.vc)
[![New Sponsor](https://user-images.githubusercontent.com/10214025/90518111-e74bbb00-e198-11ea-8f88-c9e3c1aa4b5b.png)](https://github.com/sponsors/supabase)
octodns-exoscale 0.1.0
Exoscale provider for octoDNS
Requires Python: >=3.9

<!-- do not edit anything in "template" block, its auto-generated by Pulumi -->
<!-- template:begin:header -->
<div align="center">

### octodns-exoscale

_Exoscale provider for octoDNS_

</div>

[//]: # (<div align="center">)

[//]: # ()
[//]: # ([![Pypi]&#40;https://img.shields.io/pypi/v/octodns-infomaniak?label=&logo=pypi&style=for-the-badge&logoColor=yellow&color=3776AB&#41;]&#40;https://pypi.python.org/pypi/octodns-infomaniak&#41;)

[//]: # ([![Python]&#40;https://img.shields.io/pypi/pyversions/octodns-infomaniak?label=&logo=python&style=for-the-badge&logoColor=yellow&color=3776AB&#41;]&#40;https://pypi.python.org/pypi/octodns-infomaniak&#41;)

[//]: # (</div>)

<!-- template:end:header -->

<!-- template:begin:table_of_content -->
## 🔗 Table of Contents
- [Usage](#-usage)
    - [Pypi](#-pypi)
- [Configuration](#-configuration)
- [Dev](#%EF%B8%8F-dev)
    - [Run linter and formatter](#run-linter-and-formatter)
    - [Run test](#run-test)
- [Support &amp; Assistance](#-support--assistance)
- [License](#-license)
<!-- template:end:table_of_content -->

<!-- template:begin:usage/title -->
## 🪐 Usage
<!-- template:end:usage/title -->

<!-- template:begin:usage/pypi -->
#### 🐍 Pypi
Install the package `pip install octodns-exoscale`.
<!-- template:end:usage/pypi -->

<!-- template:begin:configuration -->
## 📜 Configuration
<!-- template:end:configuration -->
```yaml
providers:
  exoscale:
    class: octodns_exoscale.ExoscaleProvider
    # The auth-key, auth-secret and auth-zone are required.
    auth-key: env/EXOSCALE_AUTH_KEY
    auth-secret: env/EXOSCALE_AUTH_SECRET
    auth-zone: env/EXOSCALE_AUTH_ZONE
```

<!-- template:begin:dev -->
## 🛠️ Dev


### Run linter and formatter
```bash
black octodns_exoscale/ test/
isort octodns_exoscale/ test/
```


### Run test
```bash
# Run all tests
pytest

# Run a single test
pytest test/test_main.py::test_populate_A
```


<!-- template:end:dev -->

<!-- template:begin:support -->
## 🙋‍♂️ Support & Assistance
For all questions/features/bugs/issues [head over here](/../../issues/new/choose).
<!-- template:end:support -->

<!-- template:begin:license -->
## ⚖️ License

See [here](LICENSE).
<!-- template:end:license -->
tts-tg-bot 1.0.1
Telegram bot for text-to-speech and speech-to-text conversion
Requires Python: >=3.8
Keywords: telegram, bot, tts, stt, speech, text-to-speech

# W3C TTS Bot

Telegram 文字转语音机器人

## 功能特性

- ✅ 文字转语音（中英文支持）
- ✅ 使用微软 Edge TTS（免费）
- ✅ 多种语音选择
- ✅ 自动语音回复

## 快速开始

### 1. 安装

```bash
pip install tts-tg-bot
```

### 2. 配置 Token

创建 `token.txt` 文件，写入你的 Telegram Bot Token：

```bash
echo "YOUR_BOT_TOKEN" > token.txt
```

### 3. 启动 Bot

```bash
tts-tg-bot
```

或使用 Python 模块：

```bash
python -m tts_bot.bot
```

## 使用方法

1. 在 Telegram 搜索 `@w3c_tts_bot`
2. 发送 `/start` 查看帮助
3. 发送任何文字，Bot 会返回语音
4. 使用 `/voice` 命令切换语音

## 支持的语音

- 中文女声：zh-CN-XiaoxiaoNeural（默认）
- 中文男声：zh-CN-YunxiNeural
- 英文女声：en-US-JennyNeural
- 英文男声：en-US-GuyNeural

## 技术栈

- Python 3
- python-telegram-bot - Telegram Bot API
- edge-tts - 微软免费 TTS 服务

## Bot 信息

- Bot 名称: W3C TTS Bot
- Username: @w3c_tts_bot

## 开发者

TTS Bot 开发战士 ⚔️
cuvis-ai-schemas 0.1.4
Lightweight schema definitions for cuvis-ai ecosystem
Requires Python: <3.12,>=3.11
Keywords: schema, validation, pydantic, pipeline, hyperspectral, cuvis, grpc, protobuf, ai, machine-learning, type-safety

# cuvis-ai-schemas

Lightweight schema definitions for the cuvis-ai ecosystem.

[![PyPI version](https://img.shields.io/pypi/v/cuvis-ai-schemas.svg)](https://pypi.org/project/cuvis-ai-schemas/)
[![CI Status](https://github.com/cubert-hyperspectral/cuvis-ai-schemas/actions/workflows/ci.yml/badge.svg)](https://github.com/cubert-hyperspectral/cuvis-ai-schemas/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/cubert-hyperspectral/cuvis-ai-schemas/branch/main/graph/badge.svg)](https://codecov.io/gh/cubert-hyperspectral/cuvis-ai-schemas)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
[![Python](https://img.shields.io/badge/python-3.11-blue.svg)](https://www.python.org/downloads/)

## Overview

`cuvis-ai-schemas` is a centralized, dependency-light package of schema definitions used across the cuvis-ai ecosystem. It enables type-safe communication between services without heavy runtime requirements.

Key points:
- Minimal deps (pydantic + pyyaml)
- Full Pydantic validation
- Optional extras for proto, torch, numpy, lightning

## Installation

```bash
uv add cuvis-ai-schemas
uv add "cuvis-ai-schemas[proto]"
uv add "cuvis-ai-schemas[full]"
```

Extras:
- `proto`: gRPC and protobuf support
- `torch`: PyTorch dtype handling (validation only)
- `numpy`: NumPy array support
- `lightning`: PyTorch Lightning training configs
- `full`: All features
- `dev`: Development dependencies

## Usage

```python
from cuvis_ai_schemas.pipeline import PipelineConfig, NodeConfig

pipeline = PipelineConfig(
    nodes=[NodeConfig(id="node_1", class_name="DataLoader", params={"batch_size": 32})],
    connections=[],
)

pipeline_json = pipeline.to_json()
pipeline = PipelineConfig.from_json(pipeline_json)
```

## Development

```bash
uv sync --extra dev
uv run pytest tests/ -v
uv run ruff check cuvis_ai_schemas/ tests/
uv run ruff format cuvis_ai_schemas/ tests/
uv run mypy cuvis_ai_schemas/
```

## Contributing

Contributions are welcome. Please:
1. Ensure tests pass
2. Run ruff format and ruff check
3. Keep type hints and update docs as needed

## License

Licensed under the Apache License 2.0. See [LICENSE](LICENSE) for details.
xsocs 2026.2.0
Xray Strain Orientation Calculation Software
Requires Python: >=3.10

X-SOCS
======

The X-ray Strain Orientation Calculation Software (X-SOCS) is a user-friendly software,
developed for automatic analysis of 5D sets of data recorded during continuous mapping measurements.
X-SOCS aims at retrieving strain and tilt maps of nanostructures, films, surfaces or even embedded structures.

`Documentation <http://kmap.gitlab-pages.esrf.fr/xsocs>`_

Installation
------------

X-SOCS runs on Linux, Windows and macOS with `Python <https://www.python.org/>`_ >=3.8 and can be installed with::

    pip install xsocs[gui]

or with conda::

    conda install -c conda-forge xsocs

See `How to install XSocs <http://kmap.gitlab-pages.esrf.fr/xsocs/install.html>`_ for details.

Using XSOCS
------------

Once installed, you can run X-SOCS from the console with either::

    xsocs

Or::

    python -m xsocs

See `Using X-Socs documentation <http://kmap.gitlab-pages.esrf.fr/xsocs/using.html>`_ and
the `video tutorials <http://kmap.gitlab-pages.esrf.fr/xsocs/tutorials.html>`_.

License
-------

The source code of X-SOCS is licensed under the `MIT license <https://gitlab.esrf.fr/kmap/xsocs/blob/main/LICENSE>`_.

References
----------

X-SOCS can be referred by its DOI on Zenodo: |zenodo DOI|

.. |zenodo DOI| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.10777448.svg
  :target: https://doi.org/10.5281/zenodo.10777448

Reference publication:

Chahine, G. A., Richard, M.-I., Homs-Regojo, R. A., Tran-Caliste, T. N., Carbone, D., Jacques, V. L. R., Grifone, R., Boesecke, P., Katzer, J., Costina, I., Djazouli, H., Schroeder, T. & Schulli, T. U. *"Imaging of strain and lattice orientation by quick scanning X-ray microscopy combined with three-dimensional reciprocal space mapping."* `J. Appl. Cryst. (2014) 47, 762-769. <https://doi.org/10.1107/S1600576714004506>`_