latzero 0.1.0__tar.gz

latzero-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: latzero
+Version: 0.1.0
+Summary: Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.
+Home-page: https://github.com/latzero/latzero
+Author: BRAHMAI
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🧠 latzero
+
+**Tagline:** Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.
+
+## 🚀 Overview
+
+**latzero** is a Python package designed to make **inter-process communication (IPC)** and **shared-memory data exchange** effortless. Unlike traditional shared memory systems that require fixed buffer sizes and manual serialization, latzero enables developers to:
+
+- Create **dynamic shared-memory pools** accessible by multiple processes or clients.
+- Pass **any pickleable object** directly — no manual encoding/decoding.
+- Enable **optional encryption + authentication** for secure multi-process collaboration.
+
+latzero is ideal for AI workloads, distributed systems, and low-latency microservices that need real-time shared state management.
+
+## 🧩 Core Features
+
+| Feature                         | Description                                                                                                                      |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| **Dynamic Shared Memory Pools** | No predefined memory size. Pools expand and contract dynamically as new data arrives.                                            |
+| **Multi-Client Access**         | Multiple processes/clients can connect to the same pool simultaneously and share data in real time.                              |
+| **Auto Cleanup**                | Data can have optional timeouts (`auto_clean=5`), automatically clearing entries after specified seconds.                        |
+| **Encryption & Authentication** | Pools can be protected with passwords. If `encryption=True`, the password becomes the encryption key.                            |
+| **Data-Type Preservation**      | Stored data retains its type (`int`, `str`, `dict`, etc.) across clients.                                                        |
+| **Self-Destructing Pools**      | Pools live only as long as one or more connected processes are active. When all disconnect, the pool is automatically destroyed. |
+| **Pickle-Based Serialization**  | Any pickleable Python object can be stored and retrieved seamlessly.                                                             |
+| **Event Sync** *(Future)*       | Hooks for client events like `on_connect`, `on_disconnect`, `on_update` for real-time sync logic.                                |
+
+## ⚙️ Installation
+
+```bash
+pip install latzero
+```
+
+## ⚙️ API Usage
+
+### Pool Creation
+
+```python
+from latzero import SharedMemoryPool
+
+pool_manager = SharedMemoryPool()
+pool_manager.create(
+    name="myPool",
+    auth=True,
+    auth_key="super_secret",
+    encryption=True
+)
+```
+
+### Connecting to a Pool
+
+```python
+ipc = pool_manager.connect(
+    name="myPool",
+    auth_key="super_secret"
+)
+```
+
+### Set and Get Operations
+
+```python
+ipc.set("key", value, auto_clean=5)
+result = ipc.get("key")
+```
+
+### Type-Safe Example
+
+```python
+ipc.set("number", 42)
+ipc.set("text", "yo bro")
+ipc.set("data", {"a": 1, "b": 2})
+
+print(ipc.get("number"))  # 42 (int)
+print(ipc.get("text"))    # "yo bro" (str)
+print(ipc.get("data"))    # {"a": 1, "b": 2} (dict)
+```
+
+## 🛠️ System Architecture
+
+### Core Components
+
+1. **Memory Controller** - Manages shared memory segments dynamically.
+2. **Pool Registry** - Tracks all active pools via metadata.
+3. **Encryption Layer** - AES-GCM encryption for secure reads/writes.
+4. **Data Layer (Pickle Serializer)** - Automatic serialization with zlib compression.
+5. **IPC Protocol** - Uses `multiprocessing.shared_memory` for communication.
+6. **Auto-Reclaim Daemon** - Monitors idle pools and clears them when unused.
+
+## 🔒 Security Model
+
+| Concern             | Mechanism                                                             |
+| ------------------- | --------------------------------------------------------------------- |
+| Unauthorized access | Password-based authentication                                         |
+| Data leakage        | AES-256 encryption when `encryption=True`                             |
+| Data tampering      | Integrity checked using HMAC                                          |
+| Memory persistence  | Pools are ephemeral; memory is released after last client disconnects |
+
+## ⚡ Performance Targets
+
+| Metric                 | Target                             |
+| ---------------------- | ---------------------------------- |
+| Read latency           | < 1ms                              |
+| Write latency          | < 2ms                              |
+| Max concurrent clients | 128+                               |
+| Memory scaling         | Dynamic up to available system RAM |
+| Pool cleanup delay     | < 100ms post last disconnect       |
+
+## Examples
+
+Check the `examples/` directory for usage demos:
+
+- `simple_pool.py` - Basic pool operations
+- `encrypted_pool.py` - Secure pool with encryption
+- `multi_client_demo.py` - Concurrent multi-client access
+
+## Dependencies
+
+- `multiprocessing.shared_memory`
+- `cryptography` (for AES)
+- `pickle`, `zlib`
+- `threading`, `multiprocessing`
+- `psutil` (for process detection)
+
+## 🧭 Roadmap
+
+- **Phase 1:** Core shared memory pools + pickle serialization
+- **Phase 2:** Auth + encryption
+- **Phase 3:** Dynamic memory expansion + auto-clean
+- **Phase 4:** Performance optimization + PyPI release
+- **Phase 5:** Real-time event hooks, WebSocket bridges
+
+## 🧃 Use Cases
+
+- AI agents sharing memory
+- Game servers syncing states
+- Local caching for microservices
+- High-speed analytics
+- Multi-agent orchestration
+
+## 🧠 TL;DR
+
+`latzero` makes **shared-memory IPC as easy as Redis**, without the network overhead. Fast, simple, encrypted, ephemeral — a *zero-latency* memory layer for Python devs.

