blockdevice 1.14.0__tar.gz

blockdevice-1.14.0/COPYING.md

@@ -0,0 +1,131 @@
+# 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.

blockdevice-1.14.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include include *

blockdevice-1.14.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: blockdevice
+Version: 1.14.0
+Summary: A simple C++ Python library for block device operations
+Home-page: https://github.com/Omena0/blockdevice
+Author: Omena0
+Author-email: omena0mc@gmail.com
+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.13
+Description-Content-Type: text/markdown
+License-File: COPYING.md
+Requires-Dist: pybind11>=2.6.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# Blockdevice
+
+Simple library for creating Block Devices.

blockdevice-1.14.0/README.md

@@ -0,0 +1,4 @@
+
+# Blockdevice
+
+Simple library for creating Block Devices.

blockdevice-1.14.0/blockdevice/__init__.py

@@ -0,0 +1,26 @@
+"""
+BlockDevice - A simple C++ Python library for block device operations
+
+This module provides a BlockDevice class with decorators for read, write, and list operations.
+It also includes FUSE filesystem support for mounting the block device as a real filesystem.
+"""
+
+from typing import TYPE_CHECKING
+
+# 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"
+
+__all__ = ["BlockDevice", "BlockDeviceFUSE", "Object", "DiskObject", "CompressedDiskObject", "NetworkObject"]
+

blockdevice-1.14.0/blockdevice/_blockdevice.pyi

@@ -0,0 +1,192 @@
+"""
+Type stubs for BlockDevice C++ extension module
+"""
+
+from typing import Any, Callable, List, Optional, TypeVar, overload
+from typing_extensions import ParamSpec
+
+P = ParamSpec('P')
+T = TypeVar('T')
+
+# Type aliases for callback functions
+ReadCallback = Callable[[str], bytes | str]
+WriteCallback = Callable[[str, bytes], bool]
+ListCallback = Callable[[str], List[str]]
+DeleteCallback = Callable[[str], bool]
+
+class BlockDevice:
+    """
+    BlockDevice class for creating virtual block devices with custom read/write/list operations.
+    
+    This class provides decorators (@bd.read, @bd.write, @bd.list) to register callback functions
+    that handle filesystem operations when the device is mounted as a FUSE filesystem.
+    """
+    
+    def __init__(
+        self, 
+        mountpoint: str, 
+        dolphin: bool = False, 
+        name: str = ""
+    ) -> None:
+        """
+        Initialize BlockDevice with mountpoint and optional parameters.
+        
+        Args:
+            mountpoint: Path where the filesystem will be mounted
+            dolphin: Whether to enable Dolphin file manager integration
+            name: Display name for the device (defaults to mountpoint if empty)
+        """
+        ...
+    
+    @property
+    def mountpoint(self) -> str:
+        """Get the mountpoint path."""
+        ...
+    
+    @property
+    def name(self) -> str:
+        """Get the display name."""
+        ...
+    
+    @property
+    def dolphin_integration(self) -> bool:
+        """Get whether Dolphin integration is enabled."""
+        ...
+    
+    # Decorator methods
+    def read(self, func: Callable[[str], T]) -> Callable[[str], T]:
+        """
+        Decorator to register a read callback function.
+        
+        The decorated function should take a file path (str) and return the file content
+        as bytes or string.
+        
+        Example:
+            @bd.read
+            def read_file(path: str) -> bytes:
+                return b"file content"
+        
+        Args:
+            func: Function that takes a path and returns file content
+            
+        Returns:
+            The same function (for decorator chaining)
+        """
+        ...
+    
+    def write(self, func: Callable[[str, bytes], bool]) -> Callable[[str, bytes], bool]:
+        """
+        Decorator to register a write callback function.
+        
+        The decorated function should take a file path (str) and data (bytes),
+        then return True if the write was successful, False otherwise.
+        
+        Example:
+            @bd.write
+            def write_file(path: str, data: bytes) -> bool:
+                # Save data to path
+                return True
+        
+        Args:
+            func: Function that takes a path and data, returns success boolean
+            
+        Returns:
+            The same function (for decorator chaining)
+        """
+        ...
+    
+    def list(self, func: Callable[[str], List[str]]) -> Callable[[str], List[str]]:
+        """
+        Decorator to register a directory listing callback function.
+        
+        The decorated function should take a directory path (str) and return
+        a list of filenames/subdirectories in that directory.
+        
+        Example:
+            @bd.list
+            def list_directory(path: str) -> List[str]:
+                return ["file1.txt", "subdir/"]
+        
+        Args:
+            func: Function that takes a path and returns list of contents
+            
+        Returns:
+            The same function (for decorator chaining)
+        """
+        ...
+    
+    def delete(self, func: Callable[[str], bool]) -> Callable[[str], bool]:
+        """
+        Decorator to register a delete callback function.
+        
+        The decorated function should take a file or directory path (str)
+        and return True if the deletion was successful, False otherwise.
+        
+        Example:
+            @bd.delete
+            def delete_file(path: str) -> bool:
+                # Delete file or directory at path
+                return True
+        
+        Args:
+            func: Function that takes a path and returns success boolean
+            
+        Returns:
+            The same function (for decorator chaining)
+        """
+        ...
+    
+    # Direct callback setters (alternative to decorators)
+    def set_read_callback(self, func: ReadCallback) -> None:
+        """Set the read callback function directly."""
+        ...
+    
+    def set_write_callback(self, func: WriteCallback) -> None:
+        """Set the write callback function directly."""
+        ...
+    
+    def set_list_callback(self, func: ListCallback) -> None:
+        """Set the list callback function directly."""
+        ...
+    
+    def set_delete_callback(self, func: DeleteCallback) -> None:
+        """Set the delete callback function directly."""
+        ...
+    
+    # Callback invocation methods (used internally by FUSE operations)
+    def call_read(self, path: str) -> Any:
+        """Call the registered read callback with the given path."""
+        ...
+    
+    def call_write(self, path: str, data: Any) -> bool:
+        """Call the registered write callback with the given path and data."""
+        ...
+    
+    def call_list(self, path: str) -> List[str]:
+        """Call the registered list callback with the given path."""
+        ...
+    
+    def call_delete(self, path: str) -> bool:
+        """Call the registered delete callback with the given path."""
+        ...
+    
+    # FUSE filesystem methods
+    def mount(self) -> None:
+        """Mount the filesystem at the specified mountpoint."""
+        ...
+    
+    def unmount(self) -> None:
+        """Unmount the filesystem."""
+        ...
+    
+    def start(self, foreground: bool = True) -> None:
+        """Start the FUSE filesystem."""
+        ...
+    
+    def stop(self) -> None:
+        """Stop the FUSE filesystem."""
+        ...
+    
+    def is_mounted(self) -> bool:
+        """Check if the filesystem is currently mounted."""
+        ...