def test_get_item(self):
client = create_class_with_framework(core.SanicMongoAgnosticClient,
asyncio_framework,
self.__module__)()
db = client['some-db']
comp_db = create_class_with_framework(core.SanicMongoAgnosticDatabase,
asyncio_framework,
self.__module__)
self.assertTrue(isinstance(db, comp_db))
def wrap(self, obj):
if obj.__class__ == Database:
db_class = create_class_with_framework(MotorEngineDatabase,
self._framework,
self.__module__)
return db_class(self, obj.name, _delegate=obj)
elif obj.__class__ == CommandCursor:
command_cursor_class = create_class_with_framework(
AgnosticCommandCursor, self._framework, self.__module__)
return command_cursor_class(obj, self)
elif obj.__class__ == ClientSession:
session_class = create_class_with_framework(
AgnosticClientSession, self._framework, self.__module__)
return session_class(obj, self)
def wrap(self, obj):
if obj.__class__ is Collection:
return self.__class__(self.database, obj.name, _delegate=obj)
elif obj.__class__ is Cursor:
return MotorEngineCursor(obj, self)
elif obj.__class__ is CommandCursor:
command_cursor_class = create_class_with_framework(
AgnosticCommandCursor, self._framework, self.__module__)
return command_cursor_class(obj, self)
elif obj.__class__ is ChangeStream:
change_stream_class = create_class_with_framework(
AgnosticChangeStream, self._framework, self.__module__)
return change_stream_class(obj, self)
else:
return obj
def test_getattr_with_under(self, *args, **kwrags):
connection = Mock(spec=core.SanicMongoAgnosticClient)
delegate = MagicMock()
delegate.name = 'blabla'
connection.delegate = delegate
name = 'blabla'
db = create_class_with_framework(core.SanicMongoAgnosticDatabase,
asyncio_framework,
self.__module__)(connection, name)
coll = create_class_with_framework(core.SanicMongoAgnosticCollection,
asyncio_framework, self.__module__)
coll = coll(db, name)
self.assertEqual(coll._get_write_mode, coll.delegate._get_write_mode)
def test_get_item(self, *args, **kwargs):
connection = Mock(spec=core.SanicMongoAgnosticClient)
delegate = MagicMock()
connection.delegate = delegate
name = 'blabla'
db = create_class_with_framework(core.SanicMongoAgnosticDatabase,
asyncio_framework,
self.__module__)(connection, name)
comp_coll = create_class_with_framework(
core.SanicMongoAgnosticCollection, asyncio_framework,
self.__module__)
coll = db['bla']
self.assertTrue(isinstance(coll, comp_coll))
def __init__(self, database, collection="fs"):
"""An instance of GridFS on top of a single Database.
:Parameters:
- `database`: a :class:`~SanicMongo.SanicMongoDatabase`
- `collection` (optional): A string, name of root collection to use,
such as "fs" or "my_files"
.. mongodoc:: gridfs
"""
db_class = create_class_with_framework(SanicMongoAgnosticDatabase,
database._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError("First argument to SanicMongoGridFS must be "
"SanicMongoDatabase, not %r" % database)
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(database.delegate, collection)
self._GridFS__collection = self.delegate._GridFS__collection
self._GridFS__files = self.delegate._GridFS__files
self._GridFS__chunks = self.delegate._GridFS__chunks
def __init__(
self,
root_collection,
file_id=None,
file_document=None,
delegate=None,
):
collection_class = create_class_with_framework(
AgnosticCollection, self._framework, self.__module__)
if not isinstance(root_collection, collection_class):
raise TypeError(
"First argument to MotorGridOut must be "
"MotorCollection, not %r" % root_collection)
if delegate:
self.delegate = delegate
else:
self.delegate = self.__delegate_class__(
root_collection.delegate,
file_id,
file_document,
_connect=False)
self.io_loop = root_collection.get_io_loop()
def __init__(self, database, collection="fs"):
"""An instance of GridFS on top of a single Database.
:Parameters:
- `database`: a :class:`~motor.MotorDatabase`
- `collection` (optional): A string, name of root collection to use,
such as "fs" or "my_files"
.. mongodoc:: gridfs
.. versionchanged:: 0.2
``open`` method removed; no longer needed.
"""
db_class = create_class_with_framework(
AgnosticDatabase, self._framework, self.__module__)
if not isinstance(database, db_class):
raise TypeError("First argument to MotorGridFS must be "
"MotorDatabase, not %r" % database)
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(
database.delegate,
collection,
_connect=False)
def __init__(
self,
root_collection,
file_id=None,
file_document=None,
delegate=None,
):
collection_class = create_class_with_framework(
AgnosticCollection, self._framework)
if not isinstance(root_collection, collection_class):
raise TypeError(
"First argument to MotorGridOut must be "
"MotorCollection, not %r" % root_collection)
if delegate:
self.delegate = delegate
else:
self.delegate = self.__delegate_class__(
root_collection.delegate,
file_id,
file_document,
_connect=False)
self.io_loop = root_collection.get_io_loop()
def __init__(self,
database,
name,
codec_options=None,
read_preference=None,
write_concern=None,
read_concern=None,
_delegate=None):
db_class = create_class_with_framework(MotorEngineDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to MotorEngineCollection must be MotorEngineDatabase, not %r"
% database)
delegate = _delegate or Collection(database.delegate,
name,
codec_options=codec_options,
read_preference=read_preference,
write_concern=write_concern,
read_concern=read_concern)
super(AgnosticBaseProperties, self).__init__(delegate)
self.database = database
def __init__(self, database, collection="fs"):
"""An instance of GridFS on top of a single Database.
:Parameters:
- `database`: a :class:`~motor.MotorDatabase`
- `collection` (optional): A string, name of root collection to use,
such as "fs" or "my_files"
.. mongodoc:: gridfs
.. versionchanged:: 0.2
``open`` method removed; no longer needed.
"""
db_class = create_class_with_framework(AgnosticDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError("First argument to MotorGridFS must be "
"MotorDatabase, not %r" % database)
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(database.delegate,
collection,
_connect=False)
def find(self, *args, **kwargs):
"""Find and return the files collection documents that match ``filter``.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control.
For example::
cursor = bucket.find({"filename": "lisa.txt"}, no_cursor_timeout=True)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting no_cursor_timeout to True may be important to
prevent the cursor from timing out during long multi-file processing
work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
Follows a similar interface to
:meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `filter`: Search query.
- `batch_size` (optional): The number of documents to return per
batch.
- `limit` (optional): The maximum number of documents to return.
- `no_cursor_timeout` (optional): The server normally times out idle
cursors after an inactivity period (10 minutes) to prevent excess
memory use. Set this option to True prevent that.
- `skip` (optional): The number of documents to skip before
returning.
- `sort` (optional): The order by which to sort results. Defaults to
None.
- `session` (optional): a
:class:`~pymongo.client_session.ClientSession`, created with
:meth:`~MotorClient.start_session`.
If a :class:`~pymongo.client_session.ClientSession` is passed to
:meth:`find`, all returned :class:`MotorGridOut` instances
are associated with that session.
.. versionchanged:: 1.2
Added session parameter.
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(AgnosticGridOutCursor,
self._framework,
self.__module__)
return grid_out_cursor(cursor, self.collection)
def test_pymongo_method(self):
"""Ensures that the original pymongo methods are returned
after the collection is created."""
coll = create_class_with_framework(core.SanicMongoAgnosticCollection,
asyncio_framework, self.__module__)
self.assertEqual(coll.insert, Collection.insert)
def test_find(self, *args, **kwargs):
connection = Mock(spec=core.SanicMongoAgnosticClient)
delegate = MagicMock()
delegate.name = 'blabla'
connection.delegate = delegate
name = 'blabla'
db = create_class_with_framework(core.SanicMongoAgnosticDatabase,
asyncio_framework,
self.__module__)(connection, name)
coll = create_class_with_framework(core.SanicMongoAgnosticCollection,
asyncio_framework,
self.__module__)(db, name)
cursor = create_class_with_framework(core.SanicMongoAgnosticCursor,
asyncio_framework,
self.__module__)
self.assertIsInstance(coll.find(), cursor)
def find(self, *args, **kwargs):
"""Find and return the files collection documents that match ``filter``.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control.
For example::
cursor = bucket.find({"filename": "lisa.txt"}, no_cursor_timeout=True)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting no_cursor_timeout to True may be important to
prevent the cursor from timing out during long multi-file processing
work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
Follows a similar interface to
:meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `filter`: Search query.
- `batch_size` (optional): The number of documents to return per
batch.
- `limit` (optional): The maximum number of documents to return.
- `no_cursor_timeout` (optional): The server normally times out idle
cursors after an inactivity period (10 minutes) to prevent excess
memory use. Set this option to True prevent that.
- `skip` (optional): The number of documents to skip before
returning.
- `sort` (optional): The order by which to sort results. Defaults to
None.
- `session` (optional): a
:class:`~pymongo.client_session.ClientSession`, created with
:meth:`~MotorClient.start_session`.
If a :class:`~pymongo.client_session.ClientSession` is passed to
:meth:`find`, all returned :class:`MotorGridOut` instances
are associated with that session.
.. versionchanged:: 1.2
Added session parameter.
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_cursor(cursor, self.collection)
def put(self, data, **kwargs):
"""Put data into GridFS as a new file.
Equivalent to doing:
.. code-block:: python
@gen.coroutine
def f(data, **kwargs):
try:
f = yield my_gridfs.new_file(**kwargs)
yield f.write(data)
finally:
yield 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:`~MotorGridIn` for possible arguments.
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.
- `callback`: Optional function taking parameters (_id, error)
- `**kwargs` (optional): keyword arguments for file creation
If no callback is provided, returns a Future that resolves to the
``"_id"`` of the created file. Otherwise, executes the callback
with arguments (_id, error).
Note that PyMongo allows unacknowledged ("w=0") puts to GridFS,
but Motor does not.
"""
# PyMongo's implementation uses requests, so rewrite for Motor.
grid_in_class = create_class_with_framework(
AgnosticGridIn, self._framework)
grid_file = grid_in_class(self.collection, **kwargs)
# w >= 1 necessary to avoid running 'filemd5' command before
# all data is written, especially with sharding.
if 0 == self.collection.write_concern.get('w'):
raise pymongo.errors.ConfigurationError(
"Motor does not allow unacknowledged put() to GridFS")
try:
yield self._framework.yieldable(grid_file.write(data))
finally:
yield self._framework.yieldable(grid_file.close())
raise self._framework.return_value(grid_file._id)
def __init__(self, root_collection, delegate=None, session=None, **kwargs):
"""
Class to write data to GridFS. Application developers should not
generally need to instantiate this class - see
:meth:`~motor.MotorGridFSBucket.open_upload_stream`.
Any of the file level options specified in the `GridFS Spec
<http://dochub.mongodb.org/core/gridfs>`_ may be passed as
keyword arguments. Any additional keyword arguments will be
set as additional fields on the file document. Valid keyword
arguments include:
- ``"_id"``: unique ID for this file (default:
:class:`~bson.objectid.ObjectId`) - this ``"_id"`` must
not have already been used for another file
- ``"filename"``: human name for the file
- ``"contentType"`` or ``"content_type"``: valid mime-type
for the file
- ``"chunkSize"`` or ``"chunk_size"``: size of each of the
chunks, in bytes (default: 256 kb)
- ``"encoding"``: encoding used for this file. In Python 2,
any :class:`unicode` that is written to the file will be
converted to a :class:`str`. In Python 3, any :class:`str`
that is written to the file will be converted to
:class:`bytes`.
:Parameters:
- `root_collection`: root collection to write to
- `session` (optional): a
:class:`~pymongo.client_session.ClientSession` to use for all
commands
- `**kwargs` (optional): file level options (see above)
.. versionchanged:: 3.0
Removed support for the `disable_md5` parameter (to match the
GridIn class in PyMongo).
.. versionchanged:: 0.2
``open`` method removed, no longer needed.
"""
collection_class = create_class_with_framework(AgnosticCollection,
self._framework,
self.__module__)
if not isinstance(root_collection, collection_class):
raise TypeError(
"First argument to MotorGridIn must be MotorCollection, not %r"
% root_collection)
self.io_loop = root_collection.get_io_loop()
# Short cut.
self.delegate = delegate or self.__delegate_class__(
root_collection.delegate, session=session, **kwargs)
def wrap(self, obj):
if obj.__class__ is grid_file.GridIn:
grid_in_class = create_class_with_framework(
AgnosticGridIn, self._framework, self.__module__)
return grid_in_class(root_collection=self.collection, delegate=obj)
elif obj.__class__ is grid_file.GridOut:
grid_out_class = create_class_with_framework(
AgnosticGridOut, self._framework, self.__module__)
return grid_out_class(root_collection=self.collection,
delegate=obj)
elif obj.__class__ is gridfs.GridOutCursor:
grid_out_class = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_class(cursor=obj, collection=self.collection)
def fs(self):
if not self._fs:
db = get_db(self.db_alias)
grid_class = create_class_with_framework(
gridfs.SanicMongoAgnosticGridFS, db._framework,
'SanicMongo.gridfs')
self._fs = grid_class(db, self.collection_name)
return self._fs
def next_object(self):
"""Get next GridOut object from cursor."""
grid_out = super(self.__class__, self).next_object()
if grid_out:
grid_out_class = create_class_with_framework(
AgnosticGridOut, self._framework, self.__module__)
return grid_out_class(self.collection, delegate=grid_out)
else:
# Exhausted.
return None
def __init__(self, root_collection, delegate=None, **kwargs):
"""
Class to write data to GridFS. Application developers should not
generally need to instantiate this class - see
:meth:`~motor.MotorGridFSBucket.open_upload_stream`.
Any of the file level options specified in the `GridFS Spec
<http://dochub.mongodb.org/core/gridfs>`_ may be passed as
keyword arguments. Any additional keyword arguments will be
set as additional fields on the file document. Valid keyword
arguments include:
- ``"_id"``: unique ID for this file (default:
:class:`~bson.objectid.ObjectId`) - this ``"_id"`` must
not have already been used for another file
- ``"filename"``: human name for the file
- ``"contentType"`` or ``"content_type"``: valid mime-type
for the file
- ``"chunkSize"`` or ``"chunk_size"``: size of each of the
chunks, in bytes (default: 256 kb)
- ``"encoding"``: encoding used for this file. In Python 2,
any :class:`unicode` that is written to the file will be
converted to a :class:`str`. In Python 3, any :class:`str`
that is written to the file will be converted to
:class:`bytes`.
:Parameters:
- `root_collection`: A :class:`~motor.MotorCollection`, the root
collection to write to
- `**kwargs` (optional): file level options (see above)
.. versionchanged:: 0.2
``open`` method removed, no longer needed.
"""
collection_class = create_class_with_framework(
AgnosticCollection, self._framework, self.__module__)
if not isinstance(root_collection, collection_class):
raise TypeError(
"First argument to MotorGridIn must be "
"MotorCollection, not %r" % root_collection)
self.io_loop = root_collection.get_io_loop()
if delegate:
# Short cut.
self.delegate = delegate
else:
self.delegate = self.__delegate_class__(
root_collection.delegate,
**kwargs)
def next_object(self):
"""Get next GridOut object from cursor."""
grid_out = super(self.__class__, self).next_object()
if grid_out:
grid_out_class = create_class_with_framework(
AgnosticGridOut, self._framework, self.__module__)
return grid_out_class(self.collection, delegate=grid_out)
else:
# Exhausted.
return None
def find(self, *args, **kwargs):
if 'callback' in kwargs:
raise InvalidOperation(
"Pass a callback to each, to_list, or count, not to find.")
cursor = self.delegate.find(*unwrap_args_session(args),
**unwrap_kwargs_session(kwargs))
cursor_class = create_class_with_framework(MotorEngineCursor,
self._framework,
self.__module__)
return cursor_class(cursor, self)
def __init__(self, database, collection="fs"):
db_class = create_class_with_framework(AgnosticDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to %s must be MotorDatabase, not %r" %
(self.__class__, database))
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(database.delegate, collection)
def __init__(self, database, name, _delegate=None):
db_class = create_class_with_framework(SanicMongoAgnosticDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError("First argument to SanicMongoCollection must be "
"SanicMongoDatabase, not %r" % database)
delegate = _delegate or Collection(database.delegate, name)
super(AgnosticCollection, self).__init__(delegate)
self.database = database
def test_create_attribute(self):
class TestDelegate:
def a(self):
pass
class TestClass:
__motor_class_name__ = 'MyDelegateTest'
__delegate_class__ = TestDelegate
a = metaprogramming.OriginalDelegate()
tc = create_class_with_framework(TestClass, asyncio_framework,
self.__module__)
self.assertEqual(tc.a, TestDelegate.a)
def __init__(self, database, collection="fs"):
db_class = create_class_with_framework(
AgnosticDatabase, self._framework, self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to %s must be MotorDatabase, not %r" % (
self.__class__, database))
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(
database.delegate,
collection)
def watch(self,
pipeline=None,
full_document='default',
resume_after=None,
max_await_time_ms=None,
batch_size=None,
collation=None,
start_at_operation_time=None,
session=None):
cursor_class = create_class_with_framework(AgnosticChangeStream,
self._framework,
self.__module__)
return cursor_class(self, pipeline, full_document, resume_after,
max_await_time_ms, batch_size, collation,
start_at_operation_time, session)
def wrap(self, obj):
if obj.__class__ is grid_file.GridIn:
grid_in_class = create_class_with_framework(
AgnosticGridIn, self._framework, self.__module__)
return grid_in_class(
root_collection=self.collection,
delegate=obj)
elif obj.__class__ is grid_file.GridOut:
grid_out_class = create_class_with_framework(
AgnosticGridOut, self._framework, self.__module__)
return grid_out_class(
root_collection=self.collection,
delegate=obj)
elif obj.__class__ is gridfs.GridOutCursor:
grid_out_class = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_class(
cursor=obj,
collection=self.collection)
def __init__(self, database, collection="fs", disable_md5=False):
"""Create a handle to a GridFS bucket.
Raises :exc:`~pymongo.errors.ConfigurationError` if `write_concern`
is not acknowledged.
This class conforms to the `GridFS API Spec
<https://github.com/mongodb/specifications/blob/master/source/gridfs/gridfs-spec.rst>`_
for MongoDB drivers.
:Parameters:
- `database`: database to use.
- `bucket_name` (optional): The name of the bucket. Defaults to 'fs'.
- `chunk_size_bytes` (optional): The chunk size in bytes. Defaults
to 255KB.
- `write_concern` (optional): The
:class:`~pymongo.write_concern.WriteConcern` to use. If ``None``
(the default) db.write_concern is used.
- `read_preference` (optional): The read preference to use. If
``None`` (the default) db.read_preference is used.
- `disable_md5` (optional): When True, MD5 checksums will not be
computed for uploaded files. Useful in environments where MD5
cannot be used for regulatory or other reasons. Defaults to False.
.. versionadded:: 1.0
.. mongodoc:: gridfs
"""
db_class = create_class_with_framework(AgnosticDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to %s must be MotorDatabase, not %r" %
(self.__class__, database))
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(database.delegate,
collection,
disable_md5=disable_md5)
def __init__(self, database, collection="fs", disable_md5=False):
"""Create a handle to a GridFS bucket.
Raises :exc:`~pymongo.errors.ConfigurationError` if `write_concern`
is not acknowledged.
This class conforms to the `GridFS API Spec
<https://github.com/mongodb/specifications/blob/master/source/gridfs/gridfs-spec.rst>`_
for MongoDB drivers.
:Parameters:
- `database`: database to use.
- `bucket_name` (optional): The name of the bucket. Defaults to 'fs'.
- `chunk_size_bytes` (optional): The chunk size in bytes. Defaults
to 255KB.
- `write_concern` (optional): The
:class:`~pymongo.write_concern.WriteConcern` to use. If ``None``
(the default) db.write_concern is used.
- `read_preference` (optional): The read preference to use. If
``None`` (the default) db.read_preference is used.
- `disable_md5` (optional): When True, MD5 checksums will not be
computed for uploaded files. Useful in environments where MD5
cannot be used for regulatory or other reasons. Defaults to False.
.. versionadded:: 1.0
.. mongodoc:: gridfs
"""
db_class = create_class_with_framework(
AgnosticDatabase, self._framework, self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to %s must be MotorDatabase, not %r" % (
self.__class__, database))
self.io_loop = database.get_io_loop()
self.collection = database[collection]
self.delegate = self.__delegate_class__(
database.delegate,
collection,
disable_md5=disable_md5)
def find(self, *args, **kwargs):
"""Create a :class:`SanicMongoAgnosticCursor`. Same parameters as for
PyMongo's :meth:`~pymongo.collection.Collection.find`.
Note that ``find`` does not take a `callback` parameter, nor does
it return a Future, because ``find`` merely creates a
:class:`SanicMongoAgnosticCursor` without performing any operations
on the server.
``SanicMongoAgnosticCursor`` methods such as
:meth:`~SanicMongoAgnosticCursor.to_list` or
:meth:`~SanicMongoAgnosticCursor.count` perform actual operations.
"""
if 'callback' in kwargs:
raise pymongo.errors.InvalidOperation(
"Pass a callback to each, to_list, or count, not to find.")
cursor = self.delegate.find(*args, **kwargs)
cursor_class = create_class_with_framework(SanicMongoAgnosticCursor,
self._framework,
self.__module__)
return cursor_class(cursor, self)
def find(self, *args, **kwargs):
"""Query GridFS for files.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control. For example::
cursor = fs.find({"filename": "lisa.txt"}, timeout=False)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting timeout to False may be important to prevent the
cursor from timing out during long multi-file processing work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
:meth:`~motor.MotorGridFS.find` follows a similar
interface to :meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `spec` (optional): a SON object specifying elements which
must be present for a document to be included in the
result set
- `skip` (optional): the number of files to omit (from
the start of the result set) when returning the results
- `limit` (optional): the maximum number of results to
return
- `timeout` (optional): if True (the default), any returned
cursor is closed by the server after 10 minutes of
inactivity. If set to False, the returned cursor will never
time out on the server. Care should be taken to ensure that
cursors with timeout turned off are properly closed.
- `sort` (optional): a list of (key, direction) pairs
specifying the sort order for this query. See
:meth:`~pymongo.cursor.Cursor.sort` for details.
- `max_scan` (optional): limit the number of file documents
examined when performing the query
- `read_preference` (optional): The read preference for
this query.
- `tag_sets` (optional): The tag sets for this query.
- `secondary_acceptable_latency_ms` (optional): Any replica-set
member whose ping time is within secondary_acceptable_latency_ms of
the nearest member may accept reads. Default 15 milliseconds.
**Ignored by mongos** and must be configured on the command line.
See the localThreshold_ option for more information.
- `compile_re` (optional): if ``False``, don't attempt to compile
BSON regex objects into Python regexes. Return instances of
:class:`~bson.regex.Regex` instead.
Returns an instance of :class:`~motor.MotorGridOutCursor`
corresponding to this query.
.. versionadded:: 0.2
.. mongodoc:: find
.. _localThreshold: http://docs.mongodb.org/manual/reference/mongos/#cmdoption-mongos--localThreshold
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_cursor(cursor, self.collection)
def find(self, *args, **kwargs):
"""Query GridFS for files.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control. For example::
cursor = fs.find({"filename": "lisa.txt"}, no_cursor_timeout=True)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting no_cursor_timeout may be important to prevent
the cursor from timing out during long multi-file processing work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
:meth:`~motor.MotorGridFS.find` follows a similar
interface to :meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `filter` (optional): a SON object specifying elements which
must be present for a document to be included in the
result set
- `skip` (optional): the number of files to omit (from
the start of the result set) when returning the results
- `limit` (optional): the maximum number of results to
return
- `no_cursor_timeout` (optional): if False (the default), any
returned cursor is closed by the server after 10 minutes of
inactivity. If set to True, the returned cursor will never
time out on the server. Care should be taken to ensure that
cursors with no_cursor_timeout turned on are properly closed.
- `sort` (optional): a list of (key, direction) pairs
specifying the sort order for this query. See
:meth:`~pymongo.cursor.Cursor.sort` for details.
Raises :class:`TypeError` if any of the arguments are of
improper type. Returns an instance of
:class:`~gridfs.grid_file.GridOutCursor`
corresponding to this query.
.. versionchanged:: 1.0
Removed the read_preference, tag_sets, and
secondary_acceptable_latency_ms options.
.. versionadded:: 0.2
.. mongodoc:: find
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_cursor(cursor, self.collection)
def __getitem__(self, name):
db_class = create_class_with_framework(SanicMongoAgnosticDatabase,
self._framework,
self.__module__)
return db_class(self, name)
def __init__(self,
database,
bucket_name="fs",
disable_md5=False,
chunk_size_bytes=DEFAULT_CHUNK_SIZE,
write_concern=None,
read_preference=None,
collection=None):
"""Create a handle to a GridFS bucket.
Raises :exc:`~pymongo.errors.ConfigurationError` if `write_concern`
is not acknowledged.
This class conforms to the `GridFS API Spec
<https://github.com/mongodb/specifications/blob/master/source/gridfs/gridfs-spec.rst>`_
for MongoDB drivers.
:Parameters:
- `database`: database to use.
- `bucket_name` (optional): The name of the bucket. Defaults to 'fs'.
- `chunk_size_bytes` (optional): The chunk size in bytes. Defaults
to 255KB.
- `write_concern` (optional): The
:class:`~pymongo.write_concern.WriteConcern` to use. If ``None``
(the default) db.write_concern is used.
- `read_preference` (optional): The read preference to use. If
``None`` (the default) db.read_preference is used.
- `disable_md5` (optional): When True, MD5 checksums will not be
computed for uploaded files. Useful in environments where MD5
cannot be used for regulatory or other reasons. Defaults to False.
- `collection` (optional): Deprecated, an alias for `bucket_name`
that exists solely to provide backwards compatibility.
.. versionchanged:: 2.1
Added support for the `bucket_name`, `chunk_size_bytes`,
`write_concern`, and `read_preference` parameters.
Deprecated the `collection` parameter which is now an alias to
`bucket_name` (to match the GridFSBucket class in PyMongo).
.. versionadded:: 1.0
.. mongodoc:: gridfs
"""
# Preserve backwards compatibility of "collection" parameter
if collection is not None:
warnings.warn(
'the "collection" parameter is deprecated, use '
'"bucket_name" instead',
DeprecationWarning,
stacklevel=2)
bucket_name = collection
db_class = create_class_with_framework(AgnosticDatabase,
self._framework,
self.__module__)
if not isinstance(database, db_class):
raise TypeError(
"First argument to %s must be MotorDatabase, not %r" %
(self.__class__, database))
self.io_loop = database.get_io_loop()
self.collection = database.get_collection(
bucket_name,
write_concern=write_concern,
read_preference=read_preference)
self.delegate = self.__delegate_class__(
database.delegate,
bucket_name,
chunk_size_bytes=chunk_size_bytes,
write_concern=write_concern,
read_preference=read_preference,
disable_md5=disable_md5)
def find(self, *args, **kwargs):
"""Query GridFS for files.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control. For example::
cursor = fs.find({"filename": "lisa.txt"}, no_cursor_timeout=True)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting no_cursor_timeout may be important to prevent
the cursor from timing out during long multi-file processing work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
:meth:`~motor.MotorGridFS.find` follows a similar
interface to :meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `filter` (optional): a SON object specifying elements which
must be present for a document to be included in the
result set
- `skip` (optional): the number of files to omit (from
the start of the result set) when returning the results
- `limit` (optional): the maximum number of results to
return
- `no_cursor_timeout` (optional): if False (the default), any
returned cursor is closed by the server after 10 minutes of
inactivity. If set to True, the returned cursor will never
time out on the server. Care should be taken to ensure that
cursors with no_cursor_timeout turned on are properly closed.
- `sort` (optional): a list of (key, direction) pairs
specifying the sort order for this query. See
:meth:`~pymongo.cursor.Cursor.sort` for details.
Raises :class:`TypeError` if any of the arguments are of
improper type. Returns an instance of
:class:`~gridfs.grid_file.GridOutCursor`
corresponding to this query.
.. versionchanged:: 1.0
Removed the read_preference, tag_sets, and
secondary_acceptable_latency_ms options.
.. versionadded:: 0.2
.. mongodoc:: find
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(
AgnosticGridOutCursor, self._framework, self.__module__)
return grid_out_cursor(cursor, self.collection)
def __get__(self, instance, owner):
collection_class = create_class_with_framework(
AgnosticCollection, owner.database._framework, owner.database.__module__)
return collection_class(owner.database, owner.collection_name())
def find(self, *args, **kwargs):
"""Query GridFS for files.
Returns a cursor that iterates across files matching
arbitrary queries on the files collection. Can be combined
with other modifiers for additional control. For example::
cursor = fs.find({"filename": "lisa.txt"}, timeout=False)
while (yield cursor.fetch_next):
grid_out = cursor.next_object()
data = yield grid_out.read()
This iterates through all versions of "lisa.txt" stored in GridFS.
Note that setting timeout to False may be important to prevent the
cursor from timing out during long multi-file processing work.
As another example, the call::
most_recent_three = fs.find().sort("uploadDate", -1).limit(3)
would return a cursor to the three most recently uploaded files
in GridFS.
:meth:`~motor.MotorGridFS.find` follows a similar
interface to :meth:`~motor.MotorCollection.find`
in :class:`~motor.MotorCollection`.
:Parameters:
- `spec` (optional): a SON object specifying elements which
must be present for a document to be included in the
result set
- `skip` (optional): the number of files to omit (from
the start of the result set) when returning the results
- `limit` (optional): the maximum number of results to
return
- `timeout` (optional): if True (the default), any returned
cursor is closed by the server after 10 minutes of
inactivity. If set to False, the returned cursor will never
time out on the server. Care should be taken to ensure that
cursors with timeout turned off are properly closed.
- `sort` (optional): a list of (key, direction) pairs
specifying the sort order for this query. See
:meth:`~pymongo.cursor.Cursor.sort` for details.
- `max_scan` (optional): limit the number of file documents
examined when performing the query
- `read_preference` (optional): The read preference for
this query.
- `tag_sets` (optional): The tag sets for this query.
- `secondary_acceptable_latency_ms` (optional): Any replica-set
member whose ping time is within secondary_acceptable_latency_ms of
the nearest member may accept reads. Default 15 milliseconds.
**Ignored by mongos** and must be configured on the command line.
See the localThreshold_ option for more information.
- `compile_re` (optional): if ``False``, don't attempt to compile
BSON regex objects into Python regexes. Return instances of
:class:`~bson.regex.Regex` instead.
Returns an instance of :class:`~motor.MotorGridOutCursor`
corresponding to this query.
.. versionadded:: 0.2
.. mongodoc:: find
.. _localThreshold: http://docs.mongodb.org/manual/reference/mongos/#cmdoption-mongos--localThreshold
"""
cursor = self.delegate.find(*args, **kwargs)
grid_out_cursor = create_class_with_framework(AgnosticGridOutCursor,
self._framework,
self.__module__)
return grid_out_cursor(cursor, self.collection)
# -*- coding: utf-8 -*-
# Copyright 2016 Juca Crispim <*****@*****.**>
# This file is part of SanicMongo.
# SanicMongo is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# SanicMongo is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with SanicMongo. If not, see <http://www.gnu.org/licenses/>.
from motor.frameworks import asyncio as asyncio_framework
from motor.metaprogramming import create_class_with_framework
from SanicMongo.core import (SanicMongoAgnosticClient)
SanicMongoAsyncIOClient = create_class_with_framework(SanicMongoAgnosticClient,
asyncio_framework,
'SanicMongo.clients')
