sqlalchemy.orm.clear_mappers - python examples

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 7

3 View Complete Implementation : fixtures.py
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
    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
    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
    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
    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
    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
    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
@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
@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
    def tearDown(self):
        self.session.close()
        clear_mappers()
        self.Base.metadata.drop_all(engine)