semvec/pypi-packages huggingface dataset:
pyhelper-utils 2.0.0
Collective utility functions for python projects
Requires Python: >=3.10

# pyhelper-utils

Repository for various python utilities

## Installation

```bash
python3 -m pip install pyhelper-utils
```

## Release new version

### requirements:

- Export GitHub token

```bash
export GITHUB_TOKEN=<your_github_token>
```

- [release-it](https://github.com/release-it/release-it)

- Run the following once (execute outside repository dir for example `~/`):

```bash
sudo npm install --global release-it
npm install --save-dev @j-ulrich/release-it-regex-bumper
rm -f package.json package-lock.json
```

### usage:

- Create a release, run from the relevant branch.
  To create a new release, run:

```bash
git checkout main
git pull
release-it # Follow the instructions
```

### Examples:

Enables running a command against a remote server over SSH. It expects a host object, created using [python-rrmngmnt](https://github.com/rhevm-qe-automation/python-rrmngmnt).

#### Sample code:

```bash
from rrmngmnt import Host, UserWithPKey
host = Host("1.1.1.1")
user = UserWithPKey('user', '/path/to/pkey'))
host.executor_user =  user
run_ssh_command(host=host, commands=shlex.split("ls -l"))
```
fundi 1.5.0
Dependency injection library
Requires Python: >=3.10

![FunDI logo](https://raw.githubusercontent.com/kuyugama/fundi/refs/heads/main/docs/_static/FunDI_horizontal.png)

# # _FunDI_
> Solution for problem no one had before

> Fun stays for function(or for fun if you wish) and DI for Dependency Injection

This library provides fast(to write!) and convenient(to use!) Dependency Injection 
for functional programming on python.

## Why?  

This library was inspired by FastAPI's dependency injection. The reasons for its existence are simple:  

- **A standalone dependency injection library.** DI shouldn't be tied to a specific framework.  
- **It simplifies code writing.** Dependency injection reduces boilerplate and improves maintainability.  
- **Lack of DI libraries for functional programming in Python.** Or maybe I just didn't want to find one :3  


## No more words, let's try!

```python
from fundi import scan, from_, inject


def require_user():
    return "Alice"


def greet(user: str = from_(require_user)):
    print(f"Hello, {user}!")


inject({}, scan(greet))
```

See the documentation to get more examples: https://fundi.readthedocs.io/en/stable/
livekit-plugins-openai-sse-tts 0.1.0
Agent Framework plugin for OpenAI Server-Sent Events TTS API
Requires Python: >=3.9.0
Keywords: audio, livekit, openai, realtime, sse, tts, video, webrtc

# OpenAI Server-Sent Events plugin for LiveKit Agents

Support for OpenAI SSE TTS API.

## Installation

```bash
pip install git+https://github.com/livex-ai/livekit-plugins-openai-sse.git
```

## Pre-requisites

You'll need an API key from OpenAI. It can be set as an environment variable: `OPENAI_API_KEY`
rolly 1.0.1
Roll dice on the command line because why not?
Requires Python: >=3.14

![Rolly Mascot](mascot.png)

# Rolly

Rolling dice the boring way.

## Introduction

A roll is expressed as a single string of text that contains a
sequence of instructions. Whitespace between instructions is entirely
ignored. There are different ways to express the same roll,
some being shorter than others. Below, we roll 3 D20s with
advantage in three different ways.

```
d20 d20 d20+

d20 x3+

d20 d20x2 +
```

## Instructions

The available instructions are listed below.

  * A die to be rolled: `dN`, `N` is the number of sides
  * Roll multiple dice: `xM`, `M` is the number of the previous die to roll
  * Advantage on the roll: `+` anywhere in the string
  * Disadvantage on the roll: `-` anywhere in the string

## Examples

So a number prefixed with `d` implies `x1` and a space between a number
and a count is ignored. Advantage is indicated by a `+` anywhere in the
string, disadvantage is a `-`.

```
d20x2 +
a d20 d20
d20x2-
```

## CLI

The CLI is straightforward. Once the package is installed, it can be run
as a module:

```
$ python -m rolly
```

This will show the help text. The primary command is `roll`, which takes
a string of instructions and displays the result.

```
$ python -m rolly roll d20x3
   ▄▄▄▄              ▄▄▄     ▄▄▄▄▄▄▄▄           ▄▄▄▄▄
  ██▀▀▀█            █▀██     ▀▀▀▀▀███          █▀▀▀▀██▄
 ██ ▄▄▄               ██         ▄██                ▄██
 ███▀▀██▄             ██         ██              █████
 ██    ██             ██        ██                  ▀██
 ▀██▄▄██▀          ▄▄▄██▄▄▄    ██              █▄▄▄▄██▀
   ▀▀▀▀            ▀▀▀▀▀▀▀▀   ▀▀                ▀▀▀▀▀
```

The default uses ASCII art, but passing the `--plain` (`-p`) flag will
cause it to use plain text.
```
$ python -m rolly roll d20x3
6 17 3
```

It is also possible to sum the dice automatically using the `--add` (`-a`)
flag:

```
$ python -m rolly roll -ap d20x3
16 12 7
= 35
```

The ASCII art theme can be changed with the `--theme` (`-t`) option and
the available themes can be listed with the `themes` command.

## Install

Probably easiest from PyPI: https://pypi.org/project/rolly/

I've become kind of a [uv](https://github.com/astral-sh/uv) fanboy recently,
and you can use that to run Rolly directly, which is slick.

```
uvx --from rolly rolly roll d20x3
```