def update_from_config(self, filename): """Update a Petri Net with a configuration file Read a configuration file and update the transition parameters with the values specifies on it. Args: filename (str): String representing the path of the configuration file """ config_file = utils.load_configuration(filename) config = config_file['conditions'] for t_conf in config: t_name = t_conf.get('transition', None) t_min = t_conf.get('time-min', None) t_max = t_conf.get('time-max', None) t_guard = t_conf.get('condition', None) # transition doesn't exist if not self._pn.has_transition(t_name): continue # there are no modifications t = self._pn.transition(t_name) if [t.min_time, t.max_time, str(t.guard)] == [t_min, t_max, t_guard]: continue self.update_transition(t_name, t_min, t_max, self._str_to_expression(t_guard))
def main(): conf = load_configuration('conf.ini') with open(os.path.join(here, 'data', 'counters.json')) as fp: counters_data = json.load(fp) counters = [] sortkey = lambda x: counters_data[x[0]] cconf = sorted(conf['catalogs'].iteritems(), key=sortkey, reverse=True) maxcount = max(counters_data.itervalues()) for name, catalog in cconf: count = counters_data[name] counters.append({ 'name': name, 'title': catalog.get('title') or name, 'cfg': catalog, 'count': count, 'width': '{0:.2f}'.format(count * 100 / maxcount), }) loader = jinja2.FileSystemLoader(os.path.join(here, 'templates')) env = jinja2.Environment(loader=loader) template = env.get_template('index.jinja') rendered = template.render({ 'counters': counters, }) print(rendered)
def get_mongo_client(db='informed_investing', connect=True): m_cfg = load_configuration('mongo') client = MongoClient( f"mongodb://{m_cfg['user']}:{m_cfg['password']}@{m_cfg['host']}:{m_cfg['port']}", connect=connect) db = client[db] return db
def _load_configuration(input_directory, experiment, keys): config = utils.load_configuration( os.path.join(input_directory, "..", "config_" + experiment + ".yaml")) if len(keys) > 1: return config[keys[0]][keys[1]] else: return config[keys[0]]
def main(): conf = utils.load_configuration("drwatson.conf") app = api.create_app() app.run(host='0.0.0.0', debug=conf.getboolean('app', 'Debug'), port=int(conf["app"]["port"]))
def main(): # We want to update counters for each catalog # and print on the standard output. counters = {} conf = load_configuration('conf.ini') for catalog_name, catalog in conf['catalogs'].iteritems(): counters[catalog_name] = count_datasets(catalog) print(json.dumps(counters))
def main(): # Load sawyer specific configuration sawyer_configuration = load_configuration('sawyer_configuration.json') sample_configurations = sawyer_configuration['sample_configurations'] # Setup simulator sim, sawyer_robot, obstacles = init_sim_with_sawyer() # Moving Sawyer to a start position sawyer_robot.move_to_joint_pos(sample_configurations['config0']) time.sleep(2) manual_control(sawyer_robot)
def __init__(self, pn, path_conf): """Initialization of the Improver class. Args: pn (PetriNet): Petri net to be walked path_conf (str): Path to the configuration file """ self._pn = copy.deepcopy(pn) configuration = utils.load_configuration(path_conf) self._actions = self._get_actions(configuration) self._pn.update_from_config(path_conf) self._add_environment_pn() self._current_time = 0.0 self.restart()
def main(): # Load sawyer specific configuration sawyer_configuration = load_configuration('sawyer_configuration.json') excluded_pairs = sawyer_configuration['excluded_pairs'] sample_configurations = sawyer_configuration['sample_configurations'] # Setup simulator sim, sawyer_robot, obstacles = init_sim_with_sawyer() # Moving Sawyer to a start position sawyer_robot.move_to_joint_pos(sample_configurations['config0']) time.sleep(3) start_state_config = sample_configurations['config0'] goal_state_config = sample_configurations['config1'] sawyer_id = sawyer_robot.get_simulator_id() link_pairs = get_link_pairs(sawyer_id, excluded_pairs=excluded_pairs) # Initializing STOMP stomp = STOMP(sim, sawyer_robot, link_pairs, obstacles, start_state_config, goal_state_config, N=10, control_coefficient=0.1, play_pause=True) # stomp.visualize_trajectory(show_only_dot=True) stomp.plan() stomp.visualize_trajectory() stomp.print_trajectory() trajectory_data = stomp.get_trajectory(1) sawyer_robot.execute_trajectory(trajectory_data) # Loop until someone shuts us down try: while True: sim.step() except KeyboardInterrupt: p.disconnect() sys.exit(0)
def create_app(): """ Defines routes and returns a Flask object. """ conf = utils.load_configuration("drwatson.conf") app = flask.Flask(__name__) app.secret_key = os.urandom(128) cors.CORS(app) mongo = pymongo.MongoClient("localhost", 27017) db = mongo.drwatson Watson = w.WatsonConnector(url=conf["watson"]["url"], username=conf["watson"]["username"], password=conf["watson"]["password"], version=conf["watson"]["version"]) Person = p.Personality(url=conf["personality"]["url"], username=conf["personality"]["username"], password=conf["personality"]["password"], version=conf["personality"]["version"]) Chatbot = c.Chatbot(url=conf["chatbot"]["url"], username=conf["chatbot"]["username"], password=conf["chatbot"]["password"], version=conf["chatbot"]["version"], workspace_id=conf["chatbot"]["workspace"]) chatbot_sessions = {} ######### # Feeds # ######### @app.route('/feeds', methods=['GET']) def get_feeds(): """ Returns all available feeds. """ feeds = db.feeds output = [] for s in feeds.find(): output.append(s) return json_util.dumps(output) @app.route('/feeds/<path:feed>', methods=['GET']) def get_feed(feed): """ Returns info for specified feed. """ feed = db.feeds.find({"key": feed}) return json_util.dumps(feed) @app.route('/feeds/<path:key>', methods=['PUT']) def post_feed(key): """ Post new feed """ feeds = db.feeds feed = feeds.find({"key": key}) # TODO: Validate request data key = flask.request.json['key'] url = flask.request.json['url'] name = flask.request.json['name'] active = flask.request.json['active'] date_field = flask.request.json['date_field'] text_field = flask.request.json['text_field'] new_feed = { "key": key, "url": url, "name": name, "active": active, "date_field": date_field, "text_field": text_field } feeds.replace_one({"key": key}, new_feed, True) return flask.jsonify({"result": []}, 201) @app.route('/feeds/<path:key>', methods=['DELETE']) def delete_feed(key): """ Delete a feed. """ feeds = db.feeds feed = feeds.find({"key": key}) if not feed: flask.abort(404) feeds.delete_one({"key": key}) return flask.jsonify({}, 200) ######### # Users # ######### @app.route('/users', methods=['GET']) def get_users(): """ Returns all users. """ users = db.users output = [] for s in users.find(): output.append(s) output = json_util.dumps(output) status = 200 if output == "[]": status = 204 return output, status @app.route('/users/<path:username>', methods=['GET']) def get_user(username): """ Returns Profile for specified user. """ user = db.users.find({"username": username}) user = json_util.dumps(user) status = 200 if user == "[]": status = 204 return user, status @app.route('/users/<path:username>/feeds', methods=['GET']) def get_feeds_for_user(username): """ Returns all feeds for specified user. """ user = db.users.find_one({"username": username}) try: feeds = user["feeds"] status = 200 except IndexError as e: feeds = {} status = 204 feeds = json_util.dumps(feeds) return feeds, status @app.route('/users/<path:username>', methods=['PUT']) def post_user(username): """ Create a new user profile. """ users = db.users # TODO: Validate request data username = flask.request.json['username'] password = flask.request.json['password'] mail = flask.request.json['mail'] feeds = flask.request.json['feeds'] new_user = { "username": username, "mail": mail, "password": password, "feeds": feeds } users.replace_one({"username": username}, new_user, True) return flask.jsonify({}, 201) @app.route('/users/<path:username>', methods=['DELETE']) def delete_user(username): """ Delete a user profile. """ users = db.users user = users.find({"username": username}) if not user: flask.abort(404) users.delete_one({"username": username}) return flask.jsonify({}, 200) ########### # Reports # ########### @app.route('/reports/<path:username>', methods=['GET']) @app.route('/users/<path:username>/reports', methods=['GET']) def get_user_reports(username): """ Returns all reports for specified user. """ reports = db.reports.find({"username": username}) reports = json_util.dumps(reports) status = 200 if reports == "[]": status = 204 return reports, status @app.route('/reports/<path:username>/<path:date>', methods=['GET']) def get_user_report_date(username, date): """ Returns specified report for specified user. """ report = db.reports.find({"username": username, "date": date}) report = json_util.dumps(report) status = 200 if report == "[]": status = 204 return report, status @app.route('/reports/<path:username>/<path:date>', methods=['PUT']) def post_report(username, date): """ Create a new report for a user """ reports = db.reports report = reports.find({"username": username, "date": date}) if not report: flask.abort(404) rm = r.ReportManager(username, Watson, db) rm.ta_report(date) return flask.jsonify({}, 201) @app.route('/reports/<path:username>/<path:date>', methods=['DELETE']) def delete_report(username, date): """ Delete a report """ reports = db.reports report = reports.find({"username": username, "date": date}) if not report: flask.abort(404) reports.delete_one({"username": username, "date": date}) return flask.jsonify({}, 200) @app.route('/pireport/<path:username>', methods=['GET']) def get_user_pireport(username): """ Returns PI report for specified user. """ report = db.pireports.find({"username": username}) report = json_util.dumps(report) status = 200 if report == "[]": status = 204 return report, status ############# # Functions # ############# @app.route('/functions/generate/reports/<path:username>', methods=['GET']) def generate_all_reports(username): """ Generate all reports for specified user. """ rm = r.ReportManager(username=username, watson_manager=Watson, personality=Person, db_connector=db) dates = rm.get_dates() for date in dates: pass #rm.ta_report(date) rm.pi_report() return flask.jsonify({}, 200) @app.route('/functions/chatbot', methods=['POST']) def chatbot(): """ Talk to chatbot. """ # TODO: Validate request data chat_input = flask.request.json['input'] session_id = flask.request.json['sessionid'] if session_id in chatbot_sessions: context = chatbot_sessions[session_id] else: context = {} response = Chatbot.conversate(text=chat_input, context=context) chatbot_sessions[session_id] = response['context'] response_output = response['output'] try: response_output["intent"] = response["intents"] except IndexError as e: response_output["intent"] = [] print(response_output) return flask.jsonify(response_output, 200) return app
np.random.shuffle(pos_assemblies) assemblies = np.split(np.arange(num_neurons_per_assembly * num_assemblies), num_assemblies) branch1_nodes = np.max(assemblies) + 1 + np.arange(num_branch_nodes) branch2_nodes = np.max(branch1_nodes) + 1 + np.arange(num_branch_nodes) branch3_nodes = np.max(branch2_nodes) + 1 + np.arange(num_branch_nodes) branch_nodes = [branch1_nodes, branch2_nodes, branch3_nodes] if experiment == "rewiring_ex5": idc_branch_nodes = [0, 2] else: idc_branch_nodes = range(num_branch_nodes) # Load the configuration file. config = utils.load_configuration(os.path.join( input_directory, "..", "config_" + experiment + ".yaml")) sim_simulation_time = config["simulation_time"] sim_w_max = config["connection_parameters"]["w_max"] sim_input_size = config["input_parameters"]["num_inputs"] sim_num_assemblies = config["input_parameters"]["num_assemblies"] sim_assembly_size = config["input_parameters"]["assembly_size"] sim_num_branches = config["neuron_parameters"]["num_branches"] sim_sampling_interval_weights = config["sampling_interval_weights"] input_size = config["input_parameters"]["num_inputs"] if experiment == "rewiring_ex5": assembly_idc = [] assembly_idc = np.loadtxt( os.path.join(input_directory, "assembly_neurons_idc"), dtype=np.int) # for assembly_idx_low in np.sort(assembly_idc_low): # assembly_idc.append(np.arange(assembly_idx_low, assembly_idx_low +
# # This script downloads and ingests Drop Token game # and player data into the database configured in # the `configuration.yml` file located in the same # directory. The database and its tables must be created # using the `DW_setup.sql` script (located in the same directory) # before running this script. # The script assumes that both the games and players # data sets are complete data sets each time the script runs. # Data in the `prepared` schema tables is removed before # new data gets added. from loaders import load_game_data as games, load_player_data as players import utils local_games_csv_path = './game_data.csv' config = utils.load_configuration('./configuration.yml') games.load_data(config['game_data_csv_location'], local_games_csv_path, False, config['database_server'], config['database_server_port'], config['database'], config['database_user'], config['database_password'], True) players.load_data(config['player_data_location'], config['database_server'], config['database_server_port'], config['database'], config['database_user'], config['database_password'], True)
abort(501, 'Undefined service: %s.' % service_name) @get('/service/<service_name>/status') def service_status(service_name): """Exposes the /service/<service_name>/status endpoint accessible via a GET method. Used to retrieve the number of running resources for a service as JSON. """ try: service_definition = services[service_name] running_resources = docker.count_containers_by_image( service_definition['image']) response = {} response['running_resources'] = running_resources return response except KeyError: abort(501, 'Undefined service: %s.' % service_name) if __name__ == '__main__': """Main method. Retrieve the configuration from the configuration file. It also retrieves the services from a service definition file. Finally, it creates a DockerManager instance and start the web server. """ config = load_configuration('genisys-connector.yml') services = load_services_from_file(config['connector']['service_file']) docker = DockerManager(config['docker']['url']) run(host=config['connector']['bind'], port=config['connector']['port'])
def __call__(self): yaml_spec = load_configuration() return self.klass(yaml_spec)
import requests from flask import Flask, request from utils import (get_healthy_server, healthcheck, load_configuration, process_firewall_rules_flag, process_rewrite_rules, process_rules, transform_backends_from_config) loadbalancer = Flask(__name__) config = load_configuration("loadbalancer.yaml") register = transform_backends_from_config(config) @loadbalancer.route("/") @loadbalancer.route("/<path>") def router(path="/"): updated_register = healthcheck(register) host_header = request.headers["Host"] header_dictionary = {k: v for k, v in request.headers.items()} if not process_firewall_rules_flag( config, host_header, request.environ["REMOTE_ADDR"], f"/{path}", header_dictionary, ): return "Forbidden", 403 for entry in config["hosts"]: try:
#import the class definition from "email_handler.py" file from email_handler import Class_eMail #import common import sys sys.path.insert(1, '/home/dominika/ZSW_CZW0815_SMART_HOME/main') import common import utils #set the email ID where you want to send the test email # global data utils.load_configuration() To_Email_ID = common.data['mail'] #print(To_Email_ID) # warning warning_subject = 'Warning!' warning_text = 'Warning! \ The password was incorrect. \ Please enter the correct password.' # Send Plain Text Email email = Class_eMail() email.send_Text_Mail(To_Email_ID, warning_subject, warning_text) del email
else: compute_definition = select_compute_definition(computes) except KeyError: abort(501, 'Undefined compute: {}.'.format(compute_name)) services = shared_queue.get() services.add(service_name) shared_queue.put(services) scale_service(compute_definition, service_name, resource_number) def start_webserver(host, port): run(host=host, port=port) if __name__ == '__main__': config = load_configuration('genisys.yml') computes = load_computes_from_file(config['genisys']['compute_file']) shared_queue = Queue(1) try: api_thread_args = dict(host=config['genisys']['bind'], port=config['genisys']['port']) api_thread = threading.Thread(target=start_webserver, kwargs=api_thread_args).start() poller_thread_args = dict(config=config, computes=computes, queue=shared_queue) poller_thread = threading.Thread(target=poll_connectors, kwargs=poller_thread_args).start() except Exception: print('The application failed to start.')
'G': arguments['G'], 'kernel_size': 3, 'c_dim': 3, 'G0': arguments['G0'], } model = load_model(model_parameters, arguments['vgg'], verbose=arguments['verbose']) if arguments['summary'] is True: model.rdn.summary() if arguments['train'] is True: from trainer.train import Trainer trainer = Trainer(train_arguments=arguments) trainer.train_model(model) if arguments['test'] is True: from predict import Predictor predictor = Predictor(test_arguments=arguments) predictor.get_predictions(model) if __name__ == '__main__': parser = get_parser() cl_args = parser.parse_args() cl_args = vars(cl_args) load_configuration(cl_args) main(cl_args)
from flask import Flask, request import requests, random from utils import load_configuration, transform_backends_from_config, get_healthy_server, process_rules, process_rewrite_rules, process_firewall_rules_flag from tasks import healthcheck import sys loadbalancer = Flask(__name__) config = load_configuration('loadbalancer.yaml') register = transform_backends_from_config(config) @loadbalancer.route("/") @loadbalancer.route("/<path>") def router(path="/"): updated_register = healthcheck(register) host_header = request.headers["Host"] if not process_firewall_rules_flag( config, host_header, request.environ["REMOTE_ADDR"], "/" + path): return "Forbidden", 403 for entry in config["hosts"]: if host_header == entry["host"]: healthy_server = get_healthy_server(entry["host"], updated_register) if not healthy_server: return "No Backends servers available", 503 headers = process_rules(config, host_header, {k: v for k, v in request.headers.items()}, "header") params = process_rules(config, host_header, {k: v
def __init__(self): self._name = "quickfs" self._config = load_configuration(self._name) self._api_key = self._config['API_KEY']
vm.active = False spaghetti.kernel.run_chunk(simulation_time - 40, 0, simulation_time) sm_inp.active = True vm_nrn.active = True for vm in vm_br: vm.active = True spaghetti.kernel.run_chunk(20.0, 0, simulation_time) if __name__ == '__main__': import copy from scoop import futures # Load the configuration file. config = utils.load_configuration("experiments/config_rewiring_ex2.yaml") # Change a specific parameter. param = "plateau_duration_max" delta_param = +0.1 # +-10 % # params = config["connection_parameters"] params = config["neuron_parameters"]["branch_parameters"] value = params[param] if value >= 0: params[param] += delta_param * value else: params[param] += -delta_param * value if delta_param >= 0:
def __init__(self, ticker): config = load_configuration('iexfinance') self._stock = Stock(ticker, token=config['API_KEY']) print(self._stock.get_price())
@get('/service/<service_name>/status') def service_status(service_name): """Exposes the /service/<service_name>/status endpoint accessible via a GET method. Used to retrieve the number of running resources for a service as JSON. """ try: service_definition = services[service_name] running_resources = docker.count_containers_by_image( service_definition['image']) response = {} response['running_resources'] = running_resources return response except KeyError: abort(501, 'Undefined service: %s.' % service_name) if __name__ == '__main__': """Main method. Retrieve the configuration from the configuration file. It also retrieves the services from a service definition file. Finally, it creates a DockerManager instance and start the web server. """ config = load_configuration('genisys-connector.yml') services = load_services_from_file(config['connector']['service_file']) docker = DockerManager(config['docker']['url']) run(host=config['connector']['bind'], port=config['connector']['port'])