def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
# dropping all tables then creating all of them for a migration for
# fixture test data
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
#TODO: Write tests for this
fixture_helper = FixtureHelper(dbsession)
fixture_helper.character_data()
fixture_helper.account_data()
fixture_helper.item_data()
fixture_helper.recipe_data()
fixture_helper.ingredient_data()
fixture_helper.action_data()
def run(self, shell=None):
if self.args.list:
return self.show_shells()
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
loader = self.get_config_loader(config_uri)
loader.setup_logging(config_vars)
self.pshell_file_config(loader, config_vars)
self.env = self.bootstrap(config_uri, options=config_vars)
# remove the closer from the env
self.closer = self.env.pop('closer')
try:
if shell is None:
try:
shell = self.make_shell()
except ValueError as e:
self.out(str(e))
return 1
with self.setup_env():
shell(self.env, self.help)
finally:
self.closer()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
#model = MyModel(name='one', value=1)
#DBSession.add(model)
perm_item_manage = Permission()
perm_item_manage.name = 'item'
DBSession.add(perm_item_manage)
perm_user_manage = Permission()
perm_user_manage.name = 'user'
DBSession.add(perm_user_manage)
perm_order_manage = Permission()
perm_order_manage.name = 'order'
DBSession.add(perm_order_manage)
gadmin = Group()
gadmin.name = 'Administrators'
gadmin.permissions.append(perm_item_manage)
gadmin.permissions.append(perm_order_manage)
gadmin.permissions.append(perm_user_manage)
DBSession.add(gadmin)
admin = User()
admin.name = 'admin'
admin.password = '******'
admin.email = 'admin@localhost'
admin.group = gadmin
DBSession.add(admin)
cat_food = Category()
cat_food.name = 'Food'
DBSession.add(cat_food)
cat_fruit = Category()
cat_fruit.name = 'Fruit'
cat_fruit.parent = cat_food
DBSession.add(cat_fruit)
cat_vegetable = Category()
cat_vegetable.name = 'Vegetable'
cat_vegetable.parent = cat_food
DBSession.add(cat_vegetable)
iapple = Item()
iapple.name = 'Apple'
iapple.description = '<h2>This is a <span style="color:red;">red</span> apple</h2>'
iapple.price = 1.3
iapple.category = cat_fruit
DBSession.add(iapple)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = MyModel(name='one', value=1)
DBSession.add(model)
message1 = Message(msgid = 'c1', content = 'yoloswag1', timestamp = '5.11.2015')
message2 = Message(msgid = 'c2', content = 'yoloswag2', timestamp = '5.11.2015')
DBSession.add(message1)
DBSession.add(message2)
delmessage = DelMessage(msgid = 'c1', timestamp = '6.11.2015')
DBSession.add(delmessage)
DBSession.delete(model)
DBSession.delete(message1)
DBSession.delete(message2)
DBSession.delete(delmessage)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# create one pupil named hans
pupil1 = Pupil(name='Hans')
# create a classbook entry
eintrag1 = Entry(
date=datetime.date.today(),
lesson_no=1,
attendance=True,
# delay=25,
)
# add the entry to hans
eintrag1.pupil = [pupil1]
# now add them to the database for persistence
DBSession.add(pupil1)
DBSession.add(eintrag1)
def main(argv=None):
"""
Main entrypoint for the initdb
"""
if argv is None:
argv = sys.argv
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
model = MemberModel(fname='John',
lname='Everyuser',
member_id='3333',
active=True)
dbsession.add(model)
def main(argv=None):
if argv is None:
argv = sys.argv
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
session_factory = get_session_factory(engine)
session = get_tm_session(session_factory, transaction.manager)
context = zmq.Context()
subscriber = context.socket(zmq.SUB)
subscriber.setsockopt(zmq.SUBSCRIBE, b"")
subscriber.setsockopt(zmq.RCVTIMEO, __timeoutEDDN)
ncarcount = 0
ucarcount = 0
messages = 0
totmsg = 0
hmessages = 0
mkupdates = 0
rpmsg = 0
print("Starting EDDN client.")
while True:
try:
subscriber.connect(__relayEDDN)
while True:
__message = subscriber.recv()
if not __message:
subscriber.disconnect(__relayEDDN)
break
__message = zlib.decompress(__message)
__json = simplejson.loads(__message)
totmsg = totmsg + 1
print(
f"EDDN Client running. Messages: {messages:10} New carriers: {ncarcount:10} "
f"Updated carriers: {ucarcount:10} Market updates: {mkupdates}\r",
end='')
if validsoftware(__json['header']['softwareName'], __json['header']['softwareVersion']) \
and __json['$schemaRef'] in __allowedSchema:
hmessages = hmessages + 1
data = __json['message']
messages = messages + 1
upd = process_eddn(session, data)
mkupdates = mkupdates + upd['new_commodities']
ucarcount = ucarcount + upd['updated_carriers']
ncarcount = ncarcount + upd['new_carriers']
sys.stdout.flush()
except zmq.ZMQError as e:
print('ZMQSocketException: ' + str(e))
sys.stdout.flush()
subscriber.disconnect(__relayEDDN)
time.sleep(5)
def main(argv=sys.argv):
if len(argv) < 2:
config_uri = input("Config URI: ")
else:
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
session_factory = get_session_factory(engine)
dbsession = get_tm_session(session_factory, transaction.manager)
first_name = input("First Name: ")
last_name = input("Last Name: ")
email = input("Email: ")
while True:
password = input("Password: "******"Confirm Password: "******"Password and confirm password did not match.")
else:
break
with transaction.manager:
user = User()
user.first_name = first_name
user.last_name = last_name
user.set_password(password)
user.email = email
dbsession.add(user)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
print("Running {} with {}".format(os.path.basename(argv[0]), argv[1]))
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
if options.get('create_tables'):
Base.metadata.create_all(engine)
with transaction.manager:
model = Person(first_name="John",
middles="William",
last_name="Coltrane",
email="*****@*****.**",
street="342 W 12th St Apt 3C",
city="New York",
state="NY",
country="USA",
post_code="10012")
DBSession.add(model)
print("Added Person '{model.name}'".format(model=model))
model = Person(first_name="Alfred",
middles="McCoy",
last_name="Tyner",
email="*****@*****.**",
street="342 W 12th St 3D",
city="New York",
state="NY",
country="USA",
post_code="10012")
DBSession.add(model)
print("Added Person '{model.name}'".format(model=model))
def main(argv=sys.argv):
"""Synchronize files to database."""
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri)
settings.update(options)
settings = get_config(settings=settings).get_settings()
engine = get_engine(settings)
session_factory = get_session_factory(engine)
datadirectory = settings.get('datadirectory')
if datadirectory is None:
raise ValueError('datadirectory not defined')
datadirectory = Path(datadirectory)
# Add the directories to be synchronized here.
with transaction.manager:
session = get_tm_session(session_factory, transaction.manager)
paths = datadirectory.joinpath('cpt').glob('**/*.csv')
sync_files_to_db(session, CptFile, paths, script=SCRIPT)
with transaction.manager:
session = get_tm_session(session_factory, transaction.manager)
paths = datadirectory.joinpath('psd').glob('**/*.csv')
sync_files_to_db(session, PsdFile, paths, script=SCRIPT)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
#model = MyModel(name='one', value=1)
#DBSession.add(model)
megan_user = Users.create_user(
session = DBSession,
username = '******',
password = '******',
name = 'Megan',
)
DBSession.add(megan_user)
tim_user = Users.create_user(
session = DBSession,
username = '******',
password = '******',
name = 'Tim',
)
DBSession.add(tim_user)
transaction.commit()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
user1 = User(email='*****@*****.**', status='active')
dbsession.add(user1)
user2 = User(email='*****@*****.**', status='active')
dbsession.add(user2)
user3 = User(email='*****@*****.**', status='active')
dbsession.add(user3)
rat = Rat(name="rat1", platform='pc', user=user1.id)
dbsession.add(rat)
rat = Rat(name="rat2", platform='xb', user=user2.id)
dbsession.add(rat)
rat = Rat(name="rat3", platform='ps', user=user3.id)
dbsession.add(rat)
def run(self):
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
self.setup_logging(config_uri, global_conf=config_vars)
env = self.bootstrap(config_uri, options=config_vars)
registry = env['registry']
tweens = self._get_tweens(registry)
if tweens is not None:
explicit = tweens.explicit
if explicit:
self.out('"pyramid.tweens" config value set '
'(explicitly ordered tweens used)')
self.out('')
self.out('Explicit Tween Chain (used)')
self.out('')
self.show_chain(tweens.explicit)
self.out('')
self.out('Implicit Tween Chain (not used)')
self.out('')
self.show_chain(tweens.implicit())
else:
self.out('"pyramid.tweens" config value NOT set '
'(implicitly ordered tweens used)')
self.out('')
self.out('Implicit Tween Chain')
self.out('')
self.show_chain(tweens.implicit())
return 0
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
editor = User(name='editor', role='editor')
editor.set_password('editor')
dbsession.add(editor)
basic = User(name='basic', role='basic')
basic.set_password('basic')
dbsession.add(basic)
page = Page(
name='FrontPage',
creator=editor,
data='This is the front page',
)
dbsession.add(page)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options,
name='appenlight_demo')
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
for x in range(1, 20):
model = User(username='******'.format(x))
dbsession.add(model)
model.addresses.append(Address(
address='Street {}'.format(x),
phone='123-456-77{}'.format(x))
)
for x in range(1, 30):
model = Forum(forum='forum_{}'.format(x))
dbsession.add(model)
for x in range(1, 70):
model = Post(post='post_{}'.format(x),
forum_id=random.randint(1, 20))
dbsession.add(model)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
#with transaction.manager:
# model = MyModel(name='one', value=1)
# DBSession.add(model)
c = Customers.add(
session = DBSession,
name = "GE",
description = "General Electric Corp."
)
a = Accounts.add(
session = DBSession,
customer_id = c.id,
name = 'GE Location X',
description = 'The GE Plant at Location X',
)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
# initial encryption passphrase set to ''
salt = os.urandom(32)
password = bytes(
input(
"If you would like to set a password, please enter it now. Otherwise, just press enter. > "
).encode())
# initial password is the empty string
enc_key = gen_key_from_salt_and_password(salt, password)
f = Fernet(enc_key)
secret_exponent_bytes = os.urandom(32)
secret_exponent = convert_se_bytes(secret_exponent_bytes)
address = Key(
secret_exponent=secret_exponent,
netcode=NET_CODE['bitcoin']).address(use_uncompressed=USE_COMPRESSED)
with transaction.manager:
model = KeyStore(name=PRIMARY,
encrypted=f.encrypt(secret_exponent_bytes),
salt=salt,
address=address)
DBSession.add(model)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = User(name=u'admin', password=u'admin')
DBSession.add(model)
from jinja2.utils import generate_lorem_ipsum
for id, article in enumerate(range(100), start=1):
title = generate_lorem_ipsum(
n=1, # Одно предложение
html=False, # В виде обычного текста
min=2, # Минимум 2 слова
max=5 # Максимум 5
)
content = generate_lorem_ipsum()
article = Article(**{'title': title, 'content': content})
DBSession.add(article)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
settings["sqlalchemy.url"] = os.environ["DATABASE_URL"]
engine = get_engine(settings)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
many_models = []
for item in ENTRIES:
new_entry = Entry(
title=item['title'],
body=item['body'],
creation_date=datetime.now(),
)
many_models.append(new_entry)
dbsession.add_all(many_models)
def main(argv=sys.argv):
"""Function that enables initializedb CLI command.
"""
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
# Creates a connection to the DB
engine = get_engine(settings)
# Creates tables for our models in the DB
Base.metadata.create_all(engine)
# Below is used for seeding the DB
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
roles = ['admin', 'view']
for role in roles:
model = AccountRole(name=role)
dbsession.add(model)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
post = Post(
date=datetime.date.today(),
title='It Works!',
body=
('''If you see this then your install went correctly, congratulations\n'''
'''\n'''
'''What's next?\n'''
'''============\n'''
'''\n'''
'''That is up to you.'''))
dbsession.add(post)
def main():
''' main entry point '''
if len(sys.argv) < 2:
usage()
config_uri = sys.argv[1]
options = parse_vars(sys.argv[2:])
setup_logging(config_uri)
global log
log = logging.getLogger(__name__)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
global cache_dir
cache_dir = settings['cache.dir'] + "/aws_pricing/"
try:
delta = datetime.now() - datetime.fromtimestamp(os.path.getmtime(\
cache_dir+PRICE_INDEX))
if delta.days > 1 or os.path.getsize(cache_dir+PRICE_INDEX) == 0:
collect_data()
else:
log.error('Data has been downloaded recently. Skipping download...')
load_products()
load_prices()
except OSError as exc:
log.error(exc.message)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = MyModel(name='one', value=1)
DBSession.add(model)
message1 = Message(msgid='c1',
content='yoloswag1',
timestamp='5.11.2015')
message2 = Message(msgid='c2',
content='yoloswag2',
timestamp='5.11.2015')
DBSession.add(message1)
DBSession.add(message2)
delmessage = DelMessage(msgid='c1', timestamp='6.11.2015')
DBSession.add(delmessage)
DBSession.delete(model)
DBSession.delete(message1)
DBSession.delete(message2)
DBSession.delete(delmessage)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
model = MyModel(name='one', value=1)
try:
dbsession.add(model)
except Exception as e:
print(e)
first_bucket = Bucket(bucketNumber=1024, bucketName='默认')
try:
dbsession.add(first_bucket)
except Exception as e:
print(e)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
settings['sqlalchemy.url'] = os.environ.get('DATABASE_URL')
engine = get_engine(settings)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
many_entries = []
for item in Posts:
new_entry = Entry(title=item['title'],
body=item['body'],
creation_date=item['creation_date'])
many_entries.append(new_entry)
dbsession.add_all(many_entries)
def run(self):
if not self.args.config_uri or not self.args.url:
self.out('Command requires a config file arg and a url arg')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
url = self.args.url
self.setup_logging(config_uri, global_conf=config_vars)
if not url.startswith('/'):
url = '/%s' % url
request = Request.blank(url)
env = self.bootstrap(config_uri, options=config_vars, request=request)
view = self._find_view(request)
self.out('')
self.out("URL = %s" % url)
self.out('')
if view is not None:
self.out(" context: %s" % view.__request_attrs__['context'])
self.out(" view name: %s" % view.__request_attrs__['view_name'])
if IMultiView.providedBy(view):
for dummy, view_wrapper, dummy in view.views:
self.output_view_info(view_wrapper)
if IMultiView.providedBy(view_wrapper):
for dummy, mv_view_wrapper, dummy in view_wrapper.views:
self.output_view_info(mv_view_wrapper, level=2)
else:
if view is not None:
self.output_view_info(view)
else:
self.out(" Not found.")
self.out('')
env['closer']()
return 0
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
submitter = Submitter(name='tester')
dbsession.add(submitter)
transaction.commit()
sub_id = dbsession.query(Submitter.id). \
filter(Submitter.name == 'tester').scalar()
post = Post(title="job title",
company="the testing company",
post_date="13-Apr-2016Z201530",
description="this is a really short description",
submitter=sub_id)
dbsession.add(post)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
admin_user = User(username='******',
password=bcrypt.hashpw('password', bcrypt.gensalt()),
groups='admins')
cash_account = Account("Cash", admin_user, 0, requirespin=False)
if os.path.exists("items.list"):
with open("items.list") as f:
for line in f:
if line == "":
continue
elements = [x.strip() for x in line.split(',')]
print elements
item = SaleItem(int(elements[0]), elements[1], elements[2],
int(elements[3]), 0)
if (len(elements) > 4):
item.stockCount = int(elements[4])
DBSession.add(item)
DBSession.add(admin_user)
DBSession.add(cash_account)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
#Generate fake statistics for 1 year
DAYS = 365 * 1
#Init database with example list of cities
with transaction.manager:
for c in CITIES:
city = City(name=c, owm_id=CITIES[c])
DBSession.add(city)
DBSession.flush()
print("Added city: " + city.name)
prev_y = datetime.datetime.now() - datetime.timedelta(DAYS)
for d in (prev_y + datetime.timedelta(n) for n in range(DAYS)):
is_clear = bool(random.getrandbits(1))
wr = WeatherRecord(city=city.id, date=d, is_clear=is_clear)
DBSession.add(wr)
print("Added weather record: " + str(wr.date) + " " + str(wr.is_clear))
DBSession.flush()
def get_options(self):
if (len(self.args) > 1 and self.args[1] in self.possible_subcommands):
restvars = self.args[2:]
else:
restvars = self.args[1:]
return parse_vars(restvars)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
# configure connections for Postgres, ElasticSearch and Redis
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
Session = sessionmaker() # noqa
Session.configure(bind=engine)
configure_es_from_config(settings)
queue_config = get_queue_config(settings)
batch_size = int(settings.get('elasticsearch.batch_size.syncer', 1000))
with queue_config.connection:
try:
worker = SyncWorker(
queue_config.connection, queue_config.queue, batch_size,
session_factory=Session)
log.info('Syncer started, running initial sync')
worker.sync()
log.info('Waiting on messages')
worker.run()
except KeyboardInterrupt:
log.info('Syncer stopped')
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
editor = User(name='editor', role='editor')
editor.set_password('editor')
dbsession.add(editor)
basic = User(name='basic', role='basic')
basic.set_password('basic')
dbsession.add(basic)
page = Page(
name='FrontPage',
creator=editor,
data='This is the front page',
)
dbsession.add(page)
def main(argv=sys.argv):
if len(argv) < 3:
usage(argv)
config_uri = argv[1]
json_path = argv[2]
options = parse_vars(argv[3:])
setup_logging(config_uri)
# Configure the application, so we can access the registry.
env = bootstrap(config_uri, options=options)
# Generate a DBSession using the sessionmaker:
DBSession = env['registry']['db_sessionmaker']()
# The SQLAlchemy engine is accessible as the session's bind.
engine = DBSession.bind
Base.metadata.create_all(engine)
json_data = json.load(open(json_path))
with transaction.manager:
for kitten_data in json_data:
kitten = Kitten(source_url=kitten_data['source_url'],
credit=kitten_data['credit'])
r = requests.get(kitten_data['download_url'])
if r.headers['content-type'] == 'image/jpeg':
kitten.file_extension = '.jpeg'
elif r.headers['content-type'] == 'image/png':
kitten.file_extension = '.png'
kitten.file_data = r.content
DBSession.add(kitten)
# Not strictly necessary, as everything gets unwound when main returns anyway.
# But it's a good habit to keep.
env['closer']()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
DBSession.add(FacetName(name="project"))
DBSession.add(FacetName(name="data_type"))
DBSession.add(FacetName(name="institute"))
DBSession.add(FacetName(name="product"))
DBSession.add(FacetName(name="model"))
DBSession.add(FacetName(name="instrument"))
DBSession.add(FacetName(name="experiment_family"))
DBSession.add(FacetName(name="experiment"))
DBSession.add(FacetName(name="versionnum"))
DBSession.add(FacetName(name="realm"))
DBSession.add(FacetName(name="regridding"))
DBSession.add(FacetName(name="time_frequency"))
DBSession.add(FacetName(name="grid_resolution"))
DBSession.add(FacetName(name="years_spanned"))
DBSession.add(FacetName(name="variable"))
DBSession.add(FacetName(name="variable_long_name"))
DBSession.add(FacetName(name="cf_standard_name"))
DBSession.add(FacetName(name="ensemble"))
DBSession.add(FacetName(name="data_node"))
DBSession.add(FacetName(name="range"))
def run(self):
if len(self.args) < 2:
self.out('Command requires a config file arg and a url arg')
return 2
config_uri = self.args[0]
url = self.args[1]
if not url.startswith('/'):
url = '/%s' % url
request = Request.blank(url)
env = self.bootstrap[0](config_uri, options=parse_vars(self.args[2:]),
request=request)
view = self._find_view(request)
self.out('')
self.out("URL = %s" % url)
self.out('')
if view is not None:
self.out(" context: %s" % view.__request_attrs__['context'])
self.out(" view name: %s" % view.__request_attrs__['view_name'])
if IMultiView.providedBy(view):
for dummy, view_wrapper, dummy in view.views:
self.output_view_info(view_wrapper)
if IMultiView.providedBy(view_wrapper):
for dummy, mv_view_wrapper, dummy in view_wrapper.views:
self.output_view_info(mv_view_wrapper, level=2)
else:
if view is not None:
self.output_view_info(view)
else:
self.out(" Not found.")
self.out('')
env['closer']()
return 0
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
news1 = News(Topic = 'iPhone 7 поступил в массовое производство', ShortInfo = 'До предполагаемого релиза Apple iPhone 7 остается 3 месяца и, по слухам, компания уже разместила заказ на производство 78 миллионов смартфонов. Заказ был разделен, по меньшей мере, между двумя крупными производственными компаниями: Foxconn и Pegatron. Последний, как свидетельствуют инсайдеры, на днях приступил к производству первых iPhone 7, который попадут на рынок. Как утверждает OnLeaks, Pegatron будет отвечать за продукцию только 4,7-дюймовых моделей, тогда как 5,5-дюймовый iPhone 7 Plus сойдет с конвейера Foxconn.', Data = 'До предполагаемого релиза Apple iPhone 7 остается 3 месяца и, по слухам, компания уже разместила заказ на производство 78 миллионов смартфонов. Заказ был разделен, по меньшей мере, между двумя крупными производственными компаниями: Foxconn и Pegatron. Последний, как свидетельствуют инсайдеры, на днях приступил к производству первых iPhone 7, который попадут на рынок. Как утверждает OnLeaks, Pegatron будет отвечать за продукцию только 4,7-дюймовых моделей, тогда как 5,5-дюймовый iPhone 7 Plus сойдет с конвейера Foxconn. Как показывает опыт минувших лет, вслед за подобными новостями количество реальных утечек возрастает многократно, а значит, уже скоро мы получим первые подтверждения или опровержения разных слухов, что сейчас ходят в сети. Например, утверждается, что в целом дизайн смартфонов останется прежним, однако исчезнет 3,5-мм аудиовыход, сместятся к верхнему и нижнему краю полоски антенн, возможно, уменьшатся рамки вокруг дисплея. Более смелые предположения говорят о появлении в линейке нового цвета - ярко-синего взамен темно-серого. В 4,7-дюймовом аппарате по-прежнему будет установлена единственная основная камера, тогда как в iPhone 7 Plus может появиться дублирующий модуль для повышения качества снимков. С другой стороны, по последней информации технические проблемы могут заставить Apple отказаться от двойной камеры и старшая версия в этом году тоже выйдет в прежней комплектации. Оба смартфона будут работать на базе процессора Apple A10, получат iOS 10 "из коробки" и, возможно, увеличенный объем оперативной памяти.', image_name = '1.jpg', UserId = 1)
user = User(Name='admin', Age=20, Password = '******')
user1= User(Name='root', Age=20, Password = '******')
news2 = News(Topic = 'В Windows 10 можно будет работать с одним приложением на разных устройствах', ShortInfo = 'В апреле этого года появилась информация, что Microsoft собирается реализовать в Windows 10 аналог функции Handoff из OS X и iOS. Напомним, что с её помощью пользователи могут отвечать на входящие звонки и сообщения с любого устройства, а также начать работать в приложении, например, на iPhone или iPad, а затем продолжить с того же места на Mac. В последней тестовой сборке Windows 10 Mobile в настройках появилась опция Continue App Experiences, которая предлагает пользователям те же самые возможности, что и Handoff.', Data = 'В апреле этого года появилась информация, что Microsoft собирается реализовать в Windows 10 аналог функции Handoff из OS X и iOS. Напомним, что с её помощью пользователи могут отвечать на входящие звонки и сообщения с любого устройства, а также начать работать в приложении, например, на iPhone или iPad, а затем продолжить с того же места на Mac. В последней тестовой сборке Windows 10 Mobile в настройках появилась опция Continue App Experiences, которая предлагает пользователям те же самые возможности, что и Handoff. Стоит отметить, что на данный момент речь идёт лишь о продолжении работы в приложениях на разных устройствах под управлением Windows 10. Но ранее в этом году на конференции для разработчиков Build 2016 компания Microsoft показала скриншот, где с компьютера отвечают на входящий звонок, который поступает на телефон.', image_name = '1.jpg', UserId = 2 )
dbsession.add(news1)
dbsession.add(news2)
dbsession.add(user)
dbsession.add(user1)
c = Category(Name = "Iphone")
dbsession.add(c)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
# initial encryption passphrase set to ''
salt = os.urandom(32)
password = bytes(input("If you would like to set a password, please enter it now. Otherwise, just press enter. > ").encode())
# initial password is the empty string
enc_key = gen_key_from_salt_and_password(salt, password)
f = Fernet(enc_key)
secret_exponent_bytes = os.urandom(32)
secret_exponent = convert_se_bytes(secret_exponent_bytes)
address = Key(secret_exponent=secret_exponent, netcode=NET_CODE['bitcoin']).address(use_uncompressed=USE_COMPRESSED)
with transaction.manager:
model = KeyStore(name=PRIMARY, encrypted=f.encrypt(secret_exponent_bytes),
salt=salt, address=address)
DBSession.add(model)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = Task(taskname='Learn 101 of telekinesis', status=False)
DBSession.add(model)
model = Task(taskname='Bend 20 forks', status=True)
DBSession.add(model)
model = Task(taskname='Become master in levitation', status=True)
DBSession.add(model)
model = Task(taskname='Go home flying', status=True)
DBSession.add(model)
with transaction.manager:
admin = User(name=u'admin', password=u'admin')
DBSession.add(admin)
admin = User(name=u'demo', password=u'demo')
DBSession.add(admin)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = User(name=u'admin', password=u'admin')
DBSession.add(model)
from jinja2.utils import generate_lorem_ipsum
for id, article in enumerate(range(100), start=1):
title = generate_lorem_ipsum(
n=1, # Одно предложение
html=False, # В виде обычного текста
min=2, # Минимум 2 слова
max=5 # Максимум 5
)
content = generate_lorem_ipsum()
article = Article(**{'title': title, 'content': content})
DBSession.add(article)
def main(argv=sys.argv):
from ..src import User, Address
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
Session.configure(bind=engine)
BaseModel.metadata.create_all(engine)
with transaction.manager:
brendan = User(name='Brendan', age=18)
Session.add(brendan)
Session.flush()
brendan_address = Address(city='Paris', owner_id=brendan.id)
Session.add(brendan_address)
Session.flush()
john = User(name='John', age=19, best_friend_id=brendan.id)
Session.add(john)
Session.flush()
antoine = User(name='Antoine', age=20)
Session.add(antoine)
Session.flush()
def run(self, shell=None):
if self.args.list:
return self.show_shells()
if not self.args.config_uri:
self.out('Requires a config file argument')
return 2
config_uri = self.args.config_uri
config_vars = parse_vars(self.args.config_vars)
loader = self.get_config_loader(config_uri)
loader.setup_logging(config_vars)
self.pshell_file_config(loader, config_vars)
self.env = self.bootstrap(config_uri, options=config_vars)
# remove the closer from the env
self.closer = self.env.pop('closer')
try:
if shell is None:
try:
shell = self.make_shell()
except ValueError as e:
self.out(str(e))
return 1
with self.setup_env():
shell(self.env, self.help)
finally:
self.closer()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
dbmaker = get_dbmaker(engine)
dbsession = get_session(transaction.manager, dbmaker)
Base.metadata.create_all(engine)
acl1 = [(Allow, Everyone, "view")]
acl2 = [(Allow, "editor", "view")]
acl3 = [(Allow, "admin", "view")]
with transaction.manager:
root = RootFolder(name="", title="sqltraversal Demo")
dbsession.add(root)
f1 = root["f1"] = Folder(
title="Folder 1"
# no persistent acl
)
root["f2"] = Folder(title="Folder 2 All", acl=acl1)
root["f3"] = Folder(title="Folder 3 Editor", acl=acl2)
root["f4"] = Folder(title="Folder 4 Admin", acl=acl3)
root["f5"] = Folder(title="Folder 5 Editor", acl=acl2)
root["f6"] = Folder(title="Folder 6 Admin", acl=acl3)
f1["d1"] = Document(title="Document 1")
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
#with transaction.manager:
# model = MyModel(name='one', value=1)
# DBSession.add(model)
with transaction.manager:
with open('agencies.csv','r') as f:
agencies = f.read().split('\n')
for agency in agencies:
if agency.strip() != '':
# agencyid, shortname, longname, type, description, websiteurl
parts = agency.split('\t')
agency_type = AgencyTypes.get_from_code(DBSession, parts[3])
a = Agencies(
agency_code = parts[1],
agency_name = parts[2],
type_id = agency_type.id,
description = parts[4],
website = parts[5],
)
DBSession.add(a)
transaction.commit()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
model = RasPi()
model.uuid = '11:22:33:44:55:66'
model.description = "Testing Pi"
model.url = "http://www.facebook.com"
model.orientation = 0
model.browser = True
model.lastseen = datetime.now()
DBSession.add(model)
tag = Tags()
tag.uuid = '11:22:33:44:55:66'
tag.tag = 'test'
DBSession.add(tag)
User = UserModel()
User.email = '*****@*****.**'
User.AccessLevel = 2
DBSession.add(User)
DBSession.flush()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
with transaction.manager:
model2 = Genre(id = 0,name='HipHop', info='Nigger ma f****r',year_of_found = 1990)
DBSession.add(model2)
model = Genre(id = 1,name='GlitchHop', info='Nu vaaassheee',year_of_found = 2014, parent_genre = model2)
DBSession.add(model)
model3 = Genre(id = 2,name='Grime', info='Zhostkiy rap',year_of_found = 2006, parent_genre = model2)
DBSession.add(model3)
model4 = Genre(id = 3,name='Dark Grime', info='Tyomniy Zhostkiy rap',year_of_found = 2009, parent_genre = model3)
DBSession.add(model4)
music1 = Music(author = 'Simplex_Method', title = 'Of Literal Data', year = 2015,genre = model3)
DBSession.add(music1)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
#Delete old data
Base.metadata.drop_all(engine)
#Create data
Base.metadata.create_all(engine)
with transaction.manager:
nb_sensors = 5
nb_readings = 500
minutes_between_readings = 10;
for i in range(nb_sensors):
sensor = Sensor(id=i+1,type='Moisture')
DBSession.add(sensor)
first_dttm = datetime.datetime.now()
for j in range(nb_readings,0,-1):
reading = Reading(
sensor_id=sensor.id,
timestamp=first_dttm - datetime.timedelta(minutes=minutes_between_readings*j),
value=random.randrange(1023)
)
DBSession.add(reading)
def get_options(self):
if len(self.args) > 1 and self.args[1] in self.possible_subcommands:
restvars = self.args[2:]
else:
restvars = self.args[1:]
return parse_vars(restvars)
def run(self, argv):
if len(argv) < 3:
self.usage(argv)
config_uri = argv[1]
fromDate = argv[2]
options = parse_vars(argv[3:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
url = 'https://servicesenligne2.ville.montreal.qc.ca/api/infoneige/InfoneigeWebService?wsdl'
client = Client(url)
planification_request = client.factory.create('getPlanificationsForDate')
planification_request.fromDate = fromDate
planification_request.tokenString = 'ug33-b81ab488-c335-4021-9c52-26d6b8523301-e7aa002b-0d9d-4b5c-81ef-b012979cdafb-dab06588-1962-4b16-9942-a18054094f60-a4186179-d555-4fed-b35f-ec0c74da97a3-aa3b3766-4d26-42f0-888a-a6569a1dd745'
response = client.service.GetPlanificationsForDate(planification_request)
if response['responseStatus'] == 0:
log.info('%s plannings returned', response['planifications']['count'])
cartodb_client = CartoDBOAuth(settings['cartodb.key'], settings['cartodb.secret'], settings['cartodb.user'], settings['cartodb.password'], settings['cartodb.domain'])
for result in response['planifications']['planification']:
'''
street_side_status = StreetSideHistory(
municipality_id = result['munid'],
street_side_id = result['coteRueId'],
state = result['etatDeneig'],
observed_on = result['dateMaj'],
)
DBSession.merge(street_side_status)
'''
if any(val in result for val in ['dateDebutPlanif', 'dateFinPlanif', 'dateDebutReplanif', 'dateFinReplanif']):
try:
result['dateDebutReplanif']
except AttributeError:
result['dateDebutReplanif'] = None
try:
result['dateFinReplanif']
except AttributeError:
result['dateFinReplanif'] = None
'''
print result
planning = Planning(
municipality_id = result['munid'],
street_side_id = result['coteRueId'],
planned_start_date = result['dateDebutPlanif'],
planned_end_date = result['dateFinPlanif'],
replanned_start_date = result['dateDebutReplanif'],
replanned_end_date = result['dateFinReplanif'],
modified_on = result['dateMaj'],
)
DBSession.merge(planning)
'''
#transaction.manager.commit()
cartodb_client.sql('UPDATE cote SET etat = %(etat)s WHERE cote_rue_id = %(cote_rue_id)d' %
{"etat": result['etatDeneig'], "cote_rue_id": result['coteRueId']})
else:
log.info('Status %s: %s', response['responseStatus'], response['responseDesc'])
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
with transaction.manager:
user = User(username='******', password='******', email=settings.get('admin_mail'), activated=True,
groups='admin')
DBSession.add(user)
DBSession.flush()
for k, v in Settings.settings.iteritems():
if type(v) == dict:
DBSession.add(Settings(key=unicode(k), value=unicode(v['value'])))
else:
if isinstance(v, basestring) and v.startswith('app_config.'):
v = settings.get(v[len('app_config.'):])
DBSession.add(Settings(key=unicode(k), value=unicode(v)))
DBSession.flush()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
application_pdf_doc_type = DocumentTypes.add(
name="Adobe PDF",
description="Adobe PDF file",
mime_type="application/pdf",
)
system_owner = Users.add(
first="SYSTEM",
last="USERS",
email="system@localhost",
password="******",
)
default_scraper = Scrapers.add(
name="Default Scraper",
description="CivicDocs.IO loads with a single, defualt scraper.",
owner_id=system_owner.id,
)
print("DEFAULT SCRAPER ID:\r\n{0}\r\n".format(default_scraper.id))
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
user = User(email='*****@*****.**', password='******', admin=True)
DBSession.add(user)
site = Site(name='asd', key='80d621df066348e5938a469730ae0cab')
DBSession.add(site)
site.api_keys.append(SiteAPIKey(key='GIKfxIcIHPbM0uX9PrQ1To29Pb2on0pa'))
site.users.append(user)
aspect_ratio_1_1 = SiteAspectRatio(width=1, height=1)
aspect_ratio_3_1 = SiteAspectRatio(width=3, height=1)
site.aspect_ratios.append(aspect_ratio_1_1)
site.aspect_ratios.append(aspect_ratio_3_1)
from alembic.config import Config
from alembic import command
alembic_cfg = Config("alembic.ini")
command.stamp(alembic_cfg, "head")
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
connect_string = settings['sqlalchemy.url']\
.replace('DBUser', os.environ['DBUSER'])\
.replace('DBPassword', os.environ['DBPASSWORD'])
settings['sqlalchemy.url'] = connect_string
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
store_data = json.loads(open('emporium/scripts/store_data.json').
read())
suppliers = {}
for item in store_data['suppliers']:
supplier = Supplier(name=item['name'], tax_id=item['tax_id'])
suppliers[supplier.name] = supplier
DBSession.add(supplier)
for item in store_data['bargains']:
bargain = Bargain(
sku=item['sku'],
price=item['price'],
supplier=suppliers[item['supplier_name']]
)
bargain.info = item['info']
DBSession.add(bargain)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, name="testscaffold", options=options)
engine = get_engine(settings)
session_factory = get_session_factory(engine)
dbsession = get_tm_session(session_factory, transaction.manager)
with transaction.manager:
user = User(user_name="admin", email="foo@localhost")
UserService.set_password(user, "admin")
admin_object = Group(group_name="Administrators")
group_permission = GroupPermission(perm_name="root_administration")
dbsession.add(admin_object)
admin_object.permissions.append(group_permission)
admin_object.users.append(user)
test_group = Group(group_name="Other group")
dbsession.add(test_group)
for x in range(1, 25):
user = User(user_name="test{}".format(x), email="foo{}@localhost".format(x))
UserService.set_password(user, "test")
test_group.users.append(user)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
DBSession.add(
Item("Nutrigrain Raspberry", "038000358210", 14.37, 0.47, False,
False, 3, True))
DBSession.add(
Item("Clif Bar: Chocolate Chip", "722252100900", 1.25, 1.17, False,
False, 12, True))
DBSession.add(
Item("Clif Bar: Crunchy Peanut Butter", "722252101204", 1.25, 1.14,
False, False, 11, True))
coke = Item("Coke (12 oz)", "04963406", 0.42, 0.37, True, False, 8,
True)
DBSession.add(coke)
# user = User(
# "zakir",
# "95951361",
# "Zakir Durumeric"
# )
# user.role = "administrator"
# user.password = "******"
# DBSession.add(user)
user = User("bradjc", "11519022", "Brad Campbell")
user.role = "administrator"
user.password = "******"
DBSession.add(user)
user = User("ppannuto", "64880621", "Pat Pannuto")
user.role = "administrator"
user.password = "******"
DBSession.add(user)
user = User("betty", "00000000", "Betty")
user.role = "serviceaccount"
user.password = "******"
DBSession.add(user)
account.get_virt_account("chezbetty")
account.get_cash_account("cashbox")
account.get_cash_account("chezbetty")
account.get_cash_account("btcbox")
coke_box = Box(
"Coke 32 pack", # name
"049000042511", # barcode
True, # bottle deposit
False, # sales tax
32.00, # wholesale
# enabled implicit True
)
DBSession.add(coke_box)
DBSession.flush()
DBSession.add(BoxItem(coke_box, coke, 32, 100))
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = get_engine(settings)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
# Get values from files
here = os.path.abspath(os.path.dirname(__file__))
category = json.load(open(os.path.join(here, '../mockdata/category.json'), 'r'))
part = json.load(open(os.path.join(here, '../mockdata/part.json'), 'r'))
type = json.load(open(os.path.join(here, '../mockdata/part_type.json'), 'r'))
session_factory = get_session_factory(engine)
with transaction.manager:
dbsession = get_tm_session(session_factory, transaction.manager)
with dbsession.no_autoflush:
# Insert a Person in the person table
for elem in category:
new_category = Category(
category_id=elem['category_id'],
category_name=elem['category_name'])
dbsession.add(new_category)
dbsession.flush()
transaction.commit()
for elem in type:
cat_id = random.randint(1,10)
part_type_category = dbsession.query(Category).filter_by(category_id=cat_id).first()
if part_type_category:
new_type = PartType(
part_type_id=elem['part_type_id'],
part_type_name=elem['part_type_name'],
part_type_description=elem['part_type_description'],
part_type_value=elem['part_type_value'],
part_type_image_url=elem['part_type_image_url'],
part_type_category=part_type_category.category_id)
dbsession.add(new_type)
dbsession.flush()
transaction.commit()
for index, elem in enumerate(part):
part_type = dbsession.query(PartType).filter_by(part_type_id=elem['part_type']).first()
category = dbsession.query(Category).filter_by(category_id=elem['part_category']).first()
if part_type and category:
new_part = Part(
part_uid=elem['part_id'],
part_type=part_type.part_type_id,
part_category=category.category_id)
dbsession.add(new_part)
dbsession.flush()
transaction.commit()
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, prefix='sqlalchemy.')
Base.metadata.create_all(engine)
maker = sessionmaker()
maker.configure(bind=engine)
with transaction.manager:
session = get_session(maker, transaction.manager)
dummy_User = User(First_name='GOD',
Last_name='DAMN',
role='GOD',
student_id=00000,
Email='*****@*****.**',
user_id='GODdamn',
year=0)
dummy_User.hash_password('dummy')
dummy_project = Project(
title='GOD PROJECT',
description=
'It a god very duty no such a normal human will understand.',
status='Neary done',
type='GOD duty',
start_date=datetime.date(datetime.MINYEAR, 1, 1),
finish_date=datetime.date(datetime.MAXYEAR, 12, 31))
dummy_project.leader = dummy_User
dummy_project.advisor.append(dummy_User)
dummy_project.project_member.append(dummy_User)
dummy_equipment = Equipment(
name='Legendary item',
cost=1000000000000000,
buy_date=datetime.date(datetime.MINYEAR, 1, 1),
contract='Only God will know',
status='Wait for TRUE HERO to be found',
)
dummy_equipment.asso_to = dummy_project
dummy_equipment.owner = dummy_User
dummy_obligation = Obligation(type='Duty from GOD',
description='wait for the TRUE HERO',
duty='Find Legendary item',
status='Not found yet')
dummy_obligation.asso_to = dummy_project
dummy_obligation.equipment = dummy_equipment
session.add(dummy_project)
session.add(dummy_User)
session.add(dummy_equipment)
session.add(dummy_obligation)
def main():
config_uri = sys.argv[1]
options = parse_vars(sys.argv[2:])
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, prefix="sqlalchemy.")
if bool(os.environ.get("DEBUG", "")):
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
def main(argv=sys.argv):
if len(argv) < 4:
usage(argv)
config_uri = argv[1]
filename = argv[2]
culture = argv[3]
options = parse_vars(argv[4:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
xml = ElementTree.parse(filename)
root = xml.getroot()
if root.tag == 'Quests':
print('Parsing Quests data.')
quests = [
TranslationQuest(culture=culture,
id=x.findtext('ID'),
title_ja=x.findtext('JP-Name'),
title=x.findtext('TR-Name'),
description_ja=x.findtext('JP-Detail'),
description=x.findtext('TR-Detail'))
for x in root.findall('Quest')
]
DBSession.add_all(quests)
elif root.tag == 'Ships':
print('Parsing Ships data.')
ships = [
TranslationShip(culture=culture,
name_ja=x.findtext('JP-Name'),
name=x.findtext('TR-Name'))
for x in root.findall('Ship')
]
DBSession.add_all(ships)
elif root.tag == 'ShipTypes':
print('Parsing ShipTypes data.')
shiptypes = [
TranslationShipType(culture=culture,
id=x.findtext('ID'),
name_ja=x.findtext('JP-Name'),
name=x.findtext('TR-Name'))
for x in root.findall('Type')
]
DBSession.add_all(shiptypes)
elif root.tag == 'Equipment':
print('Parsing ShipTypes data.')
equipment = [
TranslationEquipment(culture=culture,
name_ja=x.findtext('JP-Name'),
name=x.findtext('TR-Name'))
for x in root.findall('Item')
]
DBSession.add_all(equipment)
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# Setup a few initial items
DBSession.add(
Item("Nutrigrain Raspberry", "038000358210", 14.37, 0.47, False,
False, 3, True))
DBSession.add(
Item("Clif Bar: Chocolate Chip", "722252100900", 1.25, 1.17, False,
False, 12, True))
DBSession.add(
Item("Clif Bar: Crunchy Peanut Butter", "722252101204", 1.25, 1.14,
False, False, 11, True))
coke = Item("Coke (12 oz)", "04963406", 0.42, 0.37, True, False, 8,
True)
DBSession.add(coke)
# Add a test box
coke_box = Box(
"Coke 32 pack", # name
"049000042511", # barcode
True, # bottle deposit
False, # sales tax
32.00, # wholesale
# enabled implicit True
)
DBSession.add(coke_box)
DBSession.flush()
DBSession.add(BoxItem(coke_box, coke, 32, 100))
# Add the betty user
DBSession.add(coke)
user = User("betty", "00000000", "Betty")
user.role = "serviceaccount"
user.password = "******"
DBSession.add(user)
# Add an admin user
user = User("admin", "56785678", "Administrator")
user.role = "administrator"
user.password = "******"
DBSession.add(user)
# Init the accounts we need
account.get_virt_account("chezbetty")
account.get_cash_account("cashbox")
account.get_cash_account("safe")
account.get_cash_account("chezbetty")
account.get_cash_account("btcbox")
def main(argv=sys.argv):
if len(argv) < 2:
usage(argv)
config_uri = argv[1]
options = parse_vars(argv[2:])
setup_logging(config_uri)
settings = get_appsettings(config_uri, options=options)
configure_es_from_config(settings)
setup_es()
