semvec/pypi-packages huggingface dataset:
multipac-testbench 1.8.2
Post-treat the data produced by the MULTIPAC test bench.
Requires Python: >=3.11
Keywords: post treatment, multipactor

# MULTIPAC testbench
This library is designed to post-treat the data from the MULTIPAC multipactor test bench at LPSC, Grenoble, France.

## Installation

### Users
1. Create a dedicated Python environment, activate it.
2. Run `pip install multipac_testbench`

> [!NOTE]
> If you are completely new to Python and these instructions are unclear, check [this tutorial](https://python-guide.readthedocs.io/en/latest/).
> In particular, you will want to:
> 1. [Install Python](https://python-guide.readthedocs.io/en/latest/starting/installation/) 3.11 or higher.
> 2. [Learn to use Python environments](https://python-guide.readthedocs.io/en/latest/dev/virtualenvs/), `pipenv` or `virtualenv`.
> 3. [Install a Python IDE](https://python-guide.readthedocs.io/en/latest/dev/env/#ides) such as Spyder or VSCode.

### Developers
1. Clone the repository:
`git clone git@github.com:AdrienPlacais/multipac_testbench.git`
2. Create a dedicated Python environment, activate it.
3. Navigate to the main `multipac_testbench` folder and install the library with all dependencies: `pip install -e .`

Note that you will need Python 3.11 or higher to use the library.

If you want to use `conda`, you must manually install the required packages defined in `pyproject.toml`.
Then, add `multipac_testbench.src` to your `$PYTHONPATH` environment variable.

## Project info

- 📚 [Documentation](https://multipac-testbench.readthedocs.io/en/stable/)
- 📋 [Changelog](./CHANGELOG.md)
- 🤝 [Contributing](./CONTRIBUTING.md)
- 🚀 [Tutorials/examples](https://multipac-testbench.readthedocs.io/en/stable/manual/tutorials.html)

TODO:
- [ ] Add notebook execution to normal test workflow.
  - [ ] Add jupyter installation to `pip` deps for test

## Future updates

- [X] Calibration of new field probes.
- [X] Implementation of Retarding Field Analyzer.
    - [X] RPA grid in V instead of kV.
- [ ] `sweet_plot` updates for better RPA treatment:
    - [ ] Allow for `head` argument, working similarly to `tail`.
    - [X] Argument to plot increasing and decreasing values differently. Useful when plotting RPA current against RPA grid voltage.
- [ ] Option to plot maximum of a signal per power cycle.
- [ ] Bug fix: Upper threshold is given even when we did not exit the multipactor zone.
- [X] Adding a post-treater to `Power` instruments should be reflected in `SWR` and `ReflectionCoefficient` calculations.

## Labviewer to-do
- [ ] Automatic export binary -> xlsx or csv
- [ ] Automatic export of individual power step files
- [ ] Allow to take last value from individual power step file rather than highest
- [ ] Fix synxhro of dBm column
getstream-plugins-deepgram 0.1.1
Deepgram plugin for GetStream
Requires Python: >=3.10

# Deepgram Speech-to-Text Plugin

A high-quality Speech-to-Text (STT) plugin for GetStream that uses the Deepgram API.

## Installation

```bash
pip install getstream-plugins-deepgram
```

## Usage

```python
from getstream.plugins.deepgram import DeepgramSTT

# Initialize with API key from environment variable
stt = DeepgramSTT()

# Or specify API key directly
stt = DeepgramSTT(api_key="your_deepgram_api_key")

# Register event handlers
@stt.on("transcript")
def on_transcript(text, user, metadata):
    print(f"Final transcript from {user}: {text}")

@stt.on("partial_transcript")
def on_partial(text, user, metadata):
    print(f"Partial transcript from {user}: {text}")

# Process audio
await stt.process_audio(pcm_data)

# When done
await stt.close()
```

## Configuration Options

- `api_key`: Deepgram API key (default: reads from DEEPGRAM_API_KEY environment variable)
- `options`: Deepgram LiveOptions for configuring the transcription
- `sample_rate`: Sample rate of the audio in Hz (default: 16000)
- `language`: Language code for transcription (default: "en-US")
- `keep_alive_interval`: Interval in seconds to send keep-alive messages (default: 5.0)

## Requirements

- Python 3.10+
- deepgram-sdk>=4.5.0
- numpy>=2.2.6,<2.3
getstream-plugins-common 0.1.1
Common plugin for GetStream
Requires Python: >=3.10

# GetStream Common Plugin

This package provides shared abstract base classes and utilities for all GetStream AI plugins.

## Purpose

The common plugin defines the standard interfaces that all GetStream AI plugins implement:

- **STT** (Speech-to-Text): Base class for transcription plugins
- **TTS** (Text-to-Speech): Base class for synthesis plugins
- **VAD** (Voice Activity Detection): Base class for speech detection plugins
- **STS** (Speech-to-Speech): Base class for direct speech transformation plugins

## Installation

This package is automatically installed as a dependency when you install any GetStream AI plugin:

```bash
# Installing any plugin will include the common interfaces
pip install getstream-plugins-deepgram
pip install getstream-plugins-elevenlabs
# etc.
```

## Usage

Plugin developers should inherit from these base classes:

```python
from getstream.plugins.common import STT, TTS, VAD, STS

class MySTTPlugin(STT):
    async def process_audio(self, pcm_data):
        # Your STT implementation
        pass

class MyTTSPlugin(TTS):
    async def synthesize(self, text):
        # Your TTS implementation
        pass
```

## Requirements

- Python 3.10+
- getstream[webrtc]

## For Plugin Developers

If you're creating a new GetStream AI plugin, make sure to:

1. Add `getstream-plugins-common` as a dependency in your `pyproject.toml`
2. Inherit from the appropriate base class (STT, TTS, VAD, or STS)
3. Implement the required abstract methods
4. Follow the event emission patterns defined in the base classes

This ensures consistency across all GetStream AI plugins and provides users with a unified interface.
loggerex 0.7.6
Python logging made (stupidly) simple
Requires Python: <4.0,>=3.5
Keywords: LoggerEx, logging, logger, log

🚀 LoggerEx - Python Logging Made Beautifully Simple

🔍 Why LoggerEx?
Tired of complex logging setups? LoggerEx makes it simple:
from loggerex import logger  # That's it. You're done. 🎉
logger.success("Hello, beautiful logs!")

✨ Key Features:
- Zero-config magic
- Production-ready
- Developer-friendly
- Drop-in replacement for standard logging

⚡ Quick Start:
Installation:
pip install loggerex

Basic Usage:
```
from loggerex import logger
logger.debug("Debug message 🤓")
logger.info("Informational ℹ️")
logger.warning("Warning! ⚠️")
logger.error("Error occurred ❌")
logger.critical("CRITICAL! 🚨")
```

🌟 Premium Features:
1. Emoji Support: logger.rainbow("🌈 Colorful logs!")
2. Performance Tracking: @logger.timer()
3. Secret Masking: logger.mask(api_key)
4. Smart Formatting: logger.opt(colors=True)
5. Async Ready: await logger.async_debug()

🛠️ Advanced Configuration:
```
logger.configure(
    handlers=[
        {"sink": "file.log", "serialize": True},
        {"sink": sys.stderr, "colorize": True}
    ],
    levels=[{"name": "VERBOSE", "icon": "🔍"}],
    patch=True
)
```

📜 License: MIT - free forever

✨ Happy Logging! ✨
libadalina 0.1.0
A library for graph analytics with geographic data
Requires Python: ~=3.10

# libadalina

A library for graph processing with geographic data.

## Installation

### From sources

To install from the source code, clone the repository and run the following commands:

```bash
git clone --recurse-submodules git@gitlab.com:amelia_unimi/libadalina.git
pip install -e libadalina
```

To run the examples on provided samples data, you can clone the submodules as well:

```bash
git clone --recurse-submodules git@gitlab.com:amelia_unimi/libadalina.git
python libadalina/__main__.py 
```

If `JAVA_HOME` environment variable is not set a suitable JDK will be downloaded in `$HOME/.jre` and used automatically.
Not all JRE are supported, so if you encounter issues, you can try the automatically installed version.

## Usage

You can import it in your Python code:

```python
from libadalina.readers.open_street_map import OpenStreetMapReader
from libadalina.graph.graph_factory import GraphFactory
from libadalina.writers.to_geopackage import graph_to_geopackage

# Read data
reader = OpenStreetMapReader()
gfd = reader.read('path/to/your/data.csv')

# Create graph
graph_factory = GraphFactory(gfd)
graph = graph_factory.name('YourGraphName').build()

# Export graph
graph_to_geopackage(graph, 'output.gpkg')
```

## Features

- Read geographic data from OpenStreetMap
- Build and process graph structures
- Export graphs to various formats (GeoPackage, CSV, Shapefile)
- Perform graph operations like shortest path finding

## Requirements

- Python 3.10
- Dependencies:
  - apache-sedona[spark]
  - pyspark
  - pandas
  - geopandas
  - networkx
deepctl-cmd-debug-network 0.1.10
Network debug subcommand for deepctl
Requires Python: >=3.10
Keywords: deepgram, cli, debug, network, diagnostics

# deepctl-cmd-debug-network

Network debug subcommand for the Deepgram CLI (deepctl). This package provides the `network` subcommand under the `debug` command group, allowing users to debug network issues or problems connecting to api.deepgram.com
deepctl-cmd-debug-audio 0.1.10
Audio debug subcommand for deepctl
Requires Python: >=3.10
Keywords: deepgram, cli, debug, audio, diagnostics

# deepctl-cmd-debug-audio

Audio debug subcommand for the Deepgram CLI (deepctl). This package provides the `audio` subcommand under the `debug` command group, allowing users to debug audio-related issues using ffprobe presets.

`ffmpeg` is required.
deepctl-cmd-plugin 0.1.10
Plugin management command for deepctl
Requires Python: >=3.10

# deepctl-cmd-plugin

Plugin management command for deepctl CLI.

## Description

This command provides plugin management functionality for deepctl, allowing users to:

- Search for available plugins in the registry
- Install plugins from PyPI, GitHub, or local paths
- List installed plugins
- Update plugins to newer versions
- Remove plugins

This solves the environment isolation issue that occurs when deepctl is installed via pipx, uv, brew, or other package managers that create isolated environments.

## Commands

- `deepctl plugin search [query]` - Search for available plugins
- `deepctl plugin install <package>` - Install a plugin
- `deepctl plugin list` - List installed plugins
- `deepctl plugin update <package>` - Update a plugin
- `deepctl plugin remove <package>` - Remove a plugin

## Examples

### Search for plugins

```bash
# Show all available plugins
deepctl plugin search

# Search for plugins by keyword
deepctl plugin search audio

# Show only installed plugins
deepctl plugin search --installed

# Show only available (not installed) plugins
deepctl plugin search --available
```

### Install plugins

```bash
# Install from PyPI
deepctl plugin install deepctl-plugin-example

# Install from GitHub
deepctl plugin install git+https://github.com/deepgram/deepctl-plugin-custom.git

# Install specific version
deepctl plugin install deepctl-plugin-example==1.0.0

# Install from local directory
deepctl plugin install -e /path/to/plugin
```

## How it works

The plugin command automatically detects how deepctl was installed:

- **pip/pipx/uv**: Plugins install directly into the same environment
- **System installations (brew, apt, etc.)**: Plugins install into an isolated environment at `~/.deepctl/plugins/venv`

This approach ensures all installation methods support plugins while maintaining system package manager integrity.

## Plugin Registry

The `plugin search` command shows plugins from a curated registry. Currently, the registry is hardcoded but will eventually fetch from a `.well-known` URL or plugin registry service.

## Development

This is a built-in command that is part of the deepctl core distribution.
deepctl-cmd-update 0.1.10
Update command for deepctl
Requires Python: >=3.10
Keywords: deepgram, cli, update, self-update

# deepctl-cmd-update

Update command for deepctl CLI - provides self-update functionality.

## Features

- Check for newer versions on PyPI
- Detect installation method (pip, pipx, uv, system, development)
- Remember installation method for future updates
- Provide appropriate update commands
- Support for various installation scenarios

## Installation

This package is included with deepctl and doesn't need separate installation.

## Usage

Check for updates:

```bash
deepctl update --check-only
```

Update deepctl:

```bash
deepctl update
```

Force update (even if already up to date):

```bash
deepctl update --force
```

Skip confirmation:

```bash
deepctl update --yes
```

## Development

This package is part of the deepctl monorepo. See the main repository for development instructions.
deepctl-cmd-mcp 0.1.10
MCP server command for deepctl to interact with Deepgram's AI assistant service
Requires Python: >=3.10

# deepctl-cmd-mcp

MCP (Model Context Protocol) server command for deepctl, enabling LLM clients to interact with Deepgram's AI assistant service.

## Features

- 🤖 Connect to Deepgram's Gnosis AI service via MCP
- 🔧 Multiple transport modes (stdio, SSE, streamable-http)
- 🔍 Intelligent question answering about Deepgram
- 📚 API specification lookup
- 💻 Code example generation
- 📖 Documentation search

## Installation

This package is installed as part of the deepctl CLI:

```bash
pip install deepgram-cli
```

Or install directly:

```bash
pip install deepctl-cmd-mcp
```

## Usage

Run the MCP server:

```bash
deepctl mcp
```

With options:

```bash
# Use SSE transport on custom port
deepctl mcp --transport sse --port 8080

# Enable debug logging
deepctl mcp --debug

# Use custom API key
deepctl mcp --api-key YOUR_API_KEY
```

## Known Limitations

### Signal Handling in STDIO Mode

When running in STDIO mode (default), you may need to press Ctrl+C twice to stop the server. This is a known limitation of the FastMCP framework. For production deployments, consider using SSE or HTTP transport modes which handle signals more gracefully.

## Transport Modes
deepctl-cmd-debug-browser 0.1.10
Browser debug subcommand for deepctl
Requires Python: >=3.10
Keywords: deepgram, cli, debug, browser, diagnostics

# deepctl-cmd-debug-browser

Browser debug subcommand for the Deepgram CLI (deepctl). This package provides the `browser` subcommand under the `debug` command group, allowing users to debug browser-related issues when using Deepgram's web-based features