semvec/pypi-packages huggingface dataset:
fastrtc-kroko 0.1.2
The realtime communication library for Python. With support for Kroko-ASR model.
Requires Python: >=3.10
Keywords: audio, audio processing, computer vision, gradio-custom-component, image, machine learning, realtime, streaming, video, video processing, webrtc

# FastRTC

## The Real-Time Communication Library for Python

Turn any python function into a real-time audio and video stream over WebRTC or WebSockets. Now with the [Kroko-ASR TTS Model](https://huggingface.co/Banafo/Kroko-ASR)!

### Installation

```bash
pip install fastrtc-kroko
```

### Features

- Works with FastRTC with added support for the Kroko-ASR TTS model.
- Supports English and French Transcriptions (more will be added as Kroko is updated).

### Example Run

```python
import soundfile as sf
from pathlib import Path

curr_dir = Path(__file__).parent

from fastrtc_kroko import get_stt_model

m = get_stt_model() # You will need to set a HF_TOKEN env variable, or pass it in here.
audio, sr = sf.read(str(curr_dir / "test_file.wav"))
transcript = m.stt((sr, audio))
print(transcript)
```
### Documentation

Check out the [fastrtc documentation](https://fastrtc.org) for more information.

### Licence

MIT
minlog 0.6.0
a neat and simple minimalistic logging library for python
Requires Python: <4.0,>=3.7

# minlog

a neat and simple minimalistic logging library for python.

## installation

```bash
pip install minlog
```

## usage

```python
from minlog import Logger

# create a logger instance
my_logger = Logger()

# or use the global logger instance
from minlog import logger
my_logger = logger.logger_for("stuff")

# log messages with different severity levels
logger.debug("debugging info")
logger.trace("trace message")
logger.info("general information")
logger.warn("warning message")
logger.error("error condition")
logger.crit("critical failure")
```

## controlling verbosity

```python
# show only errors and critical messages
logger.be_quiet()

# show all messages including debug and trace
logger.be_verbose()

# show messages at debug level
logger.be_debug()

# temporarily change verbosity using context manager
with logger.verbosity(Verbosity.DEBUG):
    logger.debug("this will be shown")
    logger.trace("this too")

# conditional logging based on verbosity
if logger.is_verbosity_above(Verbosity.ERROR):
    logger.error("this will only show in verbose modes")
```

## source logging

organize logs by source/context:

```python
# create loggers for different components
app_logger = logger.logger_for("app")
db_logger = logger.logger_for("db")

app_logger.info("message from application")
db_logger.warn("database warning")

# temporary subsource context
with logger.subsource("api"):
    logger.info("message with api context")
```

## class decoration

automatically add logging to classes:

```python
from minlog import logged

@logged  # uses class name as source
class MyClass:
    def do_something(self):
        self.logger.info("doing something")

@logged("custom_source")  # specify custom source
class MyOtherClass:
    def do_something(self):
        self.logger.info("doing something else")
```

## advanced features

```python
# force a message regardless of verbosity
logger.force_log("important message")

# conditional logging based on verbosity threshold
logger.log_only_when_quieter_than("debug info", Verbosity.DEBUG)

# multi-line messages are supported
logger.info("line one\nline two")

# rich text formatting characters are handled correctly
logger.info("message with [brackets]")
logger.info("message with [red]color[/red]")
```
PyLogAnim 27032025
A library for animating your logos

# PyLogAnim - PYthon LOGo ANIMation

![PyLogAnim Logo](img/pyloganim.png)

---

A simple yet fancy tool to animate logos for your hacking scripts! >:3  

To run a demo, use:
```
python -m PyLogAnim
```


---

## Example Script

```python
import PyLogAnim

logo_altmono = [
    "    _   _ _                       ",
    "   /_\ | | |_ _ __  ___ _ _  ___  ",
    "  / _ \| |  _| '  \/ _ \ ' \/ _ \ ",
    " /_/ \_\_|\__|_|_|_\___/_||_\___/ ",
    "                                  "
]

PyLogAnim.animate_logo(logo=logo_altmono, colormode=PyLogAnim.colormodes.RGB, delay=0.01, reverse=False)
```
This will produce something like this (sadly without borders, as PyPi completely screwed up with those chars):<br>
![Altmono logo](img/altmono.png)

---
Tested in WT, MinGW Terminal. Should work in any other modern terminal that supports ANSI escape codes.

---
### animate_logo(logo,colormode,clear,delay,reverse)
logo - list of strings, with logo you want<br>
colormode - either one of the pre-determined color modes, or your own color/gradient, like [0,255,0] for a simple green or [[255,0,0],[0,0,255]] for a red-blue gradient<br>
clear - should terminal be cleared before showing<br>
delay - how fast or slow logo should reveal, set to 0 for instant showing<br>
reverse - should background be colored instead of the text itself

---
Color modes:<br>
from PyLogAnim.colormodes:
* RED
* GREEN
* BLUE
* YELLOW
* PURPLE
* CYAN
* WHITE
* BLACK
* RGB, RGB_DARK, RGB_DARKER
* RGB_DOUBLE, RGB_DOUBLE_DARK, RGB_DOUBLE_DARKER

---
Unlicense, 2025