semvec/pypi-packages huggingface dataset:
demo-PySide6-GlobalHotkeys 0.0.2
Demo app for system-wide hotkeys for applications developed with PySide6.
Requires Python: >=3.10.8

# Demo Global Hotkeys for PySide6 Applications

An example application for the PySide6-GlobalHotkeys library https://github.com/develOseven/PySide6-GlobalHotkeys

Shows hotkey presses/releases in a text box.
Has a button to show the hotkey configuration user interface.

Install the `data/demo-PySide6-GlobalHotkeys.desktop` file for it to work:

```sh
cp data/demo-PySide6-GlobalHotkeys.desktop ~/.local/share/applications/
```
PySide6-GlobalHotkeys 0.0.3
System-wide hotkeys for applications developed with PySide6.
Requires Python: >=3.10.8

# Global Hotkeys for PySide6 Applications

Triggers the system's user interface for setting up global hotkeys for an application.

TODO: implement custom user interfaces for the systems that don't support that.

Provides Qt signals for the hotkey presses and releases.

Your application has to set the `QCoreApplication.applicationName` to an application that exists in the system (has a `*.desktop` file in `~/.local/share/applications`).

See an example application https://github.com/develOseven/demo-PySide6-GlobalHotkeys
django-auto-authentication 0.1.0
Reusable Django authentication package: login, register, dashboard ready out-of-the-box!
Requires Python: >=3.10

# Django Auth App

A reusable Django authentication package that provides **login, logout, registration, and dashboard functionality** out-of-the-box.  
No need to rewrite authentication logic for every Django project—just install, migrate, and copy templates.

---

## Features

- Login, logout, and registration views  
- Dashboard and home page templates  
- Ready-to-use URLs  
- Easy template customization via management command  
- Works with any Django 4.x+ project  

---

## Installation

Install the package via pip:

```bash
pip install /path/to/django_auth_package
Add to INSTALLED_APPS in your settings.py:

INSTALLED_APPS = [
    ...
    'django_auth_app',
] 
```
Run migrations:
```
python manage.py migrate
```

## Copy Templates

To customize templates, copy them into your project:

python manage.py copy_templates


This will create:
```
myproject/templates/django_auth_app/
├─ login.html
├─ register.html
├─ dashboard.html
└─ home_page.html
```

You can now edit HTML/CSS as needed.
URLs

Include the app URLs in your project’s urls.py:
```
from django.urls import path, include

urlpatterns = [
    path('', include('django_auth_app.urls', namespace='django_auth_app')),
]
```
---
Available URLs:

- /login/ → Login page

- /register/ → Registration page

- /dashboard/ → Dashboard

- / → Home page
---
## Usage

Af---ter installation, your Django project will have fully functional authentication without writing a single line of authentication code. You can customize templates, add CSS, or integrate it with other apps seamlessly.
django-whatsapp 0.0.2
Django application to handle WhatsApp Webhook incoming requests
Requires Python: >=3.10
Keywords: django

# django-whatsapp

