Address review

Author: NoahStapp

gridfs/asynchronous/grid_file.py

@@ -1181,17 +1181,17 @@ def __setattr__(self, name: str, value: Any) -> None:
         if name in self.__dict__ or name in self.__class__.__dict__:
             object.__setattr__(self, name, value)
         else:
-            if _IS_SYNC:
-                # All other attributes are part of the document in db.fs.files.
-                # Store them to be sent to server on close() or if closed, send
-                # them now.
-                self._file[name] = value
-                if self._closed:
+            # All other attributes are part of the document in db.fs.files.
+            # Store them to be sent to server on close() or if closed, send
+            # them now.
+            self._file[name] = value
+            if self._closed:
+                if _IS_SYNC:
                     self._coll.files.update_one({"_id": self._file["_id"]}, {"$set": {name: value}})
-            else:
-                raise AttributeError(
-                    "AsyncGridIn does not support __setattr__. Use AsyncGridIn.set() instead"
-                )
+                else:
+                    raise AttributeError(
+                        "AsyncGridIn does not support __setattr__ after being closed(). Set the attribute before closing the file or use AsyncGridIn.set() instead"
+                    )
 
     async def set(self, name: str, value: Any) -> None:
         self._file[name] = value
@@ -1494,6 +1494,32 @@ async def __anext__(self) -> bytes:
         async def to_list(self) -> list[bytes]:
             return [x async for x in self]  # noqa: C416, RUF100
 
+        async def readline(self, size: int = -1) -> bytes:
+            """Read one line or up to `size` bytes from the file.
+
+            :param size: the maximum number of bytes to read
+            """
+            return await self._read_size_or_line(size=size, line=True)
+
+        async def readlines(self, size: int = -1) -> list[bytes]:
+            """Read one line or up to `size` bytes from the file.
+
+            :param size: the maximum number of bytes to read
+            """
+            await self.open()
+            lines = []
+            remainder = int(self.length) - self._position
+            bytes_read = 0
+            while remainder > 0:
+                line = await self._read_size_or_line(line=True)
+                bytes_read += len(line)
+                lines.append(line)
+                remainder = int(self.length) - self._position
+                if 0 < size < bytes_read:
+                    break
+
+            return lines
+
     async def open(self) -> None:
         if not self._file:
             _disallow_transactions(self._session)
