read_only=False, closed_only=False):

"""Helper for creating properties to read/write to files.

def getter(self):

if closed_only and not self._closed:

raise AttributeError("can only get %r on a closed file" %

field_name)

# Protect against PHP-237

if field_name == 'length':

return self._file.get(field_name, 0)

return self._file.get(field_name, None)

def setter(self, value):

if self._closed:

self._coll.files.update({"_id": self._file["_id"]},

{"$set": {field_name: value}}, safe=True)

self._file[field_name] = value

if read_only:

docstring = docstring + "\n\nThis attribute is read-only."

elif closed_only:

docstring = "%s\n\n%s" % (docstring, "This attribute is read-only and "

"can only be read after :meth:`close` "

"has been called.")

if not read_only and not closed_only:

return property(getter, setter, doc=docstring)

"""Class to write data to GridFS.

def __init__(self, root_collection, **kwargs):

"""Write a file to GridFS

if not isinstance(root_collection, Collection):

raise TypeError("root_collection must be an "

"instance of Collection")

# Handle alternative naming

if "content_type" in kwargs:

kwargs["contentType"] = kwargs.pop("content_type")

if "chunk_size" in kwargs:

kwargs["chunkSize"] = kwargs.pop("chunk_size")

# Defaults

kwargs["_id"] = kwargs.get("_id", ObjectId())

kwargs["chunkSize"] = kwargs.get("chunkSize", DEFAULT_CHUNK_SIZE)

root_collection.chunks.ensure_index([("files_id", ASCENDING),

("n", ASCENDING)],

unique=True)

object.__setattr__(self, "_coll", root_collection)

object.__setattr__(self, "_chunks", root_collection.chunks)

object.__setattr__(self, "_file", kwargs)

object.__setattr__(self, "_buffer", StringIO())

object.__setattr__(self, "_position", 0)

object.__setattr__(self, "_chunk_number", 0)

object.__setattr__(self, "_closed", False)

@property

def closed(self):

"""Is this file closed?

return self._closed

_id = _create_property("_id", "The ``'_id'`` value for this file.",

read_only=True)

filename = _create_property("filename", "Name of this file.")

content_type = _create_property("contentType", "Mime-type for this file.")

length = _create_property("length", "Length (in bytes) of this file.",

closed_only=True)

chunk_size = _create_property("chunkSize", "Chunk size for this file.",

read_only=True)

upload_date = _create_property("uploadDate",

"Date that this file was uploaded.",

closed_only=True)

md5 = _create_property("md5", "MD5 of the contents of this file "

"(generated on the server).",

closed_only=True)

def __getattr__(self, name):

if name in self._file:

return self._file[name]

raise AttributeError("GridIn object has no attribute '%s'" % name)

def __setattr__(self, name, value):

object.__setattr__(self, name, value)

if self._closed:

self._coll.files.update({"_id": self._file["_id"]},

{"$set": {name: value}}, safe=True)

def __flush_data(self, data):

"""Flush `data` to a chunk.

if not data:

return

assert(len(data) <= self.chunk_size)

chunk = {"files_id": self._file["_id"],

"n": self._chunk_number,

"data": Binary(data)}

self._chunks.insert(chunk)

self._chunk_number += 1

self._position += len(data)

def __flush_buffer(self):

"""Flush the buffer contents out to a chunk.

self.__flush_data(self._buffer.getvalue())

self._buffer.close()

self._buffer = StringIO()

def __flush(self):

"""Flush the file to the database.

self.__flush_buffer()

md5 = self._coll.database.command("filemd5", self._id,

root=self._coll.name)["md5"]

self._file["md5"] = md5

self._file["length"] = self._position

self._file["uploadDate"] = datetime.datetime.utcnow()

try:

return self._coll.files.insert(self._file, safe=True)

except DuplicateKeyError:

raise FileExists("file with _id %r already exists" % self._id)

def close(self):

"""Flush the file and close it.

if not self._closed:

self.__flush()

object.__setattr__(self, "_closed", True)

def write(self, data):

"""Write data to the file. There is no return value.

if self._closed:

raise ValueError("cannot write to a closed file")

try:

# file-like

read = data.read

except AttributeError:

# string

if not isinstance(data, basestring):

raise TypeError("can only write strings or file-like objects")

if isinstance(data, unicode):

try:

data = data.encode(self.encoding)

except AttributeError:

raise TypeError("must specify an encoding for file in "

"order to write unicode")

read = StringIO(data).read

if self._buffer.tell() > 0:

# Make sure to flush only when _buffer is complete

space = self.chunk_size - self._buffer.tell()

if space:

to_write = read(space)

self._buffer.write(to_write)

if len(to_write) < space:

return # EOF or incomplete

self.__flush_buffer()

to_write = read(self.chunk_size)

while to_write and len(to_write) == self.chunk_size:

self.__flush_data(to_write)

to_write = read(self.chunk_size)

self._buffer.write(to_write)

def writelines(self, sequence):

"""Write a sequence of strings to the file.

