def main(): parser = ArgumentParser(description='Scrape WMATA SmarTrip usage data.') parser.add_argument('username', metavar='USER', help='SmarTrip username') parser.add_argument('--password', dest='password', metavar='PASSWORD', help='SmarTrip password') parser.add_argument('--card-id', dest='cardID', type=int, help='card ID to fetch, defaults to first card') parser.add_argument('--db', dest='outFile', default="smartrip.sqlite", help='SQLite output file') parser.add_argument('--list', dest='list', default=False, action='store_true', help='List available SmarTrip cards') args = vars(parser.parse_args()) if args['password'] is None: args['password'] = getpass.getpass('Enter SmarTrip password: '******'username'], args['password']) cards = getCards(response) if args['list']: listCards(cards) else: engine = create_engine("sqlite:///" + args['outFile']) Session = sessionmaker(bind=engine) session = Session() metadata.bind = engine metadata.create_all() if args['cardID'] is not None: scrapeCard(br, session, str(args['cardID']), cards[str(args['cardID'])]['cardSerial']) else: cardID = cards.keys()[0] scrapeCard(br, session, str(cardID), cards[cardID]['cardSerial'])
def database(self) -> sessionmaker: """ constructs the database connection and fills it with data """ logger.info('Starting database connection') dns = self.settings['dns'] if dns.startswith("sqlite"): engine = create_engine(dns, connect_args={'isolation_level': None}) else: engine = create_engine(dns) engine.connect() metadata.bind = engine metadata.create_all(engine) factory = sessionmaker(bind=engine, autoflush=True) scope = scoped_session(factory) session = scope() for char in yaml.load(open('data/characters.yaml')): logger.debug(char) char = character.DbCharacter(**char) session.merge(char) session.commit() session.close() return scope
def main(): parse_command_line() global engine engine = sqlalchemy.create_engine(options.db_url, echo=options.debug, convert_unicode=True) if options.init_db: metadata.create_all(engine) with engine.connect() as conn: conn.execute(users.insert(), [ {'name': 'tester1', 'password': '******'}, {'name': 'tester2', 'password': '******'}, ]) return app = Application( (('/', RootHandler), ('/whoami', WhoAmIHandler), ('/login', LoginHandler), ('/games', Games), (r'/games/(\d+)', Game), (r'/games/(\d+)/moves', Moves), (r'/games/(\d+)/wait', Wait)), static_path=os.path.join(os.path.dirname(__file__), 'static'), debug=options.debug, cookie_secret='42', ) app.listen(options.port) IOLoop.current().start()
def init_db(metadata): import sqlalchemy # init table engine = sqlalchemy.create_engine( DATABASE_URL, connect_args={"check_same_thread": False}) metadata.create_all(bind=engine) engine.dispose()
def actionCreateDB(self): from models import metadata, engine from alembic.config import Config from alembic import command metadata.create_all(engine) alembic_cfg = Config() alembic_cfg.set_main_option("script_location", "alembic") alembic_cfg.set_main_option("url", config.DB_URL) command.stamp(alembic_cfg, "head")
def get_engine(path, echo=False): """Returns a connection to the database. If the database path does not exist a new blank database is created using defined metadata. """ engine = create_engine('sqlite:///%s' % (path, ), echo=echo) if not os.path.exists(path): metadata.create_all(engine) return engine
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect() self.db_handler = BaseDBHandler(self.conn) self.uuid1 = str(uuid.uuid4()) test_user = users.insert().values(user_uuid = self.uuid1, username = u"konrad", password = "******", email = "*****@*****.**") self.conn.execute(test_user) self.uuid2 = str(uuid.uuid4()) test_user2 = users.insert().values(user_uuid = self.uuid2, username = u"malgosia", password = "******", email = "*****@*****.**") self.conn.execute(test_user2)
def before(self): super(TestAnswer, self).before() self.db = create_engine('sqlite://') metadata.create_all(self.db) self.resource = Answer(self.db) self.api.add_route('/answer/{game_id}/{question_id}', self.resource) self.api.req_options.auto_parse_form_urlencoded = True # test data self.test_run_id = self.getUniqueString('run_id') self.test_score = self.getUniqueInteger() self.test_uid = self.getUniqueInteger() self.test_selected = ','.join([str(self.getUniqueInteger()) for i in range(3)])
def before(self): super(TestAnswer, self).before() self.db = create_engine('sqlite://') metadata.create_all(self.db) self.resource = Answer(self.db) self.api.add_route('/answer/{game_id}/{question_id}', self.resource) self.api.req_options.auto_parse_form_urlencoded = True # test data self.test_run_id = self.getUniqueString('run_id') self.test_score = self.getUniqueInteger() self.test_uid = self.getUniqueInteger() self.test_selected = ','.join( [str(self.getUniqueInteger()) for i in range(3)])
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect() self.db_handler = BaseDBHandler(self.conn) self.uuid1 = str(uuid.uuid4()) test_user = users.insert().values(user_uuid=self.uuid1, username=u"konrad", password="******", email="*****@*****.**") self.conn.execute(test_user) self.uuid2 = str(uuid.uuid4()) test_user2 = users.insert().values(user_uuid=self.uuid2, username=u"malgosia", password="******", email="*****@*****.**") self.conn.execute(test_user2)
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect() self.db_handler = BaseDBHandler(self.conn) self.uuid1 = str(uuid.uuid4()) test_user = users.insert().values(user_uuid = self.uuid1, username = u"konrad", password = "******", email = "*****@*****.**") self.conn.execute(test_user) self.uuid2 = str(uuid.uuid4()) test_user2 = users.insert().values(user_uuid = self.uuid2, username = u"malgosia", password = "******", email = "*****@*****.**") self.conn.execute(test_user2) self.uuid3 = str(uuid.uuid4()) test_user3 = users.insert().values(user_uuid = self.uuid3, username = u"kuba", password = "******", email = "*****@*****.**") self.conn.execute(test_user3) self.product_uuid1 = str(uuid.uuid4()) self.product_uuid2 = str(uuid.uuid4()) self.product_uuid3 = str(uuid.uuid4()) product_1 = products.insert().values(product_uuid = self.product_uuid1, product_name = u"wiertarka", product_desc = u"test" ) self.conn.execute(product_1) product_2 = products.insert().values(product_uuid = self.product_uuid2, product_name = u"suszarka", product_desc = u"test" ) self.conn.execute(product_2) product_3 = products.insert().values(product_uuid = self.product_uuid3, product_name = u"pralka", product_desc = u"test" ) self.conn.execute(product_3) buyout1 = bought_products.insert().values(quantity = 10, user_id = 1, product_id = 1) self.conn.execute(buyout1) buyout2 = bought_products.insert().values(quantity = 5, user_id = 1, product_id = 2) self.conn.execute(buyout2) buyout3 = bought_products.insert().values(quantity = 1, user_id = 1, product_id = 3) self.conn.execute(buyout3) buyout4 = bought_products.insert().values(quantity = 11, user_id = 2, product_id = 1) self.conn.execute(buyout4) buyout5 = bought_products.insert().values(quantity = 1, user_id = 2, product_id = 2) self.conn.execute(buyout5) buyout6 = bought_products.insert().values(quantity = 2, user_id = 3, product_id = 1) self.conn.execute(buyout6)
def create_table(self): metadata.create_all(self.engine)
from db import create_engine from models import metadata from configuration import config # ### 初始化redis客户端 redis_config = config['REDIS'] # 当decode_responses参数为True时redis-py会自动将redis返回的字符菜转换为unicode。 # 默认不这么做的原因是:如果需要转换结果为数字,先转换为unicode就造成了额外花销。 # 节点本身不会从redis读取大量数字,但在归档数据时可能需要注意。 redis_config.update(decode_responses=True) r = redis.StrictRedis(**redis_config) # ###初始化数据库 db = create_engine(config['DATABASE_URL']) # 程序在创建表格之前会检测是否存在 metadata.create_all(db) """ ### API接口 按falcon的设计模式,每条url规则对应一个[资源] * /api/start/{game_id} - [开始游戏] * /api/end/{game_id} - [结束游戏] * /api/answer/{game_id}/{question_id} - [记录答题选择] [资源]: resources.html [开始游戏]: resources.html#Start [结束游戏]: resources.html#End [记录答题选择]: resources.html#Answer """ api = falcon.API()
def init_db(): with app.app_context(): engine = get_engine() metadata.create_all(engine)
from fixture import DataTestCase, SQLAlchemyFixture from sqlalchemy import create_engine, text from models import metadata, UserTable, RegionTable from fixtures import RegionData, UserData # import logging # logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO) engine = create_engine('postgresql://postgres:@localhost/sqlagg_test') metadata.bind = engine metadata.create_all() engine.execute( text('CREATE OR REPLACE VIEW "user_view" as SELECT * from user_table')) class BaseTest(DataTestCase): datasets = [UserData, RegionData] fixture = SQLAlchemyFixture(engine=metadata.bind, env={ "UserData": UserTable, "RegionData": RegionTable }) @classmethod def metadata(cls): return metadata
def get_app(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine self.conn = engine.connect() metadata.create_all() return Application(self.conn)
class UFC(): "ULL Flow Control" # Únicamente tenemos en cuenta correos cuyo remitente sea de nuestro dominio only_from_domain = True # Lista de usuarios a los que no se le aplica este filtro whitelist = [] # Mensajes de respuesta ans = 'El usuario ha superado el limite de correos enviados por minuto' hold = "HOLD %s" % ans reject = "REJECT %s" % ans dunno = "DUNNO" # Configuración del correo smtp_server = 'localhost' recipients = [ 'root', ] fqdn = socket.getfqdn() tls_required = True def __init__(self, verbose=False, listen_tcp=True): if verbose: log.setLevel(logging.DEBUG) self.listen_tcp = listen_tcp self.configure() def configure(self): config = ConfigParser.ConfigParser() try: config.read(config_path) except IOError: log.error('Error reading configuration from %s' % config_path) return False log.info("Reading configuration from %s" % config_path) self.smtp_server = self.get_config(config, 'smtp', 'server', self.smtp_server) self.recipients = self.get_config(config, 'smtp', 'recipients', self.recipients) if type(self.recipients) == str: self.recipients = str_to_list(self.recipients) # Limits configuration self.max_time = int(self.get_config(config, 'limits', 'max_time')) self.max_email = int(self.get_config(config, 'limits', 'max_email')) self.domain = self.get_config(config, 'limits', 'domain') if self.domain is None: try: self.domain = self.fqdn.split('.', 1)[1] except IndexError: self.domain = 'localdomain' log.info("Domain: %s " % self.domain) self.whitelist = self.get_config(config, 'limits', 'whitelist', self.whitelist) if type(self.whitelist) == str: self.whitelist = str_to_list(self.whitelist) log.info("Whitelist: %s " % self.whitelist) connection_string = self.get_config(config, 'database', 'connection_string') try: connection = create_engine(connection_string, pool_size=25, max_overflow=25, pool_recycle=30) except Exception, e: log.error( 'Database access error, connection string used: %s. Error: %s' % (connection_string, e)) return False metadata.create_all(connection, checkfirst=True) self.session = sessionmaker(bind=connection) return True
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect()
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect() self.db_handler = BaseDBHandler(self.conn) self.uuid1 = str(uuid.uuid4()) test_user = users.insert().values(user_uuid=self.uuid1, username=u"konrad", password="******", email="*****@*****.**") self.conn.execute(test_user) self.uuid2 = str(uuid.uuid4()) test_user2 = users.insert().values(user_uuid=self.uuid2, username=u"malgosia", password="******", email="*****@*****.**") self.conn.execute(test_user2) self.uuid3 = str(uuid.uuid4()) test_user3 = users.insert().values(user_uuid=self.uuid3, username=u"kuba", password="******", email="*****@*****.**") self.conn.execute(test_user3) self.product_uuid1 = str(uuid.uuid4()) self.product_uuid2 = str(uuid.uuid4()) self.product_uuid3 = str(uuid.uuid4()) product_1 = products.insert().values(product_uuid=self.product_uuid1, product_name=u"wiertarka", product_desc=u"test") self.conn.execute(product_1) product_2 = products.insert().values(product_uuid=self.product_uuid2, product_name=u"suszarka", product_desc=u"test") self.conn.execute(product_2) product_3 = products.insert().values(product_uuid=self.product_uuid3, product_name=u"pralka", product_desc=u"test") self.conn.execute(product_3) buyout1 = bought_products.insert().values(quantity=10, user_id=1, product_id=1) self.conn.execute(buyout1) buyout2 = bought_products.insert().values(quantity=5, user_id=1, product_id=2) self.conn.execute(buyout2) buyout3 = bought_products.insert().values(quantity=1, user_id=1, product_id=3) self.conn.execute(buyout3) buyout4 = bought_products.insert().values(quantity=11, user_id=2, product_id=1) self.conn.execute(buyout4) buyout5 = bought_products.insert().values(quantity=1, user_id=2, product_id=2) self.conn.execute(buyout5) buyout6 = bought_products.insert().values(quantity=2, user_id=3, product_id=1) self.conn.execute(buyout6)
from db import create_engine from models import metadata from configuration import config # ### 初始化redis客户端 redis_config = config['REDIS'] # 当decode_responses参数为True时redis-py会自动将redis返回的字符菜转换为unicode。 # 默认不这么做的原因是:如果需要转换结果为数字,先转换为unicode就造成了额外花销。 # 节点本身不会从redis读取大量数字,但在归档数据时可能需要注意。 redis_config.update(decode_responses=True) r = redis.StrictRedis(**redis_config) # ###初始化数据库 db = create_engine(config['DATABASE_URL']) # 程序在创建表格之前会检测是否存在 metadata.create_all(db) """ ### API接口 按falcon的设计模式,每条url规则对应一个[资源] * /api/start/{game_id} - [开始游戏] * /api/end/{game_id} - [结束游戏] * /api/answer/{game_id}/{question_id} - [记录答题选择] [资源]: resources.html [开始游戏]: resources.html#Start [结束游戏]: resources.html#End [记录答题选择]: resources.html#Answer """
from models import ( DBSession, metadata ) from sqlalchemy import create_engine import settings engine = create_engine('mysql+mysqldb://'+settings.db_user+':'+settings.db_password+'@'+settings.db_host+'/'+settings.db_name) DBSession.configure(bind=engine) metadata.bind = engine import models metadata.drop_all() DBSession.flush() metadata.create_all() from business.game import Game game = Game('The game you just lost') DBSession.add(game) from business.game.player import PlayerGame player = PlayerGame('Me') DBSession.add(player) player.game = game from business.army.army import Army
from models import checkin, metadata from sqlalchemy import create_engine, MetaData # Generates the variables used later engine = create_engine('sqlite:///checkins.db') #TODO: get the name associated with cardnumber from API def returnName(numb): #Temp name until API is in place name = "Onliner" return name # Connects and safely creates the DB if it doesn't exist try: conn = engine.connect() metadata.create_all(engine) except: print("Oooops. Something went wrong while connecting to the database, is it up?") number = "" # Main program that loops while (number != 'exit'): print ("Scan Card:") # Gets input from card-reader number = str(input()) dateNow = datetime.datetime.now() firstWatch = dateNow.replace(hour=8, minute=0, second=0, microsecond=0)
from typing import Any from sqlalchemy import create_engine, Table, and_ from models import metadata _USER = '******' _PASSWORD = '******' _HOST = 'localhost:5432' _DBNAME = 'combat_sports_db' _ENGINE = create_engine( f"postgresql+psycopg2://{_USER}:{_PASSWORD}@{_HOST}/{_DBNAME}") metadata.create_all(_ENGINE) def get_entity(table: Table, conditions: dict[str, Any]) -> dict: with _ENGINE.connect() as connection: return connection.execute(table.select().where( and_(*[ getattr(table.c, column_name) == column_value for column_name, column_value in conditions.items() ]))).fetchone() def create_entity(table: Table, values: dict) -> dict: with _ENGINE.connect() as connection: return connection.execute( table.insert().values(**values).returning(*table.c)).fetchone()
def setUp(self): engine = create_engine("sqlite:///:memory:") metadata.bind = engine metadata.create_all() self.conn = engine.connect() self.product_handler = ProductDatabaseHandler(self.conn)
def init(engine: Engine) -> None: """ init tables""" metadata.create_all(bind=engine)
def create_test_database(): engine = sqlalchemy.create_engine(DATABASE_URL) metadata.create_all(engine) yield metadata.drop_all(engine)
def create_db(): engine = get_engine() metadata.create_all(engine)
pymysql.install_as_MySQLdb() from gevent.queue import Queue from gevent.queue import Empty from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker, scoped_session from models import metadata, Region, Xiaoqu, Chengjiao from LianJiaSpider import do_xiaoqu_spider, xiaoqu_chengjiao_spider from optparse import OptionParser engine = create_engine('mysql://root@localhost/lianjia?charset=utf8', echo=False) xiaoqu_queue = Queue(maxsize=20) default_xiaoqu_thread = 10 metadata.create_all(engine) Session = sessionmaker(bind=engine, autoflush=True, autocommit=False) # Session = scoped_session(sessionmaker(bind=engine, autoflush=True, autocommit=False)) def xiaoqu_callback(res): session = Session() for item in res: xiaoqu = session.query(Xiaoqu).filter(Xiaoqu.href == item.href).first() if not xiaoqu: session.add(item) session.commit() def get_all_xiaoqu(): session = Session()