Beispiel #1
0
    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()
Beispiel #2
0
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
Beispiel #3
0
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')
Beispiel #4
0
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)
Beispiel #5
0
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
Beispiel #6
0
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
Beispiel #8
0
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
Beispiel #9
0
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()
Beispiel #11
0
def db():
    config = get_config(['-c', TEST_CONFIG_PATH.as_posix()])
    cb_conf = config['couchbase']

    setup_db(cb_conf)
    yield
    teardown_db(cb_conf)
Beispiel #12
0
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.
Beispiel #13
0
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
Beispiel #14
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)
Beispiel #15
0
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
Beispiel #16
0
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'])
Beispiel #17
0
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'])
Beispiel #18
0
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
Beispiel #19
0
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'
        )
Beispiel #20
0
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
Beispiel #21
0
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()
Beispiel #23
0
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
Beispiel #24
0
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
Beispiel #25
0
    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()
Beispiel #26
0
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
Beispiel #27
0
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
Beispiel #28
0
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
Beispiel #29
0
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(
Beispiel #30
0
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)
Beispiel #31
0
#! -*- 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()
Beispiel #33
0

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)
Beispiel #34
0
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'])

Beispiel #35
0
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'],