def __init__(self, uri='sqlite://',
                 app=None,
                 echo=False,
                 pool_size=None,
                 pool_timeout=None,
                 pool_recycle=None,
                 convert_unicode=True,
                 query_cls=BaseQuery):

        self.uri = uri
        self.info = make_url(uri)
        self.options = self._cleanup_options(
            echo=echo,
            pool_size=pool_size,
            pool_timeout=pool_timeout,
            pool_recycle=pool_recycle,
            convert_unicode=convert_unicode,
        )

        self.connector = None
        self._engine_lock = threading.Lock()
        self.session = _create_scoped_session(self, query_cls=query_cls)

        self.Model = declarative_base(cls=Model, name='Model')
        self.BaseModel = declarative_base(cls=BaseModel, name='BaseModel')

        self.Model.db, self.BaseModel.db = self, self
        self.Model.query, self.BaseModel.query = self.session.query, self.session.query

        if app is not None:
            self.init_app(app)

        _include_sqlalchemy(self)

    def __init__(self, config):
        """
        Initializes the declarative bases that are used throughout the project.
        Initializes the empty engines and sessionmakers that support
        `get_session`, `get_mw_session` and `get_ca_session`.
        """

        self.config = config

        self.WikimetricsBase = declarative_base(cls=SerializableBase)
        self.MediawikiBase = declarative_base(cls=SerializableBase)
        self.CentralAuthBase = declarative_base(cls=SerializableBase)

        self.wikimetrics_engine = None
        self.wikimetrics_sessionmaker = None
        self.wikimetrics_session = None

        self.mediawiki_engines = {}
        self.mediawiki_sessions = {}

        self.centralauth_engine = None
        self.centralauth_sessionmaker = None
        self.centralauth_session = None

        # we instantiate project_host_map lazily
        self._project_host_map = None

def MakeClasses(metadata):
  Base = declarative_base(metadata=metadata)
  class GBID(Base):
      __tablename__ = 'gbid'
      __table_args__ = (UniqueConstraint('name'), {})
      id = Column(Integer, primary_key=True)
      name = Column(String, index = True)
      offset = Column(Integer)
      def __init__(self, name, offset):
          self.name = name
          self.offset = offset
  
  sgjBase = declarative_base(metadata = metadata)
  class GBID_SequenceJoin(sgjBase):
    __tablename__ = 'gbid_sequencejoin'
    __table_args__ = (UniqueConstraint('sequence'), {})

    id = Column(Integer, primary_key=True)
    sequence = Column(Integer, 
                      ForeignKey('sequence.id'),
                      index = True)
    gbid = Column(Integer,
                  ForeignKey('gbid.id'))
    def __init__(self, gbid, sequence):
      self.gbid = gbid
      self.sequence = sequence
  return dict(GBID = GBID, GBID_SequenceJoin = GBID_SequenceJoin)

def MakeClasses(metadata):
  Base = declarative_base(metadata=metadata)
  class Gbfile(Base):
      __tablename__ = 'gbfile'
      __table_args__ = (UniqueConstraint('name'), {})
      id = Column(Integer, primary_key=True)
      name = Column(String, index = True)
      def __init__(self, name):
          self.name = name
  
  sgjBase = declarative_base(metadata = metadata)
  class Gbfile_GBIDJoin(sgjBase):
    __tablename__ = 'gbfile_gbidjoin'
    __table_args__ = (UniqueConstraint('gbid'), {})

    id = Column(Integer, primary_key=True)
    gbfile = Column(Integer, 
                      ForeignKey('gbfile.id'))
    gbid = Column(Integer,
                  ForeignKey('gbid.id'),
                  index = True)
    def __init__(self, gbfile, gbid):
      self.gbid = gbid
      self.gbfile = gbfile
  return dict(Gbfile = Gbfile, Gbfile_GBIDJoin = Gbfile_GBIDJoin)

def extended_declarative_base(db_session, forms=True, **kw):
    if forms:
        Base = declarative_base(cls=FormBase, **kw)
    else:
        Base = declarative_base(cls=ExtendedBase, **kw)
    Base.query = db_session.query_property()
    return Base

