def get_session(self):
if not self.sessionmaker:
engine = self.get_db_engine()
self.sessionmaker = scoped_session(sessionmaker(bind=engine))
session = self.sessionmaker()
session.rollback()
return session
def __init__(self,keep_session=False):
#cache
self.dash_engines = []
#check db
if len(settings.SQL_BACKENDS)==0:
raise Exception('Settings SQL_BACKENDS need one db at least!')
#初始化数据库连接
#初始化session marker
for backend in settings.SQL_BACKENDS:
engine = create_engine(
backend['db_url'],
pool_size=backend['db_pool_size'],
echo=settings.SQL_DEBUG,
encoding=backend['db_charset'],
pool_recycle=backend['db_pool_recycle']
)
self.dash_engines.append(engine)
#初始化shardstat
idx=0
s=scoped_session(sessionmaker(bind=self.dash_engines[0]))()
for db_setting in settings.SQL_BACKENDS:
ss=ShardStat(shard_name=db_setting['db_name'],
shard_id=idx)
s.add(ss)
idx+=1
try:
s.commit()
except:
s.rollback()
s.close()
def setUp(self):
"""Creates the Flask application and the APIManager."""
# create the Flask application
app = Flask(__name__)
app.config['DEBUG'] = True
app.config['TESTING'] = True
app.config['SECRET_KEY'] = "testing..."
del app.logger.handlers[0]
# sqlalchemy flask
self.base = declarative_base()
self.engine = create_engine('sqlite://')
self.session = scoped_session(sessionmaker(autocommit=False,
autoflush=False,
bind=self.engine))
self.app = app
self._ctx = self.app.test_request_context()
self._ctx.push()
self.client = self.app.test_client()
# Add an error handler that returns straight LeverException
# recommendations
@self.app.errorhandler(LeverException)
def handler(exc):
tb = exc.extra.pop('tb', None)
self.app.logger.debug("Lever Exception Thrown!\n"
"Extra: {0}\nEnd User: {1}"
.format(exc.extra, exc.end_user),
exc_info=True)
if tb:
self.app.logger.debug("Traceback from lever exception:"
"\n{0}".format(tb.replace('\\n', '\n')))
return jsonify(**exc.end_user), exc.code
return app
def session(self, dbname):
# set up a session for each db; this uses scoped_session (based on the
# thread ID) to ensure only one session per thread
if dbname not in self._sessions:
Session = orm.sessionmaker(bind=self.engine(dbname))
self._sessions[dbname] = scoping.scoped_session(Session)
return self._sessions[dbname]
def _create_sessions(self):
''' Creates database sessions '''
gi_tax_engine = create_engine(self.gi_taxonomy_url, echo=False,
convert_unicode=True, encoding='utf-8',
pool_recycle=3600)
gi_tax_session = scoped_session(sessionmaker(
bind=gi_tax_engine, autocommit=False, autoflush=False))
self.gi_tax_session = gi_tax_session
def session(app):
sess = None
try:
sess = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=app.engine))
yield sess
finally:
if sess:
sess.close()
def __init__(self, db_connection, library_path, login, slot_id):
self.dry_run = False
self.db_engine = sqlalchemy.create_engine(db_connection)
self._session_creator = scoping.scoped_session(orm.sessionmaker(bind=self.db_engine, autocommit=True))
self.crypto_plugin = p11_crypto.P11CryptoPlugin(CONF)
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.pkcs11 = self.crypto_plugin.pkcs11
self.session = self.pkcs11.get_session()
def start(self):
db_dir_path = self.resource_manager.get_fs_resource_path("store")
self.db_string = "sqlite:///%s/app.db" % db_dir_path
self.engine = create_engine(self.db_string)
self.session = scoped_session(sessionmaker(bind=self.engine,
autocommit=False,
autoflush=True))
Base.metadata.create_all(self.engine)
def _create_sessions(self):
''' Creates database sessions '''
unity_engine = create_engine (self.unity_db_url, echo=False,
convert_unicode=True, encoding='utf-8',
pool_recycle=3600)
unity_session = scoped_session(sessionmaker(
bind=unity_engine, autocommit=False, autoflush=False))
self.unity_session = unity_session
ncbitax_engine = create_engine (self.ncbitax_db_url, echo=False,
convert_unicode=True, encoding='utf-8',
pool_recycle=3600)
ncbitax_session = scoped_session(sessionmaker(
bind=ncbitax_engine, autocommit=False, autoflush=False))
self.ncbitax_session = ncbitax_session
def __init__(self, connection=None):
self.connection = connection or cfg.db.connection
self.engine = sqlalchemy.create_engine(self.connection)
self.DBSession = scoping.scoped_session(
orm.sessionmaker(
bind=self.engine,
autocommit=True
)
)
def init_session(database_filename):
engine = create_engine('sqlite:///{0}'.format(database_filename), echo=False)
DBSession = scoped_session(
sessionmaker(
autoflush=True,
autocommit=False,
bind=engine
)
)
return DBSession
def dispatch(self):
"""Add the database session to the request's scope."""
try:
self.db_session = scoped_session(sessionmaker(bind=self.engine))
ret = super(BaseHandler, self).dispatch()
self.db_session.commit()
return ret
except:
self.db_session.rollback()
raise
def SelectAll(self,pModel):
try:
Session = scoped_session(sessionmaker(bind=connect.ConnectorMySql()))
ses = Session()
lst = ses.query(pModel).all()
return lst
except Exception as e:
raise Exception('Type Error In SelectAll :'+ str(e))
def init(self):
'''Initialize(reset) mocked in-memory copy.
'''
self.url = 'sqlite://'
self.mock_engine = sqlalchemy.create_engine(self.url)
self.MBase = declarative_base()
self.MBase.metadata = self.TBase.metadata
self.MBase.metadata.bind = self.mock_engine
self.MBase.metadata.create_all()
self._Session = scoped_session(sessionmaker(bind=self.mock_engine))
def __init__(self):
self.nv_log_handler = nv_logger(self.__class__.__name__).get_logger()
self.db_engine = create_engine(NVDB_SQLALCHEMY_DB,
connect_args={'check_same_thread': False},
poolclass=StaticPool, echo=False)
session_maker = sessionmaker(bind=self.db_engine)
self.Session = scoped_session(session_maker)
self.db_session = None
db_base.metadata.create_all(self.db_engine)
self.nv_midbox_db_entry = None
self.nv_webserver = None
self.nv_log_handler.debug("Tables created in nvdb")
def InsertWithOutGetID(self,pmodel):
try:
Session = scoped_session(sessionmaker(bind=connect.ConnectorMySql()))
Base.query = Session.query_property()
ses = Session()
ses.add(pmodel)
ses.commit()
ses.close()
return
except Exception as e:
raise Exception('Type Error In Insert :'+ str(e))
def _init_db(self):
print '>>>', 'init_db'
db_config_file = os.path.abspath('config/database.py')
# execfile(db_config_file)
db_info = {'username':'******',
'password':'******',
'host':'127.0.0.1',
'db':'storm'}
engine = create_engine('mysql://%s:%s@%s/%s?charset=utf8' % (db_info['username'], db_info['password'], db_info['host'], db_info['db']),
echo=False)
# Session = sessionmaker(bind=engine)
self.db = scoped_session(sessionmaker(bind=engine))
def __init__(self):
"""
dialect+driver://username:password@host:port/database
"""
self.conf = SysUtil().get_sys_conf()
db_username = self.conf["db_username"]
db_password = self.conf["db_password"]
db_url = self.conf["db_url"]
db_name = self.conf["db_name"]
self.engine = create_engine("sqlite://", connect_args={"check_same_thread": False}, poolclass=StaticPool)
self._scoped_session = scoped_session(sessionmaker(bind=self.engine, expire_on_commit=True))
self.session = None
def open_db_connection(dsn):
"""
Sets up and configures the SQLAlchemy session using the provided L{dsn}.
:param dsn: The DSN to connect too
:type dsn: str
"""
assert isinstance(dsn, str)
assert dsn
engine = create_engine(dsn, echo=False, pool_recycle=3600)
global Session
Session = scoped_session(sessionmaker(bind=engine, autocommit=True))
def initialize(settings, **kwargs):
create_db = kwargs.get('create_db', settings['app.create_db'])
engine = engine_from_config(
settings, prefix='sa.', echo=settings['app.echo']
)
maker = scoped_session(sessionmaker(
extension=ZopeTransactionExtension()
))
maker.configure(bind=engine)
db.register_maker(maker)
Base.metadata.bind = engine
if create_db:
logger.info(u"Flag 'app.create_db' is ON. Creating tables ...")
Base.metadata.create_all(engine)
def get_repo_storage_id(repo_id):
if repo_storage_id.has_key(repo_id):
return repo_storage_id[repo_id]
else:
from .db import Base
from sqlalchemy.orm.scoping import scoped_session
RepoStorageId = Base.classes.RepoStorageId
storage_id = None
session = scoped_session(objstore_factory.session)
q = session.query(RepoStorageId).filter(RepoStorageId.repo_id==repo_id)
r = q.first()
storage_id = r.storage_id if r else None
repo_storage_id[repo_id] = storage_id
session.remove()
return storage_id
def loader(url):
u"""농식품종합정보시스템 식품 정보(식단명 및 재료)를 DB에 저장합니다.
:param URL: 저장할 데이터베이스 URL (ex. mysql://scott@tiger:example.com/dbname)
"""
engine = create_engine(url)
Session = scoped_session(sessionmaker(engine))
sess = Session()
Base.metadata.bind = engine
Base.metadata.create_all()
for food in koreafood.get_food_list():
mfood = koreafood.food_to_model(sess, food)
sess.merge(mfood)
sess.commit()
def __init__(self, conf):
self.dry_run = False
self.db_engine = sqlalchemy.create_engine(conf.sql_connection)
self._session_creator = scoping.scoped_session(
orm.sessionmaker(
bind=self.db_engine,
autocommit=True
)
)
self.crypto_plugin = p11_crypto.P11CryptoPlugin(conf)
self.pkcs11 = self.crypto_plugin.pkcs11
self.plugin_name = utils.generate_fullname_for(self.crypto_plugin)
self.hsm_session = self.pkcs11.get_session()
self.new_mkek_label = self.crypto_plugin.mkek_label
self.new_hmac_label = self.crypto_plugin.hmac_label
self.new_mkek = self.crypto_plugin._get_master_key(self.new_mkek_label)
self.new_mkhk = self.crypto_plugin._get_master_key(self.new_hmac_label)
def loader(url):
"""
농식품종합정보시스템 식품 정보(식단명 및 재료) 정보를 DB에 저장합니다.
URL 저장할 데이터베이스 URL (ex. mysql://scott@tiger:example.com/dbname)
"""
engine = create_engine(url)
Session = scoped_session(sessionmaker(engine))
sess = Session()
food_model.Base.metadata.bind = engine
food_model.Base.metadata.create_all()
for food in koreafood.get_food_list():
mfood = food_to_model(sess, food)
add_food(sess, mfood)
for aliment in mfood.aliments:
add_aliment(sess, aliment)
add_food_aliment(sess, mfood, aliment)
def get_session(dbpath=None, scoped=False):
"""
Create an sql alchemy session for IO db operations
:param dbpath: the path to the database, e.g. sqlite:///path_to_my_dbase.sqlite
if None or missing, it defaults to the 'dburi' field in config.yaml
:param scoped: boolean (False by default) if the session must be scoped session
"""
if dbpath is None:
dbpath = get_default_dbpath()
# init the session:
engine = create_engine(dbpath)
Base.metadata.create_all(engine) # @UndefinedVariable
if not scoped:
# create a configured "Session" class
session = sessionmaker(bind=engine)
# create a Session
return session()
# return session
else:
session_factory = sessionmaker(bind=engine)
return scoped_session(session_factory)
def get_session (database_alias = 'default'):
Session = _session_classes.get(database_alias, None)
if Session is None:
db_settings = settings.DATABASES[database_alias]
port = db_settings['PORT']
engine = create_engine(URL(
ENGINE[db_settings['ENGINE'].split('.')[-1]],
username = db_settings['USER'],
password = db_settings['PASSWORD'],
host = db_settings['HOST'],
port = None if port == '' else port,
database = db_settings['NAME']
), echo = settings.DEBUG)
session_factory = sessionmaker(bind = engine)
Session = scoped_session(session_factory)
_session_classes[database_alias] = Session
return Session
def test_order_clause_list(self):
# This emulates customized comparators which return clause lists
# for .asc and .desc operations.
old_asc = Person.name.asc
expected_expr = OrderClauseList(Person.id.asc(),
Person.name.asc(),
Person.age.asc())
self.assert_equal(str(expected_expr),
'person.id ASC, person.name ASC, person.age ASC')
try:
Person.name.asc = lambda : OrderClauseList(Person.id.asc(),
old_asc())
expr = self._run_visitor('two-asc-asc')
self.assert_equal(str(expr), str(expected_expr))
finally:
Person.name.asc = old_asc
# Make sure the correct ORDER BY clause is generated.
sm = scoped_session(sessionmaker())
sess = sm()
q = sess.query(Person).order_by(expr) # pylint: disable=E1101
q_str = str(q.statement)
self.assert_not_equal(q_str.find("ORDER BY %s" % expr), -1)
def process_message(self, peer, mailfrom, rcpttos, data):
try:
# print(data)
time_received = time.time()
ttl_ts = time_received + self._message_ttl
self._session.add(Message(source=str(peer), sender=str(mailfrom), recipients=str(rcpttos), body=str(data),
time_received=time_received, ttl_ts=ttl_ts))
process_message_hook(peer, mailfrom, rcpttos, data)
if self._message_ttl_enabled:
self._session.query(Message).filter(Message.ttl_ts <= time.time()).delete()
self._session.commit()
self._message_retry_count = 0
with open('message_parsed_file', 'w') as f:
f.write(str(time_received))
except:
self._session.rollback()
self._message_retry_count += 1
if self._message_retry_count > 4:
self._logger.send_error(traceback.format_exc())
self._session = scoped_session(sessionmaker(bind=create_engine(self._conn_str)))
if self._message_retry_count > 5:
raise
self.process_message(peer, mailfrom, rcpttos, data)
def start(self, path):
now = datetime.now()
self.logger.info("**********%s**********" %
now.strftime("%Y-%m-%d %H-%M-%S"))
wb = load_workbook(path) # 加载excel文件
config = yaml.load(wb["配置文件"].cell(row=1, column=1).value)
# config = json.load(open("配置文件.json", encoding="utf-8"))
# 接口地址
self.url = config.get("网址", None)
if not self.url:
self.logger.error("配置文件 中网址为空，程序退出。")
return
self.sleepnum = config.get("休眠时间", 2)
self.ispatch = config.get("补数据", None) == "是"
self.timeslot = config.get("时间段", [])
self.prefixname = config.get("自定义扩展表名", "")
# 加载区域代码
self.area_code = [
str(cell.value) for cell in wb["区域代码"]["A"]
if str(cell.value) != "None"
]
# self.area_code = json.load(
# open("区域代码.json", encoding="utf-8")).get("区域代码", None)
# print(len(self.area_code), self.area_code)
self.logger.debug("area len: {0}, areas: {1}".format(
len(self.area_code), self.area_code))
if not self.area_code:
self.logger.error("区域代码加载失败，请检查")
return
# 加载指标代码
self.kpi_code = [
str(cell.value) for cell in wb["指标代码"]["A"]
if str(cell.value) != "None"
]
# self.kpi_code = json.load(
# open("指标代码.json", encoding="utf-8")).get("指标代码", None)
# print(len(self.kpi_code), self.kpi_code)
self.logger.debug("kpi len: {0}, kpis: {1}".format(
len(self.kpi_code), self.kpi_code))
if not self.kpi_code:
self.logger.error("指标代码加载失败，请检查")
return
# 数据库地址
databaseurl = config.get("数据库连接地址", None)
if not databaseurl:
# print("没有找到数据库连接地址")
self.logger.error("没有找到数据库连接地址")
return
# 采集天数
self.days = config.get("天数", 10)
if self.ispatch and isinstance(self.timeslot, list) and len(
self.timeslot) == 2:
start = datetime.strptime(self.timeslot[0], "%Y-%m-%d")
end = datetime.strptime(self.timeslot[1], "%Y-%m-%d")
if start.year != end.year:
# print("起始时间段必须在同一年")
self.logger.error("起始时间段必须在同一年")
return
# 保证最小的日期在前面
if start > end:
start, end = end, start
else: # 当前日期的前self.days天
start = now + timedelta(days=-self.days)
end = now + timedelta(days=-1)
self.comparenum = config.get("比对差量", 100)
self.threadnum = config.get("线程数", 4)
self.executor = ThreadPoolExecutor(max_workers=self.threadnum)
self.logger.info("线程数量: %s" % str(self.threadnum))
_dates = self._getDates(start, end) # 日期段
try:
engine = create_engine(
databaseurl,
pool_size=self.threadnum,
poolclass=QueuePool,
)
Base.metadata.create_all(engine) # 创建表
self.session = scoped_session(
sessionmaker(bind=engine, autocommit=False, autoflush=True))
except Exception as e:
traceback.print_exc() # 初始化失败
self.logger.error(str(e))
return
# 预发送人
preSheet = wb["预发送"]
if not preSheet:
self.logger.warn("无法找到预发送人表")
self.preSend = []
else:
self.preSend = [
str(cell.value) for cell in preSheet["A"]
if str(cell.value) != "None"
] # list(preSheet.columns)[0]]
self.logger.debug("预发送人: {0}".format(self.preSend))
self._startTasks(path, _dates)
#!/usr/bin/python3
"""
lists all State objects from the database hbtn_0e_6_usa using sqlalchemy
"""
import sys
import os
from sqlalchemy import *
import MySQLdb
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy import MetaData, Table
from model_state import Base, State
if __name__ == '__main__':
engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
sys.argv[1], sys.argv[2], sys.argv[3]))
Session = scoped_session(sessionmaker(bind=engine))
session = Session()
state = session.query(State.id, State.name).first()
metadata = MetaData()
Base.metadata.create_all(engine)
try:
print("{}: {}".format(state[0], state[1]))
except:
print("Nothing")
session.close()
def db_session(self):
session = scoped_session(sessionmaker(bind=self.engine))()
yield session
session.close()
def reload(self):
'''This is the 'reload' method'''
Base.metadata.create_all(self.__engine)
self.__session = scoped_session(sessionmaker(bind=self.__engine))
def init_session(self) -> None:
engine = create_engine("sqlite:///{sqlite_filepath}".format(sqlite_filepath=self.db_path), echo=True)
self.session = scoped_session(sessionmaker())
self.session.configure(bind=engine)
Base.metadata.create_all(engine)
def __init__(self, connection):
""""""
self.engine = sqlalchemy.create_engine(connection)
self.db = scoping.scoped_session(orm.sessionmaker(bind=self.engine))
def __init__(self, connection=None):
self.connection = connection
self.engine = sa.create_engine(self.connection)
self.DBSession = scoping.scoped_session(
orm.sessionmaker(bind=self.engine, autocommit=False))
from sqlalchemy.engine import create_engine
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy.orm.session import sessionmaker, Session
engine = create_engine("sqlite:///:memory:")
session_factory = scoped_session(sessionmaker(bind=engine))
class SqlalchemyContext(object):
def __init__(self):
self._db = session_factory()
@property
def db(self) -> Session:
return self._db
# return self.session_factory()
def cleanup(self, exception=None):
if exception:
self.db.rollback()
return
self.db.commit()
from sqlalchemy import create_engine
from sqlalchemy.orm import Session
username = os.environ['cleardb_username']
pw = os.environ['cleardb_pw']
host = os.environ['cleardb_host']
database = os.environ['cleardb_db']
databaseurl = os.environ['CLEARDB_DATABASE_URL']
SQLALCHEMY_DATABASE_URI = 'mysql://' + username + ":" + pw + host + database
# engine = create_engine('mysql+mysqlconnector://'+username+':'+ pw +'@localhost/movies', pool_recycle=3600)
engine = create_engine(databaseurl, pool_recycle=360, pool_pre_ping=True)
with engine.connect() as connection:
con = connection.execute
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
app.session = scoped_session(SessionLocal,
scopefunc=_app_ctx_stack.__ident_func__)
def request_db():
#queries for 2 random actor names in the database and saves them as session
result_list = [
p for (p, ) in app.session.query(distinct(Movies.actor_name)).order_by(
func.rand()).limit(2)
]
session['result_list'] = result_list
app.session.close()
@app.route('/', methods=['POST', 'GET'])
def index():
request_db()
def prepare_storage(connect_str):
engine = create_engine(connect_str, pool_recycle=7200)
return scoped_session(sessionmaker(bind=engine))
from contextlib import contextmanager
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm.scoping import scoped_session
from app.core.config import settings
engine = create_engine(settings.SQLALCHEMY_DATABASE_URI, pool_pre_ping=True)
Session = sessionmaker(autocommit=False, autoflush=False, bind=engine)
SessionLocal = scoped_session(Session)
@contextmanager
def session_scope():
"""Provide a transactional scope around a series of operations."""
# session = __Session()
session = SessionLocal
try:
yield session
session.commit()
except:
session.rollback()
raise
finally:
session.close()
def create_session(self):
return scoped_session(
sessionmaker(bind=self._engine, autocommit=True, autoflush=False))
class Meta:
abstract = True
sqlalchemy_session = scoped_session(get_session)
sqlalchemy_session_persistence = 'commit'
user_id = Column(Integer, ForeignKey(User.id))
text = Column(Text(collation="utf8_unicode_ci"))
withdraw = Column(Boolean, default=False)
data = Column(DateTime, server_default=func.now())
def __repr__(self):
return '<Transaction %r, %r>' % (self.price, self.text)
class Notice(Base):
__tablename__ = 'notice'
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey(User.id))
text = Column(Text(collation="utf8_unicode_ci"))
hypertext = Column(Unicode(255, collation='utf8_unicode_ci'), default='')
read = Column(Boolean, default=False)
data = Column(DateTime, server_default=func.now())
ban = Column(Boolean, default=False)
engine = create_engine(
'mysql://%s:%s@%s/%s?charset=utf8' %
(school.config['DATABASE_USER'], school.config['DATABASE_PASSWORD'],
school.config['DATABASE_IP'], school.config['DATABASE_NAME']),
encoding='utf8',
echo=False)
Base.metadata.create_all(engine)
Session = scoped_session(sessionmaker())
Session.configure(bind=engine)
# __db_engine = create_engine(config.SQLALCHEMY_DB, listeners=[ForeignKeysListener()], echo=config.SQLALCHEMY_ECHO)
BaseModel.metadata.bind = __db_engine
def db_init():
BaseModel.metadata.create_all(__db_engine)
def db_reset(delete=False):
if delete and os.path.exists(config.SQLITE_FILE):
os.remove(config.SQLITE_FILE)
for table in reversed(BaseModel.metadata.sorted_tables):
db.execute(table.delete())
db.commit()
db_init()
DBSession = scoped_session(sessionmaker(bind=__db_engine))
db = DBSession()
db_init()
def __init__(self, connection_url: str, connect_args: dict = None):
self.url = connection_url
self.engine = create_engine(connection_url, connect_args)
self._session_factory = sessionmaker(bind=self.engine)
# Session is the actual constructor object
self.Session = scoped_session(self._session_factory)
SQLALCHEMY_RECORD_QUERIES = True
'''
SQL DB
'''
# SQLALCHEMY_DATABASE_URI = 'mysql://*****:*****@localhost/reporting'
SQLALCHEMY_DATABASE_URI = 'mysql://' + os.environ.get('MYSQL_USER') + ':' + os.environ.get(
'MYSQL_PASS') + '@' + os.environ.get('MYSQL_HOST') + '/' + os.environ.get('MYSQL_DBNAME')
log = logging.getLogger()
engine = create_engine(SQLALCHEMY_DATABASE_URI, poolclass=NullPool)
db_session = scoped_session(sessionmaker(autocommit=False,
autoflush=False,
bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
'''
Data Processor Constants
'''
BUCKET_NAME = os.environ.get('BUCKET_NAME')
ARCHIVE_BUCKET_NAME = os.environ.get('ARCHIVE_BUCKET_NAME')
QUOTA_VIEW = os.environ.get('QUOTA_VIEW')
USAGE_VIEW = os.environ.get('USAGE_VIEW')
SCHEDULER_HOUR = os.environ.get('SCHEDULER_HOUR')
SCHEDULER_MIN = os.environ.get('SCHEDULER_MIN')
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.types import Enum
from exchange import Exchange, get_exchange_api
from utils import get_conf
conf = get_conf()
if conf.get('dry_run', False):
db_handle = 'sqlite:///tradesv2.dry_run.sqlite'
else:
db_handle = 'sqlite:///tradesv2.sqlite'
engine = create_engine(db_handle, echo=False)
session = scoped_session(
sessionmaker(bind=engine, autoflush=True, autocommit=True))
Session = session()
Base = declarative_base()
class Trade(Base):
__tablename__ = 'trades'
query = session.query_property()
id = Column(Integer, primary_key=True)
exchange = Column(Enum(Exchange), nullable=False)
pair = Column(String, nullable=False)
is_open = Column(Boolean, nullable=False, default=True)
open_rate = Column(Float, nullable=False)
close_rate = Column(Float)
close_profit = Column(Float)
def __init__(self, connection_string):
self.engine = create_engine(connection_string)
self._session_factory = sessionmaker(bind=self.engine)
# Session is the actual constructor object
self.Session = scoped_session(self._session_factory)
sel_signup_date = lambda e: e.cssselect('td span')[6].text
sel_pv = lambda e: e.cssselect('td span')[7].text
sel_network_pv = lambda e: e.cssselect('td span')[8].text
TREE_URL = 'https://www.atomy.kr/v2/Home/MyAtomy/GroupTree2'
DATA_TEMPLATE = "Slevel={}&VcustNo={}&VbuCustName=0&VgjisaCode=1&VgmemberAuth=0&VglevelCnt=0&Vglevel=1&VglevelMax=1&VgregDate=1&VgcustDate=0&VgstopDate=0&VgtotSale=1&VgcumSale=0&VgcurSale=1&VgbuName=1&SDate=2021-02-23&EDate=2021-02-23&glevel=1&glevelMax=1&gbu_name=1&gjisaCode=1&greg_date=1>ot_sale=1&gcur_sale=1"
DB_HOST = os.environ.get('DB_HOST') or 'localhost'
DB_USER = os.environ.get('DB_USER') or 'omc'
DB_PASS = os.environ.get('DB_PASSWORD') or 'omc'
DB_DB = os.environ.get('DB_DB') or 'order_master_common'
engine = create_engine(
f"mysql+mysqldb://{DB_USER}:{DB_PASS}@{DB_HOST}/{DB_DB}?auth_plugin=mysql_native_password&charset=utf8",
pool_size=30,
max_overflow=0)
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
logging.basicConfig(
level=logging.INFO,
force=True,
format="%(asctime)s\t%(levelname)s\t%(threadName)s\t%(name)s\t%(message)s")
logger = logging.getLogger('build_network')
def build_network(username='******',
password='******',
root_id='S5832131',
update=False,
incremental=False,
cont=False,
active=True,
# -*- coding: utf-8 -*-
# Conexión a bases de datos
# Lección 2
# SQLAlchemy: Conexión y sesión
from Leccion_1 import Base
from sqlalchemy.engine import create_engine
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy.orm.session import sessionmaker
engine = create_engine('sqlite:///books.sqlite')
session = scoped_session(sessionmaker(bind=engine))
Base.metadata.bind = engine
class Meta:
model = models.Rate
sqlalchemy_session = scoped_session(get_session, scopefunc=get_session)
import pickle
except ImportError:
import cPickle as pickle
__all_ = ["dynamic_table", "OrmBase", "Model", "MyModel"]
create_engine = partial(
sa.create_engine,
# convert_unicode=True,
pool_recycle=3600,
echo=False,
connect_args={"check_same_thread": False},
poolclass=StaticPool,
)
SESSION = scoped_session(sessionmaker(autocommit=False, autoflush=False))
@contextmanager
def db_write(*args, **kwargs):
""" Provide a transactional scope around a series of operations. """
session = SESSION()
try:
yield session
session.commit()
except Exception as e:
traceback.print_exc()
url = 'mysql+pymysql://root:[email protected]:3306/python01?charset=utf8' engine = create_engine( url, max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=10, # 连接池大小 pool_timeout=30 # 池中没有线程最多等待的时间，否则报错 ) # 创建表结构,已存在表则无需执行 # base.metadata.create_all(engine) # 2. 创建与数据库的会话, class, 不是实例 print("== 实现方式(一) ==") # 使用thread local storage技术, 使 session 线程隔离 SessionFactory = sessionmaker(bind=engine) # 生成session实例, 单例模式, 与线程绑定 session = scoped_session(SessionFactory) # over ''' # print("== 实现方式(二) ==") Session = sessionmaker(bind=engine) # 生成session实例, 每次生成一个新的 session = Session() # over ''' # 3. add stu = Student() Student.set(stu, sid=9, sname='新增9', createTime='2021-08-22 17:25:03') # 把要创建的数据对象添加到这个session里 session.add(stu) # 提交，使前面修改的数据生效
#!/usr/bin/env python
# encoding: utf-8
from os.path import expanduser
import ConfigParser
import sqlalchemy
from sqlalchemy import Column, Integer, String, DateTime, Float
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy import desc
from sqlalchemy import or_
from sqlalchemy.sql import func
config_file = expanduser("~") + '/.opensourcefeeds.cfg'
Config = ConfigParser.ConfigParser()
Config.read(config_file)
engine = create_engine('mysql://%s:%s@%s/%s?charset=utf8&use_unicode=0' % (Config.get('DATABASE', 'username'), Config.get('DATABASE', 'password'), Config.get('DATABASE', 'host'), Config.get('DATABASE', 'database')))
session = scoped_session(sessionmaker(autocommit=False, autoflush=False, bind=engine))
Base = declarative_base()
Base.query = session.query_property()
def reload(self):
Base.metadata.create_all(self.__engine)
self.__session = scoped_session(sessionmaker(bind=self.__engine))
