semvec/pypi-packages huggingface dataset:
livekit-plugins-piper-tts 0.1.0
A custom TTS plugin for LiveKit which can be used with self hosted Piper TTS
Requires Python: >=3.9
Keywords: voice, ai, realtime, audio, video, livekit, piper-tts, tts

# LiveKit Plugins Piper TTS

## Pre-requisites

The following environment variables need to be set:

| Variable | Description | Example |
|----------|-------------|---------|
| `base_url` | Base URL of the Piper TTS server | `http://localhost:5000` |


## Installation

### Step 1: Install the PiperTTS Server (open source)

Follow the instructions to setup the PiperTTS Web Server:

https://github.com/OHF-Voice/piper1-gpl

### Step 2: Install the LiveKit Plugin

```bash
pip install livekit-plugins-piper-tts

```

## Usage examples

```
from livekit.plugins import piper_tts

....
 session = AgentSession(
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=piper_tts.TTS("http://localhost:5000/"),
        ....
    )

```
boreal-python 1.1.0
Python bindings to the boreal YARA scanner
Requires Python: >=3.11

# Python bindings for the boreal YARA scanner

The library allows using the [boreal](https://github.com/vthib/boreal) library
to scan files and processes using YARA rules.

```py
import boreal

scanner = boreal.compile(source="""
rule example {
    meta:
        description = "This is an YARA rule example"
        date = "2022-11-11"
    strings:
        $s1 = { 78 6d 6c 68 74 74 70 2e 73 65 6e 64 28 29 }
        $s2 = "tmp.dat" fullword wide
    condition:
        any of them
}
""");

results = scanner.match(data=b"<\0t\0m\0p\0.\0d\0a\0t\0>\0")
assert [rule.name for rule in results] == ["example"]
```

## Description

This library can serve as a drop-in replacement of the YARA python library,
while also providing improvements and saner default behavior.

- Literal replacement to the yara library:
  replace `import yara` with `import boreal` and everything will work.

- Saner default behavior compared to the yara library: fast scanning enabled
  by default, proper hash implementations of python objects, use of the bytes
  type in some places to avoid losing information, etc.

- 100% compatibility with the yara library guaranteed if needed through
  a yara compatibility mode.

This library is fully compatible with free-threaded python.

## Yara compatibility

This library guarantees 100% compatibility with the YARA library: the whole API
is entirely tested against both libraries to guarantee perfect compatibility.

However, a few differences are introduced in the default behavior of this library
to ensure that this default behavior fixes some issues in the behavior of the yara
library. Those changes are minimal, but can introduce breakage when replacing
the yara library.

Therefore, you can either:

- Use the compatibility mode to ensure 100% compatibility with the yara library:

```py
import boreal

boreal.set_config(yara_compatibility=True)
```

This guarantees that the yara library can be replaced and nothing will break.
However, it also keeps alive a few issues in this library. It is therefore
only recommended to enable this mode when replacing the yara library and wanting
to ensure that nothing can break.

- Use boreal as is. This fixes a few issues while still providing almost
  entirely the same API.

This is recommended if using this library from scratch, or when all the uses
of the yara library can be easily checked to ensure nothing will break.

For a description of all the differences that exists when the compatibility mode
is not enabled, you can consult [this documentation](https://vthib.github.io/boreal/boreal-py/dev/yara_compatibility_mode/).
akio 0.0.4.dev0
An agentic AI for red team tasks.
Requires Python: >=3.11
Keywords: ai, llm, agent, autonomous, pentest, redteam, local, rag, mcp

<div align="center">
  <img src="https://raw.githubusercontent.com/Fastiraz/akio/refs/heads/dev/assets/logo.png" width="250">
</div>

<div align="center">
  <h1><code>akio</code></h1>
  <p>Your red team assistant who helps you break things.</p>
</div>

---

> [!WARNING]
> **Akio is under active development.**
> The project is not yet fully functional and may not work as expected out of the box.
> If you'd like to contribute, feel free to open a [pull request](https://github.com/Fastiraz/akio/pulls).
> Found a bug, vulnerability, or something unusual? Please open an [issue](https://github.com/Fastiraz/akio/issues).

---

## What is Akio?

Akio is an autonomous AI agent specialized in offensive security. It combines the power of a large language model (LLM) with real-world capabilities by integrating with a shell, a web browser, a Retrieval-Augmented Generation (RAG) pipeline, and popular tools like **Ghidra** and **Burp Suite** through an MCP server.

**It's not build to replace** penetration testers, Akio is designed to **assist** them helping automate tasks, accelerate workflows, and provide intelligent interaction with common red team tools.

---

## Features

- Uncensored LLM
- Autonomous AI agent
- Tools
- - Shell commands execution
- - RAG for offensive security topics
- - Browser use
- - Message interaction with user
- - Web search (DuckDuckGo)
- - Coding agent

---

## The Grimoire

The Grimoire is the official Akio's documentation.
You can read it [here](https://fastiraz.github.io/grimoire/).

---

## Installation

You can read the installation instructions in the [Grimoire](https://fastiraz.github.io/grimoire/docs/getting-started/installation).

### Using pipx (recommend)

```sh
pipx install akio
```

### From source

```sh
git clone https://github.com/Fastiraz/akio.git
cd akio

uv build
uv venv
uv pip install dist/*.whl
uv run -- akio
```

---

<div align="center">
  <p><code>Coming soon...</code></p>
</div>
cinemagoerng 0.7
Retrieve data from the IMDb.
Requires Python: ~=3.11
Keywords: imdb, cinema, movie, film, cast, actor, director

# CinemagoerNG

CinemagoerNG is a Python library and command-line utility
for retrieving data from IMDb.
It provides a clean, modern API for accessing movie, TV show,
and celebrity information from IMDb.

> [!Note]
> This project and its authors are not affiliated
> with the Internet Movie Database Inc.
> See the [`DISCLAIMER.txt`](DISCLAIMER.txt)
> file for details about terms of use.

## Features

- Retrieve comprehensive movie and TV show information.
- Support for alternate titles (AKAs).
- Taglines and parental guide information.
- Episode data for TV series.
- Modern Python typing support.
- Clean, intuitive API.

## Installation

CinemagoerNG supports Python 3.11 and later versions.
You can install it using pip:

```bash
pip install cinemagoerng
```

## Basic usage

Here's a simple example of retrieving movie information:

```python
from cinemagoerng import web as imdb

# Get basic movie information
movie = imdb.get_title("tt0133093")  # The Matrix
print(movie.title)       # "The Matrix"
print(movie.sort_title)  # "Matrix"
print(movie.year)        # 1999
print(movie.runtime)     # 136

# Access movie genres
for genre in movie.genres:
    print(genre)         # "Action", "Sci-Fi"

# Get director information
for credit in movie.directors:
    print(credit.name)   # "Lana Wachowski", "Lilly Wachowski"
```

### Retrieving additional information

You can fetch additional details using the relevant `set_` functions:

```python
# Set all taglines
imdb.set_taglines(movie)
for tagline in movie.taglines:
    print(tagline)

# Get alternate titles (AKAs)
imdb.set_akas(movie)
for aka in movie.akas:
    print(f"{aka.title} ({aka.country})")
```

## Available data

CinemagoerNG can retrieve various types of information:

### Basic information

- Title
- Year
- Runtime
- Genres
- Plot summary
- Rating
- Number of votes

### Credits

- Directors
- Writers
- Cast members
- Producers
- Composers
- Crew members

### Additional details

- Taglines
- Alternative titles (AKAs)
- Episode information (for TV series)
- Parental guide

## Development

It is recommended to use `uv` for development:

```bash
# Clone the repository
git clone https://github.com/cinemagoer/cinemagoerng.git
cd cinemagoerng

# Set up environment
uv sync

# Run tests
uv run pytest

# Run type checks
uv run mypy src tests

# Check code style
uv run ruff check --preview src tests

# Test under all supported Python versions
uv run tox
```

## License

This project is licensed under the
GNU Lesser General Public License v3 or later - see the
[`LICENSE.txt`](LICENSE.txt) file for details.

## Acknowledgments

CinemagoerNG is a modern reimagining of the original
[Cinemagoer/IMDbPY](https://github.com/cinemagoer/cinemagoer) project.
Special thanks to:

- All contributors to the original Cinemagoer (IMDbPY) project.
- The IMDb website for providing the data.
pnotp 0.1.6
PnotP client and API wrappers for the P¬P platform.
Requires Python: >=3.9

# PnotP

Unified API and Python client for PathoVision vision models.

## Packages
- `pnotp_api`: FastAPI service that wraps PathoVision ensembles under a consistent `/v1` surface with API-key auth.
- `pnotp`: Python client for calling the PnotP API.

## Install (client only)
```bash
pip install pnotp
```

## Install (client + server extra)
```bash
pip install "pnotp[server]"
```

## Usage (client)
```python
import pnotp as pnp

client = pnp.client(api_key="YOUR_KEY")  # default base URL: https://api.pnotp.ai
client.models()
model = client.models("pneumonia_binary_classification")
result = model.predict("image.jpg")
heatmap = model.attention_map("image.jpg")
```

Set your key once per shell:
```bash
export PNOTP_API_KEY="your_api_key_here"
python your_script.py  # pnp.client() will read the env var automatically
```

## Run the API locally
```bash
export PNOTP_INTERNAL_SECRET="dev-secret"
export PATHOVISION_ROOT="/absolute/path/to/PathoVision"  # if not default
uvicorn pnotp_api.main:app --host 0.0.0.0 --port 8000
```

## Issue an API key (internal)
```bash
curl -X POST http://127.0.0.1:8000/internal/api-keys \
  -H "X-Internal-Secret: $PNOTP_INTERNAL_SECRET" \
  -H "Content-Type: application/json" \
  -d '{"user_external_id":"demo-user","plan_code":"pathovision_starter"}'
```
pyxtend 0.5.0
Some functions for Python
Requires Python: >=3.8

# pyxtend

Functions to be more productive in Python.

## struct

`struct` is for examining objects to understand their contents.

## Usage

```python
from pyxtend import struct
struct(obj)
struct(obj, examples=True)
```

## Example 1
A simple list of integers

```python
Input: [1, 2, 3, 4, 5]
Output (without examples): {'list': ['int', 'int', 'int', '...5 total']}
Output (with examples): {'list': [1, 2, 3, '...5 total']}
```

## Example 2
A list of lists

```python
Input: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Output (without examples): {'list': [{'list': ['int', 'int', 'int']}, {'list': ['int', 'int', 'int']}, {'list': ['int', 'int', 'int']}]}
Output (with examples): {'list': [[1, 2, 3], [4, 5, 6], [7, 8, 9]]}
```
SecretStorage 3.5.0
Python bindings to FreeDesktop.org Secret Service API
Requires Python: >=3.10

.. image:: https://github.com/mitya57/secretstorage/workflows/tests/badge.svg
   :target: https://github.com/mitya57/secretstorage/actions
   :alt: GitHub Actions status
.. image:: https://codecov.io/gh/mitya57/secretstorage/branch/master/graph/badge.svg
   :target: https://codecov.io/gh/mitya57/secretstorage
   :alt: Coverage status
.. image:: https://readthedocs.org/projects/secretstorage/badge/?version=latest
   :target: https://secretstorage.readthedocs.io/en/latest/
   :alt: ReadTheDocs status

Module description
==================

This module provides a way for securely storing passwords and other secrets.

It uses D-Bus `Secret Service`_ API that is supported by GNOME Keyring,
KWallet (since version 5.97) and KeePassXC.

The main classes provided are ``secretstorage.Item``, representing a secret
item (that has a *label*, a *secret* and some *attributes*) and
``secretstorage.Collection``, a place items are stored in.

SecretStorage supports most of the functions provided by Secret Service,
including creating and deleting items and collections, editing items,
locking and unlocking collections.

The documentation can be found on `secretstorage.readthedocs.io`_.

.. _`Secret Service`: https://specifications.freedesktop.org/secret-service/
.. _`secretstorage.readthedocs.io`: https://secretstorage.readthedocs.io/en/latest/

Building the module
===================

SecretStorage requires Python ≥ 3.10 and these packages to work:

* Jeepney_
* `python-cryptography`_

To build SecretStorage, use this command::

   python3 -m build

If you have Sphinx_ installed, you can also build the documentation::

   python3 -m sphinx docs build/sphinx/html

.. _Jeepney: https://pypi.org/project/jeepney/
.. _`python-cryptography`: https://pypi.org/project/cryptography/
.. _Sphinx: https://www.sphinx-doc.org/en/master/

Testing the module
==================

First, make sure that you have the Secret Service daemon installed.
The `GNOME Keyring`_ is the reference server-side implementation for the
Secret Service specification.

.. _`GNOME Keyring`: https://download.gnome.org/sources/gnome-keyring/

Then, start the daemon and unlock the ``default`` collection, if needed.
The testsuite will fail to run if the ``default`` collection exists and is
locked. If it does not exist, the testsuite can also use the temporary
``session`` collection, as provided by the GNOME Keyring.

Then, run the Python unittest module::

   python3 -m unittest discover -s tests

If you want to run the tests in an isolated or headless environment, run
this command in a D-Bus session::

   dbus-run-session -- python3 -m unittest discover -s tests

Get the code
============

SecretStorage is available under BSD license. The source code can be found
on GitHub_.

.. _GitHub: https://github.com/mitya57/secretstorage