littlefs-python 0.16.0__tar.gz → 0.17.1__tar.gz

{littlefs_python-0.16.0 → littlefs_python-0.17.1}/.github/workflows/deploy.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-22.04, macos-13, windows-latest]
+        os: [ubuntu-22.04, macos-15-intel, windows-latest]
 
     env:
       CIBW_BUILD: "cp38-* cp39-* cp310-* cp311-* cp312-* cp313-* cp314-*"
@@ -23,7 +23,7 @@ jobs:
       CIBW_ARCHS_LINUX: "x86_64 i686 aarch64"
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: "recursive"
           fetch-depth: 0
@@ -35,9 +35,9 @@ jobs:
           platforms: all
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v3.2.1
+        uses: pypa/cibuildwheel@v3.3.1
 
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         with:
           name: wheels-${{ matrix.os }}
           path: ./wheelhouse/*.whl
@@ -51,13 +51,13 @@ jobs:
         cibw_archs: ["arm64"]
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: "recursive"
           fetch-depth: 0
 
       - name: Build wheels
-        uses: pypa/cibuildwheel@v3.2.1
+        uses: pypa/cibuildwheel@v3.3.1
         env:
           CIBW_BUILD: ${{ matrix.cibw_build }}
           CIBW_SKIP: "pp*"
@@ -84,7 +84,7 @@ jobs:
             delocate-listdeps --all {dest_dir}/$WHEEL_SIMPLE_FILENAME
 
             echo "DONE."
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         with:
           name: wheels-macos-arm64
           path: ./wheelhouse/*.whl
@@ -93,7 +93,7 @@ jobs:
     name: Build source distribution
     runs-on: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: "recursive"
           fetch-depth: 0
@@ -103,7 +103,7 @@ jobs:
           pip install build
           python -m build . --sdist
 
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         with:
           name: wheels-sdist
           path: dist/*.tar.gz
@@ -113,7 +113,7 @@ jobs:
     runs-on: ubuntu-22.04
     if: ${{ inputs.upload_to_pypi }}
     steps:
-      - uses: actions/download-artifact@v6
+      - uses: actions/download-artifact@v7
         with:
           path: dist
           pattern: wheels-*
@@ -123,3 +123,4 @@ jobs:
         with:
           user: __token__
           password: ${{ secrets.pypi_api_token }}
+          skip-existing: true

{littlefs_python-0.16.0 → littlefs_python-0.17.1}/.github/workflows/run-tests.yml

@@ -14,11 +14,11 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-22.04, macos-13, windows-latest]
+        os: [ubuntu-22.04, macos-15, windows-latest]
         python-version: [3.8, 3.9, "3.10", "3.11", "3.12", "3.13", "3.14"]
 
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           submodules: "recursive"
       - name: Set up Python ${{ matrix.python-version }}

{littlefs_python-0.16.0 → littlefs_python-0.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: littlefs-python
-Version: 0.16.0
+Version: 0.17.1
 Summary: A python wrapper for littlefs
 Home-page: https://github.com/jrast/littlefs-python
 Author: Jürg Rast

littlefs_python-0.17.1/requirements.txt

@@ -0,0 +1,3 @@
+pytest>=4.0.0
+tox>=3.14.0
+pywin32; sys_platform == "win32"

{littlefs_python-0.16.0 → littlefs_python-0.17.1}/src/littlefs/__main__.py

@@ -1,5 +1,6 @@
 import argparse
 from contextlib import suppress
+import os
 from pathlib import Path
 import sys
 import textwrap
@@ -7,7 +8,7 @@ import textwrap
 from littlefs import LittleFS, __version__
 from littlefs.errors import LittleFSError
 from littlefs.repl import LittleFSRepl
-from littlefs.context import UserContextFile
+from littlefs.context import UserContextFile, UserContext
 
 # Dictionary mapping suffixes to their size in bytes
 _suffix_map = {
@@ -17,10 +18,12 @@ _suffix_map = {
 }
 
 
-def _fs_from_args(args: argparse.Namespace, mount=True) -> LittleFS:
+def _fs_from_args(args: argparse.Namespace, block_count=None, mount=True, context: UserContext = None) -> LittleFS:
+    block_count = block_count if block_count is not None else getattr(args, "block_count", 0)
     return LittleFS(
+        context=context,
         block_size=args.block_size,
-        block_count=getattr(args, "block_count", 0),
+        block_count=block_count,
         name_max=args.name_max,
         mount=mount,
     )
@@ -51,6 +54,16 @@ def size_parser(size_str):
     return int(size_str, base)
 
 
+def _walk_all(root):
+    """Recursively yield all paths under root, following symlinks."""
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=True):
+        dirpath = Path(dirpath)
+        for dirname in dirnames:
+            yield dirpath / dirname
+        for filename in filenames:
+            yield dirpath / filename
+
+
 def create(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     """Create LittleFS image from file/directory contents."""
     # fs_size OR block_count may be populated; make them consistent.
@@ -72,7 +85,7 @@ def create(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
 
     source = Path(args.source).absolute()
     if source.is_dir():
-        sources = source.rglob("*")
+        sources = list(_walk_all(source))
         root = source
     else:
         sources = [source]
@@ -94,21 +107,14 @@ def create(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     if args.compact:
         if args.verbose:
             print(f"Compacting... {fs.used_block_count} / {args.block_count}")
-        compact_fs = LittleFS(
-            block_size=args.block_size,
-            block_count=fs.used_block_count,
-            name_max=args.name_max,
-        )
-        for root, dirs, files in fs.walk("/"):
-            if not root.endswith("/"):
-                root += "/"
-            for _dir in dirs:
-                compact_fs.makedirs(root + _dir, exist_ok=True)
-            for file in files:
-                path = root + file
-                print(path)
-                with fs.open(path, "rb") as src, compact_fs.open(path, "wb") as dest:
-                    dest.write(src.read())
+        compact_fs = _fs_from_args(args, block_count=fs.used_block_count)
+        for path in sources:
+            rel_path = path.relative_to(root)
+            if path.is_dir():
+                compact_fs.mkdir(rel_path.as_posix())
+            else:
+                with compact_fs.open(rel_path.as_posix(), "wb") as dest:
+                    dest.write(path.read_bytes())
         compact_fs.fs_grow(args.block_count)
         data = compact_fs.context.buffer
         if not args.no_pad:
@@ -121,21 +127,37 @@ def create(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     return 0
 
 
-def _list(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
-    """List LittleFS image contents."""
-    fs = _fs_from_args(args, mount=False)
-    fs.context.buffer = bytearray(args.source.read_bytes())
+def _mount_from_context(parser: argparse.ArgumentParser, args: argparse.Namespace, context: UserContext) -> LittleFS:
+    # Block count is 0 because we don't know the size of the real image yet, the source file may be compacted (with the create --compact option).
+    fs = _fs_from_args(args, block_count=0, mount=False, context=context)
     fs.mount()
 
     if args.verbose:
-        fs_size = len(fs.context.buffer)
+        input_image_size = context.in_size
+        actual_image_size = fs.block_count * args.block_size
         print("LittleFS Configuration:")
         print(f"  Block Size:  {args.block_size:9d}  /  0x{args.block_size:X}")
-        print(f"  Image Size:  {fs_size:9d}  /  0x{fs_size:X}")
+        if input_image_size != actual_image_size:
+            print(f"  Image Size:  {actual_image_size:9d}  /  0x{actual_image_size:X}")
+            print(f"  Input Image Size (compacted): {input_image_size:9d}  /  0x{input_image_size:X}")
+        else:
+            print(f"  Image Size:  {input_image_size:9d}  /  0x{input_image_size:X}")
         print(f"  Block Count: {fs.block_count:9d}")
         print(f"  Name Max:    {args.name_max:9d}")
         print(f"  Image:       {args.source}")
 
+    return fs
+
+
+def _list(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
+    """List LittleFS image contents."""
+    source: Path = args.source
+    if not source.is_file():
+        parser.error(f"Source image '{source}' does not exist.")
+    context = UserContext(buffer=bytearray(source.read_bytes()))
+
+    fs = _mount_from_context(parser, args, context)
+
     for root, dirs, files in fs.walk("/"):
         if not root.endswith("/"):
             root += "/"
@@ -148,18 +170,12 @@ def _list(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
 
 def extract(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     """Extract LittleFS image contents to a directory."""
-    fs = _fs_from_args(args, mount=False)
-    fs.context.buffer = bytearray(args.source.read_bytes())
-    fs.mount()
+    source: Path = args.source
+    if not source.is_file():
+        parser.error(f"Source image '{source}' does not exist.")
+    context = UserContext(buffer=bytearray(source.read_bytes()))
 
-    if args.verbose:
-        fs_size = len(fs.context.buffer)
-        print("LittleFS Configuration:")
-        print(f"  Block Size:  {args.block_size:9d}  /  0x{args.block_size:X}")
-        print(f"  Image Size:  {fs_size:9d}  /  0x{fs_size:X}")
-        print(f"  Block Count: {fs.block_count:9d}")
-        print(f"  Name Max:    {args.name_max:9d}")
-        print(f"  Image:       {args.source}")
+    fs = _mount_from_context(parser, args, context)
 
     root_dest = args.destination.absolute()
     if not root_dest.exists():
@@ -192,36 +208,19 @@ def extract(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
 
 def repl(parser: argparse.ArgumentParser, args: argparse.Namespace) -> int:
     """Inspect an existing LittleFS image through an interactive shell."""
-
     source: Path = args.source
     if not source.is_file():
         parser.error(f"Source image '{source}' does not exist.")
+    context = UserContextFile(str(source))  # In repl we want context to be the file itself, so commands will change it
 
-    image_size = source.stat().st_size
-    if not image_size or image_size % args.block_size:
-        parser.error(
-            f"Image size ({image_size} bytes) is not a multiple of the supplied block size ({args.block_size})."
-        )
-
-    block_count = image_size // args.block_size
-    if block_count == 0:
-        parser.error("Image is smaller than a single block; cannot mount.")
-
-    context = UserContextFile(str(source))
-    fs = LittleFS(
-        context=context,
-        block_size=args.block_size,
-        block_count=block_count,
-        name_max=args.name_max,
-        mount=False,
-    )
-
-    shell = LittleFSRepl(fs)
     try:
         try:
-            shell.do_mount()
+            fs = _mount_from_context(parser, args, context)
         except LittleFSError as exc:
             parser.error(f"Failed to mount '{source}': {exc}")
+
+        shell = LittleFSRepl(fs)
+
         shell.cmdloop()
     finally:
         if shell._mounted:
@@ -358,10 +357,13 @@ def get_parser():
     return parser
 
 
-def main():
+# Getting argv optionally from the caller to enable call from python (generally for testing, but could be used for other purposes)
+def main(argv=None):
+    if argv is None:
+        argv = sys.argv
     parser = get_parser()
-    parser.parse_known_args(sys.argv[1:])  # Allows for ``littlefs-python --version``
-    args = parser.parse_args(sys.argv[1:])
+    parser.parse_known_args(argv[1:])  # Allows for ``littlefs-python --version``
+    args = parser.parse_args(argv[1:])
     return args.func(parser, args)
 
 

{littlefs_python-0.16.0 → littlefs_python-0.17.1}/src/littlefs/context.py

@@ -10,8 +10,14 @@ if typing.TYPE_CHECKING:
 class UserContext:
     """Basic User Context Implementation"""
 
-    def __init__(self, buffsize: int) -> None:
-        self.buffer = bytearray([0xFF] * buffsize)
+    def __init__(self, buffsize: int = None, buffer: bytearray = None) -> None:
+        if buffer is not None:
+            self.buffer = buffer
+        elif buffsize is not None:
+            self.buffer = bytearray([0xFF] * buffsize)
+        else:
+            raise ValueError("Either buffsize or buffer must be provided")
+        self.in_size = len(self.buffer)
 
     def read(self, cfg: "LFSConfig", block: int, off: int, size: int) -> bytearray:
         """read data
@@ -91,6 +97,7 @@ class UserContextFile(UserContext):
 
         self._path = file_path
         self._fh = open(file_path, mode)
+        self.in_size = os.path.getsize(file_path)
 
     def read(self, cfg: "LFSConfig", block: int, off: int, size: int) -> bytearray:
         logging.getLogger(__name__).debug("LFS Read : Block: %d, Offset: %d, Size=%d" % (block, off, size))
@@ -150,10 +157,11 @@ class UserContextWinDisk(UserContext):
                 "Unable to import 'win32file'. This module is required for Windows-specific functionality. Please ensure you are running on a Windows platform or install 'pywin32' using: 'pip install pywin32'."
             )
         self.device = win32file.CreateFile(
-            disk_path, win32file.GENERIC_READ, win32file.FILE_SHARE_READ, None, win32file.OPEN_EXISTING, 0, None
+            disk_path, win32file.GENERIC_READ | win32file.GENERIC_WRITE, win32file.FILE_SHARE_READ, None, win32file.OPEN_EXISTING, 0, None
         )
         if self.device == win32file.INVALID_HANDLE_VALUE:
             raise IOError("Could not open disk %s" % disk_path)
+        self.in_size = win32file.GetFileSize(self.device)
 
     def read(self, cfg: "LFSConfig", block: int, off: int, size: int) -> bytearray:
         """read data
@@ -214,7 +222,7 @@ class UserContextWinDisk(UserContext):
         start = block * cfg.block_size
 
         win32file.SetFilePointer(self.device, start, win32file.FILE_BEGIN)
-        win32file.WriteFile(self.device, [0xFF] * cfg.block_size)
+        win32file.WriteFile(self.device, b'\xff' * cfg.block_size)
         return 0
 
     def sync(self, cfg: "LFSConfig") -> int: