def main(keep_saved, config_location):
if not config_location:
config_location = os.path.dirname(os.path.abspath(__file__)) + "\\config.ini"
try:
open(config_location)
except IOError:
print "Problem opening config.ini at " + config_location
engine = create_engine(make_connection(config_location), echo=False)
Session = sessionmaker(bind=engine)
session = Session()
Base = declarative_base()
class FeverItems(Base):
__tablename__ = 'fever_items'
id = Column(INTEGER, primary_key=True)
description = Column(LONGTEXT)
is_saved = Column(TINYINT)
records = session.query(FeverItems.description).filter_by(is_saved=1)
contents = []
for record in records:
contents.append(record)
if not keep_saved:
session.query(FeverItems).filter_by(is_saved=1).update({"is_saved": 0})
session.commit()
return contents
if __name__ == "__main__":
main(bool(sys.argv[1]), str(sys.argv[2]))
def make_declarative_base(self,
model=object,
metaclass=DeclarativeMeta,
metadata=None):
"""Creates the declarative base that all models will inherit from.
:param model: base model class (or a tuple of base classes) to pass
to :func:`~sqlalchemy.ext.declarative.declarative_base`. Or a class
returned from ``declarative_base``, in which case a new base class
is not created.
:param metadata: :class:`~sqlalchemy.MetaData` instance to use, or
none to use SQLAlchemy's default.
:param metaclass:
"""
if not isinstance(model, DeclarativeMeta):
model = declarative_base(bind=self.engine,
cls=model,
name='DbModel',
metadata=metadata,
metaclass=metaclass,
class_registry=self._class_registry)
# if user passed in a declarative base and a metaclass for some reason,
# make sure the base uses the metaclass
if metadata is not None and model.metadata is not metadata:
model.metadata = metadata
if not getattr(model, 'query_class', None):
model.query_class = self.Query
model.query = _QueryProperty(self)
return model
def __init__(self, binds):
# Setup mdoels and engines
if not binds:
binds = {}
elif isinstance(binds, str):
binds = {'default': binds}
if 'default' not in binds:
raise ImproperlyConfigured('default datastore not specified')
self._engines = {}
self._declarative_register = {}
self._bases = {}
self._base_declarative = declarative_base(name='OdmBase',
metaclass=DeclarativeMeta)
self.binds = {}
self.is_green = False
for name, bind in tuple(binds.items()):
key = None if name == 'default' else name
engine = create_engine(bind)
dialect = engine.dialect
# Dialect requires Green Pool
if getattr(dialect, 'is_green', False):
self.is_green = True
self._engines[key] = engine
def __init__(self) -> None:
super().__init__()
self.engine: Engine = get_engine(get_database_uri())
self.Model: DeclarativeMeta = declarative_base(bind=self.engine)
for module in sa, sa.orm:
for key in module.__all__:
if not hasattr(self, key):
setattr(self, key, getattr(module, key))
def prepare_schema_connection(model_cls, config_cls):
model_cls.SCHEMA = config_cls.SCHEMA
class Base(object):
__table_args__ = {'schema': config_cls.SCHEMA, 'extend_existing':True}
model_cls.Base = declarative_base(cls=Base)
model_cls.metadata = model_cls.Base.metadata
engine = create_engine("%s://%s:%s@%s/%s" % (config_cls.DBTYPE, config_cls.DBUSER, config_cls.DBPASS, config_cls.DBHOST, config_cls.DBNAME), convert_unicode=True, pool_recycle=3600)
model_cls.Base.metadata.bind = engine
session_maker = sessionmaker(bind=engine)
return session_maker
class Basic:
base = declarative_base()
__url = 'postgresql://{}:{}@{}:{}/{}'
__url = __url.format(dbUserName, dbPassword, dbHost, dbPort, dbName)
con = create_engine(__url, client_encoding='utf8')
meta = sqlalchemy.MetaData(bind=con, reflect=True)
__Session = sessionmaker(con)
session = __Session()
def prepare_schema_connection(dbtype, dbhost, dbname, schema, dbuser, dbpass):
class Base(object):
__table_args__ = {'schema': schema, 'extend_existing': True}
Base = declarative_base(cls=Base)
Base.schema = schema
metadata = Base.metadata
engine_key = "%s://%s:%s@%s/%s" % (dbtype, dbuser, dbpass, dbhost, dbname)
engine = create_engine(engine_key, pool_recycle=3600)
Base.metadata.bind = engine
session_maker = sessionmaker(bind=engine)
return session_maker
def prepare_schema_connection(model_cls, dbtype, dbhost, dbname, schema, dbuser, dbpass):
class Base(object):
__table_args__ = {'schema': schema, 'extend_existing':True}
model_cls.Base = declarative_base(cls=Base)
model_cls.Base.schema = schema
model_cls.metadata = model_cls.Base.metadata
engine_key = "%s://%s:%s@%s/%s" % (dbtype, dbuser, dbpass, dbhost, dbname)
engine = create_engine(engine_key, pool_recycle=3600)
model_cls.Base.metadata.bind = engine
session_maker = sessionmaker(bind=engine)
return session_maker
class AVTables(declarative_base(metaclass=DeclarativeABCMeta)):
__abstract__ = True
@abc.abstractmethod
def serialize(self, recurse=False) -> Mapping[str, SerializedData]: # noqa: E501 pylint: disable=no-self-use
"""Serialize the data so that it can be turned into a JSON format"""
return {}
@classmethod
def serialize_date(cls, date: Optional[datetime.date]):
if isinstance(date, datetime.date):
return date.isoformat()
return None
def init_declarative_base(override_base=None):
global Base
if Base:
return
if override_base:
Base = override_base
else:
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"
}
metadata = MetaData(naming_convention=convention)
Base = declarative_base(metadata=metadata)
def load_dataset_with_columns() -> Generator[SqlaTable, None, None]:
with app.app_context():
engine = create_engine(app.config["SQLALCHEMY_DATABASE_URI"], echo=True)
meta = MetaData()
session = db.session
students = Table(
"students",
meta,
Column("id", Integer, primary_key=True),
Column("name", String(255)),
Column("lastname", String(255)),
Column("ds", Date),
)
meta.create_all(engine)
students.insert().values(name="George", ds="2021-01-01")
dataset = SqlaTable(
database_id=db.session.query(Database).first().id, table_name="students"
)
column = TableColumn(table_id=dataset.id, column_name="name")
dataset.columns = [column]
session.add(dataset)
session.commit()
yield dataset
# cleanup
students_table = meta.tables.get("students")
if students_table is not None:
base = declarative_base()
# needed for sqlite
session.commit()
base.metadata.drop_all(engine, [students_table], checkfirst=True)
session.delete(dataset)
session.delete(column)
session.commit()
def get_base_meta_class(module):
return declarative_base().__class__
import re
from sqlalchemy.ext.declarative.api import declared_attr, has_inherited_table, declarative_base
class _Base_(object):
"""
This class allows us to base the tablename off the class name.
We also check for has_inherited_table, so as not to redeclare.
We make the table name to lower case and underscored.
We don't implement the primary key in base as some classes will use
a foreign key to a parent table as their primary key.
see: http://docs.sqlalchemy.org/en/rel_0_7/orm/extensions/declarative.html#augmenting-the-base
"""
@declared_attr
def __tablename__(self):
if has_inherited_table(self):
return None
name = self.__name__
return (
name[0].lower() +
re.sub(r'([A-Z])', lambda m: "_" + m.group(0).lower(), name[1:]))
__table_args__ = {'mysql_engine': 'InnoDB'}
Base = declarative_base(cls=_Base_)
from sqlalchemy.ext.declarative.api import declarative_base
from puyol.orm.query import PuyolQuery
__author__ = 'USER'
AlchemyBase = declarative_base()
class Base(object):
@classmethod
def get(cls, *criteria, **kwargs):
from puyol.connector import session
return PuyolQuery(session.query(cls), cls, *criteria, **kwargs)
URLS = {
'SQL': os.environ['SUBDB'],
}
#print message or not
parser = argparse.ArgumentParser()
parser.add_argument('-v', '--verbose', action='store_true')
parser.add_argument('-a', '--alerts', action='store_true')
args = parser.parse_args()
if args.verbose:
logging.basicConfig(format="%(levelname)s: %(message)s",
level=logging.DEBUG)
else:
logging.basicConfig(format="%(levelname)s: %(message)s",
level=logging.WARNING)
try:
engine = sqlalchemy.create_engine(URLS['SQL'])
Session = sessionmaker(bind=engine)
Base = declarative_base(bind=engine)
DBSession = sessionmaker(bind=engine)
Base.metadata.create_all(engine)
except Exception:
logging.error('Database is not reachable with provided path : %s',
URLS['SQL'])
logging.error(
'Please check database instance is running and database name exists')
exit(0)
import sqlalchemy as sa
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from sqlalchemy import engine_from_config
from zope.sqlalchemy import ZopeTransactionExtension
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative.api import declarative_base
from seth import db
from seth.db.base import Model
from seth.classy.rest import generics
Base = declarative_base(cls=Model)
# Basic model definition
class SuperModel(Base):
string_column = sa.Column(sa.String(512))
def __repr__(self):
return u"SuperModel {0}".format(self.id)
class SampleResource(generics.GenericApiView):
def get(self):
print SuperModel.query.count()
SuperModel.query.all()
def init_declarative_base(override_base=None):
global Base
if override_base:
Base=override_base
else:
Base = declarative_base()
class BaseCFG(object):
"""
Class that contains custom configuration for a
:func:`sqlalchemy.ext.declarative.declarative_base` to be used with the
ORM. It automatically figures out a tablename (thus no need to set
``__tablename__``).
"""
@declared_attr
def __tablename__(cls): # @NoSelf
return cls.__name__.lower()
def __str__(self):
return unicode(self).encode("utf-8")
Base = declarative_base(cls=BaseCFG)
"""Base class for all ORM classes. Uses :class:`BaseCFG` configuration."""
class RootFactory(object):
"""Skeleton for simple ACL permission protection."""
def __init__(self, request):
self.request = request
def __acl__(self):
from .settings import CTF_BEFORE, CTF_STARTED, CTF_ARCHIVE, CTF_ENDED
permission_map = {
CTF_BEFORE: [
('group:team', ['teams', 'logged_in']),
(Everyone, ['teams', 'login', 'register']),
import datetime
import os
import threading
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm.session import object_session
import sqlalchemy as SA
import time
class tBase(object):
session = property(lambda self: object_session(self))
created_date = SA.Column(SA.DateTime, default=datetime.datetime.utcnow)
modified_date = SA.Column(SA.DateTime, default=datetime.datetime.utcnow, onupdate=SA.text('current_timestamp'))
Base = declarative_base(cls=tBase)
def id_generate():
return IdGenerator.generate()
class IdGenerator(object):
_inc = 0
_inc_lock = threading.Lock()
@staticmethod
def generate():
# 32 bits time
id = (int(time.time()) & 0xffffffff) << 32
# 8 bits pid
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.sql.schema import Column
from sqlalchemy.sql.sqltypes import Integer, CHAR
DB_CONNECT_STRING = 'mysql://*****:*****@127.0.0.1:3306/test?charset=utf8&use_unicode=1'
params = {'pool_recycle': 60, 'echo_pool': True, 'pool_size': 500, 'echo': True}
engine = create_engine(DB_CONNECT_STRING, *(), **params)
# engine = create_engine(DB_CONNECT_STRING)
DB_Session = sessionmaker(bind=engine)
session = DB_Session()
# declarative_base() 创建了一个 BaseModel 类，这个类的子类可以自动与一个表关联。
BaseModel = declarative_base()
class User(BaseModel):
__tablename__ = 'user'
id = Column('id', Integer, primary_key=True)
name = Column('name', CHAR(30)) # or Column(String(30))
def init_db():
# BaseModel.metadata.create_all(engine) 会找到 BaseModel 的所有子类，并在数据库中建立这些表;
BaseModel.metadata.create_all(engine)
def drop_db():
BaseModel.metadata.drop_all(engine)
init_db()
import os
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from eventsourcing.infrastructure.datastore import Datastore, DatastoreConnectionError, DatastoreSettings
ActiveRecord = declarative_base()
DEFAULT_SQLALCHEMY_DB_URI = 'sqlite:///:memory:'
class SQLAlchemySettings(DatastoreSettings):
DB_URI = os.getenv('DB_URI', DEFAULT_SQLALCHEMY_DB_URI)
def __init__(self, uri=DEFAULT_SQLALCHEMY_DB_URI):
self.uri = uri or self.DB_URI
class SQLAlchemyDatastore(Datastore):
def __init__(self, base=ActiveRecord, tables=None, connection_strategy='plain',
# connect_args=None, poolclass=None,
**kwargs):
super(SQLAlchemyDatastore, self).__init__(**kwargs)
self._session = None
self._engine = None
self._base = base
self._tables = tables
self._connection_strategy = connection_strategy
"""
Created on Nov 29, 2013
@author: be07336
"""
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy.schema import Column, ForeignKey
from sqlalchemy.types import Integer, String, NUMERIC
from model.connection import ConnectionManager
Base = declarative_base(bind=ConnectionManager.get_instance().get_engine())
class Candidate(Base):
"""
Candidate class
"""
__tablename__ = 'CANDIDATE'
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
year = Column(String)
destination = Column(String)
company = Column(String)
evaluations = relationship(
"Evaluation", primaryjoin="Candidate.id == Evaluation.candidate")
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.sql.schema import Column
from sqlalchemy.sql.sqltypes import Integer, String, DateTime, Text
import datetime
DBSession = scoped_session(sessionmaker())
Base = declarative_base()
class JobModel(Base):
__tablename__ = 'jobs'
id = Column(Integer, primary_key=True)
city = Column(String(100), nullable=False)
companyLogo = Column(String(150))
companySize = Column(String(30))
companyName = Column(String(30), nullable=False)
industryField = Column(String(30))
financeStage = Column(String(30))
website = Column(String(50))
salary = Column(String(30), nullable=False)
jobNature = Column(String(50))
createTime = Column(DateTime,
default=datetime.datetime.now,
nullable=False)
positionName = Column(String(30), nullable=False)
positionType = Column(String(30))
from sqlalchemy import *
from sqlalchemy.orm import relationship, backref
from sqlalchemy.schema import Column, Sequence, PrimaryKeyConstraint, ForeignKey
from sqlalchemy.types import Integer, String
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm.session import sessionmaker
engine = create_engine("sqlite:///development.sqlite3", echo=False)
Base = declarative_base(engine)
documents_tags = Table(
"documents_tags",
Base.metadata,
Column("document_id", Integer, ForeignKey("documents.id")),
Column("tag_id", Integer, ForeignKey("tags.id")),
)
authors_documents = Table(
"authors_documents",
Base.metadata,
Column("author_id", Integer, ForeignKey("authors.id")),
Column("document_id", Integer, ForeignKey("documents.id")),
)
class Document(Base):
__tablename__ = "documents"
id = Column(Integer, Sequence("document_id_seq"), primary_key=True)
from sqlalchemy.engine import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.schema import Column, Sequence
from sqlalchemy.types import Integer, String, DateTime
#definicao do banco de dados
DATABASE="sqlite:///blog.db"
engine = create_engine(DATABASE, echo=True)
BASE = declarative_base(engine)
class Post(BASE):
""" modelo de post """
__tablename__ = 'posts'
id = Column(Integer, Sequence('post_id_seq'), primary_key=True)
title = Column(String(250))
content = Column(String())
date=Column(DateTime())
def __init__(self, title, content, date):
self.title = title
self.content = content
self.date = date
def __repr__(self):
return "<User('%s','%s', '%s')>" % (self.id, self.title, self.date)
#essa linha roda na primeira vez que o modulo eh carregado e apenas uma vez
BASE.metadata.create_all(engine)
def rebind(self, database_uri: str):
self.engine = get_engine(database_uri)
self.Model = declarative_base(bind=self.engine, metadata=self.metadata)
# create_table_orm.py
from sqlalchemy import Column, String, INTEGER, DateTime
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import sessionmaker
BASE = declarative_base()
# 定义学生对象
class Company(BASE):
# 表的名字:STUDENT
__tablename__ = 'tab_company'
# id
id = Column(INTEGER,primary_key=True)
# 表号
name = Column(String(20))
#创建时间
createTime=Column(DateTime)
#创建人
createUser=Column(String(50))
# 创建表的参数
__table_args__ = {
"mysql_charset": "utf8"
}
def __str__(self): # 格式输出查询出的数据
return '%s,%s,%s,%s' % (self.id, self.name,self.createTime,self.createUser)
from sqlalchemy.ext.declarative.api import declarative_base
vxlan_id = -1
vm_id = 0
BASEOBJ = declarative_base()
class base(BASEOBJ):
"""Base class for Nova and Glance Models"""
__abstract__ = True
__table_args__ = {'mysql_engine': 'InnoDB'}
__table_initialized__ = False
class test(base):
""" Base class for resource type object """
__abstract__ = True
_resource_name_ = None
_alias_name_ = None
__protected_attributes__ = set([
"created_at", "updated_at", "deleted_at", "deleted"])
class g_var(object):
def __init__(self):
global vxlan_id
pass
@classmethod
def print_cls(cls):
print cls.__class__
class ModelBase:
Base = declarative_base()
from sqlalchemy import Column, types
import datetime
from mittn.issue import Issue
from sqlalchemy.ext.declarative.api import declarative_base
import json
import socket
HOSTNAME = socket.gethostbyname(socket.gethostname())
Base = declarative_base(cls=Issue)
class ScannerIssue(Base):
__tablename__ = 'headlessscanner_issues'
# We use LargeBinary in message because it can be very big
# XXX fields that are used in all tools come from issue.py
severity = Column(types.Text)
issuetype = Column(types.Text)
issuename = Column(types.Text)
issuedetail = Column(types.Text)
confidence = Column(types.Text)
host = Column(types.Text)
port = Column(types.Text)
protocol = Column(types.Text)
messages = Column(types.LargeBinary)
def unique_fields(self):
""" These fields are used when checking for false
import logging
db_ip = "112.74.48.66"
db_port = "3306"
#用户
db_user = "******"
#密码
db_password = "******"
#数据库名
db_name = "bs_user"
#目标路径
target_location = 'mysql+pymysql://'+db_user+':'+db_password+'@'+db_ip+':3306/'+db_name
#相应的数据库表名
tb_accountFund = "accountfunds"
DynamicBase = declarative_base(class_registry=dict())
engine = sqlalchemy.create_engine(target_location)
def insert_funds(property_list):
pass
def delete_content(table_name,user_field,user_id):
conn = engine.connect()
try:
delete_str = "DELETE FROM "+ table_name +" WHERE "+ user_field + " = " + user_id
conn.connect()
conn.execute(delete_str)
except Exception as e:
logging.exception('erorr msg')
#if no env variable has been defined, a default one is set
if not(os.environ.has_key("SUBDB")):
os.environ['SUBDB'] = 'mysql://*****:*****@127.0.0.1:3306/sub_ai'
URLS = {
'SQL':os.environ['SUBDB'],
}
#print message or not
parser = argparse.ArgumentParser()
parser.add_argument('-v','--verbose',action='store_true')
parser.add_argument('-a','--alerts',action='store_true')
args = parser.parse_args()
if args.verbose:
logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG)
else:
logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.WARNING)
try:
engine = sqlalchemy.create_engine(URLS['SQL'])
Session = sessionmaker(bind=engine)
Base = declarative_base(bind=engine)
DBSession = sessionmaker(bind = engine)
Base.metadata.create_all(engine)
except Exception:
logging.error('Database is not reachable with provided path : %s',URLS['SQL'])
logging.error('Please check database instance is running and database name exists')
exit(0)
@declared_attr
def __tablename__(self):
if has_inherited_table(self):
return None
name = self.__name__
return (
name[0].lower() +
re.sub(r'([A-Z])', lambda m:"_" + m.group(0).lower(), name[1:])
)
__table_args__ = {'mysql_engine': 'InnoDB'}
Base = declarative_base(cls=_Base_)
def connect(url):
engine = create_engine(url)
Session = sessionmaker(autocommit=False,
autoflush=False,
bind=engine)
return Session
def create_all(engine):
Base.metadata.create_all(engine)
def drop_all(session):
String,
Time,
UniqueConstraint,
)
from sqlalchemy.dialects.postgresql import TSVECTOR
from sqlalchemy.exc import IntegrityError, SQLAlchemyError
from sqlalchemy.ext.declarative.api import declarative_base, DeclarativeMeta
from sqlalchemy.orm import relationship, Session
from sqlalchemy.sql.schema import CheckConstraint
from app.config import PSQL_ENVIRONMENT
from app.dependencies import logger
from app.internal.privacy import PrivacyKinds
import app.routers.salary.config as SalaryConfig
Base: DeclarativeMeta = declarative_base()
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
username = Column(String, unique=True, nullable=False)
email = Column(String, unique=True, nullable=False)
password = Column(String, nullable=False)
full_name = Column(String)
description = Column(String, default="Happy new user!")
avatar = Column(String, default="profile.png")
telegram_id = Column(String, unique=True)
is_active = Column(Boolean, default=False)
disabled = Column(Boolean, default=False, nullable=False)
import os
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from eventsourcing.infrastructure.datastore import Datastore, DatastoreConnectionError, DatastoreSettings
ActiveRecord = declarative_base()
DEFAULT_SQLALCHEMY_DB_URI = 'sqlite:///:memory:'
class SQLAlchemySettings(DatastoreSettings):
DB_URI = os.getenv('DB_URI', DEFAULT_SQLALCHEMY_DB_URI)
def __init__(self, uri=DEFAULT_SQLALCHEMY_DB_URI):
self.uri = uri or self.DB_URI
class SQLAlchemyDatastore(Datastore):
def __init__(self, base=ActiveRecord, tables=None, connection_strategy='plain',
# connect_args=None, poolclass=None,
**kwargs):
super(SQLAlchemyDatastore, self).__init__(**kwargs)
self._session = None
self._engine = None
self._base = base
self._tables = tables
self._connection_strategy = connection_strategy
from wsgiref.simple_server import make_server
import sqlalchemy as sa
from sqlalchemy import engine_from_config
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative.api import declarative_base
from zope.sqlalchemy import ZopeTransactionExtension
from marshmallow import Schema, fields
from seth import db
from seth import filtering
from seth.classy.rest import generics
from seth.db.base import TimeStampedModel
Base = declarative_base(cls=TimeStampedModel)
# Basic model definition
class SuperModel(Base):
string_column = sa.Column(sa.String(512))
# Define model filter
class SuperModelFilters(filtering.FilterFactory):
model = SuperModel
string_column = filtering.CharFilter()
# Basic schema definition - TimeStampedModel predefines four fields:
# id, is_deleted, created_at, updated_at
import re
import sys
from tempfile import NamedTemporaryFile
from sqlalchemy.engine import create_engine
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.schema import MetaData, Column
from sqlalchemy.types import Integer, Float, String
# connstr = 'sqlite://'
## four slashes for absolute paths - three for relative
connstr = 'sqlite:///{0}'.format('/tmp/profile.sqlite')
engine = create_engine(connstr)
metadata = MetaData(bind=engine)
Base = declarative_base(metadata=metadata)
Session = sessionmaker(bind=engine)
class Results(Base):
__tablename__ = 'results'
rid = Column(Integer, primary_key=True)
ncalls = Column(Integer)
tottime = Column(Float)
filename = Column(String)
percall_tottime = Column(Float)
cumtime = Column(Float)
percall_cumtime = Column(Float)
class ExecutionInfo(Base):
def get_base_meta_class(module):
return declarative_base().__class__
from sqlalchemy.ext.declarative import api
from sqlalchemy.ext.declarative import declared_attr
from datetime import datetime
from sqlalchemy import Column, Integer, Boolean, Float, ARRAY, DateTime, BigInteger
class BaseModel(object):
@declared_attr
def __tablename__(cls):
return cls.__name__.lower()
id = Column(BigInteger, primary_key=True)
created_at = Column(
DateTime, default=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"))
updated_at = Column(
DateTime,
default=datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
onupdate=datetime.utcnow().strftime('"%Y-%m-%d %H:%M:%S"'))
Base = api.declarative_base(cls=BaseModel)
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy.sql.schema import ForeignKey, Column
from sqlalchemy.sql.sqltypes import Integer, String
__author__ = 'chiesa'
BASE = declarative_base()
class Managers(BASE):
__tablename__ = 'managers'
id = Column(Integer, primary_key=True)
name = Column(String)
class Employees(BASE):
__tablename__ = 'employees'
id = Column(Integer, primary_key=True)
name = Column(String)
surname = Column(String)
manager_id = Column(Integer, ForeignKey('managers.id'))
manager = relationship(Managers, backref='employees')
class Context(object):
'''
Singelton context of a running instance providing general information / configuration
'''
configuration = None
base = declarative_base()
version = "$EOSS_PROJECT_ID$"
orm_initialized = None
def __init__(self, url=None):
'''
Singelton context of a running instance providing general information / configuration
'''
self.version = 'v1'
if url == None:
self.url = read_OS_var("EOSS_CATALOG_DB", mandatory=False)
else:
self.url = url
if self.orm_initialized is None:
assert self.url != None, 'Please specify DB connection with EOSS_CATALOG_DB'
self.init_orm()
def __str__(self):
return "<EOSS context version:%s>" % (self.version)
def init_orm(self):
"""
Initualize ORM component and create tables if necessary.
:param url: sqlalchemy compatible DB url string
:return: None - set sqlalchemy session as class attribute
"""
prog = os.path.basename(sys.argv[0]) or 'eoss-api'
username = pwd.getpwuid(os.getuid()).pw_name
hostname = socket.gethostname().split(".")[0]
self.engine = create_engine(
self.url,
# pool_size=10,
# max_overflow=5,
# pool_recycle=600,
connect_args={
'application_name': "%s:%s@%s" % (prog, username, hostname)
},
poolclass=NullPool)
self.getBase().metadata.create_all(self.engine)
# metadata = schema.MetaData()
self.session_factory = sessionmaker(bind=self.engine,
autocommit=False,
autoflush=False,
expire_on_commit=True)
self.session = scoped_session(self.session_factory)
self.base.metadata.create_all(self.engine)
self.orm_initialized = True
def getSession(self):
'''
Return sqlalchemy session (http://docs.sqlalchemy.org/en/latest/orm/session_api.html)
:return:
'''
return self.session()
def closeSession(self):
self.session.remove()
def get_engine(self):
"""
Get DB engine from sqlalchemy for direct manipulation
(http://docs.sqlalchemy.org/en/latest/core/connections.html?highlight=engine#module-sqlalchemy.engine)
:return: sqlalchemy db engine
"""
return self.engine
def getBase(self):
"""
Return sqlalchemy base necessary for table registrations (http://docs.sqlalchemy.org/en/latest/orm/extensions/declarative/api.html)
:return:
"""
return self.base
def __new__(cls, *attr, **kwargs):
""" Handle Context object as singelton"""
if not hasattr(cls, '_inst'):
cls._inst = super(Context, cls).__new__(cls, *attr, **kwargs)
return cls._inst
import os
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.orm.scoping import scoped_session
from sqlalchemy.ext.declarative.api import declarative_base
import sqlalchemy
BASE = os.path.dirname(__file__)
Engine = sqlalchemy.create_engine('sqlite:///%s'%(os.path.join(BASE, "data.db")), echo=True)
Entity = declarative_base(bind=Engine)
session_factory = sessionmaker(bind=Engine)
session = scoped_session(session_factory=session_factory)
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm.session import sessionmaker
from sqlalchemy.types import Integer, Float, String
from tempfile import NamedTemporaryFile, mkdtemp
import sys
import re
import os
import shutil
#connstr = 'sqlite://'
## four slashes for absolute paths - three for relative
connstr = 'sqlite:///{0}'.format('/tmp/profile.sqlite')
engine = create_engine(connstr)
metadata = MetaData(bind=engine)
Base = declarative_base(metadata=metadata)
Session = sessionmaker(bind=engine)
class Results(Base):
__tablename__ = 'results'
rid = Column(Integer,primary_key=True)
ncalls = Column(Integer)
tottime = Column(Float)
filename = Column(String)
percall_tottime = Column(Float)
cumtime = Column(Float)
percall_cumtime = Column(Float)
class ExecutionInfo(Base):
#!/usr/bin/python # -*- coding: utf-8 -*- #coding=utf-8 """ Create On 2015年11月11日 @deprecated: 构造持久化类基类：Base @author: Linked """ from sqlalchemy.ext.declarative.api import declarative_base Base = declarative_base() #持久化的Base类
def legacy_database_fixer(database_path, database, database_name,
database_exists):
database_directory = os.path.dirname(database_path)
old_database_path = database_path
old_filename = os.path.basename(old_database_path)
new_filename = f"Pre_Alembic_{old_filename}"
pre_alembic_path = os.path.join(database_directory, new_filename)
pre_alembic_database_exists = False
if os.path.exists(pre_alembic_path):
database_path = pre_alembic_path
pre_alembic_database_exists = True
datas = []
if database_exists:
Session, engine = db_helper.create_database_session(database_path)
database_session = Session()
result = engine.dialect.has_table(engine, 'alembic_version')
if not result:
if not pre_alembic_database_exists:
os.rename(old_database_path, pre_alembic_path)
pre_alembic_database_exists = True
if pre_alembic_database_exists:
Session, engine = db_helper.create_database_session(pre_alembic_path)
database_session = Session()
api_table = database.api_table()
media_table = database.media_table()
Base = declarative_base()
# DON'T FORGET TO REMOVE
# database_name = "posts"
# DON'T FORGET TO REMOVE
legacy_api_table = api_table.legacy(Base, database_name)
legacy_media_table = media_table.legacy(Base)
result = database_session.query(legacy_api_table)
post_db = result.all()
for post in post_db:
post_id = post.id
created_at = post.created_at
new_item = {}
new_item["post_id"] = post_id
new_item["text"] = post.text
new_item["price"] = post.price
new_item["paid"] = post.paid
new_item["postedAt"] = created_at
new_item["medias"] = []
result2 = database_session.query(legacy_media_table)
media_db = result2.filter_by(post_id=post_id).all()
for media in media_db:
new_item2 = {}
new_item2["media_id"] = media.id
new_item2["post_id"] = media.post_id
new_item2["links"] = [media.link]
new_item2["directory"] = media.directory
new_item2["filename"] = media.filename
new_item2["size"] = media.size
new_item2["media_type"] = media.media_type
new_item2["downloaded"] = media.downloaded
new_item2["created_at"] = created_at
new_item["medias"].append(new_item2)
datas.append(new_item)
print
database_session.close()
x = export_sqlite(old_database_path,
datas,
database_name,
legacy_fixer=True)
print
"""
Created on Nov 29, 2013
@author: be07336
"""
from sqlalchemy.ext.declarative.api import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy.schema import Column, ForeignKey
from sqlalchemy.types import Integer, String, NUMERIC
from model.connection import ConnectionManager
Base = declarative_base(bind=ConnectionManager.get_instance().get_engine())
class Candidate(Base):
"""
Candidate class
"""
__tablename__ = 'CANDIDATE'
id = Column(Integer, primary_key=True)
name = Column(String)
email = Column(String)
year = Column(String)
destination = Column(String)
company = Column(String)
evaluations = relationship("Evaluation", primaryjoin="Candidate.id == Evaluation.candidate")
others = relationship("Document", primaryjoin="and_(Candidate.id == Document.candidate,"
if redis_config["pass"]:
redis_url = "redis://:" + redis_config["pass"] + "@" + redis_config[
"host"] + ":" + redis_config["port"]
rds_instance = redis.Redis(host=redis_config["host"],
port=redis_config["port"],
password=redis_config["pass"])
else:
redis_url = "redis://" + redis_config["host"] + ":" + redis_config["port"]
rds_instance = redis.Redis(host=redis_config["host"],
port=redis_config["port"])
mongo_url = "mongodb://{username}:{password}@{host}:{port}".format(
username=get_config("MONGODB_USERNAME", ""),
password=get_config("MONGODB_PASSWORD", ""),
host=get_config("MONGODB_HOST", "mongodb"),
port=get_config("MONGODB_PORT", "27017"))
engine = create_engine(mysql_url)
metadata = MetaData()
Base = declarative_base()
# Base.prepare(engine, reflect=True)
db_session = scoped_session(
sessionmaker(autocommit=False, autoflush=False, bind=engine))
Base.query = db_session.query_property()
def init_declarative_base(override_base=None):
global Base
if override_base:
Base = override_base
else:
Base = declarative_base()