latzero-0.1.0/README.md

@@ -0,0 +1,142 @@
+# 🧠 latzero
+
+**Tagline:** Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.
+
+## 🚀 Overview
+
+**latzero** is a Python package designed to make **inter-process communication (IPC)** and **shared-memory data exchange** effortless. Unlike traditional shared memory systems that require fixed buffer sizes and manual serialization, latzero enables developers to:
+
+- Create **dynamic shared-memory pools** accessible by multiple processes or clients.
+- Pass **any pickleable object** directly — no manual encoding/decoding.
+- Enable **optional encryption + authentication** for secure multi-process collaboration.
+
+latzero is ideal for AI workloads, distributed systems, and low-latency microservices that need real-time shared state management.
+
+## 🧩 Core Features
+
+| Feature                         | Description                                                                                                                      |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| **Dynamic Shared Memory Pools** | No predefined memory size. Pools expand and contract dynamically as new data arrives.                                            |
+| **Multi-Client Access**         | Multiple processes/clients can connect to the same pool simultaneously and share data in real time.                              |
+| **Auto Cleanup**                | Data can have optional timeouts (`auto_clean=5`), automatically clearing entries after specified seconds.                        |
+| **Encryption & Authentication** | Pools can be protected with passwords. If `encryption=True`, the password becomes the encryption key.                            |
+| **Data-Type Preservation**      | Stored data retains its type (`int`, `str`, `dict`, etc.) across clients.                                                        |
+| **Self-Destructing Pools**      | Pools live only as long as one or more connected processes are active. When all disconnect, the pool is automatically destroyed. |
+| **Pickle-Based Serialization**  | Any pickleable Python object can be stored and retrieved seamlessly.                                                             |
+| **Event Sync** *(Future)*       | Hooks for client events like `on_connect`, `on_disconnect`, `on_update` for real-time sync logic.                                |
+
+## ⚙️ Installation
+
+```bash
+pip install latzero
+```
+
+## ⚙️ API Usage
+
+### Pool Creation
+
+```python
+from latzero import SharedMemoryPool
+
+pool_manager = SharedMemoryPool()
+pool_manager.create(
+    name="myPool",
+    auth=True,
+    auth_key="super_secret",
+    encryption=True
+)
+```
+
+### Connecting to a Pool
+
+```python
+ipc = pool_manager.connect(
+    name="myPool",
+    auth_key="super_secret"
+)
+```
+
+### Set and Get Operations
+
+```python
+ipc.set("key", value, auto_clean=5)
+result = ipc.get("key")
+```
+
+### Type-Safe Example
+
+```python
+ipc.set("number", 42)
+ipc.set("text", "yo bro")
+ipc.set("data", {"a": 1, "b": 2})
+
+print(ipc.get("number"))  # 42 (int)
+print(ipc.get("text"))    # "yo bro" (str)
+print(ipc.get("data"))    # {"a": 1, "b": 2} (dict)
+```
+
+## 🛠️ System Architecture
+
+### Core Components
+
+1. **Memory Controller** - Manages shared memory segments dynamically.
+2. **Pool Registry** - Tracks all active pools via metadata.
+3. **Encryption Layer** - AES-GCM encryption for secure reads/writes.
+4. **Data Layer (Pickle Serializer)** - Automatic serialization with zlib compression.
+5. **IPC Protocol** - Uses `multiprocessing.shared_memory` for communication.
+6. **Auto-Reclaim Daemon** - Monitors idle pools and clears them when unused.
+
+## 🔒 Security Model
+
+| Concern             | Mechanism                                                             |
+| ------------------- | --------------------------------------------------------------------- |
+| Unauthorized access | Password-based authentication                                         |
+| Data leakage        | AES-256 encryption when `encryption=True`                             |
+| Data tampering      | Integrity checked using HMAC                                          |
+| Memory persistence  | Pools are ephemeral; memory is released after last client disconnects |
+
+## ⚡ Performance Targets
+
+| Metric                 | Target                             |
+| ---------------------- | ---------------------------------- |
+| Read latency           | < 1ms                              |
+| Write latency          | < 2ms                              |
+| Max concurrent clients | 128+                               |
+| Memory scaling         | Dynamic up to available system RAM |
+| Pool cleanup delay     | < 100ms post last disconnect       |
+
+## Examples
+
+Check the `examples/` directory for usage demos:
+
+- `simple_pool.py` - Basic pool operations
+- `encrypted_pool.py` - Secure pool with encryption
+- `multi_client_demo.py` - Concurrent multi-client access
+
+## Dependencies
+
+- `multiprocessing.shared_memory`
+- `cryptography` (for AES)
+- `pickle`, `zlib`
+- `threading`, `multiprocessing`
+- `psutil` (for process detection)
+
+## 🧭 Roadmap
+
+- **Phase 1:** Core shared memory pools + pickle serialization
+- **Phase 2:** Auth + encryption
+- **Phase 3:** Dynamic memory expansion + auto-clean
+- **Phase 4:** Performance optimization + PyPI release
+- **Phase 5:** Real-time event hooks, WebSocket bridges
+
+## 🧃 Use Cases
+
+- AI agents sharing memory
+- Game servers syncing states
+- Local caching for microservices
+- High-speed analytics
+- Multi-agent orchestration
+
+## 🧠 TL;DR
+
+`latzero` makes **shared-memory IPC as easy as Redis**, without the network overhead. Fast, simple, encrypted, ephemeral — a *zero-latency* memory layer for Python devs.

