python-filewrap 0.0.4.1__tar.gz → 0.0.6__tar.gz

{python_filewrap-0.0.4.1 → python_filewrap-0.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-filewrap
-Version: 0.0.4.1
+Version: 0.0.6
 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.4.1 → python_filewrap-0.0.6}/filewrap/__init__.py

@@ -2,12 +2,14 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 4)
+__version__ = (0, 0, 6)
 __all__ = [
     "SupportsRead", "SupportsWrite", 
     "bio_chunk_iter", "bio_chunk_async_iter", 
     "bio_skip_iter", "bio_skip_async_iter", 
     "bytes_iter_to_reader", "bytes_iter_to_async_reader", 
+    "bytes_to_chunk_iter", "bytes_to_chunk_async_iter", 
+    "bytes_ensure_part_iter", "bytes_ensure_part_async_iter", 
 ]
 
 from asyncio import to_thread, Lock as AsyncLock
@@ -19,7 +21,12 @@ from shutil import COPY_BUFSIZE # type: ignore
 from threading import Lock
 from typing import Any, Protocol, TypeVar
 
-from asynctools import ensure_async
+try:
+    from collections.abc import Buffer # type: ignore
+except ImportError:
+    Buffer = Any
+
+from asynctools import ensure_async, ensure_aiter
 
 
 _T_co = TypeVar("_T_co", covariant=True)
@@ -35,12 +42,12 @@ class SupportsWrite(Protocol[_T_contra]):
 
 
 def bio_chunk_iter(
-    bio: SupportsRead[bytes] | Callable[[int], bytes], 
+    bio: SupportsRead[Buffer] | Callable[[int], Buffer], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
-) -> Iterator[bytes]:
+) -> Iterator[Buffer]:
     if callable(bio):
         read = bio
     else:
@@ -66,12 +73,12 @@ def bio_chunk_iter(
 
 
 async def bio_chunk_async_iter(
-    bio: SupportsRead[bytes] | Callable[[int], bytes | Awaitable[bytes]], 
+    bio: SupportsRead[Buffer] | Callable[[int], Buffer | Awaitable[Buffer]], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
     callback: None | Callable[[int], Any] = None, 
-) -> AsyncIterator[bytes]:
+) -> AsyncIterator[Buffer]:
     if callable(bio):
         read = ensure_async(bio)
     else:
@@ -96,7 +103,7 @@ async def bio_chunk_async_iter(
 
 
 def bio_skip_iter(
-    bio: SupportsRead[bytes] | Callable[[int], bytes], 
+    bio: SupportsRead[Buffer] | Callable[[int], Buffer], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
@@ -167,7 +174,7 @@ def bio_skip_iter(
 
 
 async def bio_skip_async_iter(
-    bio: SupportsRead[bytes] | Callable[[int], bytes | Awaitable[bytes]], 
+    bio: SupportsRead[Buffer] | Callable[[int], Buffer | Awaitable[Buffer]], 
     /, 
     size: int = -1, 
     chunksize: int = COPY_BUFSIZE, 
@@ -236,7 +243,7 @@ async def bio_skip_async_iter(
 
 
 def bytes_iter_to_reader(
-    it: Iterable[bytes | bytearray], 
+    it: Iterable[Buffer], 
     /, 
 ) -> SupportsRead[bytearray]:
     getnext = iter(it).__next__
@@ -324,7 +331,7 @@ def bytes_iter_to_reader(
 
 
 def bytes_iter_to_async_reader(
-    it: Iterable[bytes | bytearray] | AsyncIterable[bytes | bytearray], 
+    it: Iterable[Buffer] | AsyncIterable[Buffer], 
     /, 
     threaded: bool = True, 
 ) -> SupportsRead[bytearray]:
@@ -414,3 +421,79 @@ def bytes_iter_to_async_reader(
         "__repr__": staticmethod(lambda: reprs), 
     })()
 
+
+def bytes_to_chunk_iter(
+    b: Buffer, 
+    /, 
+    chunksize: int = COPY_BUFSIZE, 
+) -> Iterator[memoryview]:
+    m = memoryview(b)
+    for i in range(0, len(m), chunksize):
+        yield m[i:i+chunksize]
+
+
+async def bytes_to_chunk_async_iter(
+    b: Buffer, 
+    /, 
+    chunksize: int = COPY_BUFSIZE, 
+) -> AsyncIterator[memoryview]:
+    m = memoryview(b)
+    for i in range(0, len(m), chunksize):
+        yield m[i:i+chunksize]
+
+
+def bytes_ensure_part_iter(
+    it: Iterable[Buffer], 
+    /, 
+    partsize: int = COPY_BUFSIZE, 
+) -> Iterator[Buffer | memoryview]:
+    n = partsize
+    for b in it:
+        m = memoryview(b)
+        l = len(m)
+        if l <= n:
+            yield b
+            if l == n:
+                n = partsize
+            else:
+                n -= l
+        else:
+            yield m[:n]
+            m = m[n:]
+            while len(m) >= partsize:
+                yield m[:partsize]
+                m = m[partsize:]
+            if m:
+                yield m
+                n = partsize - len(m)
+            else:
+                n = partsize
+
+
+async def bytes_ensure_part_async_iter(
+    it: Iterable[Buffer] | AsyncIterable[Buffer], 
+    /, 
+    partsize: int = COPY_BUFSIZE, 
+) -> AsyncIterator[Buffer | memoryview]:
+    n = partsize
+    async for b in ensure_aiter(it):
+        m = memoryview(b)
+        l = len(m)
+        if l <= n:
+            yield b
+            if l == n:
+                n = partsize
+            else:
+                n -= l
+        else:
+            yield m[:n]
+            m = m[n:]
+            while len(m) >= partsize:
+                yield m[:partsize]
+                m = m[partsize:]
+            if m:
+                yield m
+                n = partsize - len(m)
+            else:
+                n = partsize
+

{python_filewrap-0.0.4.1 → python_filewrap-0.0.6}/pyproject.toml

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