blockdevice 1.16.0__tar.gz → 2.0.0__tar.gz

blockdevice-2.0.0/MANIFEST.in

@@ -0,0 +1,6 @@
+recursive-include include *
+recursive-include tests *
+recursive-include examples *
+include LICENSE.md
+include README.md
+include requirements.txt

blockdevice-2.0.0/PKG-INFO

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: blockdevice
+Version: 2.0.0
+Summary: A simple C++ Python library for block device operations
+Author-email: Omena0 <omena0mc@gmail.com>
+License: # PolyForm Noncommercial License 1.0.0
+        
+        <https://polyformproject.org/licenses/noncommercial/1.0.0>
+        
+        ## Acceptance
+        
+        In order to get any license under these terms, you must agree
+        to them as both strict obligations and conditions to all
+        your licenses.
+        
+        ## Copyright License
+        
+        The licensor grants you a copyright license for the
+        software to do everything you might do with the software
+        that would otherwise infringe the licensor's copyright
+        in it for any permitted purpose.  However, you may
+        only distribute the software according to [Distribution
+        License](#distribution-license) and make changes or new works
+        based on the software according to [Changes and New Works
+        License](#changes-and-new-works-license).
+        
+        ## Distribution License
+        
+        The licensor grants you an additional copyright license
+        to distribute copies of the software.  Your license
+        to distribute covers distributing the software with
+        changes and new works permitted by [Changes and New Works
+        License](#changes-and-new-works-license).
+        
+        ## Notices
+        
+        You must ensure that anyone who gets a copy of any part of
+        the software from you also gets a copy of these terms or the
+        URL for them above, as well as copies of any plain-text lines
+        beginning with `Required Notice:` that the licensor provided
+        with the software.  For example:
+        
+        > Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+        
+        ## Changes and New Works License
+        
+        The licensor grants you an additional copyright license to
+        make changes and new works based on the software for any
+        permitted purpose.
+        
+        ## Patent License
+        
+        The licensor grants you a patent license for the software that
+        covers patent claims the licensor can license, or becomes able
+        to license, that you would infringe by using the software.
+        
+        ## Noncommercial Purposes
+        
+        Any noncommercial purpose is a permitted purpose.
+        
+        ## Personal Uses
+        
+        Personal use for research, experiment, and testing for
+        the benefit of public knowledge, personal study, private
+        entertainment, hobby projects, amateur pursuits, or religious
+        observance, without any anticipated commercial application,
+        is use for a permitted purpose.
+        
+        ## Noncommercial Organizations
+        
+        Use by any charitable organization, educational institution,
+        public research organization, public safety or health
+        organization, environmental protection organization,
+        or government institution is use for a permitted purpose
+        regardless of the source of funding or obligations resulting
+        from the funding.
+        
+        ## Fair Use
+        
+        You may have "fair use" rights for the software under the
+        law. These terms do not limit them.
+        
+        ## No Other Rights
+        
+        These terms do not allow you to sublicense or transfer any of
+        your licenses to anyone else, or prevent the licensor from
+        granting licenses to anyone else.  These terms do not imply
+        any other licenses.
+        
+        ## Patent Defense
+        
+        If you make any written claim that the software infringes or
+        contributes to infringement of any patent, your patent license
+        for the software granted under these terms ends immediately. If
+        your company makes such a claim, your patent license ends
+        immediately for work on behalf of your company.
+        
+        ## Violations
+        
+        The first time you are notified in writing that you have
+        violated any of these terms, or done anything with the software
+        not covered by your licenses, your licenses can nonetheless
+        continue if you come into full compliance with these terms,
+        and take practical steps to correct past violations, within
+        32 days of receiving notice.  Otherwise, all your licenses
+        end immediately.
+        
+        ## No Liability
+        
+        ***As far as the law allows, the software comes as is, without
+        any warranty or condition, and the licensor will not be liable
+        to you for any damages arising out of these terms or the use
+        or nature of the software, under any kind of legal claim.***
+        
+        ## Definitions
+        
+        The **licensor** is the individual or entity offering these
+        terms, and the **software** is the software the licensor makes
+        available under these terms.
+        
+        **You** refers to the individual or entity agreeing to these
+        terms.
+        
+        **Your company** is any legal entity, sole proprietorship,
+        or other kind of organization that you work for, plus all
+        organizations that have control over, are under the control of,
+        or are under common control with that organization.  **Control**
+        means ownership of substantially all the assets of an entity,
+        or the power to direct its management and policies by vote,
+        contract, or otherwise.  Control can be direct or indirect.
+        
+        **Your licenses** are all the licenses granted to you for the
+        software under these terms.
+        
+        **Use** means anything you do with the software requiring one
+        of your licenses.
+        
+Keywords: block-device,fuse,filesystem,storage
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Filesystems
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# Blockdevice
+
+[![Build](https://github.com/Omena0/blockdevice/actions/workflows/publish.yml/badge.svg)](https://github.com/Omena0/blockdevice/actions/workflows/publish.yml)
+[![pytest](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml/badge.svg)](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml)
+[![Coverage](https://img.shields.io/badge/coverage-48%25-brightgreen)](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml)
+![AI Code](https://img.shields.io/badge/AI_code-99%25-red?logo=Github%20copilot)
+
+A Python library for creating and managing block devices with FUSE filesystem support. Provides persistent object storage with compression options and real-time synchronization capabilities.
+
+## Features
+
+- **Block Device Operations**: C++ extension for efficient block device operations
+- **FUSE Filesystem**: Mount block devices as user-space filesystems
+- **Persistent Storage**: Multiple storage backends including disk-based and compressed storage
+- **Real-time Sync**: Network synchronization for distributed applications
+- **Python Integration**: Seamless integration with Python applications
+
+## Installation
+
+### From Source
+```bash
+git clone https://github.com/Omena0/blockdevice.git
+cd blockdevice
+pip install .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from blockdevice import BlockDevice, DiskObject
+
+# Create a block device
+dev = BlockDevice("/path/to/device", dolphin=True)
+
+# Create persistent storage
+storage = DiskObject("data.pkl")
+storage['key'] = 'value'
+print(storage['key'])  # 'value'
+
+dev.start(True) # Start FUSE filesystem
+```
+
+### Compressed Storage
+
+```python
+from blockdevice import CompressedDiskObject
+
+# Create compressed persistent storage
+storage = CompressedDiskObject("data.zst", compression_level=10)
+storage['large_data'] = 'x' * 10000  # Automatically compressed
+```
+
+### Network Synchronization
+
+```python
+from blockdevice import NetworkObject
+
+# Create synchronized object (connects to server or becomes server)
+sync_obj = NetworkObject('localhost', 8080)
+sync_obj['shared_data'] = 'available on all connected instances'
+```
+
+## Architecture
+
+The library consists of several key components:
+
+- **BlockDevice**: C++ extension providing low-level block operations
+- **Storage Objects**: 
+  - `Object`: Abstract base class for persistent objects
+  - `DiskObject`: Pickle-based disk storage
+  - `CompressedDiskObject`: Zstd-compressed disk storage
+  - `NetworkObject`: Real-time synchronized storage
+- **FUSE Integration**: `BlockDeviceFUSE` class for filesystem mounting
+
+## Development
+
+### Setup
+```bash
+git clone https://github.com/Omena0/blockdevice.git
+cd blockdevice
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+pip install -e .
+```
+
+### Testing
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=blockdevice --cov-report=html
+
+# Run specific test file
+pytest tests/test_utils.py
+```
+
+### Building
+```bash
+# Build the C++ extension
+python setup.py build_ext --inplace
+
+# Build distribution
+python setup.py sdist bdist_wheel
+```
+
+## Examples
+
+See the `examples/` directory for sample applications:
+
+- `compressed.py`: Filesystem implementation with compression
+- `network/`: Client-server examples
+
+## API Reference
+
+### BlockDevice
+```python
+BlockDevice(path: str, dolphin: bool = False)
+```
+Core block device operations.
+
+### Storage Classes
+
+#### DiskObject
+```python
+DiskObject(path: str, default_value=None)
+```
+Persistent dictionary stored as pickle file.
+
+#### CompressedDiskObject
+```python
+CompressedDiskObject(path: str, default_value=None, compression_level=5)
+```
+Compressed persistent storage using zstd.
+
+#### NetworkObject
+```python
+NetworkObject(host: str, port: int = None, default_value=None)
+```
+Real-time synchronized storage across network.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+## License
+
+See LICENSE.md for license information.
+

blockdevice-2.0.0/README.md

@@ -0,0 +1,156 @@
+# Blockdevice
+
+[![Build](https://github.com/Omena0/blockdevice/actions/workflows/publish.yml/badge.svg)](https://github.com/Omena0/blockdevice/actions/workflows/publish.yml)
+[![pytest](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml/badge.svg)](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml)
+[![Coverage](https://img.shields.io/badge/coverage-48%25-brightgreen)](https://github.com/Omena0/blockdevice/actions/workflows/pytest.yml)
+![AI Code](https://img.shields.io/badge/AI_code-99%25-red?logo=Github%20copilot)
+
+A Python library for creating and managing block devices with FUSE filesystem support. Provides persistent object storage with compression options and real-time synchronization capabilities.
+
+## Features
+
+- **Block Device Operations**: C++ extension for efficient block device operations
+- **FUSE Filesystem**: Mount block devices as user-space filesystems
+- **Persistent Storage**: Multiple storage backends including disk-based and compressed storage
+- **Real-time Sync**: Network synchronization for distributed applications
+- **Python Integration**: Seamless integration with Python applications
+
+## Installation
+
+### From Source
+```bash
+git clone https://github.com/Omena0/blockdevice.git
+cd blockdevice
+pip install .
+```
+
+## Quick Start
+
+### Basic Usage
+
+```python
+from blockdevice import BlockDevice, DiskObject
+
+# Create a block device
+dev = BlockDevice("/path/to/device", dolphin=True)
+
+# Create persistent storage
+storage = DiskObject("data.pkl")
+storage['key'] = 'value'
+print(storage['key'])  # 'value'
+
+dev.start(True) # Start FUSE filesystem
+```
+
+### Compressed Storage
+
+```python
+from blockdevice import CompressedDiskObject
+
+# Create compressed persistent storage
+storage = CompressedDiskObject("data.zst", compression_level=10)
+storage['large_data'] = 'x' * 10000  # Automatically compressed
+```
+
+### Network Synchronization
+
+```python
+from blockdevice import NetworkObject
+
+# Create synchronized object (connects to server or becomes server)
+sync_obj = NetworkObject('localhost', 8080)
+sync_obj['shared_data'] = 'available on all connected instances'
+```
+
+## Architecture
+
+The library consists of several key components:
+
+- **BlockDevice**: C++ extension providing low-level block operations
+- **Storage Objects**: 
+  - `Object`: Abstract base class for persistent objects
+  - `DiskObject`: Pickle-based disk storage
+  - `CompressedDiskObject`: Zstd-compressed disk storage
+  - `NetworkObject`: Real-time synchronized storage
+- **FUSE Integration**: `BlockDeviceFUSE` class for filesystem mounting
+
+## Development
+
+### Setup
+```bash
+git clone https://github.com/Omena0/blockdevice.git
+cd blockdevice
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+pip install -e .
+```
+
+### Testing
+```bash
+# Run all tests
+pytest
+
+# Run with coverage
+pytest --cov=blockdevice --cov-report=html
+
+# Run specific test file
+pytest tests/test_utils.py
+```
+
+### Building
+```bash
+# Build the C++ extension
+python setup.py build_ext --inplace
+
+# Build distribution
+python setup.py sdist bdist_wheel
+```
+
+## Examples
+
+See the `examples/` directory for sample applications:
+
+- `compressed.py`: Filesystem implementation with compression
+- `network/`: Client-server examples
+
+## API Reference
+
+### BlockDevice
+```python
+BlockDevice(path: str, dolphin: bool = False)
+```
+Core block device operations.
+
+### Storage Classes
+
+#### DiskObject
+```python
+DiskObject(path: str, default_value=None)
+```
+Persistent dictionary stored as pickle file.
+
+#### CompressedDiskObject
+```python
+CompressedDiskObject(path: str, default_value=None, compression_level=5)
+```
+Compressed persistent storage using zstd.
+
+#### NetworkObject
+```python
+NetworkObject(host: str, port: int = None, default_value=None)
+```
+Real-time synchronized storage across network.
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+## License
+
+See LICENSE.md for license information.
+

{blockdevice-1.16.0 → blockdevice-2.0.0}/blockdevice/__init__.py

@@ -5,20 +5,12 @@ This module provides a BlockDevice class with decorators for read, write, and li
 It also includes FUSE filesystem support for mounting the block device as a real filesystem.
 """
 
-from typing import TYPE_CHECKING
+from ._blockdevice import BlockDevice
+from .fuse_ops import BlockDeviceFUSE
+from .utils import Object, DiskObject, CompressedDiskObject, NetworkObject
 
-# Debug flag - set to True to enable debug output
 debug = False
 
-if TYPE_CHECKING:
-    from ._blockdevice import BlockDevice as _BlockDevice
-    BlockDevice = _BlockDevice
-else:
-    from ._blockdevice import BlockDevice
-
-from .fuse_ops import BlockDeviceFUSE
-from .utils import *
-
 __version__ = "0.1.0"
 __author__ = "Omena0"
 

{blockdevice-1.16.0 → blockdevice-2.0.0}/blockdevice/fuse_ops.py

@@ -19,21 +19,6 @@ def _debug_print(*args, **kwargs):
         # Silently fail if debug flag is not available
         pass
 
-import threading
-from typing import Any, Dict, List, Optional, Union
-from fuse import FuseOSError, Operations
-
-# Import debug function from parent module
-def _debug__debug_print(*args, **kwargs):
-    """Debug print that respects the module's debug flag"""
-    try:
-        import blockdevice
-        if blockdevice.debug:
-            _debug_print(*args, **kwargs)
-    except (ImportError, AttributeError):
-        # Fallback if debug flag is not available
-        pass
-
 
 class BlockDeviceFUSE(Operations):
     """
@@ -54,7 +39,7 @@ class BlockDeviceFUSE(Operations):
 
     def getattr(self, path: str, fh: Optional[int] = None) -> Dict[str, Any]:
         """Get file attributes"""
-        _debug__debug_print(f"FUSE getattr: {path}")
+        _debug_print(f"FUSE getattr: {path}")
 
         try:
             # If it's the root, always return directory attributes