latzero-0.1.0/latzero/__init__.py

@@ -0,0 +1,3 @@
+from .core.pool import SharedMemoryPool
+
+__all__ = ['SharedMemoryPool']

latzero-0.1.0/latzero.egg-info/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: latzero
+Version: 0.1.0
+Summary: Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.
+Home-page: https://github.com/latzero/latzero
+Author: BRAHMAI
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography
+Requires-Dist: psutil
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🧠 latzero
+
+**Tagline:** Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.
+
+## 🚀 Overview
+
+**latzero** is a Python package designed to make **inter-process communication (IPC)** and **shared-memory data exchange** effortless. Unlike traditional shared memory systems that require fixed buffer sizes and manual serialization, latzero enables developers to:
+
+- Create **dynamic shared-memory pools** accessible by multiple processes or clients.
+- Pass **any pickleable object** directly — no manual encoding/decoding.
+- Enable **optional encryption + authentication** for secure multi-process collaboration.
+
+latzero is ideal for AI workloads, distributed systems, and low-latency microservices that need real-time shared state management.
+
+## 🧩 Core Features
+
+| Feature                         | Description                                                                                                                      |
+| ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| **Dynamic Shared Memory Pools** | No predefined memory size. Pools expand and contract dynamically as new data arrives.                                            |
+| **Multi-Client Access**         | Multiple processes/clients can connect to the same pool simultaneously and share data in real time.                              |
+| **Auto Cleanup**                | Data can have optional timeouts (`auto_clean=5`), automatically clearing entries after specified seconds.                        |
+| **Encryption & Authentication** | Pools can be protected with passwords. If `encryption=True`, the password becomes the encryption key.                            |
+| **Data-Type Preservation**      | Stored data retains its type (`int`, `str`, `dict`, etc.) across clients.                                                        |
+| **Self-Destructing Pools**      | Pools live only as long as one or more connected processes are active. When all disconnect, the pool is automatically destroyed. |
+| **Pickle-Based Serialization**  | Any pickleable Python object can be stored and retrieved seamlessly.                                                             |
+| **Event Sync** *(Future)*       | Hooks for client events like `on_connect`, `on_disconnect`, `on_update` for real-time sync logic.                                |
+
+## ⚙️ Installation
+
+```bash
+pip install latzero
+```
+
+## ⚙️ API Usage
+
+### Pool Creation
+
+```python
+from latzero import SharedMemoryPool
+
+pool_manager = SharedMemoryPool()
+pool_manager.create(
+    name="myPool",
+    auth=True,
+    auth_key="super_secret",
+    encryption=True
+)
+```
+
+### Connecting to a Pool
+
+```python
+ipc = pool_manager.connect(
+    name="myPool",
+    auth_key="super_secret"
+)
+```
+
+### Set and Get Operations
+
+```python
+ipc.set("key", value, auto_clean=5)
+result = ipc.get("key")
+```
+
+### Type-Safe Example
+
+```python
+ipc.set("number", 42)
+ipc.set("text", "yo bro")
+ipc.set("data", {"a": 1, "b": 2})
+
+print(ipc.get("number"))  # 42 (int)
+print(ipc.get("text"))    # "yo bro" (str)
+print(ipc.get("data"))    # {"a": 1, "b": 2} (dict)
+```
+
+## 🛠️ System Architecture
+
+### Core Components
+
+1. **Memory Controller** - Manages shared memory segments dynamically.
+2. **Pool Registry** - Tracks all active pools via metadata.
+3. **Encryption Layer** - AES-GCM encryption for secure reads/writes.
+4. **Data Layer (Pickle Serializer)** - Automatic serialization with zlib compression.
+5. **IPC Protocol** - Uses `multiprocessing.shared_memory` for communication.
+6. **Auto-Reclaim Daemon** - Monitors idle pools and clears them when unused.
+
+## 🔒 Security Model
+
+| Concern             | Mechanism                                                             |
+| ------------------- | --------------------------------------------------------------------- |
+| Unauthorized access | Password-based authentication                                         |
+| Data leakage        | AES-256 encryption when `encryption=True`                             |
+| Data tampering      | Integrity checked using HMAC                                          |
+| Memory persistence  | Pools are ephemeral; memory is released after last client disconnects |
+
+## ⚡ Performance Targets
+
+| Metric                 | Target                             |
+| ---------------------- | ---------------------------------- |
+| Read latency           | < 1ms                              |
+| Write latency          | < 2ms                              |
+| Max concurrent clients | 128+                               |
+| Memory scaling         | Dynamic up to available system RAM |
+| Pool cleanup delay     | < 100ms post last disconnect       |
+
+## Examples
+
+Check the `examples/` directory for usage demos:
+
+- `simple_pool.py` - Basic pool operations
+- `encrypted_pool.py` - Secure pool with encryption
+- `multi_client_demo.py` - Concurrent multi-client access
+
+## Dependencies
+
+- `multiprocessing.shared_memory`
+- `cryptography` (for AES)
+- `pickle`, `zlib`
+- `threading`, `multiprocessing`
+- `psutil` (for process detection)
+
+## 🧭 Roadmap
+
+- **Phase 1:** Core shared memory pools + pickle serialization
+- **Phase 2:** Auth + encryption
+- **Phase 3:** Dynamic memory expansion + auto-clean
+- **Phase 4:** Performance optimization + PyPI release
+- **Phase 5:** Real-time event hooks, WebSocket bridges
+
+## 🧃 Use Cases
+
+- AI agents sharing memory
+- Game servers syncing states
+- Local caching for microservices
+- High-speed analytics
+- Multi-agent orchestration
+
+## 🧠 TL;DR
+
+`latzero` makes **shared-memory IPC as easy as Redis**, without the network overhead. Fast, simple, encrypted, ephemeral — a *zero-latency* memory layer for Python devs.

latzero-0.1.0/latzero.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+setup.py
+latzero/__init__.py
+latzero.egg-info/PKG-INFO
+latzero.egg-info/SOURCES.txt
+latzero.egg-info/dependency_links.txt
+latzero.egg-info/requires.txt
+latzero.egg-info/top_level.txt

latzero-0.1.0/latzero.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

latzero-0.1.0/latzero.egg-info/requires.txt

@@ -0,0 +1,2 @@
+cryptography
+psutil

latzero-0.1.0/latzero.egg-info/top_level.txt

@@ -0,0 +1 @@
+latzero

latzero-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

latzero-0.1.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="latzero",
+    version="0.1.0",
+    author="BRAHMAI",
+    description="Zero-latency, zero-fuss shared memory for Python — dynamic, encrypted, and insanely fast.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/latzero/latzero",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+    ],
+    python_requires=">=3.7",
+    install_requires=[
+        "cryptography",
+        "psutil",
+    ],
+)