Here are the examples of the python api sqlalchemy.orm.clear_mappers taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
20 Examples
3
View Complete Implementation : fixtures.py
Copyright MIT License
Author : analyzeDFIR
Copyright MIT License
Author : analyzeDFIR
def _teardown_each_mappers(self):
# some tests create mappers in the test bodies
# and will define setup_mappers as None -
# clear mappers in any case
if self.run_setup_mappers != 'once':
sa.orm.clear_mappers()
3
View Complete Implementation : testing.py
Copyright Mozilla Public License 2.0
Author : AnyBlok
Copyright Mozilla Public License 2.0
Author : AnyBlok
def tearDown(self):
""" Clear the registry, unload the blok manager and drop the database
"""
if self.registry:
self.registry.close()
RegistryManager.clear()
BlokManager.unload()
clear_mappers()
super(DBTestCase, self).tearDown()
3
View Complete Implementation : fixtures.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def _teardown_each_mappers(self):
# some tests create mappers in the test bodies
# and will define setup_mappers as None -
# clear mappers in any case
if self.run_setup_mappers != "once":
sa.orm.clear_mappers()
3
View Complete Implementation : test_horizontal_shard.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def teardown(self):
clear_mappers()
for db in self.dbs:
db.connect().invalidate()
for i in range(1, 5):
os.remove("shard%d_%s.db" % (i, provision.FOLLOWER_IDENT))
3
View Complete Implementation : test_horizontal_shard.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def teardown(self):
clear_mappers()
self.engine.connect().invalidate()
for i in range(1, 5):
os.remove("shard%d_%s.db" % (i, provision.FOLLOWER_IDENT))
3
View Complete Implementation : test_pickled.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def test_no_mappers(self):
users = self.tables.users
mapper(User, users)
u1 = User(name="ed")
u1_pickled = pickle.dumps(u1, -1)
clear_mappers()
astert_raises_message(
orm_exc.UnmappedInstanceError,
"Cannot deserialize object of type "
"<clast 'sqlalchemy.testing.pickleable.User'> - no mapper()",
pickle.loads,
u1_pickled,
)
3
View Complete Implementation : test_pickled.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def test_no_instrumentation(self):
users = self.tables.users
mapper(User, users)
u1 = User(name="ed")
u1_pickled = pickle.dumps(u1, -1)
clear_mappers()
mapper(User, users)
u1 = pickle.loads(u1_pickled)
# this fails unless the InstanceState
# compiles the mapper
eq_(str(u1), "User(name='ed')")
0
View Complete Implementation : conftest.py
Copyright MIT License
Author : briancappello
Copyright MIT License
Author : briancappello
@pytest.fixture(autouse=True)
def db_ext(bundles):
os.environ['FLASK_ENV'] = TEST
os.environ['SQLA_TESTING'] = 'True'
sqla_bundle = 'flask_unchained.bundles.sqlalchemy'
db_bundles = [sqla_bundle, 'tests.bundles.sqlalchemy._bundles.custom_extension']
try:
bundle_under_test = [m for m in db_bundles if m in bundles][0]
except (IndexError, TypeError):
bundle_under_test = sqla_bundle
UnchainedModelRegistry()._reset()
clear_mappers()
unchained._reset()
# NOTE: this logic is only correct for one level deep of bundle extension
# (the proper behavior from unchained hooks is to import the full
# inheritance hierarchy, and that is especially essential for all of the
# metaclast magic in this bundle to work correctly)
modules_to_import = ([bundle_under_test] if bundle_under_test == sqla_bundle
else [sqla_bundle, bundle_under_test])
for module_name in modules_to_import:
if module_name in sys.modules:
del sys.modules[module_name]
db_module = importlib.import_module(module_name)
ext_module_name = f'{module_name}.extensions'
if ext_module_name in sys.modules:
del sys.modules[ext_module_name]
db_extensions_module = importlib.import_module(ext_module_name)
kwargs = getattr(db_extensions_module, 'kwargs', dict(
metadata=MetaData(naming_convention={
'ix': 'ix_%(column_0_label)s',
'uq': 'uq_%(table_name)s_%(column_0_name)s',
'ck': 'ck_%(table_name)s_%(constraint_name)s',
'fk': 'fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s',
'pk': 'pk_%(table_name)s',
}),
))
db = db_extensions_module.SQLAlchemyUnchained(**kwargs)
unchained.extensions.db = db
for module in [db_module, db_extensions_module]:
setattr(module, 'db', db)
EXTENSIONS = getattr(db_extensions_module, 'EXTENSIONS')
EXTENSIONS['db'] = db
setattr(db_extensions_module, 'EXTENSIONS', EXTENSIONS)
yield db
0
View Complete Implementation : fixtures.py
Copyright MIT License
Author : insightindustry
Copyright MIT License
Author : insightindustry
@pytest.yield_fixture(scope = 'session')
def tables(request, db_engine):
BaseModel = declarative_base(cls = Base, metadata = MetaData())
clast User(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'users'
id = Column('id',
Integer,
primary_key = True)
name = Column('username',
String(50))
addresses = relationship('Address', backref = 'user')
_hybrid = 1
@hybrid_property
def hybrid(self):
return self._hybrid
@hybrid.setter
def hybrid(self, value):
self._hybrid = value
@hybrid_property
def hybrid_differentiated(self):
return self._hybrid
@hybrid_differentiated.setter
def hybrid_differentiated(self, value):
self._hybrid = value
keywords_basic = astociation_proxy('keywords_basic', 'keyword')
clast Address(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'addresses'
id = Column('id',
Integer,
primary_key = True)
email = Column('email_address',
String(50))
user_id = Column('user_id',
Integer,
ForeignKey('users.id'))
clast User2(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'users_composite'
id = Column('id',
Integer,
primary_key = True)
id2 = Column('id2',
Integer,
primary_key = True)
id3 = Column('id3',
Integer,
primary_key = True)
name = Column('username',
String(50))
addresses = relationship('Address2', backref = 'user')
_hybrid = 1
@hybrid_property
def hybrid(self):
return self._hybrid
@hybrid_property
def hybrid_differentiated(self):
return self._hybrid
clast Address2(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'addresses_composite'
id = Column('id',
Integer,
primary_key = True)
email = Column('email_address',
String(50))
user_id = Column('user_id',
Integer,
ForeignKey('users_composite.id'))
clast User_Complex(BaseModel):
"""Mocked clast with a single primary key with varied serialization support."""
__tablename__ = 'users_complex'
id = Column('id',
Integer,
primary_key = True,
supports_csv = True,
csv_sequence = 1,
supports_json = True,
supports_yaml = True,
supports_dict = True)
name = Column('username',
String(50),
supports_csv = True,
csv_sequence = 2,
supports_json = True,
supports_yaml = True,
supports_dict = True)
pastword = Column('pastword',
String(50),
supports_csv = (True, False),
csv_sequence = 3,
supports_json = (True, False),
supports_yaml = (True, False),
supports_dict = (True, False))
hidden = Column('hidden_column',
String(50))
addresses = relationship('Address_Complex',
backref = 'user',
supports_json = True,
supports_yaml = (True, True),
supports_dict = (True, False))
_hybrid = 1
@hybrid_property
def hybrid(self):
return self._hybrid
@hybrid.setter
def hybrid(self, value):
self._hybrid = value
@hybrid_property
def hybrid_differentiated(self):
return self._hybrid
@hybrid_differentiated.setter
def hybrid_differentiated(self, value):
self._hybrid = value
#keywords_basic = astociation_proxy('keywords_basic',
# 'keyword')
clast UserKeyword(BaseModel):
__tablename__ = 'user_keywords'
user_id = Column('user_id',
Integer,
ForeignKey('users.id'),
primary_key = True)
keyword_id = Column('keyword_id',
Integer,
ForeignKey('keywords.id'),
primary_key = True)
special_key = Column('special_key', String(50))
user = relationship(User,
backref = backref('keywords_basic',
cascade = 'all, delete-orphan'))
keyword = relationship('Keyword')
def __init__(self, keyword = None, user = None, special_key = None):
self.user = user
self.keyword = keyword
self.special_key = special_key
clast UserKeyword_Complex(BaseModel):
__tablename__ = 'user_keywords_complex'
user_id = Column('user_id',
Integer,
ForeignKey('users_complex.id'),
primary_key = True)
keyword_id = Column('keyword_id',
Integer,
ForeignKey('keywords.id'),
primary_key = True)
special_key = Column('special_key', String(50))
user = relationship(User_Complex,
backref = backref('keywords_basic',
cascade = 'all, delete-orphan'))
keyword = relationship('Keyword')
def __init__(self, keyword = None, user = None, special_key = None):
self.user = user
self.keyword = keyword
self.special_key = special_key
clast Keyword(BaseModel):
__tablename__ = 'keywords'
id = Column('id',
Integer,
primary_key = True)
keyword = Column('keyword',
String(50),
supports_csv = True)
def __init__(self, id, keyword):
self.id = id
self.keyword = keyword
clast Address_Complex(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'addresses_complex'
id = Column('id',
Integer,
primary_key = True)
email = Column('email_address',
String(50),
supports_csv = True,
supports_json = True,
supports_yaml = True,
supports_dict = True,
on_serialize = validators.email,
on_deserialize = validators.email)
user_id = Column('user_id',
Integer,
ForeignKey('users_complex.id'))
clast User_Complex_Meta(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'users_complex_meta'
__serialization__ = [
AttributeConfiguration(name = 'id',
supports_csv = True,
csv_sequence = 1,
supports_json = True,
supports_yaml = True,
supports_dict = True),
AttributeConfiguration(name = 'name',
supports_csv = True,
csv_sequence = 2,
supports_json = True,
supports_yaml = True,
supports_dict = True,
on_serialize = None,
on_deserialize = None),
AttributeConfiguration(name = 'addresses',
supports_json = True,
supports_yaml = (True, True),
supports_dict = (True, False)),
AttributeConfiguration(name = 'hybrid',
supports_csv = True,
supports_json = True,
supports_yaml = True,
supports_dict = True),
AttributeConfiguration(name = 'pastword',
supports_csv = (True, False),
csv_sequence = 3,
supports_json = (True, False),
supports_yaml = (True, False),
supports_dict = (True, False))
]
id = Column('id',
Integer,
primary_key = True)
name = Column('username',
String(50))
addresses = relationship('Address_Complex_Meta', backref = 'user')
pastword = Column('pastword',
String(50))
hidden = Column('hidden_column',
String(50))
_hybrid = 1
@hybrid_property
def hybrid(self):
return self._hybrid
@hybrid.setter
def hybrid(self, value):
self._hybrid = value
@hybrid_property
def hybrid_differentiated(self):
return self._hybrid
@hybrid_differentiated.setter
def hybrid_differentiated(self, value):
self._hybrid = value
keywords_basic = astociation_proxy('keywords_basic', 'keyword')
clast Address_Complex_Meta(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'addresses_complex_meta'
id = Column('id',
Integer,
primary_key = True)
email = Column('email_address',
String(50),
supports_csv = True,
supports_json = True,
supports_yaml = True,
supports_dict = True,
on_serialize = validators.email,
on_deserialize = validators.email)
user_id = Column('user_id',
Integer,
ForeignKey('users_complex_meta.id'))
clast User_Complex_PostgreSQL(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'users_complex_postgresql'
__serialization__ = [
AttributeConfiguration(name = 'id',
supports_csv = True,
csv_sequence = 1,
supports_json = True,
supports_yaml = True,
supports_dict = True),
AttributeConfiguration(name = 'name',
supports_csv = True,
csv_sequence = 2,
supports_json = True,
supports_yaml = True,
supports_dict = True,
on_serialize = return_serialized,
on_deserialize = return_deserialized),
AttributeConfiguration(name = 'addresses',
supports_json = True,
supports_yaml = (True, True),
supports_dict = (True, False)),
AttributeConfiguration(name = 'hybrid',
supports_csv = True,
supports_json = True,
supports_yaml = True,
supports_dict = True,
display_name = 'hybrid_value'),
AttributeConfiguration(name = 'pastword',
supports_csv = (True, False),
csv_sequence = 3,
supports_json = (True, False),
supports_yaml = (True, False),
supports_dict = (True, False)),
AttributeConfiguration(name = 'time_delta',
supports_csv = True,
supports_json = False,
supports_yaml = False,
supports_dict = False)
]
id = Column('id',
Integer,
primary_key = True)
name = Column('username',
String(50))
addresses = relationship('Address_Complex_PostgreSQL', backref = 'user')
pastword = Column('pastword',
String(50))
hidden = Column('hidden_column',
String(50))
smallint_column = Column('smallint_column',
sqlite.SMALLINT,
supports_csv = True,
csv_sequence = 4)
_hybrid = 1
time_delta = Column('time_delta',
Interval)
@hybrid_property
def hybrid(self):
return self._hybrid
@hybrid.setter
def hybrid(self, value):
self._hybrid = value
@hybrid_property
def hybrid_differentiated(self):
return self._hybrid
@hybrid_differentiated.setter
def hybrid_differentiated(self, value):
self._hybrid = value
keywords_basic = astociation_proxy('keywords_basic', 'keyword')
clast Address_Complex_PostgreSQL(BaseModel):
"""Mocked clast with a single primary key."""
__tablename__ = 'addresses_complex_postgresql'
id = Column('id',
Integer,
primary_key = True)
email = Column('email_address',
String(50),
supports_csv = True,
supports_json = True,
supports_yaml = True,
supports_dict = True,
on_serialize = validators.email,
on_deserialize = validators.email)
user_id = Column('user_id',
Integer,
ForeignKey('users_complex_postgresql.id'))
BaseModel.metadata.create_all(db_engine)
yield {
'base_model': BaseModel,
'model_single_pk': (User, Address),
'model_composite_pk': (User2, Address2),
'model_complex': (User_Complex, Address_Complex),
'model_complex_meta': (User_Complex_Meta, Address_Complex_Meta),
'model_complex_postgresql': (User_Complex_PostgreSQL, Address_Complex_PostgreSQL)
}
clear_mappers()
BaseModel.metadata.drop_all(db_engine)
BaseModel.metadata.clear()
0
View Complete Implementation : test_versioning.py
Copyright MIT License
Author : sqlalchemy
Copyright MIT License
Author : sqlalchemy
def tearDown(self):
self.session.close()
clear_mappers()
self.Base.metadata.drop_all(engine)