flatfs 0.3.0__tar.gz → 0.5.0__tar.gz

{flatfs-0.3.0 → flatfs-0.5.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: flatfs
-Version: 0.3.0
+Version: 0.5.0
 Summary: Minimal filesystem abstraction with pluggable backends, treating paths as keys and file contents as values.
 License: MIT
 License-File: LICENSE.txt
 Keywords: flat,filesystem,abstraction,library
 Author: Maciej Wiatrzyk
 Author-email: maciej.wiatrzyk@gmail.com
-Requires-Python: >=3.10,<4
+Requires-Python: >=3.9,<4
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent

flatfs-0.5.0/flatfs/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.0"

flatfs-0.5.0/flatfs/_compat.py

@@ -0,0 +1,17 @@
+from typing import Any, Coroutine, Generic, Optional, Protocol, TypeVar
+
+T = TypeVar("T")
+Tco = TypeVar("Tco", covariant=True)
+
+
+class SupportsAnext(Protocol, Generic[Tco]):
+    def __anext__(self) -> Coroutine[Any, Any, Tco]: ...
+
+
+async def anext(obj: SupportsAnext[T], default: Optional[T] = None) -> T:
+    try:
+        return await obj.__anext__()
+    except StopAsyncIteration:
+        if default is not None:
+            return default
+        raise

flatfs-0.5.0/flatfs/aio/api.py

@@ -0,0 +1,15 @@
+"""The all-in-one import helper for :mod:`flatfs.aio` module."""
+
+from .backends import __all__ as _backends_all
+from .helpers import __all__ as _helpers_all
+from .interface import __all__ as _interface_all
+
+from .backends import *
+from .helpers import *
+from .interface import *
+
+__all__ = (
+    *_backends_all,
+    *_helpers_all,
+    *_interface_all,
+)  # type: ignore

flatfs-0.5.0/flatfs/aio/backends.py

@@ -0,0 +1,90 @@
+import asyncio
+from queue import Queue
+from typing import AsyncGenerator, AsyncIterator, Union
+
+from flatfs import _export, _utils
+from flatfs.interface import FlatFsReaderWriter, Stat
+
+__all__ = export = _export.Export()  # type: ignore
+
+
+@export
+class AsyncFlatFsAdapter:
+    """Adapter that wraps given :class:`flatfs.interface.FlatFsReaderWriter`
+    with async interface.
+
+    You can use this to adapt e.g. :class:`LocalFlatFs` or
+    :class:`InMemoryFlatFs` objects with async interface allowing for
+    convenient use with async code. The blocking calls are dispatched to
+    background worker which communicates with the caller using queues.
+
+    :param target:
+        The target FlatFS reader-writer to wrap.
+    """
+
+    def __init__(self, target: FlatFsReaderWriter):
+        self.__target = target
+
+    async def scan(self) -> AsyncGenerator[str, None]:
+
+        def scanner():
+            for path in self.__target.scan():
+                loop.call_soon_threadsafe(queue.put_nowait, path)
+            loop.call_soon_threadsafe(queue.put_nowait, "")
+
+        loop = asyncio.get_running_loop()
+        asyncio.create_task(_utils.run_blocking(scanner))
+        queue: asyncio.Queue[str] = asyncio.Queue()
+        while True:
+            path = await queue.get()
+            if not path:
+                break
+            yield path
+
+    async def exists(self, path: str) -> bool:
+        return await _utils.run_blocking(self.__target.exists, path)
+
+    async def stat(self, path: str) -> Stat:
+        return await _utils.run_blocking(self.__target.stat, path)
+
+    async def read_chunks(self, path: str, chunk_size: int = 65535) -> AsyncIterator[bytes]:
+
+        def reader():
+            try:
+                for chunk in self.__target.read_chunks(path, chunk_size):
+                    loop.call_soon_threadsafe(queue.put_nowait, chunk)
+                loop.call_soon_threadsafe(queue.put_nowait, b"")
+            except Exception as e:
+                loop.call_soon_threadsafe(queue.put_nowait, e)
+
+        loop = asyncio.get_running_loop()
+        queue: asyncio.Queue[Union[bytes, Exception]] = asyncio.Queue()
+        asyncio.create_task(_utils.run_blocking(reader))
+        while True:
+            chunk_or_exc = await queue.get()
+            if not chunk_or_exc:
+                break
+            if isinstance(chunk_or_exc, Exception):
+                raise chunk_or_exc
+            yield chunk_or_exc
+
+    async def write_chunks(self, path: str, chunk_gen: AsyncGenerator[bytes, None]) -> AsyncGenerator[int, None]:
+
+        def blocking_writer():
+            for write_count in self.__target.write_chunks(path, _utils.generate_chunks_from_queue(chunk_queue)):
+                loop.call_soon_threadsafe(ack_queue.put_nowait, write_count)
+
+        loop = asyncio.get_running_loop()
+        chunk_queue: Queue[bytes] = Queue()
+        ack_queue: asyncio.Queue[int] = asyncio.Queue()
+        task = asyncio.create_task(_utils.run_blocking(blocking_writer))
+        try:
+            async for chunk in chunk_gen:
+                chunk_queue.put(chunk)
+                yield await ack_queue.get()
+        finally:
+            chunk_queue.put(b"")
+            await task
+
+    async def remove(self, path: str):
+        await _utils.run_blocking(self.__target.remove, path)

flatfs-0.5.0/flatfs/aio/helpers.py

@@ -0,0 +1,148 @@
+import asyncio
+from contextlib import AbstractAsyncContextManager
+from typing import AsyncIterator, Optional
+
+from flatfs import _export, _utils, _compat
+
+from .interface import SupportsAsyncReadChunks, SupportsAsyncWriteChunks
+
+__all__ = export = _export.Export()  # type: ignore
+
+
+@export
+async def async_read_bytes(fs: SupportsAsyncReadChunks, path: str, chunk_size: int = 65535) -> bytes:
+    """Async variant of the :func:`read_bytes` helper."""
+    out = b""
+    async for chunk in fs.read_chunks(path, chunk_size):
+        out += chunk
+    return out
+
+
+@export
+async def async_write_bytes(fs: SupportsAsyncWriteChunks, path: str, data: bytes, chunk_size: int = 65535) -> int:
+    """Async variant of the :func:`write_bytes` helper."""
+    total_bytes = 0
+    async for byte_count in fs.write_chunks(path, _utils.async_split_into_chunks(data, chunk_size)):
+        total_bytes += byte_count
+    return total_bytes
+
+
+@export
+async def async_read_text(
+    fs: SupportsAsyncReadChunks, path: str, encoding: str = "utf-8", chunk_size: int = 65535
+) -> str:
+    """Async variant of the :func:`read_text` helper."""
+    return (await async_read_bytes(fs, path, chunk_size)).decode(encoding)
+
+
+@export
+async def async_write_text(
+    fs: SupportsAsyncWriteChunks, path: str, data: str, encoding: str = "utf-8", chunk_size: int = 65535
+):
+    """Async variant of the :func:`write_text` helper."""
+    await async_write_bytes(fs, path, data.encode(encoding), chunk_size)
+
+
+@export
+class AsyncBufferedWriter(AbstractAsyncContextManager):
+    """Async variant of the :class:`BufferedWriter` class."""
+
+    def __init__(self, fs: SupportsAsyncWriteChunks, path: str, buffer_size: int = 65535):
+        self.__chunk_queue: asyncio.Queue[bytes] = asyncio.Queue()
+        self.__buffer_size = buffer_size
+        self.__buffer = b""
+        self.__writer = fs.write_chunks(path, _utils.async_generate_chunks_from_queue(self.__chunk_queue))
+
+    async def __aenter__(self) -> "AsyncBufferedWriter":
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
+        return await self.close()
+
+    async def __write_chunk(self, chunk: bytes):
+        self.__chunk_queue.put_nowait(chunk)
+        await _compat.anext(self.__writer)
+
+    async def write(self, data: bytes) -> int:
+        self.__buffer += data
+        while len(self.__buffer) > self.__buffer_size:
+            chunk = self.__buffer[: self.__buffer_size]
+            await self.__write_chunk(chunk)
+            self.__buffer = self.__buffer[self.__buffer_size :]
+        return len(data)
+
+    async def flush(self):
+        if not self.__buffer:
+            return  # Nothing to do
+        await self.__write_chunk(self.__buffer)
+        self.__buffer = b""
+
+    async def close(self):
+        await self.flush()
+        await self.__writer.aclose()
+
+
+@export
+class AsyncBufferedReader(AbstractAsyncContextManager):
+    """Async variant of the :class:`BufferedReader` class."""
+
+    def __init__(self, fs: SupportsAsyncReadChunks, path: str, buffer_size: int = 65535):
+        self.__reader = fs.read_chunks(path, chunk_size=buffer_size)
+        self.__buffer = b""
+
+    async def __aenter__(self) -> "AsyncBufferedReader":
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
+        return await self.close()
+
+    async def close(self):
+        self.__buffer = b""
+        await self.__reader.aclose()
+
+    async def read(self, count: int) -> bytes:
+        if not self.__buffer:
+            self.__buffer = await _compat.anext(self.__reader, b"")
+        data = self.__buffer[:count]
+        self.__buffer = self.__buffer[count:]
+        return data
+
+
+@export
+class AsyncBufferedTextReader(AbstractAsyncContextManager):
+    """Async variant of the :class:`BufferedTextReader` class."""
+
+    def __init__(self, fs: SupportsAsyncReadChunks, path: str, encoding: str = "utf-8", buffer_size: int = 65535):
+        self.__reader = fs.read_chunks(path, chunk_size=buffer_size)
+        self.__encoding = encoding
+        self.__buffer = ""
+
+    async def __read_next_chunk(self) -> str:
+        return (await _compat.anext(self.__reader, b"")).decode(self.__encoding)
+
+    async def __aenter__(self) -> "AsyncBufferedTextReader":
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
+        return await self.close()
+
+    async def __aiter__(self) -> AsyncIterator[str]:
+        while next_chunk := await self.__read_next_chunk():
+            self.__buffer += next_chunk
+            lines = self.__buffer.splitlines()
+            if len(lines) > 1:
+                for line in lines[:-1]:
+                    yield line
+                self.__buffer = lines[-1]
+        yield self.__buffer
+
+    async def read(self, count: int) -> str:
+        if not self.__buffer:
+            self.__buffer = await self.__read_next_chunk()
+        out = self.__buffer[:count]
+        self.__buffer = self.__buffer[count:]
+        return out
+
+    async def close(self):
+        self.__buffer = ""
+        await self.__reader.aclose()

flatfs-0.5.0/flatfs/aio/interface.py

@@ -0,0 +1,91 @@
+from typing import AsyncGenerator, AsyncIterator, Protocol
+
+from flatfs import _export
+from flatfs.interface import Stat
+
+__all__ = export = _export.Export()  # type: ignore
+
+
+@export
+class SupportsAsyncReadChunks(Protocol):
+    """Async variant of the :class:`SupportsReadChunks` protocol."""
+
+    def read_chunks(self, path: str, chunk_size: int = 65535) -> AsyncGenerator[bytes, None]:
+        """Return a generator for reading file in chunks of given maximum size.
+
+        This is the async version of :meth:`SupportsReadChunks.read_chunks`
+        method.
+
+        :param path:
+            The path to a file to read.
+
+        :param chunk_size:
+            The maximum chunk size, in bytes.
+        """
+        ...
+
+
+@export
+class SupportsAsyncWriteChunks(Protocol):
+    """Async variant of the :class:`SupportsWriteChunks` protocol."""
+
+    def write_chunks(self, path: str, chunk_gen: AsyncGenerator[bytes, None]) -> AsyncGenerator[int, None]:
+        """Generator for creating or overwriting files.
+
+        This is the async version of :meth:`SupportsWriteChunks.write_chunks`
+        method.
+
+        :param path:
+            The path to a file to create or replace.
+
+        :param chunk_gen:
+            Async generator yielding file chunks.
+        """
+        ...
+
+
+@export
+class AsyncFlatFsReader(SupportsAsyncReadChunks, Protocol):
+    """Async variant of the :class:`FlatFsReader` protocol."""
+
+    def scan(self) -> AsyncIterator[str]:
+        """Return iterator that yields normalized paths to existing files.
+
+        This is the async version of :meth:`FlatFsReader.scan` method.
+        """
+        ...
+
+    async def stat(self, path: str) -> Stat:
+        """Get stats of a file at given path.
+
+        This is the async version of :meth:`FlatFsReader.stat` method.
+
+        :param path:
+            The path to a file.
+        """
+        ...
+
+    async def exists(self, path: str) -> bool:
+        """Check if file at given path exists.
+
+        This is the async version of :meth:`FlatFsReader.exists` method.
+
+        :param path:
+            The path to check.
+        """
+        ...
+
+
+@export
+class AsyncFlatFsReaderWriter(AsyncFlatFsReader, SupportsAsyncWriteChunks, Protocol):
+    """Async variant of the :class:`FlatFsReaderWriter` protocol."""
+
+    async def remove(self, path: str):
+        """Remove existing file.
+
+        This is the async version of :meth:`FlatFsReaderWriter.remove` method.
+
+        :param path:
+            The path to a file to remove.
+        """
+        ...

{flatfs-0.3.0 → flatfs-0.5.0}/flatfs/api.py

@@ -1,13 +1,21 @@
 """The all-in-one import helper for FlatFS public API."""
 
+from .aio.api import __all__ as _aio_all
 from .backends import __all__ as _backends_all
 from .exc import __all__ as _exc_all
 from .helpers import __all__ as _helpers_all
 from .interface import __all__ as _interface_all
 
+from .aio.api import *
 from .backends import *
 from .exc import *
 from .helpers import *
 from .interface import *
 
-__all__ = _backends_all + _exc_all + _helpers_all + _interface_all  # type: ignore
+__all__ = (
+    *_aio_all,
+    *_backends_all,
+    *_exc_all,
+    *_helpers_all,
+    *_interface_all,
+)  # type: ignore

{flatfs-0.3.0 → flatfs-0.5.0}/flatfs/backends.py

@@ -1,14 +1,12 @@
-import asyncio
 import dataclasses
 import datetime
 import fnmatch
 import os
 import pathlib
-from queue import Queue
-from typing import AsyncGenerator, AsyncIterator, Generator, Iterator, Optional
+from typing import Generator, Iterator, Optional
 
 from flatfs.exc import PathAccessError, PathNotFoundError
-from flatfs.interface import FlatFsReaderWriter, Stat
+from flatfs.interface import Stat
 
 from . import _utils, _export
 
@@ -181,85 +179,3 @@ class InMemoryFlatFs:
         if key not in self.__storage:
             raise PathNotFoundError(path)
         del self.__storage[key]
-
-
-@export
-class AsyncFlatFsAdapter:
-    """Adapter that wraps given :class:`flatfs.interface.FlatFsReaderWriter`
-    with async interface.
-
-    You can use this to adapt e.g. :class:`LocalFlatFs` or
-    :class:`InMemoryFlatFs` objects with async interface allowing for
-    convenient use with async code. The blocking calls are dispatched to
-    background worker which communicates with the caller using queues.
-
-    :param target:
-        The target FlatFS reader-writer to wrap.
-    """
-
-    def __init__(self, target: FlatFsReaderWriter):
-        self.__target = target
-
-    async def scan(self) -> AsyncGenerator[str, None]:
-
-        def scanner():
-            for path in self.__target.scan():
-                loop.call_soon_threadsafe(queue.put_nowait, path)
-            loop.call_soon_threadsafe(queue.put_nowait, "")
-
-        loop = asyncio.get_running_loop()
-        asyncio.create_task(_utils.run_blocking(scanner))
-        queue: asyncio.Queue[str] = asyncio.Queue()
-        while True:
-            path = await queue.get()
-            if not path:
-                break
-            yield path
-
-    async def exists(self, path: str) -> bool:
-        return await _utils.run_blocking(self.__target.exists, path)
-
-    async def stat(self, path: str) -> Stat:
-        return await _utils.run_blocking(self.__target.stat, path)
-
-    async def read_chunks(self, path: str, chunk_size: int = 65535) -> AsyncIterator[bytes]:
-
-        def reader():
-            try:
-                for chunk in self.__target.read_chunks(path, chunk_size):
-                    loop.call_soon_threadsafe(queue.put_nowait, chunk)
-                loop.call_soon_threadsafe(queue.put_nowait, b"")
-            except Exception as e:
-                loop.call_soon_threadsafe(queue.put_nowait, e)
-
-        loop = asyncio.get_running_loop()
-        queue: asyncio.Queue[bytes | Exception] = asyncio.Queue()
-        asyncio.create_task(_utils.run_blocking(reader))
-        while True:
-            chunk_or_exc = await queue.get()
-            if not chunk_or_exc:
-                break
-            if isinstance(chunk_or_exc, Exception):
-                raise chunk_or_exc
-            yield chunk_or_exc
-
-    async def write_chunks(self, path: str, chunk_gen: AsyncGenerator[bytes, None]) -> AsyncGenerator[int, None]:
-
-        def blocking_writer():
-            for write_count in self.__target.write_chunks(path, _utils.generate_chunks_from_queue(chunk_queue)):
-                loop.call_soon_threadsafe(ack_queue.put_nowait, write_count)
-
-        loop = asyncio.get_running_loop()
-        chunk_queue: Queue[bytes] = Queue()
-        ack_queue: asyncio.Queue[int] = asyncio.Queue()
-        task = asyncio.create_task(_utils.run_blocking(blocking_writer))
-        try:
-            async for chunk in chunk_gen:
-                chunk_queue.put(chunk)
-                yield await ack_queue.get()
-        finally:
-            chunk_queue.put(b"")
-            await task
-
-    async def remove(self, path: str):
-        await _utils.run_blocking(self.__target.remove, path)

{flatfs-0.3.0 → flatfs-0.5.0}/flatfs/helpers.py

@@ -1,11 +1,9 @@
-import asyncio
-from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from contextlib import AbstractContextManager
 from queue import Queue
-from types import TracebackType
-from typing import Iterator, AsyncIterator
+from typing import Iterator, Optional
 
 from . import _export, _utils
-from .interface import SupportsAsyncReadChunks, SupportsAsyncWriteChunks, SupportsReadChunks, SupportsWriteChunks
+from .interface import SupportsReadChunks, SupportsWriteChunks
 
 __all__ = export = _export.Export()  # type: ignore
 
@@ -34,15 +32,6 @@ def read_bytes(fs: SupportsReadChunks, path: str, chunk_size: int = 65535) -> by
     return out
 
 
-@export
-async def async_read_bytes(fs: SupportsAsyncReadChunks, path: str, chunk_size: int = 65535) -> bytes:
-    """Async variant of the :func:`read_bytes` helper."""
-    out = b""
-    async for chunk in fs.read_chunks(path, chunk_size):
-        out += chunk
-    return out
-
-
 @export
 def write_bytes(fs: SupportsWriteChunks, path: str, data: bytes, chunk_size: int = 65535) -> int:
     """Write given data to file at given path either creating the file, or
@@ -73,15 +62,6 @@ def write_bytes(fs: SupportsWriteChunks, path: str, data: bytes, chunk_size: int
     return total_bytes
 
 
-@export
-async def async_write_bytes(fs: SupportsAsyncWriteChunks, path: str, data: bytes, chunk_size: int = 65535) -> int:
-    """Async variant of the :func:`write_bytes` helper."""
-    total_bytes = 0
-    async for byte_count in fs.write_chunks(path, _utils.async_split_into_chunks(data, chunk_size)):
-        total_bytes += byte_count
-    return total_bytes
-
-
 @export
 def read_text(fs: SupportsReadChunks, path: str, encoding: str = "utf-8", chunk_size: int = 65535) -> str:
     """Read whole text file and return as string.
@@ -106,14 +86,6 @@ def read_text(fs: SupportsReadChunks, path: str, encoding: str = "utf-8", chunk_
     return read_bytes(fs, path, chunk_size).decode(encoding)
 
 
-@export
-async def async_read_text(
-    fs: SupportsAsyncReadChunks, path: str, encoding: str = "utf-8", chunk_size: int = 65535
-) -> str:
-    """Async variant of the :func:`read_text` helper."""
-    return (await async_read_bytes(fs, path, chunk_size)).decode(encoding)
-
-
 @export
 def write_text(fs: SupportsWriteChunks, path: str, data: str, encoding: str = "utf-8", chunk_size: int = 65535):
     """Create new text file or replace existing with given text data.
@@ -138,14 +110,6 @@ def write_text(fs: SupportsWriteChunks, path: str, data: str, encoding: str = "u
     return write_bytes(fs, path, data.encode(encoding), chunk_size)
 
 
-@export
-async def async_write_text(
-    fs: SupportsAsyncWriteChunks, path: str, data: str, encoding: str = "utf-8", chunk_size: int = 65535
-):
-    """Async variant of the :func:`write_text` helper."""
-    await async_write_bytes(fs, path, data.encode(encoding), chunk_size)
-
-
 @export
 class BufferedWriter(AbstractContextManager):
     """Buffered writer for creating new or replacing existing files.
@@ -180,9 +144,7 @@ class BufferedWriter(AbstractContextManager):
     def __enter__(self) -> "BufferedWriter":
         return self
 
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
+    def __exit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
         return self.close()
 
     def __write_chunk(self, chunk: bytes):
@@ -221,47 +183,6 @@ class BufferedWriter(AbstractContextManager):
         return len(data)
 
 
-@export
-class AsyncBufferedWriter(AbstractAsyncContextManager):
-    """Async variant of the :class:`BufferedWriter` class."""
-
-    def __init__(self, fs: SupportsAsyncWriteChunks, path: str, buffer_size: int = 65535):
-        self.__chunk_queue: asyncio.Queue[bytes] = asyncio.Queue()
-        self.__buffer_size = buffer_size
-        self.__buffer = b""
-        self.__writer = fs.write_chunks(path, _utils.async_generate_chunks_from_queue(self.__chunk_queue))
-
-    async def __aenter__(self) -> "AsyncBufferedWriter":
-        return self
-
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
-        return await self.close()
-
-    async def __write_chunk(self, chunk: bytes):
-        self.__chunk_queue.put_nowait(chunk)
-        await anext(self.__writer)
-
-    async def write(self, data: bytes) -> int:
-        self.__buffer += data
-        while len(self.__buffer) > self.__buffer_size:
-            chunk = self.__buffer[: self.__buffer_size]
-            await self.__write_chunk(chunk)
-            self.__buffer = self.__buffer[self.__buffer_size :]
-        return len(data)
-
-    async def flush(self):
-        if not self.__buffer:
-            return  # Nothing to do
-        await self.__write_chunk(self.__buffer)
-        self.__buffer = b""
-
-    async def close(self):
-        await self.flush()
-        await self.__writer.aclose()
-
-
 @export
 class BufferedReader(AbstractContextManager):
     """Helper for buffered reading from underlying flat filesystem.
@@ -292,9 +213,7 @@ class BufferedReader(AbstractContextManager):
     def __enter__(self) -> "BufferedReader":
         return self
 
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
+    def __exit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
         return self.close()
 
     def close(self):
@@ -309,34 +228,6 @@ class BufferedReader(AbstractContextManager):
         return data
 
 
-@export
-class AsyncBufferedReader(AbstractAsyncContextManager):
-    """Async variant of the :class:`BufferedReader` class."""
-
-    def __init__(self, fs: SupportsAsyncReadChunks, path: str, buffer_size: int = 65535):
-        self.__reader = fs.read_chunks(path, chunk_size=buffer_size)
-        self.__buffer = b""
-
-    async def __aenter__(self) -> "AsyncBufferedReader":
-        return self
-
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
-        return await self.close()
-
-    async def close(self):
-        self.__buffer = b""
-        await self.__reader.aclose()
-
-    async def read(self, count: int) -> bytes:
-        if not self.__buffer:
-            self.__buffer = await anext(self.__reader, b"")
-        data = self.__buffer[:count]
-        self.__buffer = self.__buffer[count:]
-        return data
-
-
 @export
 class BufferedTextReader(AbstractContextManager):
     """Equivalent of :class:`BufferedReader` for text files.
@@ -371,9 +262,7 @@ class BufferedTextReader(AbstractContextManager):
     def __enter__(self) -> "BufferedTextReader":
         return self
 
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
+    def __exit__(self, exc_type, exc_value, traceback) -> Optional[bool]:
         return self.close()
 
     def __iter__(self) -> Iterator[str]:
@@ -405,45 +294,3 @@ class BufferedTextReader(AbstractContextManager):
         """
         self.__buffer = ""
         self.__reader.close()
-
-
-@export
-class AsyncBufferedTextReader(AbstractAsyncContextManager):
-    """Async variant of the :class:`BufferedTextReader` class."""
-
-    def __init__(self, fs: SupportsAsyncReadChunks, path: str, encoding: str = "utf-8", buffer_size: int = 65535):
-        self.__reader = fs.read_chunks(path, chunk_size=buffer_size)
-        self.__encoding = encoding
-        self.__buffer = ""
-
-    async def __read_next_chunk(self) -> str:
-        return (await anext(self.__reader, b"")).decode(self.__encoding)
-
-    async def __aenter__(self) -> "AsyncBufferedTextReader":
-        return self
-
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
-    ) -> bool | None:
-        return await self.close()
-
-    async def __aiter__(self) -> AsyncIterator[str]:
-        while next_chunk := await self.__read_next_chunk():
-            self.__buffer += next_chunk
-            lines = self.__buffer.splitlines()
-            if len(lines) > 1:
-                for line in lines[:-1]:
-                    yield line
-                self.__buffer = lines[-1]
-        yield self.__buffer
-
-    async def read(self, count: int) -> str:
-        if not self.__buffer:
-            self.__buffer = await self.__read_next_chunk()
-        out = self.__buffer[:count]
-        self.__buffer = self.__buffer[count:]
-        return out
-
-    async def close(self):
-        self.__buffer = ""
-        await self.__reader.aclose()

{flatfs-0.3.0 → flatfs-0.5.0}/flatfs/interface.py

@@ -1,6 +1,6 @@
 import dataclasses
 import datetime
-from typing import AsyncGenerator, AsyncIterator, Generator, Iterator, Protocol
+from typing import Generator, Iterator, Protocol
 
 from . import _export
 
@@ -111,88 +111,3 @@ class FlatFsReaderWriter(FlatFsReader, SupportsWriteChunks, Protocol):
             The path to a file to remove.
         """
         ...
-
-
-@export
-class SupportsAsyncReadChunks(Protocol):
-    """Async variant of the :class:`SupportsReadChunks` protocol."""
-
-    def read_chunks(self, path: str, chunk_size: int = 65535) -> AsyncGenerator[bytes, None]:
-        """Return a generator for reading file in chunks of given maximum size.
-
-        This is the async version of :meth:`SupportsReadChunks.read_chunks`
-        method.
-
-        :param path:
-            The path to a file to read.
-
-        :param chunk_size:
-            The maximum chunk size, in bytes.
-        """
-        ...
-
-
-@export
-class SupportsAsyncWriteChunks(Protocol):
-    """Async variant of the :class:`SupportsWriteChunks` protocol."""
-
-    def write_chunks(self, path: str, chunk_gen: AsyncGenerator[bytes, None]) -> AsyncGenerator[int, None]:
-        """Generator for creating or overwriting files.
-
-        This is the async version of :meth:`SupportsWriteChunks.write_chunks`
-        method.
-
-        :param path:
-            The path to a file to create or replace.
-
-        :param chunk_gen:
-            Async generator yielding file chunks.
-        """
-        ...
-
-
-@export
-class AsyncFlatFsReader(SupportsAsyncReadChunks, Protocol):
-    """Async variant of the :class:`FlatFsReader` protocol."""
-
-    def scan(self) -> AsyncIterator[str]:
-        """Return iterator that yields normalized paths to existing files.
-
-        This is the async version of :meth:`FlatFsReader.scan` method.
-        """
-        ...
-
-    async def stat(self, path: str) -> Stat:
-        """Get stats of a file at given path.
-
-        This is the async version of :meth:`FlatFsReader.stat` method.
-
-        :param path:
-            The path to a file.
-        """
-        ...
-
-    async def exists(self, path: str) -> bool:
-        """Check if file at given path exists.
-
-        This is the async version of :meth:`FlatFsReader.exists` method.
-
-        :param path:
-            The path to check.
-        """
-        ...
-
-
-@export
-class AsyncFlatFsReaderWriter(AsyncFlatFsReader, SupportsAsyncWriteChunks, Protocol):
-    """Async variant of the :class:`FlatFsReaderWriter` protocol."""
-
-    async def remove(self, path: str):
-        """Remove existing file.
-
-        This is the async version of :meth:`FlatFsReaderWriter.remove` method.
-
-        :param path:
-            The path to a file to remove.
-        """
-        ...

{flatfs-0.3.0 → flatfs-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flatfs"
-version = "0.3.0"
+version = "0.5.0"
 description = "Minimal filesystem abstraction with pluggable backends, treating paths as keys and file contents as values."
 authors = [
     {name = "Maciej Wiatrzyk", email = "maciej.wiatrzyk@gmail.com"}
@@ -15,7 +15,7 @@ classifiers = [
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Libraries",
 ]
-requires-python = ">=3.10,<4"
+requires-python = ">=3.9,<4"
 dependencies = [
 ]
 
@@ -28,11 +28,11 @@ requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.group.dev.dependencies]
-pytest = "^9.0.3"
+pytest = "^8.4.2"
 invoke = "^3.0.3"
-pytest-asyncio = "^1.3.0"
+pytest-asyncio = "^1.2.0"
 mockify = "^0.14.0"
 pytest-cov = "^7.1.0"
 ruff = "^0.15.12"
-mypy = "^2.0.0"
+mypy = "^1.19.1"
 bumpify = "^0.5.1"

flatfs-0.3.0/flatfs/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.3.0"