def command(self):
self._setup_logging()
self._load_migrations()
from .runner import run_migration, reset_migration, show_status, set_status
bind = create_engine(self.options.connection_url)
if self.options.database is None:
datastores = [
create_datastore(db, bind=bind)
for db in bind.conn.database_names()
if db not in ('admin', 'local') ]
else:
datastores = [ create_datastore(self.options.database, bind=bind) ]
for ds in datastores:
self.log.info('Migrate DB: %s', ds.database)
if self.options.status_only:
show_status(ds)
elif self.options.force:
set_status(ds, self._target_versions())
elif self.options.reset:
reset_migration(ds, dry_run=self.options.dry_run)
else:
run_migration(ds, self._target_versions(), dry_run=self.options.dry_run)
try:
ds.conn.disconnect()
ds._conn = None
except: # MIM doesn't do this
pass
def setUp(self):
M.doc_session.bind = ming.create_datastore(
'test',
bind=ming.create_engine(
use_class=lambda *a, **kw: mim.Connection.get()))
mim.Connection.get().clear_all()
self.doubler = Function.decorate('double')(self._double)
def setup_database():
global datastore, database_setup
if not database_setup:
datastore = create_datastore(
os.environ.get('MONGOURL', 'mim:///depottest'))
mainsession.bind = datastore
ming.odm.Mapper.compile_all()
def setUp(self):
Mapper._mapper_by_classname.clear()
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class Parent(MappedClass):
class __mongometa__:
name = 'parent'
session = self.session
_id = FieldProperty(int)
children = RelationProperty('Child')
class Child(MappedClass):
class __mongometa__:
name = 'child'
session = self.session
_id = FieldProperty(int)
parents = RelationProperty('Parent')
_parents = ForeignIdProperty('Parent', uselist=True)
Mapper.compile_all()
self.Parent = Parent
self.Child = Child
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class Parent(MappedClass):
class __mongometa__:
name='parent'
session = self.session
_id = FieldProperty(S.ObjectId)
children = ForeignIdProperty('Child', uselist=True)
field_with_default_id = ForeignIdProperty(
'Child',
uselist=True,
if_missing=lambda:[bson.ObjectId('deadbeefdeadbeefdeadbeef')])
field_with_default = RelationProperty('Child', 'field_with_default_id')
class Child(MappedClass):
class __mongometa__:
name='child'
session = self.session
_id = FieldProperty(S.ObjectId)
parent_id = ForeignIdProperty(Parent)
field_with_default_id = ForeignIdProperty(
Parent,
if_missing=lambda:bson.ObjectId('deadbeefdeadbeefdeadbeef'))
field_with_default = RelationProperty('Parent', 'field_with_default_id')
Mapper.compile_all()
self.Parent = Parent
self.Child = Child
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class BasicMapperExtension(MapperExtension):
def after_insert(self, instance, state, session):
assert 'clean'==state.status
def before_insert(self, instance, state, session):
assert 'new'==state.status
def before_update(self, instance, state, session):
assert 'dirty'==state.status
def after_update(self, instance, state, session):
assert 'clean'==state.status
class Basic(MappedClass):
class __mongometa__:
name='basic'
session = self.session
extensions = [BasicMapperExtension, MapperExtension]
_id = FieldProperty(S.ObjectId)
a = FieldProperty(int)
b = FieldProperty([int])
c = FieldProperty(dict(
d=int, e=int))
Mapper.compile_all()
self.Basic = Basic
self.session.remove(self.Basic)
def create_session(login, password, path):
global session
if session == None:
session = ThreadLocalODMSession(
bind=create_datastore('mongodb://%s:%s@%s' %
(login, password, path)))
return session
def setUp(self):
self.bind = create_datastore('mim:///testdb')
self.bind.conn.drop_all()
self.bind.db.coll.insert({'_id':'foo', 'a':2, 'c':[1,2,3],
'z': {'egg': 'spam', 'spam': 'egg'}})
for r in range(4):
self.bind.db.rcoll.insert({'_id':'r%s' % r, 'd':r})
def setUp(self):
Mapper._mapper_by_classname.clear()
self.datastore = create_datastore('mim:///test_db')
self.doc_session = Session(self.datastore)
self.odm_session = ODMSession(self.doc_session)
class Base(MappedClass):
class __mongometa__:
name = 'test_doc'
session = self.odm_session
polymorphic_on = 'type'
polymorphic_identity = 'base'
_id = FieldProperty(S.ObjectId)
type = FieldProperty(str, if_missing='base')
a = FieldProperty(int)
class Derived(Base):
class __mongometa__:
polymorphic_identity = 'derived'
type = FieldProperty(str, if_missing='derived')
b = FieldProperty(int)
Mapper.compile_all()
self.Base = Base
self.Derived = Derived
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
class Parent(object):
pass
class Child(object):
pass
parent = collection('parent', session, Field('_id', int))
child = collection('child', session, Field('_id', int),
Field('parent_id', int))
mapper(Parent,
parent,
self.session,
properties=dict(children=RelationProperty(Child)))
mapper(Child,
child,
self.session,
properties=dict(parent_id=ForeignIdProperty(Parent),
parent=RelationProperty(Parent)))
self.Parent = Parent
self.Child = Child
def test_replica_set(self, MockConn):
from pymongo import MongoClient
result = create_datastore(
'mongodb://localhost:23,localhost:27017,localhost:999/test_db',
replicaSet='foo')
print(result.bind._conn_args[0])
assert result.bind._conn_args[0].startswith('mongodb://localhost:23,localhost:27017,localhost:999')
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
base = collection('test_doc',
session,
Field('_id', S.ObjectId),
Field('type', str, if_missing='base'),
Field('a', int),
polymorphic_on='type',
polymorphic_identity='base')
derived = collection(base,
Field('type', str, if_missing='derived'),
Field('b', int),
polymorphic_identity='derived')
class Base(object):
pass
class Derived(Base):
pass
mapper(Base, base, self.session)
mapper(Derived, derived, self.session)
self.Base = Base
self.Derived = Derived
def get_session(self):
if 'session_uri' not in self.config_values:
self.set_session_uri("mongodb://localhost:27017/mldatahub")
if self.session is None:
self.session = ThreadLocalODMSession(bind=create_datastore(self.config_values['session_uri']))
return self.session
def setUp(self):
self.bind = create_datastore('mim:///luna')
self.db = self.bind.db.luna
self.path = path
if not os.path.exists(self.path):
os.makedirs(self.path)
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class GrandParent(MappedClass):
class __mongometa__:
name='grand_parent'
session=self.session
_id = FieldProperty(int)
class Parent(MappedClass):
class __mongometa__:
name='parent'
session = self.session
_id = FieldProperty(int)
grandparent_id = ForeignIdProperty('GrandParent')
grandparent = RelationProperty('GrandParent')
children = RelationProperty('Child')
class Child(MappedClass):
class __mongometa__:
name='child'
session = self.session
_id = FieldProperty(int)
parent_id = ForeignIdProperty('Parent', allow_none=True)
parent = RelationProperty('Parent')
Mapper.compile_all()
self.GrandParent = GrandParent
self.Parent = Parent
self.Child = Child
def connecting_datastore():
from ming import create_datastore
datastore = create_datastore('mongodb://localhost:27017/tutorial')
datastore
# The connection is actually performed lazily
# the first time db is accessed
datastore.db
datastore
def includeme(config):
engine = create_datastore(os.getenv(config.registry.settings['mongo_url_env'], 'openrosetta'))
session.bind = engine
Mapper.compile_all()
for mapper in Mapper.all_mappers():
session.ensure_indexes(mapper.collection)
config.add_tween('openrosetta.models.ming_autoflush_tween', over=EXCVIEW)
def setUp(self):
self.bind = create_datastore('mim:///testdb')
self.bind.conn.drop_all()
self.bind.db.coll.insert(
{'_id':'foo', 'a':2,
'b': { 'c': 1, 'd': 2, 'e': [1,2,3],
'f': [ { 'g': 1 }, { 'g': 2 } ] },
'x': {} })
self.coll = self.bind.db.coll
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
basic = collection('basic', session)
class Basic(object):
pass
self.session.mapper(Basic, basic)
self.basic = basic
self.Basic = Basic
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
basic = collection('basic', session)
class Basic(object):
pass
self.session.mapper(Basic, basic)
self.basic = basic
self.Basic = Basic
def connection_session():
from ming import create_datastore
from ming.odm import ThreadLocalODMSession
session = ThreadLocalODMSession(
bind=create_datastore('mongodb://localhost:27017/tutorial')
)
session
# The database and datastore are still available
# through the session as .db and .bind
session.db
session.bind
def create_ming_datastore(conf):
from ming import create_datastore
url = conf['ming.url']
database = conf.get('ming.db', '')
try:
connection_options = get_partial_dict('ming.connection', conf)
except AttributeError:
connection_options = {}
if database and url[-1] != '/':
url += '/'
ming_url = url + database
return create_datastore(ming_url, **connection_options)
def setUp(self):
self.bind = create_datastore('mim:///luna')
self.db = self.bind.db.luna
self.path = '/tmp/luna'
if not os.path.exists(self.path):
os.makedirs(self.path)
cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
def create_ming_datastore(conf):
from ming import create_datastore
url = conf['ming.url']
database = conf.get('ming.db', '')
try:
connection_options = get_partial_dict('ming.connection', conf)
except AttributeError:
connection_options = {}
if database and url[-1] != '/':
url += '/'
ming_url = url + database
return create_datastore(ming_url, **connection_options)
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ThreadLocalODMSession(Session(bind=self.datastore))
class Parent(MappedClass):
class __mongometa__:
name='parent'
session = self.session
_id = FieldProperty(S.ObjectId)
Mapper.compile_all()
self.Parent = Parent
self.create_app = TestApp(MingMiddleware(self._wsgi_create_object))
self.remove_app = TestApp(MingMiddleware(self._wsgi_remove_object))
self.remove_exc = TestApp(MingMiddleware(self._wsgi_remove_object_exc))
def __init__(self, path=None, dbtype='auto'):
"""
path - Path to store sandbox files.
dbtype - Type of the dabatabse. [auto|mongo|ming]
"""
if 'LUNA_TEST_DBTYPE' in os.environ:
dbtype = os.environ['LUNA_TEST_DBTYPE']
if not path:
self.path = tempfile.mkdtemp(prefix='luna')
else:
# can cause race condition, but ok
if not os.path.exists(path):
os.makedirs(path)
self.path = path
self._dbconn = None
self._mingdatastore = None
self._mongopath = self.path + "/mongo"
if not os.path.exists(self._mongopath):
os.makedirs(self._mongopath)
self._mongoprocess = None
if dbtype == 'auto':
try:
self._start_mongo()
self.dbtype = 'mongo'
except OSError:
self._mingdatastore = ming.create_datastore('mim:///' +
str(uuid.uuid4()))
self._dbconn = self._mingdatastore.db.luna
self.dbtype = 'ming'
elif dbtype == 'mongo':
self._start_mongo()
self.dbtype = 'mongo'
else:
self._mingdatastore = ming.create_datastore('mim:///' +
str(uuid.uuid4()))
self._dbconn = self._mingdatastore.db.luna
self.dbtype = 'ming'
self._create_luna_homedir()
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
basic = collection('basic', session, Field('_id', S.ObjectId),
Field('a', int), Field('b', [int]),
Field('c', dict(d=int, e=int)))
class Basic(object):
pass
self.session.mapper(Basic, basic)
self.basic = basic
self.Basic = Basic
def __init__(self, path = None, dbtype = 'auto'):
"""
path - Path to store sandbox files.
dbtype - Type of the dabatabse. [auto|mongo|ming]
"""
if 'LUNA_TEST_DBTYPE' in os.environ:
dbtype = os.environ['LUNA_TEST_DBTYPE']
if not path:
self.path = tempfile.mkdtemp(prefix='luna')
else:
# can cause race condition, but ok
if not os.path.exists(path):
os.makedirs(path)
self.path = path
self._dbconn = None
self._mingdatastore = None
self._mongopath = self.path + "/mongo"
if not os.path.exists(self._mongopath):
os.makedirs(self._mongopath)
self._mongoprocess = None
if dbtype == 'auto':
try:
self._start_mongo()
self.dbtype = 'mongo'
except OSError:
self._mingdatastore = ming.create_datastore('mim:///' + str(uuid.uuid4()))
self._dbconn = self._mingdatastore.db.luna
self.dbtype = 'ming'
elif dbtype == 'mongo':
self._start_mongo()
self.dbtype = 'mongo'
else:
self._mingdatastore = ming.create_datastore('mim:///' + str(uuid.uuid4()))
self._dbconn = self._mingdatastore.db.luna
self.dbtype = 'ming'
self._create_luna_homedir()
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class TestCollection(MappedClass):
class __mongometa__:
name='test_collection'
session = self.session
_id = FieldProperty(int)
children = RelationProperty('TestCollection')
_children = ForeignIdProperty('TestCollection', uselist=True)
parents = RelationProperty('TestCollection', via=('_children', False))
Mapper.compile_all()
self.TestCollection = TestCollection
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
basic = collection(
'basic', session,
Field('_id', S.ObjectId),
Field('a', int),
Field('b', [int]),
Field('c', dict(
d=int, e=int)))
class Basic(object):
pass
self.session.mapper(Basic, basic)
self.basic = basic
self.Basic = Basic
def setUp(self):
Mapper._mapper_by_classname.clear()
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class Basic(MappedClass):
class __mongometa__:
name = 'hook'
session = self.session
_id = FieldProperty(S.ObjectId)
a = FieldProperty(int)
Mapper.compile_all()
self.Basic = Basic
self.session.remove(self.Basic)
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ThreadLocalODMSession(Session(bind=self.datastore))
class Parent(MappedClass):
class __mongometa__:
name = 'parent'
session = self.session
_id = FieldProperty(S.ObjectId)
Mapper.compile_all()
self.Parent = Parent
self.create_app = TestApp(MingMiddleware(self._wsgi_create_object))
self.remove_app = TestApp(MingMiddleware(self._wsgi_remove_object))
self.remove_exc = TestApp(MingMiddleware(self._wsgi_remove_object_exc))
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
class Basic(MappedClass):
class __mongometa__:
name='basic'
session = self.session
_id = FieldProperty(S.ObjectId)
a = FieldProperty(int)
b = FieldProperty([int])
c = FieldProperty(dict(
d=int, e=int))
d = FieldPropertyWithMissingNone(str, if_missing=S.Missing)
e = FieldProperty(str, if_missing=S.Missing)
Mapper.compile_all()
self.Basic = Basic
self.session.remove(self.Basic)
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.session = ThreadLocalODMSession(Session(bind=self.datastore))
class TestRelationParent(MappedClass):
"""This class _must_ have a unique class name or it will conflict
with other tests."""
class __mongometa__:
name = 'parent'
session = self.session
_id = FieldProperty(S.ObjectId)
Mapper.compile_all()
self.Parent = TestRelationParent
self.create_app = TestApp(MingMiddleware(self._wsgi_create_object))
self.remove_app = TestApp(MingMiddleware(self._wsgi_remove_object))
self.remove_exc = TestApp(MingMiddleware(self._wsgi_remove_object_exc))
def setUp(self):
self.bind = create_datastore('mim:///luna')
self.db = self.bind.db.luna
self.path = '/tmp/luna'
if not os.path.exists(self.path):
os.makedirs(self.path)
cluster = luna.Cluster(mongo_db=self.db,
create=True,
path=self.path,
user=getpass.getuser())
self.net = luna.Network(name='test',
mongo_db=self.db,
create=True,
NETWORK='172.16.1.0',
PREFIX='24',
ns_hostname='controller',
ns_ip='172.16.1.254')
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
class Parent(object): pass
class Child(object): pass
parent = collection(
'parent', session,
Field('_id', int))
child = collection(
'child', session,
Field('_id', int),
Field('parent_id', int))
mapper(Parent, parent, self.session, properties=dict(
children=RelationProperty(Child)))
mapper(Child, child, self.session, properties=dict(
parent_id=ForeignIdProperty(Parent),
parent = RelationProperty(Parent)))
self.Parent = Parent
self.Child = Child
def setUp(self):
Mapper._mapper_by_classname.clear()
self.datastore = create_datastore('mim:///test_db')
self.session = ODMSession(bind=self.datastore)
self.hooks_called = defaultdict(list)
tc = self
class Basic(MappedClass):
class __mongometa__:
name = 'hook'
session = self.session
def before_save(instance):
tc.hooks_called['before_save'].append(instance)
_id = FieldProperty(S.ObjectId)
a = FieldProperty(int)
Mapper.compile_all()
self.Basic = Basic
self.session.remove(self.Basic)
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
self.doc_session = Session(self.datastore)
self.odm_session = ODMSession(self.doc_session)
class Base(MappedClass):
class __mongometa__:
name='test_doc'
session = self.odm_session
polymorphic_on='type'
polymorphic_identity='base'
_id = FieldProperty(S.ObjectId)
type=FieldProperty(str, if_missing='base')
a=FieldProperty(int)
class Derived(Base):
class __mongometa__:
polymorphic_identity='derived'
type=FieldProperty(str, if_missing='derived')
b=FieldProperty(int)
Mapper.compile_all()
self.Base = Base
self.Derived = Derived
def setupClass(cls):
if ming is None:
raise SkipTest('Ming not available...')
cls.basic_session = Session(create_datastore('mim:///'))
cls.s = ODMSession(cls.basic_session)
class Author(MappedClass):
class __mongometa__:
session = cls.s
name = 'wiki_author'
_id = FieldProperty(schema.ObjectId)
name = FieldProperty(str)
pages = RelationProperty('WikiPage')
class WikiPage(MappedClass):
class __mongometa__:
session = cls.s
name = 'wiki_page'
_id = FieldProperty(schema.ObjectId)
title = FieldProperty(str)
text = FieldProperty(str)
order = FieldProperty(int)
author_id = ForeignIdProperty(Author)
author = RelationProperty(Author)
cls.Author = Author
cls.WikiPage = WikiPage
Mapper.compile_all()
cls.author = Author(name='author1')
author2 = Author(name='author2')
WikiPage(title='Hello', text='Text', order=1, author=cls.author)
WikiPage(title='Another', text='Text', order=2, author=cls.author)
WikiPage(title='ThirdOne', text='Text', order=3, author=author2)
cls.s.flush()
cls.s.clear()
def setUp(self):
self.datastore = create_datastore('mim:///test_db')
session = Session(bind=self.datastore)
self.session = ODMSession(session)
base = collection(
'test_doc', session,
Field('_id', S.ObjectId),
Field('type', str, if_missing='base'),
Field('a', int),
polymorphic_on='type',
polymorphic_identity='base')
derived = collection(
base,
Field('type', str, if_missing='derived'),
Field('b', int),
polymorphic_identity='derived')
class Base(object): pass
class Derived(Base): pass
mapper(Base, base, self.session)
mapper(Derived, derived, self.session)
self.Base = Base
self.Derived = Derived
def setUp(self):
self.mg = ming.create_datastore('mim://', db='nba', **kwargs)
self.nbam = NBAMongo(self.mg.db)
self.games = []
self.standings = []
self._get_scoreboard()
# Copyright : Copyright (c) 2012-2015 David Fischer. All rights reserved.
#
#**********************************************************************************************************************#
#
# This file is part of David Fischer's pytoolbox Project.
#
# This project is free software: you can redistribute it and/or modify it under the terms of the EUPL v. 1.1 as provided
# by the European Commission. This project 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 European Union Public License for more details.
#
# You should have received a copy of the EUPL General Public License along with this project.
# If not, see he EUPL licence v1.1 is available in 22 languages:
# 22-07-2013, <https://joinup.ec.europa.eu/software/page/eupl/licence-eupl>
#
# Retrieved from https://github.com/davidfischer-ch/pytoolbox.git
from __future__ import absolute_import, division, print_function, unicode_literals
from ming import create_datastore, Session
from ming.odm import ThreadLocalODMSession
from .. import module
_all = module.All(globals())
bind = create_datastore('mim://')
doc_session = Session(bind)
odm_session = ThreadLocalODMSession(doc_session=doc_session)
from ming import Session, create_datastore
from ming import Document, Field, schema
import json
import urllib2
bind = create_datastore('mongodb://localhost/paperMiningTest')
session = Session(bind)
class Paper(Document):
class __mongometa__:
session = session
name = 'paperCoCitation'
id = Field(str)
cocitation = Field([]) #put cite paper id
if __name__ == '__main__':
baseUrl = "http://140.118.175.209/paper/cocitation.php?ids="
with open('paperId.json') as data_file:
data = json.load(data_file)
for paperId in data["CitationId"]:
url = baseUrl + str(paperId)
arr = = json.load(urllib2.urlopen(url))
if len(arr) is not 0:
cocitationRelationDic = arr[0]
paperRel = Paper(dict(id = cocitationRelationDic["id"],cocitation = cocitationRelationDic["co_citation"]))
paperRel.m.save()
print paperRel
else:
print "No cocitation"
def setUp(self):
self.bind = create_datastore('mim:///testdb')
self.bind.conn.drop_all()
def setUp(self):
self.bind = create_datastore('mim:///testdb')
self.bind.conn.drop_all()
self.bind.db.coll.insert({'_id':'foo', 'a':2, 'c':[1,2,3]})
for r in range(4):
self.bind.db.rcoll.insert({'_id':'r%s' % r, 'd':r})
from ming import create_datastore
from ming.odm import ThreadLocalODMSession
from litminer import config
auth = dict(config["mongodb"])
uri = auth.pop("uri",None)
session = ThreadLocalODMSession(
bind=create_datastore(uri=uri,authenticate=auth)
)
# coding=utf-8
from ming import create_datastore, Session
from ming.odm import ODMSession
import os
session = Session()
session.bind = create_datastore(os.environ.get('MONGO_URL'))
odm_session = ODMSession(session)
def setUp(self):
self.ds = create_datastore("mim:///test")
self.Session = Session(bind=self.ds)
self.TestFS = fs.filesystem("test_fs", self.Session)
import json
self.set_raw(name, key, json.dumps(value))
def incr(self, name, key, amount=1):
val = self.get(name, key)
if val:
val += amount
else:
val = amount
self.set(name, key, val)
return val
from stubo.cache import Cache
from stubo.model.db import Scenario
import ming
mg = ming.create_datastore('mim://')
class DummyScenario(Scenario):
def __init__(self):
dbname = testdb_name()
client = getattr(mg.conn, dbname)
Scenario.__init__(self, db=client)
def __call__(self, **kwargs):
return self
# derive these methods as ming hasn't implemented '$regex' matching
def get_all(self, name=None):
if name and isinstance(name, dict) and '$regex' in name:
def create_ming_datastore():
return create_datastore(os.environ.get('MONGOURL', 'mongodb://127.0.0.1:27017/test_db'))
def setUp(self):
self.bind = create_datastore('mim:///testdb')
self.bind.conn.drop_all()
self.doc = {'_id':'foo', 'a':2, 'c':[1,2,3]}
self.bind.db.coll.insert(self.doc)
def initialize_collection(self):
client = ming.create_datastore(self.get_property('url')).conn
return client[self.get_property('database')][self.get_property(
'collection')]
def __init__(self, mongo_uri):
if mongo_uri[0]=='$':
mongo_uri = os.getenv(mongo_uri[1:])
self.mongo_engine = create_datastore(mongo_uri)
