# ZeroBuffer Python Implementation
Native Python implementation of the ZeroBuffer protocol for high-performance zero-copy inter-process communication.
## Features
- **True Zero-Copy**: Uses memoryview and buffer protocol to avoid data copies
- **Cross-Platform**: Supports Linux, Windows, and macOS
- **Protocol Compatible**: Binary compatible with C++ and C# implementations
- **Pythonic API**: Clean, idiomatic Python interface
- **Type Safe**: Full type hints for better IDE support
- **Thread Safe**: Built-in synchronization for multi-threaded applications
## Requirements
- Python 3.8 or later
- `posix-ipc` (Linux/macOS only): `pip install posix-ipc`
- `pywin32` (Windows only): `pip install pywin32`
## Installation
```bash
pip install -e .
```
## Quick Start
### Reader Example
```python
from zerobuffer import Reader, BufferConfig
# Create a buffer
config = BufferConfig(metadata_size=1024, payload_size=1024*1024)
with Reader("my-buffer", config) as reader:
# Wait for writer to connect
print("Waiting for writer...")
# Read frames
while True:
frame = reader.read_frame(timeout=5.0)
if frame:
# Option 1: Manual frame management
data = frame.data # This is a memoryview (zero-copy)
print(f"Received frame {frame.sequence}: {len(data)} bytes")
# Process the frame...
reader.release_frame(frame) # Must release to free buffer space
# Option 2: Using context manager (RAII pattern - automatic disposal)
with frame:
data = frame.data # Automatically released when exiting 'with' block
print(f"Received frame {frame.sequence}: {len(data)} bytes")
# Process the frame...
# Frame is automatically released here
```
### Writer Example
```python
from zerobuffer import Writer
# Connect to existing buffer
with Writer("my-buffer") as writer:
# Write some metadata
metadata = b"{'format': 'raw', 'version': 1}"
writer.set_metadata(metadata)
# Write frames
for i in range(100):
data = f"Frame {i}".encode()
writer.write_frame(data)
print(f"Sent frame {i}")
```
### Zero-Copy Advanced Usage
```python
# True zero-copy writing with memoryview
import numpy as np
# Create numpy array
arr = np.arange(1000, dtype=np.float32)
# Get memoryview of array (no copy)
view = memoryview(arr)
# Write with zero-copy (memoryview is handled efficiently)
writer.write_frame(view)
# Or use direct buffer access for maximum performance
buffer = writer.get_frame_buffer(size=4000)
# Write directly into shared memory
buffer[:] = arr.tobytes()
writer.commit_frame()
```
## API Reference
### Reader Class
```python
Reader(name: str, config: Optional[BufferConfig] = None)
```
Creates a new buffer and prepares for reading.
**Methods:**
- `get_metadata() -> Optional[memoryview]`: Get metadata as zero-copy memoryview
- `read_frame(timeout: Optional[float] = 5.0) -> Optional[Frame]`: Read next frame
- `release_frame(frame: Frame) -> None`: Release frame and free buffer space
- `is_writer_connected() -> bool`: Check if writer is connected
- `close() -> None`: Close reader and clean up resources
### Writer Class
```python
Writer(name: str)
```
Connects to an existing buffer for writing.
**Methods:**
- `set_metadata(data: Union[bytes, bytearray, memoryview]) -> None`: Write metadata (once only)
- `write_frame(data: Union[bytes, bytearray, memoryview]) -> None`: Write a frame (zero-copy for memoryview)
- `get_frame_buffer(size: int) -> memoryview`: Get buffer for direct writing
- `commit_frame() -> None`: Commit frame after direct writing
- `is_reader_connected() -> bool`: Check if reader is connected
- `close() -> None`: Close writer
### Frame Class
Represents a zero-copy reference to frame data with RAII support.
**Properties:**
- `data -> memoryview`: Zero-copy view of frame data
- `size -> int`: Size of frame data
- `sequence -> int`: Sequence number
- `is_valid -> bool`: Check if frame has valid data
**RAII Support:**
The Frame class implements the context manager protocol for automatic resource management:
```python
# Manual management
frame = reader.read_frame()
if frame:
process(frame.data)
reader.release_frame(frame) # Must release manually
# Automatic management with context manager (RAII)
frame = reader.read_frame()
if frame:
with frame: # Enters context, frame is valid
process(frame.data)
# Frame is automatically disposed/released here
```
Using the context manager ensures frames are always properly released, even if an exception occurs during processing.
### BufferConfig Class
```python
BufferConfig(metadata_size: int = 1024, payload_size: int = 1024*1024)
```
Configuration for creating a buffer.
## Zero-Copy Guarantees
The Python implementation provides true zero-copy access through:
1. **memoryview objects**: No data copying when accessing frame data
2. **Buffer protocol**: Direct memory access for compatible objects
3. **Shared memory**: Direct mapping of shared memory into process space
### When Copies Occur
- Converting memoryview to bytes: `bytes(frame.data)`
- Using non-buffer protocol objects with `write_frame()`
- String encoding: `"text".encode()`
### Avoiding Copies
- Use `memoryview` objects whenever possible
- Pass memoryview directly to `write_frame()` for zero-copy operation
- Use numpy arrays or other buffer protocol objects
- Access frame data directly via `frame.data` memoryview
- Use `get_frame_buffer()` and `commit_frame()` for direct memory access
## Performance Considerations
1. **Pre-allocate buffers**: Reuse buffers instead of creating new ones
2. **Batch operations**: Process multiple frames before releasing
3. **Use appropriate buffer sizes**: See capacity planning in main README
4. **Monitor buffer utilization**: Avoid buffer full conditions
## Logging Configuration
The ZeroBuffer library uses Python's standard logging module. By default, it uses a NullHandler (no output) following Python library best practices.
### Enable Logging via Environment Variable
Set the `ZEROBUFFER_LOG_LEVEL` environment variable:
```bash
export ZEROBUFFER_LOG_LEVEL=DEBUG
python your_app.py
```
Or in Python:
```python
import os
os.environ['ZEROBUFFER_LOG_LEVEL'] = 'DEBUG'
import zerobuffer # Import after setting env var
```
### Configure Logging in Your Application
```python
import logging
import zerobuffer
# Option 1: Basic configuration for debugging
logging.basicConfig(level=logging.DEBUG)
# Option 2: Configure only zerobuffer logging
logging.getLogger('zerobuffer').setLevel(logging.DEBUG)
# Add a handler to see the output
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'
))
logging.getLogger('zerobuffer').addHandler(handler)
# Option 3: Configure specific modules
logging.getLogger('zerobuffer.reader').setLevel(logging.DEBUG) # Only reader logs
logging.getLogger('zerobuffer.writer').setLevel(logging.DEBUG) # Only writer logs
logging.getLogger('zerobuffer.duplex.server').setLevel(logging.DEBUG) # Only server logs
```
### Log Levels
- **DEBUG**: Detailed information for diagnosing issues
- Buffer creation/initialization
- Frame read/write operations with sizes and sequences
- Wrap-around detection and handling
- Semaphore operations
- OIEB state changes
- **INFO**: General operational information
- Buffer connection/disconnection
- Metadata operations
- Major state changes
- **WARNING**: Important warnings that don't prevent operation
- Missing metadata
- Retry operations
- **ERROR**: Error conditions
- Connection failures
- Processing errors
- Resource cleanup failures
## Error Handling
All operations may raise exceptions from `zerobuffer.exceptions`:
- `WriterDeadException`: Writer process died (accepts optional message)
- `ReaderDeadException`: Reader process died (accepts optional message)
- `BufferFullException`: Buffer is full
- `FrameTooLargeException`: Frame exceeds buffer capacity
- `SequenceError`: Frame sequence validation failed
- `MetadataAlreadyWrittenException`: Metadata can only be written once
- `ZeroBufferException`: Base exception for all ZeroBuffer errors
## Thread Safety
The Reader and Writer classes are thread-safe. Multiple threads can:
- Call methods on the same Reader/Writer instance
- Read frames concurrently (with proper frame release)
- Write frames concurrently
However, only one Reader and one Writer can connect to a buffer at a time.
## Platform Notes
### Linux
- Uses POSIX shared memory (`/dev/shm`)
- Requires `posix-ipc` package
- File locks in `/tmp/zerobuffer/`
### Windows
- Uses Windows named shared memory
- Requires `pywin32` package
- File locks in temp directory
### macOS
- Similar to Linux with BSD-specific handling
- Requires `posix-ipc` package
## Testing Utilities
The Python implementation includes testing utilities for cross-platform compatibility with C# and C++ implementations:
### BufferNamingService
Ensures unique buffer names across test runs to prevent conflicts:
```python
from zerobuffer_serve.services import BufferNamingService
# Creates unique buffer names for test isolation
naming_service = BufferNamingService(logger)
actual_name = naming_service.get_buffer_name("test-buffer")
# Returns: "test-buffer_<pid>_<timestamp>" or uses Harmony environment variables
```
### TestDataPatterns
Provides consistent test data generation across all language implementations:
```python
from zerobuffer_serve.test_data_patterns import TestDataPatterns
# Generate deterministic frame data
data = TestDataPatterns.generate_frame_data(size=1024, sequence=1)
# Generate simple pattern data
simple_data = TestDataPatterns.generate_simple_frame_data(size=1024)
# Verify data matches pattern
is_valid = TestDataPatterns.verify_simple_frame_data(data)
# Generate test metadata
metadata = TestDataPatterns.generate_metadata(size=256)
```
These utilities ensure that Python, C#, and C++ implementations can exchange data correctly in cross-platform tests.
## Duplex Channel Support
The Python implementation includes full support for duplex channels (bidirectional request-response communication):
```python
from zerobuffer.duplex import DuplexChannelFactory, ImmutableDuplexServer, ProcessingMode
from zerobuffer import BufferConfig, Frame, Writer
# Server side
factory = DuplexChannelFactory()
config = BufferConfig(metadata_size=4096, payload_size=10*1024*1024)
server = factory.create_immutable_server("my-service", config)
def handle_request(frame: Frame, response_writer: Writer) -> None:
"""Process request and send response"""
with frame: # RAII - frame is automatically disposed
# Access request data (zero-copy)
request_data = bytes(frame.data)
# Process the request
response_data = process_data(request_data)
# Send response
response_writer.write_frame(response_data)
# Start server with single-thread processing (default)
server.start(handle_request)
# Or specify processing mode explicitly
# server.start(handle_request, mode=ProcessingMode.SINGLE_THREAD)
# Client side
client = factory.create_client("my-service")
# Send request
request_data = b"Hello, server!"
client.send_request(request_data)
# Receive response with timeout
response = client.receive_response(timeout=5.0)
if response:
with response: # RAII - automatically disposed
print(f"Response: {bytes(response.data)}")
print(f"Sequence: {response.sequence}")
```
### Server Error Handling
```python
from zerobuffer.error_event_args import ErrorEventArgs
def handle_error(args: ErrorEventArgs) -> None:
"""Handle server errors"""
print(f"Server error: {args.exception}")
# Add error handler
server.add_error_handler(handle_error)
# Start server with metadata initialization
def on_init(metadata: memoryview) -> None:
"""Process client metadata on connection"""
client_info = bytes(metadata).decode()
print(f"Client connected with metadata: {client_info}")
server.start(handle_request, on_init=on_init)
```
See [DUPLEX_CHANNEL.md](DUPLEX_CHANNEL.md) for detailed documentation.
Raw data
{
"_id": null,
"home_page": "https://github.com/zerobuffer/zerobuffer-python",
"name": "zerobuffer-ipc",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": "ipc, shared-memory, zero-copy, streaming, video",
"author": "ZeroBuffer Contributors",
"author_email": "ModelingEvolution <info@modelingevolution.com>",
"download_url": "https://files.pythonhosted.org/packages/53/5f/12314b1b07a4edf1ada724afaeb86ea45e09546d0b95ba88207571f573cc/zerobuffer_ipc-1.2.0.tar.gz",
"platform": null,
"description": "# ZeroBuffer Python Implementation\n\nNative Python implementation of the ZeroBuffer protocol for high-performance zero-copy inter-process communication.\n\n## Features\n\n- **True Zero-Copy**: Uses memoryview and buffer protocol to avoid data copies\n- **Cross-Platform**: Supports Linux, Windows, and macOS\n- **Protocol Compatible**: Binary compatible with C++ and C# implementations\n- **Pythonic API**: Clean, idiomatic Python interface\n- **Type Safe**: Full type hints for better IDE support\n- **Thread Safe**: Built-in synchronization for multi-threaded applications\n\n## Requirements\n\n- Python 3.8 or later\n- `posix-ipc` (Linux/macOS only): `pip install posix-ipc`\n- `pywin32` (Windows only): `pip install pywin32`\n\n## Installation\n\n```bash\npip install -e .\n```\n\n## Quick Start\n\n### Reader Example\n\n```python\nfrom zerobuffer import Reader, BufferConfig\n\n# Create a buffer\nconfig = BufferConfig(metadata_size=1024, payload_size=1024*1024)\nwith Reader(\"my-buffer\", config) as reader:\n # Wait for writer to connect\n print(\"Waiting for writer...\")\n \n # Read frames\n while True:\n frame = reader.read_frame(timeout=5.0)\n if frame:\n # Option 1: Manual frame management\n data = frame.data # This is a memoryview (zero-copy)\n print(f\"Received frame {frame.sequence}: {len(data)} bytes\")\n # Process the frame...\n reader.release_frame(frame) # Must release to free buffer space\n \n # Option 2: Using context manager (RAII pattern - automatic disposal)\n with frame:\n data = frame.data # Automatically released when exiting 'with' block\n print(f\"Received frame {frame.sequence}: {len(data)} bytes\")\n # Process the frame...\n # Frame is automatically released here\n```\n\n### Writer Example\n\n```python\nfrom zerobuffer import Writer\n\n# Connect to existing buffer\nwith Writer(\"my-buffer\") as writer:\n # Write some metadata\n metadata = b\"{'format': 'raw', 'version': 1}\"\n writer.set_metadata(metadata)\n \n # Write frames\n for i in range(100):\n data = f\"Frame {i}\".encode()\n writer.write_frame(data)\n print(f\"Sent frame {i}\")\n```\n\n### Zero-Copy Advanced Usage\n\n```python\n# True zero-copy writing with memoryview\nimport numpy as np\n\n# Create numpy array\narr = np.arange(1000, dtype=np.float32)\n\n# Get memoryview of array (no copy)\nview = memoryview(arr)\n\n# Write with zero-copy (memoryview is handled efficiently)\nwriter.write_frame(view)\n\n# Or use direct buffer access for maximum performance\nbuffer = writer.get_frame_buffer(size=4000)\n# Write directly into shared memory\nbuffer[:] = arr.tobytes()\nwriter.commit_frame()\n```\n\n## API Reference\n\n### Reader Class\n\n```python\nReader(name: str, config: Optional[BufferConfig] = None)\n```\n\nCreates a new buffer and prepares for reading.\n\n**Methods:**\n- `get_metadata() -> Optional[memoryview]`: Get metadata as zero-copy memoryview\n- `read_frame(timeout: Optional[float] = 5.0) -> Optional[Frame]`: Read next frame\n- `release_frame(frame: Frame) -> None`: Release frame and free buffer space\n- `is_writer_connected() -> bool`: Check if writer is connected\n- `close() -> None`: Close reader and clean up resources\n\n### Writer Class\n\n```python\nWriter(name: str)\n```\n\nConnects to an existing buffer for writing.\n\n**Methods:**\n- `set_metadata(data: Union[bytes, bytearray, memoryview]) -> None`: Write metadata (once only)\n- `write_frame(data: Union[bytes, bytearray, memoryview]) -> None`: Write a frame (zero-copy for memoryview)\n- `get_frame_buffer(size: int) -> memoryview`: Get buffer for direct writing\n- `commit_frame() -> None`: Commit frame after direct writing\n- `is_reader_connected() -> bool`: Check if reader is connected\n- `close() -> None`: Close writer\n\n### Frame Class\n\nRepresents a zero-copy reference to frame data with RAII support.\n\n**Properties:**\n- `data -> memoryview`: Zero-copy view of frame data\n- `size -> int`: Size of frame data\n- `sequence -> int`: Sequence number\n- `is_valid -> bool`: Check if frame has valid data\n\n**RAII Support:**\nThe Frame class implements the context manager protocol for automatic resource management:\n\n```python\n# Manual management\nframe = reader.read_frame()\nif frame:\n process(frame.data)\n reader.release_frame(frame) # Must release manually\n\n# Automatic management with context manager (RAII)\nframe = reader.read_frame()\nif frame:\n with frame: # Enters context, frame is valid\n process(frame.data)\n # Frame is automatically disposed/released here\n```\n\nUsing the context manager ensures frames are always properly released, even if an exception occurs during processing.\n\n### BufferConfig Class\n\n```python\nBufferConfig(metadata_size: int = 1024, payload_size: int = 1024*1024)\n```\n\nConfiguration for creating a buffer.\n\n## Zero-Copy Guarantees\n\nThe Python implementation provides true zero-copy access through:\n\n1. **memoryview objects**: No data copying when accessing frame data\n2. **Buffer protocol**: Direct memory access for compatible objects\n3. **Shared memory**: Direct mapping of shared memory into process space\n\n### When Copies Occur\n\n- Converting memoryview to bytes: `bytes(frame.data)`\n- Using non-buffer protocol objects with `write_frame()`\n- String encoding: `\"text\".encode()`\n\n### Avoiding Copies\n\n- Use `memoryview` objects whenever possible\n- Pass memoryview directly to `write_frame()` for zero-copy operation\n- Use numpy arrays or other buffer protocol objects\n- Access frame data directly via `frame.data` memoryview\n- Use `get_frame_buffer()` and `commit_frame()` for direct memory access\n\n## Performance Considerations\n\n1. **Pre-allocate buffers**: Reuse buffers instead of creating new ones\n2. **Batch operations**: Process multiple frames before releasing\n3. **Use appropriate buffer sizes**: See capacity planning in main README\n4. **Monitor buffer utilization**: Avoid buffer full conditions\n\n## Logging Configuration\n\nThe ZeroBuffer library uses Python's standard logging module. By default, it uses a NullHandler (no output) following Python library best practices.\n\n### Enable Logging via Environment Variable\n\nSet the `ZEROBUFFER_LOG_LEVEL` environment variable:\n\n```bash\nexport ZEROBUFFER_LOG_LEVEL=DEBUG\npython your_app.py\n```\n\nOr in Python:\n```python\nimport os\nos.environ['ZEROBUFFER_LOG_LEVEL'] = 'DEBUG'\nimport zerobuffer # Import after setting env var\n```\n\n### Configure Logging in Your Application\n\n```python\nimport logging\nimport zerobuffer\n\n# Option 1: Basic configuration for debugging\nlogging.basicConfig(level=logging.DEBUG)\n\n# Option 2: Configure only zerobuffer logging\nlogging.getLogger('zerobuffer').setLevel(logging.DEBUG)\n\n# Add a handler to see the output\nhandler = logging.StreamHandler()\nhandler.setFormatter(logging.Formatter(\n '%(asctime)s - %(name)s - %(levelname)s - %(message)s'\n))\nlogging.getLogger('zerobuffer').addHandler(handler)\n\n# Option 3: Configure specific modules\nlogging.getLogger('zerobuffer.reader').setLevel(logging.DEBUG) # Only reader logs\nlogging.getLogger('zerobuffer.writer').setLevel(logging.DEBUG) # Only writer logs\nlogging.getLogger('zerobuffer.duplex.server').setLevel(logging.DEBUG) # Only server logs\n```\n\n### Log Levels\n\n- **DEBUG**: Detailed information for diagnosing issues\n - Buffer creation/initialization\n - Frame read/write operations with sizes and sequences\n - Wrap-around detection and handling\n - Semaphore operations\n - OIEB state changes\n- **INFO**: General operational information\n - Buffer connection/disconnection\n - Metadata operations\n - Major state changes\n- **WARNING**: Important warnings that don't prevent operation\n - Missing metadata\n - Retry operations\n- **ERROR**: Error conditions\n - Connection failures\n - Processing errors\n - Resource cleanup failures\n\n## Error Handling\n\nAll operations may raise exceptions from `zerobuffer.exceptions`:\n\n- `WriterDeadException`: Writer process died (accepts optional message)\n- `ReaderDeadException`: Reader process died (accepts optional message)\n- `BufferFullException`: Buffer is full\n- `FrameTooLargeException`: Frame exceeds buffer capacity\n- `SequenceError`: Frame sequence validation failed\n- `MetadataAlreadyWrittenException`: Metadata can only be written once\n- `ZeroBufferException`: Base exception for all ZeroBuffer errors\n\n## Thread Safety\n\nThe Reader and Writer classes are thread-safe. Multiple threads can:\n- Call methods on the same Reader/Writer instance\n- Read frames concurrently (with proper frame release)\n- Write frames concurrently\n\nHowever, only one Reader and one Writer can connect to a buffer at a time.\n\n## Platform Notes\n\n### Linux\n- Uses POSIX shared memory (`/dev/shm`)\n- Requires `posix-ipc` package\n- File locks in `/tmp/zerobuffer/`\n\n### Windows\n- Uses Windows named shared memory\n- Requires `pywin32` package\n- File locks in temp directory\n\n### macOS\n- Similar to Linux with BSD-specific handling\n- Requires `posix-ipc` package\n\n## Testing Utilities\n\nThe Python implementation includes testing utilities for cross-platform compatibility with C# and C++ implementations:\n\n### BufferNamingService\n\nEnsures unique buffer names across test runs to prevent conflicts:\n\n```python\nfrom zerobuffer_serve.services import BufferNamingService\n\n# Creates unique buffer names for test isolation\nnaming_service = BufferNamingService(logger)\nactual_name = naming_service.get_buffer_name(\"test-buffer\")\n# Returns: \"test-buffer_<pid>_<timestamp>\" or uses Harmony environment variables\n```\n\n### TestDataPatterns\n\nProvides consistent test data generation across all language implementations:\n\n```python\nfrom zerobuffer_serve.test_data_patterns import TestDataPatterns\n\n# Generate deterministic frame data\ndata = TestDataPatterns.generate_frame_data(size=1024, sequence=1)\n\n# Generate simple pattern data\nsimple_data = TestDataPatterns.generate_simple_frame_data(size=1024)\n\n# Verify data matches pattern\nis_valid = TestDataPatterns.verify_simple_frame_data(data)\n\n# Generate test metadata\nmetadata = TestDataPatterns.generate_metadata(size=256)\n```\n\nThese utilities ensure that Python, C#, and C++ implementations can exchange data correctly in cross-platform tests.\n\n## Duplex Channel Support\n\nThe Python implementation includes full support for duplex channels (bidirectional request-response communication):\n\n```python\nfrom zerobuffer.duplex import DuplexChannelFactory, ImmutableDuplexServer, ProcessingMode\nfrom zerobuffer import BufferConfig, Frame, Writer\n\n# Server side\nfactory = DuplexChannelFactory()\nconfig = BufferConfig(metadata_size=4096, payload_size=10*1024*1024)\nserver = factory.create_immutable_server(\"my-service\", config)\n\ndef handle_request(frame: Frame, response_writer: Writer) -> None:\n \"\"\"Process request and send response\"\"\"\n with frame: # RAII - frame is automatically disposed\n # Access request data (zero-copy)\n request_data = bytes(frame.data)\n \n # Process the request\n response_data = process_data(request_data)\n \n # Send response\n response_writer.write_frame(response_data)\n\n# Start server with single-thread processing (default)\nserver.start(handle_request)\n# Or specify processing mode explicitly\n# server.start(handle_request, mode=ProcessingMode.SINGLE_THREAD)\n\n# Client side\nclient = factory.create_client(\"my-service\")\n\n# Send request\nrequest_data = b\"Hello, server!\"\nclient.send_request(request_data)\n\n# Receive response with timeout\nresponse = client.receive_response(timeout=5.0)\nif response:\n with response: # RAII - automatically disposed\n print(f\"Response: {bytes(response.data)}\")\n print(f\"Sequence: {response.sequence}\")\n```\n\n### Server Error Handling\n\n```python\nfrom zerobuffer.error_event_args import ErrorEventArgs\n\ndef handle_error(args: ErrorEventArgs) -> None:\n \"\"\"Handle server errors\"\"\"\n print(f\"Server error: {args.exception}\")\n\n# Add error handler\nserver.add_error_handler(handle_error)\n\n# Start server with metadata initialization\ndef on_init(metadata: memoryview) -> None:\n \"\"\"Process client metadata on connection\"\"\"\n client_info = bytes(metadata).decode()\n print(f\"Client connected with metadata: {client_info}\")\n\nserver.start(handle_request, on_init=on_init)\n```\n\nSee [DUPLEX_CHANNEL.md](DUPLEX_CHANNEL.md) for detailed documentation.\n",
"bugtrack_url": null,
"license": null,
"summary": "High-performance zero-copy inter-process communication library for video streaming",
"version": "1.2.0",
"project_urls": {
"Documentation": "https://github.com/modelingevolution/zerobuffer#readme",
"Homepage": "https://github.com/modelingevolution/zerobuffer",
"Issues": "https://github.com/modelingevolution/zerobuffer/issues",
"Repository": "https://github.com/modelingevolution/zerobuffer"
},
"split_keywords": [
"ipc",
" shared-memory",
" zero-copy",
" streaming",
" video"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "cf485e571b996f4e887ede60ddbefeb19fbeed9bc69670c9a7fe8f359aeec009",
"md5": "7b3eee96c8db4713055ce55030aaba4a",
"sha256": "1006d3f240edd12d90d21353f2627552084f9d1761eae13a9af6706348934de7"
},
"downloads": -1,
"filename": "zerobuffer_ipc-1.2.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7b3eee96c8db4713055ce55030aaba4a",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 100934,
"upload_time": "2025-09-17T18:41:34",
"upload_time_iso_8601": "2025-09-17T18:41:34.649988Z",
"url": "https://files.pythonhosted.org/packages/cf/48/5e571b996f4e887ede60ddbefeb19fbeed9bc69670c9a7fe8f359aeec009/zerobuffer_ipc-1.2.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "535f12314b1b07a4edf1ada724afaeb86ea45e09546d0b95ba88207571f573cc",
"md5": "296f37538951897a1e9fa0a96fe237cf",
"sha256": "f36223d3e939526b6f1a7f6802dd4d212ad6fb070258877f23d17e894833df23"
},
"downloads": -1,
"filename": "zerobuffer_ipc-1.2.0.tar.gz",
"has_sig": false,
"md5_digest": "296f37538951897a1e9fa0a96fe237cf",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 106359,
"upload_time": "2025-09-17T18:41:36",
"upload_time_iso_8601": "2025-09-17T18:41:36.078546Z",
"url": "https://files.pythonhosted.org/packages/53/5f/12314b1b07a4edf1ada724afaeb86ea45e09546d0b95ba88207571f573cc/zerobuffer_ipc-1.2.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-09-17 18:41:36",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "zerobuffer",
"github_project": "zerobuffer-python",
"github_not_found": true,
"lcname": "zerobuffer-ipc"
}
JSON
