def __init__(self, window: 'window', video_source=0, replay=False): self.window = window self.window.title(settings.get_config("window_title")) self.replay = replay if self.replay: # Load previous data instead of from camera. self.data_gen = loadDataset.dataset_generator( './dataset/imgs/scissor_frames', './dataset/csvs/scissor.csv', repeat=True) self.inputDimension = [480, 640, 3] else: # open video source (by default this will try to open the computer webcam) self.video_source = video_source self.vid = MyVideoCapture(self.video_source) self.inputDimension = [self.vid.height, self.vid.width, 3] image_size = settings.get_config("image_input_size") self.maxListSize = settings.get_config("image_history_length") self.imgList = [np.zeros(image_size)] * self.maxListSize # Create a canvas that can fit the above video source size self.canvas = Canvas(window, height=self.inputDimension[0], width=self.inputDimension[1]) self.canvas.pack() self.photo = None self.strVar = StringVar(value="None") self.lblClassification = Label(window, textvariable=self.strVar, font=("Helvetica", 16)) self.lblClassification.pack(anchor=CENTER, expand=True) # Set up frame counters and limiters. No more than (fps) frames per second. # Also set up label to display current frame rate. self.fps = settings.get_config("max_fps") self.fps_counter = window_utils.SimpleFPSCounter() self.fps_limiter = window_utils.SimpleFPSLimiter(fps=self.fps) self.fps_value = StringVar() self.fps_label = Label(window, textvariable=self.fps_value, font=("Helvetica", 16)) self.fps_label.pack(anchor=CENTER, expand=True) # Initialize Tensorflow Models tf.reset_default_graph() config = tf.ConfigProto() config.gpu_options.allow_growth = True self.session = tf.Session(config=config) self.model1 = models.model1(image_size, self.maxListSize) self.model2 = models.model2(image_size) saver = tf.train.Saver() saver.restore( self.session, os.path.join(os.getcwd(), "savedmodels\\both\\models.ckpt")) # _main_loop() will "recursively" call itself at most (fps) times per second. self._main_loop() self.window.mainloop()
def crop(images): sess = tf.InteractiveSession() ''' images, _ = ds.loadDataSet('./dataset/imgs/rock_frames', './dataset/imgs/paper_frames', './dataset/imgs/scissor_frames' , './dataset/csvs/rock.csv', './dataset/csvs/paper.csv', './dataset/csvs/scissor.csv') ''' # print (images.shape) # crop value offsetHeight = np.random.randint(0, images[0].shape[0]-settings.get_config("resizedH")) offsetWidth = np.random.randint(0, images[0].shape[1]-settings.get_config("resizedW")) crop_value = [offsetHeight, offsetWidth, settings.get_config("resizedH"), settings.get_config("resizedW")] crop_values = [] for i in range(images.shape[0]): crop_values.append(crop_value) crop_values = tf.convert_to_tensor(crop_values) # print (crop_values.shape) fn = lambda x: crop_image(x[0], x[1]) elems = (images, crop_values) cropped_images = tf.map_fn(fn, elems=elems, dtype=tf.uint8) result = sess.run(cropped_images) # print (result.shape) return result
def main(): import settings api = APISLY(username=settings.get_config('login', 'username'), password=settings.get_config('login', 'password'), force=True) #print get_notifications(ses) #get_catalog(ses) print api.get_serie_info(mediaType='1', id_media='7HV4DXUHE5')
def main(): import settings api = APISLY( username=settings.get_config("login", "username"), password=settings.get_config("login", "password"), force=True ) # print get_notifications(ses) # get_catalog(ses) # print api.get_serie_info(mediaType='1', id_media='7HV4DXUHE5') print api.get_most_valuated(mediaType=MOVIE)
async def init_app(argv=None) -> web.Application: app = web.Application(middlewares=[db]) app['config'] = config = get_config(argv) app['config']['gino'] = dict( dsn=URL( drivername=config['database']['db_driver'], database=config['database']['database'], username=config['database']['user'], password=config['database']['password'], host=config['database']['host'], port=config['database']['port'], ), echo=config['database']['echo'], min_size=config['database']['minsize'], max_size=config['database']['maxsize'], ssl=config['database']['ssl'], retry_limit=config['database']['retry_limit'], retry_interval=config['database']['retry_interval'], ) # setup routes, middlewares and db setup_routes(app) db.init_app(app) # aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('desktop_dispatcher', 'templates')) return app
def main(argv): logging.basicConfig(level=logging.DEBUG) app = init_app(argv) config = get_config(argv) web.run_app(app, host=config['host'], port=config['port'])
def __init__(self): self.boto_session = boto3.session.Session() self.config = get_config() self.table_name = self.config('state_table', namespace='gsuite_driver', default='gsuite-driver-state') self.table = None
async def init_app(argv=None): app = web.Application() app['config'] = get_config(argv) # create db connection on startup, close on exit # app.on_startup.append(init_pg) db_pool = await init_pg(app) app.on_cleanup.append(close_pg) fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup_session(app, EncryptedCookieStorage(secret_key)) aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader(PACKAGE_NAME), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) # setup views and routes setup_routes(app) return app
def main(argv): logging.basicConfig(level=logging.INFO) LOGGER.info('### Starting user service ###') config = get_config(argv) app = init_app(config) web.run_app(app, host=config['host'], port=config['port'])
def __init__(self): self.config = get_config() self.table_name = self.config('dynamodb_person_table', namespace='cis', default='fake-identity-vault') self.table = CISTable(self.table_name) setup_logging()
def db(): config = get_config(['-c', TEST_CONFIG_PATH.as_posix()]) cb_conf = config['couchbase'] setup_db(cb_conf) yield teardown_db(cb_conf)
def main(argv): # argv, what? logging.basicConfig(level=logging.DEBUG) app = init_app(argv) config = get_config(argv) web.run_app(app, host=config['host'], port=config['port'] ) # this port is for app; different from psql's port.
def setup_config(app, config_path=None): try: app['config'] = get_config(CONFIG_PATH) except Exception as e: app.logger.exception("config is broken.") return 1 setup_logger(app) return 0
def tables_and_data(): config = get_config(['-c', TEST_CONFIG_PATH.as_posix()]) cb_conf = config['couchbase'] create_index(cb_conf) data = sample_data(cb_conf) yield data drop_index(cb_conf)
async def init_app(conf=settings.get_config()): app = web.Application() mongo = await setup_mongo(app, conf) app['mongo'] = mongo setup_routes(app) return app
def main(argv): logging.basicConfig(level=logging.DEBUG) #, filename='./data/gateway.log') # use uvloop instead of asyncio event loop # uvloop.install() # init & run app with args & config app = init_app(argv) config = get_config(argv) web.run_app(app, host=config['host'], port=config['port'])
def main(): logging.basicConfig(level=logging.DEBUG) conf = settings.get_config() loop = asyncio.get_event_loop() # app = loop.run_until_complete(init_app(conf)) # web.run_app(app, host=conf['host'], port=conf['port']) app = loop.run_until_complete(init_app_proxy()) web.run_app(app, host=conf['host'], port=conf['proxy-port'])
async def init_app(argv=None): app = web.Application() app['config'] = get_config(argv) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('%s/templates/' % os.path.dirname(__file__))) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) setup_routes(app) # setup_middlewares(app) return app
def handle(event=None, context={}): config = get_config() setup_logging(config) logger.info('Initializing Clearpass driver.') appsyml = config('appsyml', namespace='clearpass_driver', default='https://cdn.sso.mozilla.com/apps.yml') clearpass_app = config('clearpass_app', namespace='clearpass_driver', default='clearpass') access_rules = get_access_rules(appsyml) app = None authorized_groups = [] for app in access_rules: actual_app = app.get('application') if actual_app.get('name') == clearpass_app: # XXX CIS with v1 profile prepend ldap groups with `ldap_` but the rest of the infra does not... so # workaround here: authorized_groups = [] known_idp_prefix = ['mozilliansorg', 'hris', 'ldap'] for g in actual_app.get('authorized_groups'): if g.split('_')[0] not in known_idp_prefix: # its an ldap group authorized_groups.append("ldap_" + g) else: authorized_groups.append(g) logger.debug('Valid and authorized users are in groups {}'.format( authorized_groups)) break if app is None: logger.warning( 'Did not find {} in access rules, will not deprovision users'. format(clearpass_app)) return logger.debug('Searching DynamoDb for people.') people = People() logger.debug('Filtering person list to groups.') allowed_users = people.people_in_group(authorized_groups) logger.debug('Found {} Clearpass users which are allowed'.format( len(allowed_users))) logger.debug('Disable Clearpass users.') if not verify_clearpass_users(allowed_users): logger.warning( 'Failed to verify clearpass users - some users may not have been deprovisioned' )
def init_app(): app = web.Application() app['config'] = get_config() aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('sample', 'templates')) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) setup_routes(app) return app
async def init_app(argv=None): app = web.Application() app['config'] = get_config(argv) # create db connection on startup, shutdown on exit app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) # setup views and routes setup_routes(app) return app
def setup_logging(): global logger config = get_config() custom_logger = utils.CISLogger( name=__name__, level=config('logging_level', namespace='cis', default='INFO'), cis_logging_output=config('logging_output', namespace='cis', default='cloudwatch'), cis_cloudwatch_log_group=config('cloudwatch_log_group', namespace='cis', default='staging')).logger() logger = custom_logger.get_logger()
def get_connection() -> connection: """connect to database and return a connection and cursor tuple""" config = get_config() cluster_config = config["CLUSTER"] conn = psycopg2.connect( "host={} dbname={} user={} password={} port={}".format( cluster_config.get("HOST"), cluster_config.get("DB_NAME"), cluster_config.get("DB_USER"), cluster_config.get("DB_PASSWORD"), cluster_config.get("DB_PORT"), )) return conn
async def init_app(argv=None): app = web.Application(client_max_size=10 * 1024 * 1024) # max client payload of 10MB app['config'] = get_config(argv) # create db connection on startup, close on exit # app.on_startup.append(init_pg) try: db_pool = await init_pg(app) app.on_cleanup.append(close_pg) except Exception as err: logging.debug(msg=err) # retry = 1 # max_retry = 5 # while retry < max_retry: # logging.info(msg='Retrying db connection {}'.format(retry)) # try: # import init_db # init_db.main() # db_pool = await init_pg(app) # app.on_cleanup.append(close_pg) # except Exception as err: # logging.debug(msg=err) # retry += 1 # time.sleep(5) # else: # break fernet_key = fernet.Fernet.generate_key() secret_key = base64.urlsafe_b64decode(fernet_key) setup_session(app, EncryptedCookieStorage(secret_key)) aiohttp_jinja2.setup( app, loader=jinja2.PackageLoader(PACKAGE_NAME), context_processors=[current_user_ctx_processor], ) setup_security(app, SessionIdentityPolicy(), DBAuthorizationPolicy(db_pool)) # setup views and routes setup_routes(app) return app
def load_settings(self, force_default=False, from_dict=None): if not from_dict: if force_default: self.config = settings.default_config else: self.config = settings.get_config() else: if from_dict == self.config: return self.config = from_dict if self.server: #TODO: Set to none only if server settings changed self.server = None self.set_ui_config()
async def init_app(): app = web.Application() app['config'] = get_config() # setup Jinja2 template renderer aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('templates')) # create db connection on startup, shutdown on exit app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) # setup routes and middlewares setup_routes(app) setup_middlewares(app) return app
async def init_app(argv=None): # argv, is ?? app = web.Application( ) # aiohttp.web.Application object supports dict interface. app['config'] = get_config(argv) # setup jinja2 template renderer # aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader('/path/to/templates/folder')) _templates_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader(_templates_path)) # create db connection on startup, shutdown on exit. app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) # setup routes; routes direct to handlers (i.e. views.py in this demo). setup_routes(app) # setup middlewares setup_middlewares(app) return app
async def init_app(argv=None): # app = web.Application() loop = asyncio.get_event_loop() app = web.Application(loop=loop) app['config'] = get_config(argv) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) app['BASE_DIR'] = BASE_DIR # create db connection on startup, shutdown on exit app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) # setup views and routes setup_routes(app) setup_static_routes(app) setup_templates_routes(app) # set up setup_middlewares(app) setup_sessions(app) return app
from couchbase.cluster import Cluster from couchbase.cluster import ClusterOptions from couchbase.auth import PasswordAuthenticator from couchbase.management.admin import Admin from settings import BASE_DIR, get_config from db import register_user from model import CreateUser adm = Admin('Administrator', 'password', host='couchbase', port=8091) USER_CONFIG_PATH = BASE_DIR / 'config' / 'users.yaml' USER_CONFIG = get_config(['-c', '../config/users.yaml']) TEST_CONFIG_PATH = BASE_DIR / 'config' / 'users_test.yaml' TEST_CONFIG = get_config(['-c', TEST_CONFIG_PATH.as_posix()]) def setup_db(conf): adm.bucket_create(conf['bucket'], bucket_type='couchbase', ram_quota=100) adm.wait_ready(conf['bucket'], timeout=30) def teardown_db(conf): adm.bucket_remove(conf['bucket']) def get_bucket(conf): cluster = Cluster("{host}:{port}".format(host=conf['host'], port=conf['port']), options=ClusterOptions(
from aiohttp import web from routes import setup_routes from settings import get_config from db import init_pg, close_pg import aiohttp_jinja2 import jinja2 def init_app(): app = web.Application() app['config'] = get_config() aiohttp_jinja2.setup(app, loader=jinja2.PackageLoader('sample', 'templates')) app.on_startup.append(init_pg) app.on_cleanup.append(close_pg) setup_routes(app) return app if __name__ == '__main__': app = init_app() config = get_config() web.run_app(app, port=8081)
#! -*- coding: utf8 -*- import os import logging from logging import handlers import settings cfg = settings.get_config() log_file = os.path.join(settings._basedir, cfg['default']['log_file']) log_format = "[%(asctime)s] %(levelname)s - %(message)s" handler = handlers.TimedRotatingFileHandler(log_file, when='midnight', interval=1, backupCount=0) formatter = logging.Formatter(log_format) handler.setFormatter(formatter) logger = logging.getLogger('graphitecd') logger.addHandler(handler) logger.setLevel(logging.DEBUG)
import asyncio from database import db from settings import get_config from game_models.humanoids import db_model db_config = get_config()['postgres'] async def db_update(): async with db.with_bind( 'postgresql://{user}:{password}@{host}:{port}/{database}'.format( database=db_config['database'], user=db_config['user'], password=db_config['password'], host=db_config['host'], port=db_config['port'])) as engine: await db.gino.create_all() async def main(): await db_update() # if __name__ == '__main__': asyncio.get_event_loop().run_until_complete(main()) # def create_elf(): # elf = models.Elf({'name': 'Ara', 'age': 15}) # elf.save() # create_elf()
def save_table_hive(rdd, database_table, hive_context): data_frame = hive_context.jsonRDD( rdd, hive_context.table(database_table).schema) data_frame.repartition(1).write.partitionBy('partition_namespace', 'partition_datetime') \ .saveAsTable(database_table, mode="append") def run(configurations): spark_context = SparkContext(appName=configurations.app_name) hdfs_directory = get_hdfs_directory(configurations.hdfs_directory_base, format_regex='%Y-%m-%d_%H') rdd = create_rdd_hdfs(spark_context=spark_context, hdfs_directory_path=hdfs_directory) rdd = rdd.map(mapJson) hive_context = create_hive_context(spark_context) save_table_hive(rdd, configurations.database_table, hive_context) if __name__ == "__main__": if len(argv) > 1: configurations = get_config(argv[1]) else: configurations = get_config(None) run(configurations)
from settings import get_config import pycouchdb conn = get_config('connection') cdb_conf = conn.get('couchdb') cdb_server = pycouchdb.Server('http://%s:%s/' % (cdb_conf['host'], cdb_conf['port'])) acc_couchdb = cdb_server.database(cdb_conf['database'])
from routes import setup_routes from settings import get_config, get_logger if __name__ == '__main__': app = web.Application() parser = argparse.ArgumentParser(description='Process arguments.') parser.add_argument('--config_file', dest='config_file', default='./config/local.yaml', help='config file path') path = parser.parse_args().config_file app['config'] = get_config(path) app['logger'] = get_logger() setup_routes(app) aiohttp_jinja2.setup(app, loader=jinja2.FileSystemLoader( os.path.abspath('templates'))) logging.basicConfig(level=logging.INFO) logging.info('Web server started on port %s' % app['config']['port']) logging.info('Config file: %s' % path) web.run_app( app, host=app['config']['host'],