semvec/pypi-packages huggingface dataset:
odm-hlp-decorations 1.0.1
Decorators for ETL functions with logging and error handling
Requires Python: >=3.8
Keywords: decorators, etl, logging, error-handling

# ODM Helper Decorations

Python decorators for ETL functions with logging and error handling.

## Installation

```bash
pip install odm-hlp-decorations
```

## Usage

```python
from odm_hlp_decorations import task

@task()
def my_function():
    # Your code here
    pass
```

## Requirements

- Python 3.8+
- python-dotenv

## Configuration

Create a `.env` file with:
```
logs_path=./logs/
```

## License

MIT
textual-countdown 1.0.0
A visual countdown widget for Textual applications
Requires Python: >=3.9
Keywords: terminal, library, widget

# textual-countdown

![Textual Countdown demo](https://raw.githubusercontent.com/davep/textual-countdown/main/docs/source/textual-countdown.gif)

[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/davep/textual-countdown/style-and-lint.yaml)](https://github.com/davep/textual-countdown/actions)
[![GitHub commits since latest release](https://img.shields.io/github/commits-since/davep/textual-countdown/latest)](https://github.com/davep/textual-countdown/commits/main/)
[![GitHub Issues or Pull Requests](https://img.shields.io/github/issues/davep/textual-countdown)](https://github.com/davep/textual-countdown/issues)
[![GitHub Release Date](https://img.shields.io/github/release-date/davep/textual-countdown)](https://github.com/davep/textual-countdown/releases)
[![PyPI - License](https://img.shields.io/pypi/l/textual-countdown)](https://github.com/davep/textual-countdown/blob/main/LICENSE)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/textual-countdown)](https://github.com/davep/textual-countdown/blob/main/pyproject.toml)
[![PyPI - Version](https://img.shields.io/pypi/v/textual-countdown)](https://pypi.org/project/textual-countdown/)

## Introduction

This library provides a simple visual countdown widget, designed to subtly
let the user know that a period of time is passing; essentially a simple
"wait some time" progress bar.

Uses could be as a non-intrusive countdown in some sort of quiz application,
or a cool-down display in an application that's waiting to hit a busy API
endpoint again.

## Installing

The package can be installed with `pip` or related tools, for example:

```sh
$ pip install textual-countdown
```

## Demo

Once installed, you can try a demo of the library with:

```sh
$ python -m textual_countdown
```

Please see [the main documentation for the
library](https://textual-countdown.davep.dev/) for details on how to use it.

## TODO

See [the TODO tag in
issues](https://github.com/davep/textual-countdown/issues?q=is%3Aissue+is%3Aopen+label%3ATODO)
to see what I'm planning.

[//]: # (README.md ends here)
error-helper 1.5
Minimalistic python module to print colorful messages
Requires Python: >=3.6

[![pypi](https://img.shields.io/pypi/v/error-helper)](https://pypi.org/project/error-helper/)
[![python](https://img.shields.io/badge/Python-3.6+-blue)](https://www.python.org/)
[![mit](https://img.shields.io/badge/license-MIT-lightgrey)](LICENSE)

# error-helper

This is a minimalistic python module which helps you print colorful messages for CLI
tools. It's available on [PyPi](https://pypi.org/project/error-helper/), but you can also add it
to your project as a git submodule.

## Usage

```pycon
>>> from error_helper import *
>>> info("this is information")                    # output will be blue
this is information
>>> hint("this is less important information")     # output will be grayed out
this is less important information
>>> warning("something didn't go quite right...")  # output will be yellow
warning: something didn't go quite right...
>>> error("something went terribly wrong")         # output will be red
error: something went terribly wrong
>>> success("completed the operation!")            # output will be green
successfully completed the operation!
```

### `prompt(...)` and `prompt_input(...)`

The `prompt(...)` function, by default, prints a newline, followed by the provided values,
a colon and another newline:

```pycon
>>> prompt("enter the server url")

enter the server url:
>>>
```

The `prompt_input(...)` function, by default, prints the provided values, followed by a colon
and a space. Then it calls the default `input(...)` function and returns it's result. The result
will be stripped if `strip=True` (default).

```pycon
>>> prompt("enter the server url"); url = prompt_input("url:")

enter the server url:
url:  https://30350n.de
>>> url
'https://30350n.de'
```
payvo-sdk 0.1.0
Python SDK для работы с Payvo API
Requires Python: >=3.8

# Payvo SDK

Python SDK для работы с [Payvo API](https://docs.payvo.ru/).
Позволяет интегрировать платёжный сервис в Python-приложения быстро и удобно.

---

## ⚡ Установка

### 🔹 Через PyPI

```bash
pip install payvo-sdk
```

---

## 🛠 Инициализация SDK

```python
from payvo_sdk import Payvo

# Инициализация
payvo = Payvo(
    merchant_id="ваш_merchant_id",
    merchant_secret_key="ваш_secret_key",
)
```

---

## 💳 Работа с платежами

### Создание платежа

```python
payment = payvo.create_payment(
    amount=200.0,
    description="Тестовый платеж"
)
print(payment)
```

### Получение информации о платеже

```python
info = payvo.get_payment(payment_uuid=payment["payment"]["uuid"])
print(info)
```

---

## 🔁 Работа с возвратами

### Создание возврата

```python
refund = payvo.create_refund(
    payment_uuid=payment["payment"]["uuid"],
    amount=50.0,
    description="Частичный возврат"
)
print(refund)
```

### Получение информации о возврате

```python
refund_info = payvo.get_refund(refund_uuid=refund["uuid"])
print(refund_info)
```

---

## 🔄 Автоплатежи

```python
autopayment = payvo.create_autopayment(
    customer_id="id_клиента",
    amount=150.0,
    description="Автоплатеж"
)
print(autopayment)
```

> ⚠️ Для автоплатежей необходимо согласовать с Payvo возможность сохранения платёжного метода.

---

## 🔔 Работа с вебхуками

### Проверка секретного ключа вебхука

```python
webhook_data = {"secret_key": "тестовый_ключ"}
is_valid = Payvo.verify_webhook(webhook_data, secret_key="тестовый_ключ")
print(is_valid)  # True или False
```

> 💡 Используйте `verify_webhook` для проверки, что уведомление пришло именно от Payvo.

---

## 📚 Полезные ссылки

* [Документация Payvo API](https://docs.payvo.ru/)
* [PyPI](https://pypi.org/)

---

## 📝 Пример полного скрипта

```python
from payvo_sdk import Payvo

payvo = Payvo(
    merchant_id="ваш_merchant_id",
    merchant_secret_key="ваш_secret_key"
)

# Список товаров (если включены Payvo.Чеки)
items = [
    {"description": "Товар 1", "amount": 42.80, "vat_code": 1, "quantity": 1},
    {"description": "Товар 2", "amount": 15.50, "vat_code": 2, "quantity": 2}
]

# Создать платеж
payment = payvo.create_payment(
    amount=58.30,  # общая сумма, для поля amount
    description="Заказ №1",
    return_url="https://www.example.com/return_url",
    email="user@example.com",
    items=items
)

# Проверка платежа
info = payvo.get_payment(payment["payment"]["uuid"])

# Частичный возврат
refund = payvo.create_refund(payment["uuid"], 50.0, "Частичный возврат")

# Проверка вебхука
webhook_data = {"secret_key": "тестовый_ключ"}
print(Payvo.verify_webhook(webhook_data, secret_key="тестовый_ключ"))
```
test.thing 0.4.0
A simple modern VM runner
Requires Python: >=3.12

# test.thing

A simple, modern VM runner.

## Goals.

 - one-file copypastelib
 - easy to hook up to pytest
 - future-oriented, built on systemd features in the guest (credentials, ssh-over-vsock, etc)
   - might limit usefulness for testing older OSes but we can add
     [workarounds](workarounds/) as required
 - works without networking configured in guest
 - supporting the existing features of [cockpit-bots](https://github.com/cockpit-project/bots)

## Host requirements

 - Python 3.12, standard library
 - qemu
 - ssh
 - [systemd-ssh-proxy](https://www.freedesktop.org/software/systemd/man/latest/systemd-ssh-proxy.html)
   (available since systemd v256, [polyfill
   available](workarounds/systemd-ssh-proxy))
 - [vhost-device-vsock](https://crates.io/crates/vhost-device-vsock)

## Guest requirements

The guest should meet the requirements of the [Virtual Machine Image API
Specification](doc/VirtualMachineAPI.md).

There are polyfills for many of the require functionalities in
[workarounds/](./workarounds/).

## Try it

The easiest way to get `test.thing` is from PyPI:
[test.thing](https://pypi.org/project/test.thing/).

If you want to depend on the package, please pin the version number exactly.
It's early days and there is no guarantees about API (or even CLI)
compatibility, even between micro releases.  You can also simply copy
[testthing.py](./testthing.py) into your project.

For cli use, the easiest thing is to `pip install test.thing` which will put an
executable called `tt` in your path.  This is sort of like the existing
cockpit-bots `vm-run`.  If you want to test Cockpit images, you can do
something like:

```sh
  tt \
      -v \
      -L 9091:127.0.0.1:9090 \
      -s cockpit.socket \
      bots/images/arch
```

An ssh control socket is created for sending commands and can also be used
externally, avoiding the need to authenticate.  A suggested ssh config:

```
Host tt.*
        ControlPath ${XDG_RUNTIME_DIR}/test.thing/%h/ssh
```

And then you can say `ssh tt.0` or `scp file tt.0:/tmp`.

You can also take a look at [`test/test_example.py`](test/test_example.py) and
run `TEST_IMAGE=/path/to/image.qcow2 pytest`.  This was originally tested with
the [examples images from
composefs-rs](https://github.com/containers/composefs-rs/tree/main/examples).
MedImageInsights 0.1.1
Pip library for MedImageInsights medical model
Requires Python: >=3.8.19

# 🩺 MedImageInsights

MedImageInsights is a package streamlined of the original HuggingFace repository mantained by the Lion-AI team available [here](https://huggingface.co/lion-ai/MedImageInsights). Its purpose is to make it easier to integrate the medical image embedding model **MedImageInsight** in Python projects by removing unecessary modules, simplifying dependencies and offering a clean `pip install` interface. 

The official guide to download and use the model belongs to Microsoft and it is defined as open-source though the installation process is quite complicated. Moreover, the model version of Lion-AI requires the cloning of the repository and the use of a package manager.

Thus, in this work we present an easy to use `pip` library for the model **MedImageInsight**. By packaging and simplifying some of the code in the repository owned by Lion-AI we are able to make it even easier to use the model, without needing to use Microsoft Azure services or downloading the whole code from the HuggingFace repo. On the contrary, the user can simply install the library **MedImageInsights** via `PyPi` in order to use the model for tasks such as zero-shot classification or embedding generation. 

## 💿 Installation 

As mentioned above, the library can easily installed via pip:

```python
pip install medimageinsights
```

## 📝 Tutorials

Once you have installed the library on your environment, you can test it by running this example [script](https://github.com/joortif/MedImageInsights/blob/main/tests/example.py).

A python notebook is also provided, that can be either run on your device or in Google Colab. You may preview the notebook [here](https://github.com/joortif/MedImageInsights/blob/main/tests/MedImageInsights_Tutorial.ipynb) or directly run it on Colab [here](https://colab.research.google.com/github/joortif/MedImageInsights/blob/main/tests/MedImageInsights_Tutorial.ipynb
).

## 🌟 Acknowledgements

Both the original Lion-AI repo and this package are based on the work described in the paper "MedImageInsight: An Open-Source Embedding Model for General Domain Medical Imaging" by Noel C. F. Codella et al ([arXiv:2410.06542](https://arxiv.org/abs/2410.06542)).

Most of the implementation is inherited from the Lion-AI repository. Credit is due to Noel C. F. Codella et al., and the Lion-AI team for designing, training, and publishing the original model and code.
create-prisma-app 0.6.0
A CLI tool to bootstrap Express + Prisma projects with PostgreSQL
Requires Python: >=3.8

# create-prisma-app

`create-prisma-app` is a Python-powered CLI that bootstraps a Node.js + Express + Prisma project with PostgreSQL.

## 🚀 Features
- Sets up an Express server
- Configures Prisma ORM
- Auto-generates database migrations
- Adds Jest for testing
- Includes a sample health check & database connection test

## 📦 Installation

Using [pipx](https://pypa.github.io/pipx/):

## Usage
usage: create-prisma-app [-h] --db-name DB_NAME --db-user DB_USER --db-pass DB_PASS project_name

Express + Prisma Bootstrap CLI

positional arguments:
  project_name       Project name

options:
  -h, --help         show this help message and exit
  --db-name DB_NAME  Database Name
  --db-user DB_USER  Database User
  --db-pass DB_PASS  Database Password

```bash
pipx install create-prisma-app
windows-snake-game 0.1.11
A Windows snake game project.It is a private project but you can use it if you trust me.
Requires Python: >=3.7



# Simple Snake Game 🐍

A minimalist snake game written in Python using `asyncio` and `pynput` for keyboard input.

---

## Author

* **userAnonymous**
* GitHub: [ramimK0bir](https://github.com/ramimk0bir)

---

## Installation

Install the game easily using pip:

```bash
pip install windows-snake-game
```

---

## Usage



You can import and run the game from Python code:

```python
import windows_snake_game as snake_game

snake_game.play()

```

---

## Parameters of `play` function

| Parameter     | Type            | Default | Description                                      |
| ------------- | --------------- | ------- | ------------------------------------------------ |
| `speed`       | int             | 5       | Controls the game speed (higher = faster).       |
| `food_emoji`  | str             | "🍎"   | Emoji to represent the food on the grid.         |
| `grid_size`   | tuple (int,int) | (15,12) | Size of the game grid as (width, height).        |
| `block_emoji` | str             | "🟫"   | Emoji or character to represent the grid blocks. |

---

## Controls

* **Arrow keys** to move the snake:

  * Up arrow: Move up
  * Down arrow: Move down
  * Left arrow: Move left
  * Right arrow: Move right
* **Space bar** to pause or resume the game.

---

## How to Play

* The snake moves continuously on the grid.
* Eat the food (represented by the food emoji) to grow longer and increase your score.
* Avoid hitting the walls or the snake's own body.
* The game ends if you collide with yourself or the grid edges.
* Your current score is displayed above the grid.

---

## Notes

* The game uses ANSI escape codes for terminal control (clear screen, colors).
* Works best on terminals supporting Unicode and ANSI colors.
* Keyboard input requires the `pynput` package (automatically handled if installed via pip).
* If running the game script directly, make sure `pynput` is installed: `pip install pynput`.

---



## Troubleshooting

* If the game does not respond to key presses, ensure your terminal supports `pynput` keyboard listening.
* On Windows, you may need to run the terminal with administrator privileges for keyboard capture.
* If `pynput` is not installed, install it via `pip install pynput`.

---

## License

This project is open source. Feel free to contribute or modify!
playlab-api 0.1.4
A Python client for the Playlab API
Requires Python: >=3.7

# Playlab Python Client

A Python client for interacting with the Playlab API, enabling you to create interactive AI tutoring experiences.

## Requirements

- Python 3.7 or later

## Installation

```bash
pip install playlab-api
```

### Getting an API Key

To use the Playlab API, you'll need to obtain an API key. 

1. Log in to your account: Once your account is set up, log in at https://playlab.ai/login.
2. Create and publish an app:
    - Navigate to a workspace within your organization or create a new one.
    - Create a new app within a workspace.
    - Develop your app using Playlab's tools.
    - Once ready, publish your app to your desired visibility.
    - Note down the project ID (also known as the app ID) - you'll need this for API calls.
      - The project ID can be found in the URL when you are on the project page as the group of characters after the last `/` .
      - For example, for: `https://www.playlab.ai/build/clzni6ang00112by7c4vwbabc` the project ID is: `clzni6ang00112by7c4vwbabc`
3. Create an API Keys: In your organization's menu bar, look for the "API Keys" link in the upper-right side of the page.

## Quick Start

```python
from playlab_api import PlaylabApp

# Initialize the app with your API key and project ID
app = PlaylabApp(
    api_key="your_api_key_here",
    project_id="your_project_id_here"
)

# Send a message and get the response
response = app.send_message("Hello, AI!")
```

## Environment Variables

You can set your API key and project ID using environment variables:

```bash
export PLAYLAB_API_KEY="your_api_key_here"
export PLAYLAB_PROJECT_ID="your_project_id_here"
```

Then initialize the app without parameters:

```python
app = PlaylabApp()
```

## Detailed Usage

Please refer to the [usage.ipynb](./usage.ipynb) notebook for more detailed examples, including:
- File attachments
- Conversation management
- History access
- System prompts
- Interactive chat