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) < 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): 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 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()