for line in sequence:

self.write(line)

def __enter__(self):

"""Support for the context manager protocol.

return self

def __exit__(self, exc_type, exc_val, exc_tb):

"""Support for the context manager protocol.

self.close()

# propogate exceptions

"""Class to read data out of GridFS.

def __init__(self, root_collection, file_id=None, file_document=None):

"""Read a file from GridFS

if not isinstance(root_collection, Collection):

raise TypeError("root_collection must be an "

"instance of Collection")

self.__chunks = root_collection.chunks

files = root_collection.files

self._file = file_document or files.find_one({"_id": file_id})

if not self._file:

raise NoFile("no file in gridfs collection %r with _id %r" %

(files, file_id))

self.__buffer = ""

self.__position = 0

_id = _create_property("_id", "The ``'_id'`` value for this file.", True)

name = _create_property("filename", "Name of this file.", True)

content_type = _create_property("contentType", "Mime-type for this file.",

True)

length = _create_property("length", "Length (in bytes) of this file.",

True)

chunk_size = _create_property("chunkSize", "Chunk size for this file.",

True)

upload_date = _create_property("uploadDate",

"Date that this file was first uploaded.",

True)

aliases = _create_property("aliases", "List of aliases for this file.",

True)

metadata = _create_property("metadata", "Metadata attached to this file.",

True)

md5 = _create_property("md5", "MD5 of the contents of this file "

"(generated on the server).", True)

def __getattr__(self, name):

if name in self._file:

return self._file[name]

raise AttributeError("GridOut object has no attribute '%s'" % name)

def read(self, size=-1):

"""Read at most `size` bytes from the file (less if there

if size == 0:

return ""

remainder = int(self.length) - self.__position

if size < 0 or size > remainder:

size = remainder

received = len(self.__buffer)

chunk_number = (received + self.__position) / self.chunk_size

chunks = []

while received < size:

chunk = self.__chunks.find_one({"files_id": self._id,

"n": chunk_number})

if not chunk:

raise CorruptGridFile("no chunk #%d" % chunk_number)

if received:

chunk_data = chunk["data"]

else:

chunk_data = chunk["data"][self.__position % self.chunk_size:]

received += len(chunk_data)

chunks.append(chunk_data)

chunk_number += 1

data = "".join([self.__buffer] + chunks)

self.__position += size

to_return = data[:size]

self.__buffer = data[size:]

return to_return

def readline(self, size=-1):

"""Read one line or up to `size` bytes from the file.

bytes = ""

while len(bytes) != size:

byte = self.read(1)

bytes += byte

if byte == "" or byte == "\n":

break

return bytes

def tell(self):

"""Return the current position of this file.

return self.__position

def seek(self, pos, whence=_SEEK_SET):

"""Set the current position of this file.

if whence == _SEEK_SET:

new_pos = pos

elif whence == _SEEK_CUR:

new_pos = self.__position + pos

elif whence == _SEEK_END:

new_pos = int(self.length) + pos

else:

raise IOError(22, "Invalid value for `whence`")

if new_pos < 0:

raise IOError(22, "Invalid value for `pos` - must be positive")

self.__position = new_pos

self.__buffer = ""

def __iter__(self):

"""Return an iterator over all of this file's data.

return GridOutIterator(self, self.__chunks)

def close(self):

"""Make GridOut more generically file-like."""

pass

def __enter__(self):

"""Makes it possible to use :class:`GridOut` files

return self

def __exit__(self, exc_type, exc_val, exc_tb):

"""Makes it possible to use :class:`GridOut` files

def __init__(self, grid_out, chunks):

self.__id = grid_out._id

self.__chunks = chunks

self.__current_chunk = 0

self.__max_chunk = math.ceil(float(grid_out.length) /

grid_out.chunk_size)

def __iter__(self):

return self

def next(self):

if self.__current_chunk >= self.__max_chunk:

raise StopIteration

chunk = self.__chunks.find_one({"files_id": self.__id,

"n": self.__current_chunk})

if not chunk:

raise CorruptGridFile("no chunk #%d" % self.__current_chunk)

self.__current_chunk += 1

"""No longer supported.

def __init__(self, *args, **kwargs):

raise UnsupportedAPI("The GridFile class is no longer supported. "