def test_iterator(self): f = GridIn(self.db.fs) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([], list(g)) f = GridIn(self.db.fs) f.write(b"hello world\nhere are\nsome lines.") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b"hello world\n", b"here are\n", b"some lines."], list(g)) self.assertEqual(b"", g.read(5)) self.assertEqual([], list(g)) g = GridOut(self.db.fs, f._id) self.assertEqual(b"hello world\n", next(iter(g))) self.assertEqual(b"here", g.read(4)) self.assertEqual(b" are\n", next(iter(g))) self.assertEqual(b"some lines", g.read(10)) self.assertEqual(b".", next(iter(g))) self.assertRaises(StopIteration, iter(g).__next__) f = GridIn(self.db.fs, chunk_size=2) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b"hello world"], list(g))
def save(self, name, content, metadata=None): """Save `content` in a file named `name`. :parameters: - `name`: The name of the file. - `content`: A file-like object, string, or bytes. - `metadata`: Metadata dictionary to be saved with the file. :returns: The id of the saved file. """ gridin_opts = {'filename': name, 'encoding': 'utf8'} if metadata is not None: gridin_opts['metadata'] = metadata gridin = GridIn(self.gridfs._collection, **gridin_opts) try: content.seek(0) except (AttributeError, UnsupportedOperation): pass if PY3 and hasattr(content, 'mode') and 'b' not in content.mode: # File opened in text mode. gridin.writelines(content) else: # File in binary mode, bytes, or text. gridin.write(content) # Finish writing the file. gridin.close() return gridin._id
def put(self, data, **kwargs): """Put data in GridFS as a new file. Equivalent to doing: >>> f = new_file(**kwargs) >>> try: >>> f.write(data) >>> finally: >>> f.close() `data` can be either an instance of :class:`str` or a file-like object providing a :meth:`read` method. Any keyword arguments will be passed through to the created file - see :meth:`~gridfs.grid_file.GridIn` for possible arguments. Returns the ``"_id"`` of the created file. If the ``"_id"`` of the file is manually specified, it must not already exist in GridFS. Otherwise :class:`~gridfs.errors.FileExists` is raised. :Parameters: - `data`: data to be written as a file. - `**kwargs` (optional): keyword arguments for file creation .. versionadded:: 1.6 """ grid_file = GridIn(self.__collection, **kwargs) try: grid_file.write(data) finally: grid_file.close() return grid_file._id
def test_readline(self): f = GridIn(self.db.fs, chunkSize=5) f.write( b( """Hello world, How are you? Hope all is well. Bye""" ) ) f.close() # Try read(), then readline(). g = GridOut(self.db.fs, f._id) self.assertEqual(b("H"), g.read(1)) self.assertEqual(b("ello world,\n"), g.readline()) self.assertEqual(b("How a"), g.readline(5)) self.assertEqual(b(""), g.readline(0)) self.assertEqual(b("re you?\n"), g.readline()) self.assertEqual(b("Hope all is well.\n"), g.readline(1000)) self.assertEqual(b("Bye"), g.readline()) self.assertEqual(b(""), g.readline()) # Try readline() first, then read(). g = GridOut(self.db.fs, f._id) self.assertEqual(b("He"), g.readline(2)) self.assertEqual(b("l"), g.read(1)) self.assertEqual(b("lo"), g.readline(2)) self.assertEqual(b(" world,\n"), g.readline()) # Only readline(). g = GridOut(self.db.fs, f._id) self.assertEqual(b("H"), g.readline(1)) self.assertEqual(b("e"), g.readline(1)) self.assertEqual(b("llo world,\n"), g.readline())
def test_grid_out_custom_opts(self): one = GridIn(self.db.fs, _id=5, filename="my_file", contentType="text/html", chunkSize=1000, aliases=["foo"], metadata={ "foo": 1, "bar": 2 }, bar=3, baz="hello") one.write(b"hello world") one.close() two = GridOut(self.db.fs, 5) self.assertEqual("my_file", two.name) self.assertEqual("my_file", two.filename) self.assertEqual(5, two._id) self.assertEqual(11, two.length) self.assertEqual("text/html", two.content_type) self.assertEqual(1000, two.chunk_size) self.assertTrue(isinstance(two.upload_date, datetime.datetime)) self.assertEqual(["foo"], two.aliases) self.assertEqual({"foo": 1, "bar": 2}, two.metadata) self.assertEqual(3, two.bar) self.assertEqual("5eb63bbbe01eeed093cb22bb8f5acdc3", two.md5) for attr in [ "_id", "name", "content_type", "length", "chunk_size", "upload_date", "aliases", "metadata", "md5" ]: self.assertRaises(AttributeError, setattr, two, attr, 5)
def test_readline(self): f = GridIn(self.db.fs, chunkSize=5) f.write((b"""Hello world, How are you? Hope all is well. Bye""")) f.close() # Try read(), then readline(). g = GridOut(self.db.fs, f._id) self.assertEqual(b"H", g.read(1)) self.assertEqual(b"ello world,\n", g.readline()) self.assertEqual(b"How a", g.readline(5)) self.assertEqual(b"", g.readline(0)) self.assertEqual(b"re you?\n", g.readline()) self.assertEqual(b"Hope all is well.\n", g.readline(1000)) self.assertEqual(b"Bye", g.readline()) self.assertEqual(b"", g.readline()) # Try readline() first, then read(). g = GridOut(self.db.fs, f._id) self.assertEqual(b"He", g.readline(2)) self.assertEqual(b"l", g.read(1)) self.assertEqual(b"lo", g.readline(2)) self.assertEqual(b" world,\n", g.readline()) # Only readline(). g = GridOut(self.db.fs, f._id) self.assertEqual(b"H", g.readline(1)) self.assertEqual(b"e", g.readline(1)) self.assertEqual(b"llo world,\n", g.readline())
def test_readlines(self): f = GridIn(self.db.fs, chunkSize=5) f.write((b"""Hello world, How are you? Hope all is well. Bye""")) f.close() # Try read(), then readlines(). g = GridOut(self.db.fs, f._id) self.assertEqual(b"He", g.read(2)) self.assertEqual([b"llo world,\n", b"How are you?\n"], g.readlines(11)) self.assertEqual([b"Hope all is well.\n", b"Bye"], g.readlines()) self.assertEqual([], g.readlines()) # Try readline(), then readlines(). g = GridOut(self.db.fs, f._id) self.assertEqual(b"Hello world,\n", g.readline()) self.assertEqual([b"How are you?\n", b"Hope all is well.\n"], g.readlines(13)) self.assertEqual(b"Bye", g.readline()) self.assertEqual([], g.readlines()) # Only readlines(). g = GridOut(self.db.fs, f._id) self.assertEqual([ b"Hello world,\n", b"How are you?\n", b"Hope all is well.\n", b"Bye" ], g.readlines()) g = GridOut(self.db.fs, f._id) self.assertEqual([ b"Hello world,\n", b"How are you?\n", b"Hope all is well.\n", b"Bye" ], g.readlines(0)) g = GridOut(self.db.fs, f._id) self.assertEqual([b"Hello world,\n"], g.readlines(1)) self.assertEqual([b"How are you?\n"], g.readlines(12)) self.assertEqual([b"Hope all is well.\n", b"Bye"], g.readlines(18)) # Try readlines() first, then read(). g = GridOut(self.db.fs, f._id) self.assertEqual([b"Hello world,\n"], g.readlines(1)) self.assertEqual(b"H", g.read(1)) self.assertEqual([b"ow are you?\n", b"Hope all is well.\n"], g.readlines(29)) self.assertEqual([b"Bye"], g.readlines(1)) # Try readlines() first, then readline(). g = GridOut(self.db.fs, f._id) self.assertEqual([b"Hello world,\n"], g.readlines(1)) self.assertEqual(b"How are you?\n", g.readline()) self.assertEqual([b"Hope all is well.\n"], g.readlines(17)) self.assertEqual(b"Bye", g.readline())
def test_grid_out_file_document(self): a = GridIn(self.db.fs) a.write("foo bar") a.close() b = GridOut(self.db.fs, file_document=self.db.fs.files.find_one()) self.assertEqual("foo bar", b.read()) c = GridOut(self.db.fs, 5, file_document=self.db.fs.files.find_one()) self.assertEqual("foo bar", c.read()) self.assertRaises(NoFile, GridOut, self.db.fs, file_document={})
def test_multi_chunk_file(self): random_string = qcheck.gen_string(qcheck.lift(300000))() f = GridIn(self.db.fs) f.write(random_string) f.close() self.assertEqual(1, self.db.fs.files.find().count()) self.assertEqual(2, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(random_string, g.read())
def test_multi_chunk_file(self): random_string = b'a' * (DEFAULT_CHUNK_SIZE + 1000) f = GridIn(self.db.fs) f.write(random_string) f.close() self.assertEqual(1, self.db.fs.files.count_documents({})) self.assertEqual(2, self.db.fs.chunks.count_documents({})) g = GridOut(self.db.fs, f._id) self.assertEqual(random_string, g.read())
def test_grid_out_file_document(self): one = GridIn(self.db.fs) one.write(b("foo bar")) one.close() two = GridOut(self.db.fs, file_document=self.db.fs.files.find_one()) self.assertEqual(b("foo bar"), two.read()) three = GridOut(self.db.fs, 5, file_document=self.db.fs.files.find_one()) self.assertEqual(b("foo bar"), three.read()) self.assertRaises(NoFile, GridOut, self.db.fs, file_document={})
def test_multi_chunk_file(self): random_string = b("a") * (DEFAULT_CHUNK_SIZE + 1000) f = GridIn(self.db.fs) f.write(random_string) f.close() self.assertEqual(1, self.db.fs.files.find().count()) self.assertEqual(2, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(random_string, g.read())
def test_multiple_reads(self): f = GridIn(self.db.fs, chunkSize=3) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(b"he", g.read(2)) self.assertEqual(b"ll", g.read(2)) self.assertEqual(b"o ", g.read(2)) self.assertEqual(b"wo", g.read(2)) self.assertEqual(b"rl", g.read(2)) self.assertEqual(b"d", g.read(2)) self.assertEqual(b"", g.read(2))
def test_alternate_collection(self): self.db.alt.files.delete_many({}) self.db.alt.chunks.delete_many({}) f = GridIn(self.db.alt) f.write(b"hello world") f.close() self.assertEqual(1, self.db.alt.files.count_documents({})) self.assertEqual(1, self.db.alt.chunks.count_documents({})) g = GridOut(self.db.alt, f._id) self.assertEqual(b"hello world", g.read())
def test_closed(self): f = GridIn(self.db.fs, chunkSize=5) f.write(b"Hello world.\nHow are you?") f.close() g = GridOut(self.db.fs, f._id) self.assertFalse(g.closed) g.read(1) self.assertFalse(g.closed) g.read(100) self.assertFalse(g.closed) g.close() self.assertTrue(g.closed)
def test_multiple_reads(self): f = GridIn(self.db.fs, chunkSize=3) f.write("hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual("he", g.read(2)) self.assertEqual("ll", g.read(2)) self.assertEqual("o ", g.read(2)) self.assertEqual("wo", g.read(2)) self.assertEqual("rl", g.read(2)) self.assertEqual("d", g.read(2)) self.assertEqual("", g.read(2))
def write_me(s, chunk_size): buf = StringIO(s) infile = GridIn(self.db.fs) while True: to_write = buf.read(chunk_size) if to_write == b(''): break infile.write(to_write) infile.close() buf.close() outfile = GridOut(self.db.fs, infile._id) data = outfile.read() self.assertEqual(s, data)
def write_me(s, chunk_size): buf = StringIO(s) infile = GridIn(self.db.fs) while True: to_write = buf.read(chunk_size) if to_write == b'': break infile.write(to_write) infile.close() buf.close() outfile = GridOut(self.db.fs, infile._id) data = outfile.read() self.assertEqual(s, data)
def test_grid_out_file_document(self): one = GridIn(self.db.fs) one.write(b"foo bar") one.close() two = GridOut(self.db.fs, file_document=self.db.fs.files.find_one()) self.assertEqual(b"foo bar", two.read()) three = GridOut(self.db.fs, 5, file_document=self.db.fs.files.find_one()) self.assertEqual(b"foo bar", three.read()) four = GridOut(self.db.fs, file_document={}) with self.assertRaises(NoFile): four.name
def test_grid_out_unsupported_operations(self): f = GridIn(self.db.fs, chunkSize=3) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertRaises(io.UnsupportedOperation, g.writelines, [b"some", b"lines"]) self.assertRaises(io.UnsupportedOperation, g.write, b"some text") self.assertRaises(io.UnsupportedOperation, g.fileno) self.assertRaises(io.UnsupportedOperation, g.truncate) self.assertFalse(g.writable()) self.assertFalse(g.isatty())
def test_read_chunks_unaligned_buffer_size(self): in_data = "This is a text that doesn't quite fit in a single 16-byte chunk." f = GridIn(self.db.fs, chunkSize=16) f.write(in_data) f.close() g = GridOut(self.db.fs, f._id) out_data = '' while 1: s = g.read(13) if not s: break out_data += s self.assertEqual(in_data, out_data)
def test_tell(self): f = GridIn(self.db.fs, chunkSize=3) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(0, g.tell()) g.read(0) self.assertEqual(0, g.tell()) g.read(1) self.assertEqual(1, g.tell()) g.read(2) self.assertEqual(3, g.tell()) g.read() self.assertEqual(g.length, g.tell())
def test_tell(self): f = GridIn(self.db.fs, chunkSize=3) f.write("hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(0, g.tell()) g.read(0) self.assertEqual(0, g.tell()) g.read(1) self.assertEqual(1, g.tell()) g.read(2) self.assertEqual(3, g.tell()) g.read() self.assertEqual(g.length, g.tell())
def test_alternate_collection(self): self.db.alt.files.remove({}) self.db.alt.chunks.remove({}) f = GridIn(self.db.alt) f.write(b("hello world")) f.close() self.assertEqual(1, self.db.alt.files.find().count()) self.assertEqual(1, self.db.alt.chunks.find().count()) g = GridOut(self.db.alt, f._id) self.assertEqual(b("hello world"), g.read()) # test that md5 still works... self.assertEqual("5eb63bbbe01eeed093cb22bb8f5acdc3", g.md5)
def test_alternate_collection(self): self.db.alt.files.remove({}) self.db.alt.chunks.remove({}) f = GridIn(self.db.alt) f.write("hello world") f.close() self.assertEqual(1, self.db.alt.files.find().count()) self.assertEqual(1, self.db.alt.chunks.find().count()) g = GridOut(self.db.alt, f._id) self.assertEqual("hello world", g.read()) # test that md5 still works... self.assertEqual("5eb63bbbe01eeed093cb22bb8f5acdc3", g.md5)
def test_alternate_collection(self): self.db.alt.files.delete_many({}) self.db.alt.chunks.delete_many({}) f = GridIn(self.db.alt) f.write(b"hello world") f.close() self.assertEqual(1, self.db.alt.files.count_documents({})) self.assertEqual(1, self.db.alt.chunks.count_documents({})) g = GridOut(self.db.alt, f._id) self.assertEqual(b"hello world", g.read()) # test that md5 still works... self.assertEqual("5eb63bbbe01eeed093cb22bb8f5acdc3", g.md5)
def put(self, data, **kwargs): """Put data in GridFS as a new file. Equivalent to doing:: try: f = new_file(**kwargs) f.write(data) finally: f.close() `data` can be either an instance of :class:`str` (:class:`bytes` in python 3) or a file-like object providing a :meth:`read` method. If an `encoding` keyword argument is passed, `data` can also be a :class:`unicode` (:class:`str` in python 3) instance, which will be encoded as `encoding` before being written. Any keyword arguments will be passed through to the created file - see :meth:`~gridfs.grid_file.GridIn` for possible arguments. Returns the ``"_id"`` of the created file. If the ``"_id"`` of the file is manually specified, it must not already exist in GridFS. Otherwise :class:`~gridfs.errors.FileExists` is raised. :Parameters: - `data`: data to be written as a file. - `**kwargs` (optional): keyword arguments for file creation .. versionadded:: 1.9 The ability to write :class:`unicode`, if an `encoding` has been specified as a keyword argument. .. versionadded:: 1.6 """ grid_file = GridIn(self.__collection, **kwargs) # Start a request - necessary if w=0, harmless otherwise request = self.__collection.database.connection.start_request() try: try: grid_file.write(data) finally: grid_file.close() finally: # Ensure request is ended even if close() throws error request.end() return grid_file._id
def put(self, data, callback, **kwargs): """Put data in GridFS as a new file. Equivalent to doing: try: f = new_file(**kwargs) f.write(data) finally f.close() `data` can be either an instance of :class:`str` (:class:`bytes` in python 3) or a file-like object providing a :meth:`read` method. If an `encoding` keyword argument is passed, `data` can also be a :class:`unicode` (:class:`str` in python 3) instance, which will be encoded as `encoding` before being written. Any keyword arguments will be passed through to the created file - see :meth:`~gridfs.grid_file.GridIn` for possible arguments. Returns the ``"_id"`` of the created file. If the ``"_id"`` of the file is manually specified, it must not already exist in GridFS. Otherwise :class:`~gridfs.errors.FileExists` is raised. :Parameters: - `data`: data to be written as a file. - `**kwargs` (optional): keyword arguments for file creation .. versionadded:: 1.9 The ability to write :class:`unicode`, if an `encoding` has been specified as a keyword argument. .. versionadded:: 1.6 """ grid_file = GridIn(self.__collection, **kwargs) def mod_callback(): def mod_callback2(response): """docstring for mod_callback""" # def mod_callback2(response): if isinstance(response, Exception): callback(response) else: callback(grid_file._id) grid_file.close(mod_callback2) grid_file.write(data, mod_callback)
def test_zip(self): zf = StringIO() z = zipfile.ZipFile(zf, "w") z.writestr("test.txt", b"hello world") z.close() zf.seek(0) f = GridIn(self.db.fs, filename="test.zip") f.write(zf) f.close() self.assertEqual(1, self.db.fs.files.count_documents({})) self.assertEqual(1, self.db.fs.chunks.count_documents({})) g = GridOut(self.db.fs, f._id) z = zipfile.ZipFile(g) self.assertSequenceEqual(z.namelist(), ["test.txt"]) self.assertEqual(z.read("test.txt"), b"hello world")
def test_zip(self): zf = BytesIO() z = zipfile.ZipFile(zf, "w") z.writestr("test.txt", b"hello world") z.close() zf.seek(0) f = GridIn(self.db.fs, filename="test.zip") f.write(zf) f.close() self.assertEqual(1, self.db.fs.files.count_documents({})) self.assertEqual(1, self.db.fs.chunks.count_documents({})) g = GridOut(self.db.fs, f._id) z = zipfile.ZipFile(g) self.assertSequenceEqual(z.namelist(), ["test.txt"]) self.assertEqual(z.read("test.txt"), b"hello world")
def test_readchunk(self): in_data = b'a' * 10 f = GridIn(self.db.fs, chunkSize=3) f.write(in_data) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(3, len(g.readchunk())) self.assertEqual(2, len(g.read(2))) self.assertEqual(1, len(g.readchunk())) self.assertEqual(3, len(g.read(3))) self.assertEqual(1, len(g.readchunk())) self.assertEqual(0, len(g.readchunk()))
def test_write_unicode(self): f = GridIn(self.db.fs) self.assertRaises(TypeError, f.write, u"foo") f = GridIn(self.db.fs, encoding="utf-8") f.write(u"foo") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual("foo", g.read()) f = GridIn(self.db.fs, encoding="iso-8859-1") f.write(u"aé") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(u"aé".encode("iso-8859-1"), g.read())
def test_readline(self): f = GridIn(self.db.fs, chunkSize=5) f.write(b("""Hello world, How are you? Hope all is well. Bye""")) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(b("H"), g.read(1)) self.assertEqual(b("ello world,\n"), g.readline()) self.assertEqual(b("How a"), g.readline(5)) self.assertEqual(b(""), g.readline(0)) self.assertEqual(b("re you?\n"), g.readline()) self.assertEqual(b("Hope all is well.\n"), g.readline(1000)) self.assertEqual(b("Bye"), g.readline()) self.assertEqual(b(""), g.readline())
def test_readline(self): f = GridIn(self.db.fs, chunkSize=5) f.write("""Hello world, How are you? Hope all is well. Bye""") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual("H", g.read(1)) self.assertEqual("ello world,\n", g.readline()) self.assertEqual("How a", g.readline(5)) self.assertEqual("", g.readline(0)) self.assertEqual("re you?\n", g.readline()) self.assertEqual("Hope all is well.\n", g.readline(1000)) self.assertEqual("Bye", g.readline()) self.assertEqual("", g.readline())
def test_readchunk(self): in_data = b("a") * 10 f = GridIn(self.db.fs, chunkSize=3) f.write(in_data) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(3, len(g.readchunk())) self.assertEqual(2, len(g.read(2))) self.assertEqual(1, len(g.readchunk())) self.assertEqual(3, len(g.read(3))) self.assertEqual(1, len(g.readchunk())) self.assertEqual(0, len(g.readchunk()))
def test_write_unicode(self): f = GridIn(self.db.fs) self.assertRaises(TypeError, f.write, u"foo") f = GridIn(self.db.fs, encoding="utf-8") f.write(u"foo") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(b"foo", g.read()) f = GridIn(self.db.fs, encoding="iso-8859-1") f.write(u"aé") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(u"aé".encode("iso-8859-1"), g.read())
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.find().count()) self.assertEqual(self.chunks, self.db.fs.chunks.find().count()) 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
def test_iterator(self): f = GridIn(self.db.fs) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([], list(g)) f = GridIn(self.db.fs) f.write(b("hello world")) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b("hello world")], list(g)) self.assertEqual(b("hello"), g.read(5)) self.assertEqual([b("hello world")], list(g)) self.assertEqual(b(" worl"), g.read(5)) f = GridIn(self.db.fs, chunk_size=2) f.write(b("hello world")) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b("he"), b("ll"), b("o "), b("wo"), b("rl"), b("d")], list(g))
def test_iterator(self): f = GridIn(self.db.fs) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([], list(g)) f = GridIn(self.db.fs) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b"hello world"], list(g)) self.assertEqual(b"hello", g.read(5)) self.assertEqual([b"hello world"], list(g)) self.assertEqual(b" worl", g.read(5)) f = GridIn(self.db.fs, chunk_size=2) f.write(b"hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([b"he", b"ll", b"o ", b"wo", b"rl", b"d"], list(g))
def test_iterator(self): f = GridIn(self.db.fs) f.close() g = GridOut(self.db.fs, f._id) self.assertEqual([], list(g)) f = GridIn(self.db.fs) f.write("hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(["hello world"], list(g)) self.assertEqual("hello", g.read(5)) self.assertEqual(["hello world"], list(g)) self.assertEqual(" worl", g.read(5)) f = GridIn(self.db.fs, chunk_size=2) f.write("hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual(["he", "ll", "o ", "wo", "rl", "d"], list(g))
def test_grid_out_custom_opts(self): one = GridIn( self.db.fs, _id=5, filename="my_file", contentType="text/html", chunkSize=1000, aliases=["foo"], metadata={"foo": 1, "bar": 2}, bar=3, baz="hello", ) one.write(b("hello world")) one.close() two = GridOut(self.db.fs, 5) self.assertEqual("my_file", two.name) self.assertEqual("my_file", two.filename) self.assertEqual(5, two._id) self.assertEqual(11, two.length) self.assertEqual("text/html", two.content_type) self.assertEqual(1000, two.chunk_size) self.assertTrue(isinstance(two.upload_date, datetime.datetime)) self.assertEqual(["foo"], two.aliases) self.assertEqual({"foo": 1, "bar": 2}, two.metadata) self.assertEqual(3, two.bar) self.assertEqual("5eb63bbbe01eeed093cb22bb8f5acdc3", two.md5) for attr in [ "_id", "name", "content_type", "length", "chunk_size", "upload_date", "aliases", "metadata", "md5", ]: self.assertRaises(AttributeError, setattr, two, attr, 5)
def test_basic(self): f = GridIn(self.db.fs, filename="test") f.write(b("hello world")) f.close() self.assertEqual(1, self.db.fs.files.find().count()) self.assertEqual(1, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(b("hello world"), g.read()) # make sure it's still there... g = GridOut(self.db.fs, f._id) self.assertEqual(b("hello world"), g.read()) f = GridIn(self.db.fs, filename="test") f.close() self.assertEqual(2, self.db.fs.files.find().count()) self.assertEqual(1, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(b(""), g.read())
def test_write_file_like(self): a = GridIn(self.db.fs) a.write(b"hello world") a.close() b = GridOut(self.db.fs, a._id) c = GridIn(self.db.fs) c.write(b) c.close() d = GridOut(self.db.fs, c._id) self.assertEqual(b"hello world", d.read()) e = GridIn(self.db.fs, chunk_size=2) e.write(b"hello") buffer = BytesIO(b" world") e.write(buffer) e.write(b" and mongodb") e.close() self.assertEqual(b"hello world and mongodb", GridOut(self.db.fs, e._id).read())
def test_write_file_like(self): one = GridIn(self.db.fs) one.write(b("hello world")) one.close() two = GridOut(self.db.fs, one._id) three = GridIn(self.db.fs) three.write(two) three.close() four = GridOut(self.db.fs, three._id) self.assertEqual(b("hello world"), four.read()) five = GridIn(self.db.fs, chunk_size=2) five.write(b("hello")) buffer = StringIO(b(" world")) five.write(buffer) five.write(b(" and mongodb")) five.close() self.assertEqual(b("hello world and mongodb"), GridOut(self.db.fs, five._id).read())
def put(self, data, **kwargs): """Put data in GridFS as a new file. Equivalent to doing:: try: f = new_file(**kwargs) f.write(data) finally: f.close() `data` can be either an instance of :class:`str` (:class:`bytes` in python 3) or a file-like object providing a :meth:`read` method. If an `encoding` keyword argument is passed, `data` can also be a :class:`unicode` (:class:`str` in python 3) instance, which will be encoded as `encoding` before being written. Any keyword arguments will be passed through to the created file - see :meth:`~gridfs.grid_file.GridIn` for possible arguments. Returns the ``"_id"`` of the created file. If the ``"_id"`` of the file is manually specified, it must not already exist in GridFS. Otherwise :class:`~gridfs.errors.FileExists` is raised. :Parameters: - `data`: data to be written as a file. - `**kwargs` (optional): keyword arguments for file creation .. versionchanged:: 3.0 w=0 writes to GridFS are now prohibited. """ grid_file = GridIn(self.__collection, disable_md5=self.__disable_md5, **kwargs) try: grid_file.write(data) finally: grid_file.close() return grid_file._id
def put(self, data, **kwargs): """Put data in GridFS as a new file. Equivalent to doing:: try: f = new_file(**kwargs) f.write(data) finally: f.close() `data` can be either an instance of :class:`str` (:class:`bytes` in python 3) or a file-like object providing a :meth:`read` method. If an `encoding` keyword argument is passed, `data` can also be a :class:`unicode` (:class:`str` in python 3) instance, which will be encoded as `encoding` before being written. Any keyword arguments will be passed through to the created file - see :meth:`~gridfs.grid_file.GridIn` for possible arguments. Returns the ``"_id"`` of the created file. If the ``"_id"`` of the file is manually specified, it must not already exist in GridFS. Otherwise :class:`~gridfs.errors.FileExists` is raised. :Parameters: - `data`: data to be written as a file. - `**kwargs` (optional): keyword arguments for file creation .. versionchanged:: 3.0 w=0 writes to GridFS are now prohibited. """ grid_file = GridIn( self.__collection, disable_md5=self.__disable_md5, **kwargs) try: grid_file.write(data) finally: grid_file.close() return grid_file._id
def test_seek(self): f = GridIn(self.db.fs, chunkSize=3) f.write("hello world") f.close() g = GridOut(self.db.fs, f._id) self.assertEqual("hello world", g.read()) g.seek(0) self.assertEqual("hello world", g.read()) g.seek(1) self.assertEqual("ello world", g.read()) self.assertRaises(IOError, g.seek, -1) g.seek(-3, _SEEK_END) self.assertEqual("rld", g.read()) g.seek(0, _SEEK_END) self.assertEqual("", g.read()) self.assertRaises(IOError, g.seek, -100, _SEEK_END) g.seek(3) g.seek(3, _SEEK_CUR) self.assertEqual("world", g.read()) self.assertRaises(IOError, g.seek, -100, _SEEK_CUR)
def test_basic(self): f = GridIn(self.db.fs, filename="test") f.write(b"hello world") f.close() self.assertEqual(1, self.db.fs.files.find().count()) self.assertEqual(1, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(b"hello world", g.read()) # make sure it's still there... g = GridOut(self.db.fs, f._id) self.assertEqual(b"hello world", g.read()) f = GridIn(self.db.fs, filename="test") f.close() self.assertEqual(2, self.db.fs.files.find().count()) self.assertEqual(1, self.db.fs.chunks.find().count()) g = GridOut(self.db.fs, f._id) self.assertEqual(b"", g.read()) # test that reading 0 returns proper type self.assertEqual(b"", g.read(0))
def test_md5(self): f = GridIn(self.db.fs) f.write("hello world\n") f.close() self.assertEqual("6f5902ac237024bdd0c176cb93063dc4", f.md5)