@@ -1613,32 +1639,6 @@ async def read(self, size: int = -1) -> bytes:
         """
         return await self._read_size_or_line(size=size)
 
-    async def readline(self, size: int = -1) -> bytes:
-        """Read one line or up to `size` bytes from the file.
-
-        :param size: the maximum number of bytes to read
-        """
-        return await self._read_size_or_line(size=size, line=True)
-
-    async def readlines(self, size: int = -1) -> list[bytes]:
-        """Read one line or up to `size` bytes from the file.
-
-        :param size: the maximum number of bytes to read
-        """
-        await self.open()
-        lines = []
-        remainder = int(self.length) - self._position
-        bytes_read = 0
-        while remainder > 0:
-            line = await self._read_size_or_line(line=True)
-            bytes_read += len(line)
-            lines.append(line)
-            remainder = int(self.length) - self._position
-            if 0 < size < bytes_read:
-                break
-
-        return lines
-
     def tell(self) -> int:
         """Return the current position of this file."""
         return self._position

gridfs/synchronous/grid_file.py

@@ -1171,17 +1171,17 @@ def __setattr__(self, name: str, value: Any) -> None:
         if name in self.__dict__ or name in self.__class__.__dict__:
             object.__setattr__(self, name, value)
         else:
-            if _IS_SYNC:
-                # All other attributes are part of the document in db.fs.files.
-                # Store them to be sent to server on close() or if closed, send
-                # them now.
-                self._file[name] = value
-                if self._closed:
+            # All other attributes are part of the document in db.fs.files.
+            # Store them to be sent to server on close() or if closed, send
+            # them now.
+            self._file[name] = value
+            if self._closed:
+                if _IS_SYNC:
                     self._coll.files.update_one({"_id": self._file["_id"]}, {"$set": {name: value}})
-            else:
-                raise AttributeError(
-                    "GridIn does not support __setattr__. Use GridIn.set() instead"
-                )
+                else:
+                    raise AttributeError(
+                        "GridIn does not support __setattr__ after being closed(). Set the attribute before closing the file or use GridIn.set() instead"
+                    )
 
     def set(self, name: str, value: Any) -> None:
         self._file[name] = value
@@ -1484,6 +1484,32 @@ def __next__(self) -> bytes:
         def to_list(self) -> list[bytes]:
             return [x for x in self]  # noqa: C416, RUF100
 
+        def readline(self, size: int = -1) -> bytes:
+            """Read one line or up to `size` bytes from the file.
+
+            :param size: the maximum number of bytes to read
+            """
+            return self._read_size_or_line(size=size, line=True)
+
+        def readlines(self, size: int = -1) -> list[bytes]:
+            """Read one line or up to `size` bytes from the file.
+
+            :param size: the maximum number of bytes to read
+            """
+            self.open()
+            lines = []
+            remainder = int(self.length) - self._position
+            bytes_read = 0
+            while remainder > 0:
+                line = self._read_size_or_line(line=True)
+                bytes_read += len(line)
+                lines.append(line)
+                remainder = int(self.length) - self._position
+                if 0 < size < bytes_read:
+                    break
+
+            return lines
+
     def open(self) -> None:
         if not self._file:
             _disallow_transactions(self._session)
@@ -1603,32 +1629,6 @@ def read(self, size: int = -1) -> bytes:
         """
         return self._read_size_or_line(size=size)
 
-    def readline(self, size: int = -1) -> bytes:
-        """Read one line or up to `size` bytes from the file.
-
-        :param size: the maximum number of bytes to read
-        """
-        return self._read_size_or_line(size=size, line=True)
-
-    def readlines(self, size: int = -1) -> list[bytes]:
-        """Read one line or up to `size` bytes from the file.
-
-        :param size: the maximum number of bytes to read
-        """
-        self.open()
-        lines = []
-        remainder = int(self.length) - self._position
-        bytes_read = 0
-        while remainder > 0:
-            line = self._read_size_or_line(line=True)
-            bytes_read += len(line)
-            lines.append(line)
-            remainder = int(self.length) - self._position
-            if 0 < size < bytes_read:
-                break
-
-        return lines
-
     def tell(self) -> int:
         """Return the current position of this file."""
         return self._position

test/asynchronous/test_grid_file.py

@@ -413,30 +413,31 @@ async def test_multi_chunk_file(self):
         g = AsyncGridOut(self.db.fs, f._id)
         self.assertEqual(random_string, await g.read())
 
-    # # TODO: https://jira.mongodb.org/browse/PYTHON-4708
-    # async def test_small_chunks(self):
-    #     self.files = 0
-    #     self.chunks = 0
-    #
-    #     async def helper(data):
-    #         f = AsyncGridIn(self.db.fs, chunkSize=1)
-    #         await f.write(data)
-    #         await f.close()
-    #
-    #         self.files += 1
-    #         self.chunks += len(data)
-    #
-    #         self.assertEqual(self.files, await self.db.fs.files.count_documents({}))
-    #         self.assertEqual(self.chunks, await self.db.fs.chunks.count_documents({}))
-    #
-    #         g = AsyncGridOut(self.db.fs, f._id)
-    #         self.assertEqual(data, await g.read())
-    #
-    #         g = AsyncGridOut(self.db.fs, f._id)
-    #         self.assertEqual(data, await g.read(10) + await g.read(10))
-    #         return True
-    #
-    #     qcheck.check_unittest(self, helper, qcheck.gen_string(qcheck.gen_range(0, 20)))
+    # TODO: https://jira.mongodb.org/browse/PYTHON-4708
+    @async_client_context.require_sync
+    async def test_small_chunks(self):
+        self.files = 0
+        self.chunks = 0
+
+        async def helper(data):
+            f = AsyncGridIn(self.db.fs, chunkSize=1)
+            await f.write(data)
+            await f.close()
+
+            self.files += 1
+            self.chunks += len(data)
+
+            self.assertEqual(self.files, await self.db.fs.files.count_documents({}))
+            self.assertEqual(self.chunks, await self.db.fs.chunks.count_documents({}))
+
+            g = AsyncGridOut(self.db.fs, f._id)
+            self.assertEqual(data, await g.read())
+
+            g = AsyncGridOut(self.db.fs, f._id)
+            self.assertEqual(data, await g.read(10) + await g.read(10))
+            return True
+
+        qcheck.check_unittest(self, helper, qcheck.gen_string(qcheck.gen_range(0, 20)))
 
     async def test_seek(self):
         f = AsyncGridIn(self.db.fs, chunkSize=3)