[![PyPI - Version](https://img.shields.io/pypi/v/django-whatsapp.svg)](https://pypi.org/project/django-whatsapp)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/django-whatsapp.svg)](https://pypi.org/project/django-whatsapp)

-----

## Table of Contents

- [Installation](#installation)
- [License](#license)

## Installation

```console
pip install django-whatsapp
```

## License

`django-whatsapp` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
pipecat-ai-tail 0.0.2
A pipeline runner for Pipecat
Requires Python: >=3.10
Keywords: pipecat, ai

<h1><div align="center">
 <img alt="tail" width="300px" height="auto" src="https://github.com/pipecat-ai/tail/raw/refs/heads/main/tail.png">
</div></h1>

[![PyPI](https://img.shields.io/pypi/v/pipecat-ai-tail)](https://pypi.org/project/pipecat-ai-tail) [![Discord](https://img.shields.io/discord/1239284677165056021)](https://discord.gg/pipecat)

# ᓚᘏᗢ Tail: A terminal dashboard for Pipecat

**Tail** is a terminal dashboard for the [Pipecat](https://github.com/pipecat-ai/pipecat) voice and multimodal conversational AI framework.

It lets you monitor your Pipecat sessions in real time with logs, conversations, metrics, and audio levels all in one place.

With Tail you can:

- 📜 Follow system logs in real time
- 💬 Track conversations as they happen
- 🔊 Monitor user and agent audio levels
- 📈 Keep an eye on service metrics and usage
- 🖥️ Run locally as a pipeline runner or connect to a remote session

<p align="center"><img src="https://raw.githubusercontent.com/pipecat-ai/tail/refs/heads/main/tail-image.gif" alt="Tail" width="500"/></p>

## 🧭 Getting started

### Requirements

- Python 3.10+

### Install Tail for Python

```bash
uv pip install pipecat-ai-tail
```

and also install Pipecat CLI so you can run Tail as a standalone application:

```bash
uv tool install pipecat-ai-cli
```

### ⚡ Option A: Pipeline runner

Use `TailRunner` as a drop-in replacement for `PipelineRunner`. For example:

```python
runner = PipelineRunner()

await runner.run(task)
```

becomes

```python
from pipecat_tail.runner import TailRunner

runner = TailRunner()

await runner.run(task)
```

### 🏠 Option B: Standalone app

You can also start Tail as a standalone application. This lets you connect to a running session, whether local or remote. All you need to do is add the `TailObserver` to your pipeline task:

```python
from pipecat_tail.observer import TailObserver

task = PipelineTask(..., observers=[TailObserver()])
```

Then start the app:

```sh
pipecat tail [--url URL]
```

By default, it will connect to `ws://localhost:9292`.

## 📚 Next steps

- See the [Pipecat documentation](https://docs.pipecat.ai) for more about building bots
chars-betterlogs 4.0.0
A project started to fix a problem I was having with the default python logging library
Requires Python: >=3.12

# Char's Better Logs

A project started to fix a problem I was having with the default python logging library

## USAGE

Simply install it with `pip install chars-betterlogs` and add it to your code with:
```python
from chars_betterlogs.logs import Logging
```

then make a variable:
```python
#                         The Filename         String to add before the log        Whether to print the log (Defaults to True)
logger:Logging = Logging('filename.log', 'This gets added before the log starts!', False)
```

Tada you now have a callable logger!

### Example Script
```python
from chars_betterlogs.logs import Logging
from datetime import datetime

logger:Logging = Logging('log_' + str(datetime.today().strftime('%d_%m_%Y-%H_%M_%S')) + '.log')

logging.log_info('yipee!')
logging.close() # Don't forget to end the log file before the script ends!
```
sb-loki-handler 1.0.0
Typed loki handler for logging
Requires Python: >=3.6

# sb-loki-handler

Typed loki handler for logging

## Installation

You can install the package via pip:

```
pip install sb-loki-handler
```

## Usage

```python
import logging

from sb_loki_handler import LokiHandler

logger = logging.getLogger("my-logger")
logger.setLevel(logging.INFO)

handler = LokiHandler(
    "https://user:pass@host/loki/api/v1/push",
    labels={"application": "my-app"}
)
logger.addHandler(handler)


logger.info("Hello world.")
logger.info("With extra", extra={"labels": {"foo": "bar"}})

with handler.labels({"foo": "bar"}):
    logger.info("With context")

```

## License

This project is licensed under the terms of the MIT license.
baax 1.0.0
A backend accelerator CLI tool for Python frameworks like Flask, Django, FastAPI.
Requires Python: >=3.7

# Baax – Backend Accelerator CLI

[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/)

Baax is a **Backend Accelerator CLI** that allows developers to instantly scaffold **production-ready backend projects** in **Flask, FastAPI, and Django** with a single command.

---

## 🚀 Features

- Scaffold Flask, FastAPI, or Django projects interactively
- Creates folder structure, starter files, and requirements
- Supports Docker, Git initialization, and environment setup (future updates)
- Open-source and modular design
- Perfect for beginners and fast prototyping

---

## ⚡ Installation

Install via **pip** (editable mode recommended for development):

```bash
pip install -e .
```

Or, after publishing to PyPI:


```bash
pip install baax
```
## 🛠️ Usage

Run the CLI:
```bash
baax create
```

You will be prompted to:

1.**Select a framework**: flask, fastapi, or django
2.**Enter the project name**:

Example:
```bash
🚀 Welcome to Baax – Backend Accelerator CLI

Select a framework (flask, fastapi, django): flask
Enter your project name: myapp
✅ Flask project 'myapp' created successfully!
```

## 📦 Project Structure (Example: Flask)

```bash

myapp/
├── app/
│   ├── __init__.py
│   ├── routes.py
│   ├── templates/
│   └── static/
├── run.py
├── requirements.txt
└── README.md

```
## 🧩 Planned Features

- Automatic Dockerfile creation
- JWT Auth / user model scaffolding
- Database integration (Postgres, MongoDB)
- Git repository initialization
- Scaffold API routes for FastAPI automatically
- Multi-framework support for future additions

## 📝 Contributing

Contributions are welcome! Please follow:

1. Fork the repository
2. Create a new branch (git checkout -b feature/my-feature)
3. Make your changes
4. Submit a pull request
planetcasio 0.5
Utilities for interacting with Planète Casio
Requires Python: <4.0,>=3.9

``planetcasio`` -- Utilities for interacting with Planète Casio
===============================================================

This project is a Python module for interacting with `Planète Casio`_
programmatically.

For example, you can use this module to post a message on the shoutbox:

.. code-block:: python

    import asyncio

    from planetcasio.client import Client

    async def main():
        async with Client(auth=("my_username", "my_password")) as client:
            channel = await client.shout.get_channel("hs")
            await channel.post("Hello, world!")

    asyncio.run(main())

The project is present at the following locations:

* `Official website and documentation at planetcasio.touhey.pro <Website_>`_;
* `thomas.touhey/planetcasio repository on Gitlab <Gitlab repository_>`_;
* `planetcasio project on PyPI <PyPI project_>`_.

.. _Planète Casio: https://www.planet-casio.com/Fr
.. _Website: https://planetcasio.touhey.pro/
.. _Gitlab repository: https://gitlab.com/thomas.touhey/planetcasio
.. _PyPI project: https://pypi.org/project/planetcasio/
score_loader 0.0.4
Python implementation of the score.dev specification, allowing to load workload definition and applying a first pass of evaluation for ${metadata...} placeholders.
Requires Python: >=3.12
Keywords: score.dev

# Score.dev Python loader

Python implementation of the [score.dev](https://docs.score.dev/docs/) specification, allowing to load workload definition and applying a first pass of evaluation for `${metadata...}` placeholders.

`${resources...}` placeholders must be evaluated after provisioning of the resources, cannot be done while loading the workload definition.


## Usage

`pip install score-loader`

or

`uv add score-loader`

then in your code:

```
from score_loader.loader import load_score_file

workload = load_score_file("score.yml")
```

## Unit tests

`uv run pytest`
flipboard 0.3.0
Apply transformations to text on the clipboard
Requires Python: >=3.10

# flipboard

CLI tool for applying useful transformations to text on the clipboard

## Usage

### copy text to the clipboard: 

```
cat in.txt > flipboard stdin
flipboard stdin < in.txt
```

### apply transformations:

```
flipboard [encode|decode] [base64|url]
flipboard [minify|pprint] [json|xml]
flipboard trim
```

### write out clipboard contents:

```
flipboard stdout
flipboard stdout > out.txt
```