semvec/pypi-packages huggingface dataset:
dhv 1.0.0
A tool to dive into Python code
Requires Python: >=3.13
Keywords: terminal, tui, chui, documentation, python, bytecode, disassembly, disassembler

# DHV

![DHV](https://raw.githubusercontent.com/davep/dhv/refs/heads/main/.images/dhv-social-banner.png)

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

## Introduction

DHV is a terminal-based tool for diving into Python code, giving easy visual
access to [bytecode disassembly](https://docs.python.org/3/library/dis.html)
and [the abstract syntax tree](https://docs.python.org/3/library/ast.html).
If you're curious about what's "under the hood" when it comes to your Python
source, this tool should help satisfy some of that curiosity.

![DHV in action](https://raw.githubusercontent.com/davep/dhv/refs/heads/main/.images/dhv.gif)

> [!IMPORTANT]
>
> Python's `dis` module is a bit of a moving target; because of this and to
> try and keep the code as clean as possible DHV only works with Python 3.13
> or later.

## Installing

### pipx

The package can be installed using [`pipx`](https://pypa.github.io/pipx/):

```sh
$ pipx install dhv
```

### uv

The package can be install using [`uv`](https://docs.astral.sh/uv/getting-started/installation/):

```sh
uv tool install --python 3.13 dhv
```

## Using DHV

Once you've installed DHV using one of the above methods, you can run the
application using the `dhv` command.

The best way to get to know DHV is to read the help screen, once in the main
application you can see this by pressing <kbd>F1</kbd>.

## Getting help

If you need help, or have any ideas, please feel free to [raise an
issue](https://github.com/davep/dhv/issues) or [start a
discussion](https://github.com/davep/dhv/discussions).

## TODO

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

[//]: # (README.md ends here)
superstream-clients 1.0.3
Superstream optimisation library for Kafka producers
Requires Python: >=3.8

<div align="center">

<img src="https://github.com/user-attachments/assets/35899c78-24eb-4507-97ed-e87e84c49fea#gh-dark-mode-only" width="300">
<img src="https://github.com/user-attachments/assets/8a7bca49-c362-4a8c-945e-a331fb26d8eb#gh-light-mode-only" width="300">

</div>

# Superclient Python

A Python library for automatically optimizing Kafka producer configurations based on topic-specific recommendations.

## Overview

Superstream Clients works as a Python import hook that intercepts Kafka producer creation and applies optimized configurations without requiring any code changes in your application. It dynamically retrieves optimization recommendations from Superstream and applies them based on impact analysis.

## Supported Libraries

- kafka-python
- aiokafka
- confluent-kafka
- Faust
- FastAPI event publishers
- Celery Kafka backends
- Any custom wrapper around these Kafka clients

## Features

- **Zero-code integration**: No code changes required in your application
- **Dynamic configuration**: Applies optimized settings based on topic-specific recommendations
- **Intelligent optimization**: Identifies the most impactful topics to optimize
- **Graceful fallback**: Falls back to default settings if optimization fails

## Installation

```bash
pip install superstream-clients && python -m superclient install_pth
```

That's it! Superclient will now automatically load and optimize all Kafka producers in your Python environment.

## Usage

After installation, superclient works automatically. Just use your Kafka clients as usual.

### Docker Integration

When using Superstream Clients with containerized applications, include the package in your Dockerfile:

```dockerfile
FROM python:3.8-slim

# Install superclient
RUN pip install superstream-clients
RUN python -m superclient install_pth

# Your application code
COPY . /app
WORKDIR /app

# Run your application
CMD ["python", "your_app.py"]
```

### Required Environment Variables

- `SUPERSTREAM_TOPICS_LIST`: Comma-separated list of topics your application produces to

### Optional Environment Variables

- `SUPERSTREAM_LATENCY_SENSITIVE`: Set to "true" to prevent any modification to linger.ms values
- `SUPERSTREAM_DISABLED`: Set to "true" to disable optimization
- `SUPERSTREAM_DEBUG`: Set to "true" to enable debug logs

Example:
```bash
export SUPERSTREAM_TOPICS_LIST=orders,payments,user-events
export SUPERSTREAM_LATENCY_SENSITIVE=true
```

## Prerequisites

- Python 3.8 or higher
- Kafka cluster that is connected to the Superstream's console
- Read and write permissions to the `superstream.*` topics

## License

Apache License 2.0
superstream-clients-beta 1.0.3
Superstream optimisation library for Kafka producers
Requires Python: >=3.8

<div align="center">

<img src="https://github.com/user-attachments/assets/35899c78-24eb-4507-97ed-e87e84c49fea#gh-dark-mode-only" width="300">
<img src="https://github.com/user-attachments/assets/8a7bca49-c362-4a8c-945e-a331fb26d8eb#gh-light-mode-only" width="300">

</div>

# Superclient Python

A Python library for automatically optimizing Kafka producer configurations based on topic-specific recommendations.

## Overview

Superstream Clients works as a Python import hook that intercepts Kafka producer creation and applies optimized configurations without requiring any code changes in your application. It dynamically retrieves optimization recommendations from Superstream and applies them based on impact analysis.

## Supported Libraries

- kafka-python
- aiokafka
- confluent-kafka
- Faust
- FastAPI event publishers
- Celery Kafka backends
- Any custom wrapper around these Kafka clients

## Features

- **Zero-code integration**: No code changes required in your application
- **Dynamic configuration**: Applies optimized settings based on topic-specific recommendations
- **Intelligent optimization**: Identifies the most impactful topics to optimize
- **Graceful fallback**: Falls back to default settings if optimization fails

## Installation

```bash
pip install superstream-clients && python -m superclient install_pth
```

That's it! Superclient will now automatically load and optimize all Kafka producers in your Python environment.

## Usage

After installation, superclient works automatically. Just use your Kafka clients as usual.

### Docker Integration

When using Superstream Clients with containerized applications, include the package in your Dockerfile:

```dockerfile
FROM python:3.8-slim

# Install superclient
RUN pip install superstream-clients
RUN python -m superclient install_pth

# Your application code
COPY . /app
WORKDIR /app

# Run your application
CMD ["python", "your_app.py"]
```

### Required Environment Variables

- `SUPERSTREAM_TOPICS_LIST`: Comma-separated list of topics your application produces to

### Optional Environment Variables

- `SUPERSTREAM_LATENCY_SENSITIVE`: Set to "true" to prevent any modification to linger.ms values
- `SUPERSTREAM_DISABLED`: Set to "true" to disable optimization
- `SUPERSTREAM_DEBUG`: Set to "true" to enable debug logs

Example:
```bash
export SUPERSTREAM_TOPICS_LIST=orders,payments,user-events
export SUPERSTREAM_LATENCY_SENSITIVE=true
```

## Prerequisites

- Python 3.8 or higher
- Kafka cluster that is connected to the Superstream's console
- Read and write permissions to the `superstream.*` topics

## License

Apache License 2.0
eveo7-mumbleserver-ice 0.0.6
Python bindings for interacting with Mumble server using ZeroC's ICE technology.
Requires Python: <3.13,>=3.12
Keywords: ice, mumble, murmur, slice2py, zeroc

# MumbleServer Ice Python Module

This Python module provides Python bindings for interacting with Mumble's Murmur server through ZeroC's ICE technology.

## Features

Auto-generated Python bindings using `slice2py` for MumbleServer ICE.

## Requirements

- `uv`: To manage dependencies.
- `requests`: To download MumbleServer.ice.
- `slice2py`: To generate Python code from MumbleServer ICE.

## Code Generation

Refer to the code generation script in the repository to regenerate the module.

## Usage

After generating the module, import it to interact with Mumble's Murmur server. Ensure you have the necessary ICE runtime and dependencies installed.

## See also

- [Code Generation in Python (ZeroC Docs)](https://doc.zeroc.com/ice/latest/language-mappings/python-mapping/client-side-slice-to-python-mapping/code-generation-in-python)
- [Mumble GitHub Repository](https://github.com/mumble-voip/mumble)
- [Latest MumbleServer.ice File](https://raw.githubusercontent.com/mumble-voip/mumble/refs/heads/master/src/murmur/MumbleServer.ice)

## License

Distributed under the terms of the [Mumble license](https://www.mumble.info/LICENSE).
st-custom-component 0.0.1
Streamlit component that allows you to do X
Requires Python: >=3.7

# streamlit-custom-component

Streamlit component that allows you to do X

## Installation instructions

```sh
pip install streamlit-custom-component
```

## Usage instructions

```python
import streamlit as st

from my_component import my_component

value = my_component()

st.write(value)
```

## Local development

1. Start Streamlit from the project root:

   ```sh
   streamlit run my_component/example.py
   ```

2. In another terminal, run the Vite dev server from `my_component/frontend`:

   ```sh
   npm install
   npm run start
   ```

### Important dev server notes

- The browser connects to the Vite dev server directly. Streamlit does **not** proxy this port, so the Vite port must be reachable from the client just like the Streamlit port.
- Vite listens on the value of `VITE_PORT` (default `3001`). This variable lives in `my_component/frontend/.env`. Update that file whenever you need to change the port, and remember that Windows/WSL/Hyper-V or dev containers may silently remap addresses like `3001`.
- If a port is unavailable or blocked by a firewall/mobile connection, set `VITE_PORT=5173` (Vite's default) or any other open port inside the `.env` file before running `npm run start`, and ensure that port is reachable from your browser.
radicalbit-ai-monitoring 0.12.0
Radicalbit AI Monitoring platform installer
Requires Python: <4.0,>=3.11

# Radicalbit AI Monitoring Installer

This tool is meant to manage the installation of the Radicalbit AI Monitoring Platform [see Open Source repo](https://github.com/radicalbit/radicalbit-ai-monitoring).

## Install

To install you can use [Poetry](https://python-poetry.org/) package manager or via `pip`.

### Using poetry

1. Clone the repository using `git clone https://github.com/radicalbit/radicalbit-ai-monitoring-installer.git`.
1. Move inside the repository using `cd radicalbit-ai-monitoring-installer`.
1. Install poetry using `poetry install`.

### Using pip

Just run `pip install radicalbit-ai-monitoring`.

## Prerequisites

- Python 3.10+
- Docker
- Docker compose

## Usage

If you use poetry to install the project, be sure to activate the shell environment with `poetry shell`.

You can use `rbit-ai-monitoring <command> --help` to get info about the command.

### Commands

- `rbit-ai-monitoring platform install`: install the radicalbit AI Monitoring Platform on the local machine.
- `rbit-ai-monitoring platform uninstall`: uninstall the radicalbit AI Monitoring Platform from the local machine.
- `rbit-ai-monitoring platform down`: stop the execution of the application.
- `rbit-ai-monitoring platform up`: start the execution of the application.
- `rbit-ai-monitoring info`: show info about Radicalbit AI.
mattermost-client-py 0.1.2
A Python client for Mattermost incoming webhooks.
Requires Python: >=3.7

# Mattermost Client for Incoming Webhooks

A simple Python client for sending messages to Mattermost using incoming webhooks.

## Installation

```bash
pip install mattermost-client-py
```

## Usage

First, you need to create an incoming webhook in your Mattermost instance. You can find instructions on how to do that [here](https://developers.mattermost.com/integrate/webhooks/incoming/).

### Synchronous Client

The synchronous client is useful for simple applications that don't require asynchronous operations.

```python
from mattermost_client import SyncMattermostClient

# Initialize the client with your Mattermost webhook URL
client = SyncMattermostClient("https://your-mattermost-instance.com/hooks/your_webhook_token")

# Send a simple message
response = client.send_message(text='Hello, Mattermost!')
print(response)

# Send a more complex message with attachments
attachments = [
    {
        "fallback": "Upgrade your client to see this attachment.",
        "color": "#FF8000",
        "pretext": "This is optional pretext that shows above the attachment.",
        "author_name": "Mattermost",
        "author_link": "https://mattermost.com/",
        "author_icon": "http://www.mattermost.org/wp-content/uploads/2016/04/icon.png",
        "title": "Example Attachment",
        "title_link": "https://docs.mattermost.com/developer/message-attachments.html",
        "text": "This is the text of the attachment. It can be formatted with Markdown.",
        "fields": [
            {
                "short": False,
                "title": "Long Field",
                "value": "This is a long field, so it is not short."
            },
            {
                "short": True,
                "title": "Short Field",
                "value": "This is a short field."
            }
        ],
        "image_url": "http://www.mattermost.org/wp-content/uploads/2016/04/icon.png"
    }
]


response = client.send_message(
    text='A message with an attachment.',
    attachments=attachments,
    channel='town-square',
    username='My Bot',
    icon_url='https://www.mattermost.org/wp-content/uploads/2016/04/icon.png'
)
print(response)
```

## Asynchronous Usage (with aiohttp)

The asynchronous client is ideal for applications using `asyncio`.

```python
import asyncio
from mattermost_client import AsyncMattermostClient

async def main():
    # Initialize the client with your Mattermost webhook URL
    mm = AsyncMattermostClient("https://your-mattermost-instance.com/hooks/your_webhook_token")

    # Send a message asynchronously
    response = await mm.send_message("Hello, Mattermost! (async)")
    print(response)

if __name__ == "__main__":
    asyncio.run(main())
```

## Contributing

Contributions are welcome! Please open an issue or submit a pull request on GitHub.

## License

This project is licensed under the MIT License.