python-filewrap 0.0.1__tar.gz → 0.0.2__tar.gz

{python_filewrap-0.0.1 → python_filewrap-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-filewrap
-Version: 0.0.1
+Version: 0.0.2
 Summary: Python file wrappers.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-filewrap
 License: MIT

{python_filewrap-0.0.1 → python_filewrap-0.0.2}/filewrap/__init__.py

@@ -2,13 +2,14 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 1)
+__version__ = (0, 0, 2)
 __all__ = [
     "SupportsRead", "SupportsWrite", "bio_chunk_iter", "bio_chunk_async_iter", 
     "bio_skip_iter", "bio_skip_async_iter", "bio_skip_bytes", "bio_skip_bytes_async"
 ]
 
 from asyncio import to_thread
+from collections.abc import Awaitable
 from functools import update_wrapper
 from inspect import isawaitable, iscoroutinefunction
 from collections.abc import AsyncIterator, Callable, Iterator
@@ -39,13 +40,16 @@ def ensure_async(func, /):
 
 
 def bio_chunk_iter(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
 ) -> Iterator[bytes]:
-    read = bio.read
+    if callable(bio):
+        read = bio
+    else:
+        read = bio.read
     if not callable(callback):
         callback = None
     if size > 0:
@@ -67,13 +71,16 @@ def bio_chunk_iter(
 
 
 async def bio_chunk_async_iter(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes | Awaitable[bytes]], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
 ) -> AsyncIterator[bytes]:
-    read = ensure_async(bio.read)
+    if callable(bio):
+        read = ensure_async(bio)
+    else:
+        read = ensure_async(bio.read)
     callback = ensure_async(callback) if callable(callback) else None
     if size > 0:
         while size:
@@ -94,7 +101,7 @@ async def bio_chunk_async_iter(
 
 
 def bio_skip_iter(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
@@ -114,7 +121,9 @@ def bio_skip_iter(
     except Exception:
         if chunksize <= 0:
             chunksize = COPY_BUFSIZE
-        if hasattr(bio, "readinto"):
+        if callable(bio):
+            read = bio
+        elif hasattr(bio, "readinto"):
             readinto = bio.readinto
             buf = bytearray(chunksize)
             if size > 0:
@@ -138,23 +147,24 @@ def bio_skip_iter(
                     if callback:
                         callback(length)
                     yield length
+            return
         else:
             read = bio.read
-            if size > 0:
-                while size:
-                    readsize = min(chunksize, size)
-                    length = len(read(readsize))
-                    if callback:
-                        callback(length)
-                    yield length
-                    if length < readsize:
-                        break
-                    size -= readsize
-            else:
-                while (length := len(read(chunksize))):
-                    if callback:
-                        callback(length)
-                    yield length
+        if size > 0:
+            while size:
+                readsize = min(chunksize, size)
+                length = len(read(readsize))
+                if callback:
+                    callback(length)
+                yield length
+                if length < readsize:
+                    break
+                size -= readsize
+        else:
+            while (length := len(read(chunksize))):
+                if callback:
+                    callback(length)
+                yield length
     else:
         if callback:
             callback(length)
@@ -162,7 +172,7 @@ def bio_skip_iter(
 
 
 async def bio_skip_async_iter(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes | Awaitable[bytes]], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
@@ -181,7 +191,9 @@ async def bio_skip_async_iter(
     except Exception:
         if chunksize <= 0:
             chunksize = COPY_BUFSIZE
-        if hasattr(bio, "readinto"):
+        if callable(bio):
+            read = ensure_async(bio)
+        elif hasattr(bio, "readinto"):
             readinto = ensure_async(bio.readinto)
             buf = bytearray(chunksize)
             if size > 0:
@@ -207,21 +219,21 @@ async def bio_skip_async_iter(
                     yield length
         else:
             read = ensure_async(bio.read)
-            if size > 0:
-                while size:
-                    readsize = min(chunksize, size)
-                    length = len(await read(readsize))
-                    if callback:
-                        await callback(length)
-                    yield length
-                    if length < readsize:
-                        break
-                    size -= readsize
-            else:
-                while (length := len(await read(chunksize))):
-                    if callback:
-                        await callback(length)
-                    yield length
+        if size > 0:
+            while size:
+                readsize = min(chunksize, size)
+                length = len(await read(readsize))
+                if callback:
+                    await callback(length)
+                yield length
+                if length < readsize:
+                    break
+                size -= readsize
+        else:
+            while (length := len(await read(chunksize))):
+                if callback:
+                    await callback(length)
+                yield length
     else:
         if callback:
             await callback(length)
@@ -229,25 +241,23 @@ async def bio_skip_async_iter(
 
 
 def bio_skip_bytes(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
-) -> SupportsRead[bytes]:
+):
     for _ in bio_skip_iter(bio, size, chunksize, callback=callback):
         pass
-    return bio
 
 
 async def bio_skip_bytes_async(
-    bio: SupportsRead[bytes], 
+    bio: SupportsRead[bytes] | Callable[[int], bytes | Awaitable[bytes]], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
-) -> SupportsRead[bytes]:
+):
     async for _ in bio_skip_async_iter(bio, size, chunksize, callback=callback):
         pass
-    return bio
 

{python_filewrap-0.0.1 → python_filewrap-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-filewrap"
-version = "0.0.1"
+version = "0.0.2"
 description = "Python file wrappers."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"