def db_connect(engine, schema=None, clobber=False):
    """Create a connection object to a database. Attempt to establish a
    schema. If there are existing tables, delete them if clobber is
    True and return otherwise. Returns a sqlalchemy engine object.

    """

    if schema is None:
        base = declarative_base()
    else:
        try:
            engine.execute(sqlalchemy.schema.CreateSchema(schema))
        except sqlalchemy.exc.ProgrammingError as err:
            logging.warn(err)
        base = declarative_base(metadata=MetaData(schema=schema))

    define_schema(base)

    if clobber:
        logging.info('Clobbering database tables')
        base.metadata.drop_all(bind=engine)

    logging.info('Creating database tables')
    base.metadata.create_all(bind=engine)

    return base

    def test_custom_mapper(self):
        class MyExt(sa.orm.MapperExtension):
            def create_instance(self):
                return "CHECK"

        def mymapper(cls, tbl, **kwargs):
            kwargs['extension'] = MyExt()
            return sa.orm.mapper(cls, tbl, **kwargs)

        from sqlalchemy.orm.mapper import Mapper
        class MyMapper(Mapper):
            def __init__(self, *args, **kwargs):
                kwargs['extension'] = MyExt()
                Mapper.__init__(self, *args, **kwargs)

        from sqlalchemy.orm import scoping
        ss = scoping.ScopedSession(create_session)
        ss.extension = MyExt()
        ss_mapper = ss.mapper

        for mapperfunc in (mymapper, MyMapper, ss_mapper):
            base = decl.declarative_base()
            class Foo(base):
                __tablename__ = 'foo'
                __mapper_cls__ = mapperfunc
                id = Column(Integer, primary_key=True)
            eq_(Foo.__mapper__.compile().extension.create_instance(), 'CHECK')

            base = decl.declarative_base(mapper=mapperfunc)
            class Foo(base):
                __tablename__ = 'foo'
                id = Column(Integer, primary_key=True)
            eq_(Foo.__mapper__.compile().extension.create_instance(), 'CHECK')

def MakeClasses(metadata):

  Base = declarative_base(metadata=metadata)
  class Alignment(Base):
    __tablename__ = 'alignment'
    __table_args__ = (UniqueConstraint('name'), {})

    id = Column(Integer, primary_key=True)
    source = Column(String)
    name = Column(String)
    def __init__(self, source = 'None'):
        self.source = source

  asjBase = declarative_base(metadata = metadata)
  class Alignment_SequenceJoin(asjBase):
    __tablename__= 'alignment_sequencejoin'
    __table_args__ = (UniqueConstraint('sequence'), {})    
    id = Column(Integer, primary_key=True)
    alignment = Column(Integer, 
                       ForeignKey('alignment.id'))
    sequence = Column(Integer,
                      ForeignKey('sequence.id'))
    def __init__(self, alignment, sequence):
      self.alignment = alignment
      self.sequence = sequence
  return dict(Alignment = Alignment, Alignment_SequenceJoin = Alignment_SequenceJoin)

def declarative_bases(metadata, registry=None):
    """Return all declarative bases bound to a single metadata object."""
    if registry is None:
        registry = dict()
    return (declarative_base(cls=BaseOps, metadata=metadata,
                             class_registry=registry),
            declarative_base(cls=Timestamped, metadata=metadata,
                             class_registry=registry))

 def test_other_base_twice__different(self):
     Base = declarative_base()
     Base2 = declarative_base()
     contract = {"Group": {"table_name": "groups"}}
     models1 = self._callFUT(Base, contract)
     models2 = self._callFUT(Base2, contract)
     self.assertNotEqual(models1, models2)
     self.assertNotEqual(models1.Group, models2.Group)

    def test_create_drop_tables_several_meta(self):
        Base1 = declarative_base()

        class A1(Base1):
            __tablename__ = 'A'
            id = Column(Integer, primary_key=True)

        Base2 = declarative_base()

        class A2(Base2):
            __tablename__ = 'A'
            id = Column(Integer, primary_key=True)

        engine1 = create_engine('sqlite://')
        engine2 = create_engine('sqlite://')
        binds = {
            A1.__table__: engine1,
            A2.__table__: engine2,
        }
        meta = {
            'm1': Base1.metadata,
            'm2': Base2.metadata,
            'm3': MetaData(),
        }
        cli = Sqla(orm.sessionmaker(binds=binds), metadata=meta)

        for verbose in [False, True]:

            cli.command_create_tables(verbose=verbose)
            self.assertTrue(engine1.has_table('A'))
            self.assertTrue(engine2.has_table('A'))

            with mock.patch.object(sys.stdin, 'readline', return_value='y'):
                cli.command_drop_tables('m1')
            self.assertFalse(engine1.has_table('A'))
            self.assertTrue(engine2.has_table('A'))

            with mock.patch.object(sys.stdin, 'readline', return_value='y'):
                cli.command_drop_tables()
            self.assertFalse(engine1.has_table('A'))
            self.assertFalse(engine2.has_table('A'))

            cli.command_create_tables('m1', verbose=verbose)
            self.assertTrue(engine1.has_table('A'))
            self.assertFalse(engine2.has_table('A'))

            with mock.patch.object(sys.stdin, 'readline', return_value='y'):
                cli.command_drop_tables()
            self.assertFalse(engine1.has_table('A'))
            self.assertFalse(engine2.has_table('A'))

            cli.command_create_tables('m3', verbose=verbose)
            self.assertFalse(engine1.has_table('A'))
            self.assertFalse(engine2.has_table('A'))

 def __init__(self, config: DBConfig) -> None:
     self.engine = create_engine(config.URI)
     self.engine.echo = config.ECHO
     self.Model = declarative_base()
     self.Model.metadata.bind = self.engine
     self.__DBSession = sessionmaker(bind=self.engine)
     self.session = self.__DBSession()

 def make_declarative_base(self):
     """Creates the declarative base."""
     base = declarative_base(cls=Model, name='Model',
                             mapper=signalling_mapper,
                             metaclass=_BoundDeclarativeMeta)
     base.query = _QueryProperty(self)
     return base

    def table_base(self):
        """Base class for all tables returned by this database

        This base class is created using
        :py:class:`declarative_base <sqlalchemy:sqlalchemy.ext.declarative.declarative_base>`.
        """
        return declarative_base(metadata=self.metadata)

    def __init__(self):
        #self.engine = create_engine('sqlite://///home/weis/code/baltic_rallye_code/common/sequences.db')
        self.engine = create_engine('sqlite://///home/pi/baltic_rallye_code/common/sequences.db')
        #self.engine = create_engine('sqlite://///home/weis/Desktop/baltic_rallye_code/common/sequences.db')
        #self.engine = create_engine('sqlite://///home/weis/code/gpslapse/common/sequences.db')

        self.base = declarative_base()
        self.meta = MetaData(bind=self.engine)
        Session = sessionmaker(bind=self.engine)
        self.session = Session()

        # first, get meta-data (structure and datatypes from all tables
        self.sequences = Table('sequences', self.meta, autoload=True, autoload_with=self.engine)
        self.sensors = Table('sensors', self.meta, autoload=True, autoload_with=self.engine)
        self.frames = Table('frames', self.meta, autoload=True, autoload_with=self.engine)
        self.annot_cars = Table('annot_cars', self.meta, autoload=True, autoload_with=self.engine)
        self.annot_taillights = Table('annot_taillights', self.meta, autoload=True, autoload_with=self.engine)

        # now, map the dummy-classes above to the tables, they inherit all fields
        # and can be used to insert or query from the database
        orm.mapper(self.Sensor, self.sensors)
        orm.mapper(self.Sequence, self.sequences)
        orm.mapper(self.Frame, self.frames)
        orm.mapper(self.AnnotCar, self.annot_cars)
        orm.mapper(self.AnnotTaillight, self.annot_taillights)