@@ -850,7 +851,6 @@ async def test_zip(self):
         self.assertEqual(1, await self.db.fs.chunks.count_documents({}))
 
         g = AsyncGridOut(self.db.fs, f._id)
-        await g.open()
         z = zipfile.ZipFile(g)
         self.assertSequenceEqual(z.namelist(), ["test.txt"])
         self.assertEqual(z.read("test.txt"), b"hello world")

test/test_grid_file.py

@@ -411,30 +411,31 @@ def test_multi_chunk_file(self):
         g = GridOut(self.db.fs, f._id)
         self.assertEqual(random_string, g.read())
 
-    # # TODO: https://jira.mongodb.org/browse/PYTHON-4708
-    # def test_small_chunks(self):
-    #     self.files = 0
-    #     self.chunks = 0
-    #
-    #     def helper(data):
-    #         f = GridIn(self.db.fs, chunkSize=1)
-    #         f.write(data)
-    #         f.close()
-    #
-    #         self.files += 1
-    #         self.chunks += len(data)
-    #
-    #         self.assertEqual(self.files, self.db.fs.files.count_documents({}))
-    #         self.assertEqual(self.chunks, self.db.fs.chunks.count_documents({}))
-    #
-    #         g = GridOut(self.db.fs, f._id)
-    #         self.assertEqual(data, g.read())
-    #
-    #         g = GridOut(self.db.fs, f._id)
-    #         self.assertEqual(data, g.read(10) + g.read(10))
-    #         return True
-    #
-    #     qcheck.check_unittest(self, helper, qcheck.gen_string(qcheck.gen_range(0, 20)))
+    # TODO: https://jira.mongodb.org/browse/PYTHON-4708
+    @client_context.require_sync
+    def test_small_chunks(self):
+        self.files = 0
+        self.chunks = 0
+
+        def helper(data):
+            f = GridIn(self.db.fs, chunkSize=1)
+            f.write(data)
+            f.close()
+
+            self.files += 1
+            self.chunks += len(data)
+
+            self.assertEqual(self.files, self.db.fs.files.count_documents({}))
+            self.assertEqual(self.chunks, self.db.fs.chunks.count_documents({}))
+
+            g = GridOut(self.db.fs, f._id)
+            self.assertEqual(data, g.read())
+
+            g = GridOut(self.db.fs, f._id)
+            self.assertEqual(data, g.read(10) + g.read(10))
+            return True
+
+        qcheck.check_unittest(self, helper, qcheck.gen_string(qcheck.gen_range(0, 20)))
 
     def test_seek(self):
         f = GridIn(self.db.fs, chunkSize=3)
@@ -848,7 +849,6 @@ def test_zip(self):
         self.assertEqual(1, self.db.fs.chunks.count_documents({}))
 
         g = GridOut(self.db.fs, f._id)
-        g.open()
         z = zipfile.ZipFile(g)
         self.assertSequenceEqual(z.namelist(), ["test.txt"])
         self.assertEqual(z.read("test.txt"), b"hello world")