def Init():
	global Base,metadata,engine,Session
	Base=declarative_base()
	metadata=MetaData()
	engine=create_engine(cp.Connect_string,pool_size=cp.dbpoolsize,max_overflow=0,pool_timeout=cp.dbpool_timeout,pool_recycle=cp.dbpool_recycle,echo=cp.dbecho)
	Session = sessionmaker(bind=engine)
	metadata.reflect(bind=engine)

        def define_tables(self, metadata):
            global User, Address
            Base = decl.declarative_base(metadata=metadata)

            class User(Base, ComparableEntity):
                __tablename__ = 'users'
                id = Column(Integer, primary_key=True)
                name = Column(String(50))
            
            class Address(Base, ComparableEntity):
                __tablename__ = 'addresses'
                id = Column(Integer, primary_key=True)
                email = Column(String(50))
                user_id = Column(Integer, ForeignKey('users.id'))
                if inline:
                    if stringbased:
                        user = relation("User", primaryjoin="User.id==Address.user_id", backref="addresses")
                    else:
                        user = relation(User, primaryjoin=User.id==user_id, backref="addresses")
            
            if not inline:
                compile_mappers()
                if stringbased:
                    Address.user = relation("User", primaryjoin="User.id==Address.user_id", backref="addresses")
                else:
                    Address.user = relation(User, primaryjoin=User.id==Address.user_id, backref="addresses")

def upgrade():
    if 'easfoldersyncstatus' in Base.metadata.tables:
        from inbox.ignition import main_engine
        engine = main_engine(pool_size=1, max_overflow=0)
        from inbox.models.session import session_scope
        from sqlalchemy.ext.declarative import declarative_base
        from sqlalchemy.orm.exc import NoResultFound
        Base = declarative_base()
        Base.metadata.reflect(engine)
        from inbox.models.backends.eas import EASFolderSyncStatus
        from inbox.models import Folder
        from inbox.util.eas.constants import SKIP_FOLDERS

        with session_scope(versioned=False, ignore_soft_deletes=False) as \
                db_session:
            statuses = db_session.query(EASFolderSyncStatus).filter(
                EASFolderSyncStatus.eas_folder_type.in_(SKIP_FOLDERS)).all()
            for s in statuses:
                db_session.delete(s)
                db_session.delete(s.folder)

            try:
                for status in db_session.query(EASFolderSyncStatus)\
                        .join(Folder).filter(
                            Folder.name == 'RecipientInfo').all():
                    db_session.delete(status)
                    db_session.delete(status.folder)
            except NoResultFound:
                pass

            db_session.commit()

def dummy_mapper(table):
    Base = declarative_base()

    class DummyMapper(Base):
        __table__ = table

    return DummyMapper

 def test_custom_base(self):
     class MyBase(object):
         def foobar(self):
             return "foobar"
     Base = decl.declarative_base(cls=MyBase)
     assert hasattr(Base, 'metadata')
     assert Base().foobar() == "foobar"