def setValueAt(self, value, row_index, column_index): property = self.getColumnName(column_index).lower() if self._column_model.is_array(column_index): value = InfrastructureHelpers.split(value) Application.get_instance().execute( self._create_set_object_property_application_command( self._objects[row_index].get_id(), property, value))
def itemStateChanged(self, event): for button in self._buttons: if button.isSelected(): Application.get_instance().execute( SetDomainDictValueCommand( SetDomainDictValueCommand.TYPE_PRE_ANALYZE_VALIDATOR, 'capturing', button.getLabel())) break
def _execute_select_objects_command(self): Application.get_instance().execute( SetDomainDictValueCommand( self._get_domain_dict_type(), 'object_ids', self._model.map_object_indexes_to_ids([ self.convertRowIndexToModel(i) for i in self.getSelectedRows() ])))
def itemStateChanged(self, event): for button in self._buttons: if button.isSelected(): Application.get_instance().execute( SetDomainDictValueCommand( SetDomainDictValueCommand.TYPE_VISIBLE_ITEMS, 'tags_operator', button.getLabel())) break
def itemStateChanged(self, event): statuses = [] for check_box in self._check_boxes: if check_box.isSelected(): statuses.append(check_box.getLabel()) Application.get_instance().execute( SetDomainDictValueCommand( SetDomainDictValueCommand.TYPE_VISIBLE_ITEMS, 'statuses', statuses))
def _prepare_application(self): database = Database(Logger()) Application.set_instance(Application( BurpServices(), database, ItemRepository(database), PathPatternRepository(database), UIServices(), ValueRepository() ))
def itemStateChanged(self, event): scope_tools = [] for check_box in self._check_boxes: if check_box.isSelected(): scope_tools.append(check_box.getLabel()) Application.get_instance().execute(SetDomainDictValueCommand( SetDomainDictValueCommand.TYPE_PRE_ANALYZE_VALIDATOR, 'scope_tools', scope_tools ))
def _execute_select_main_object_command(self): main_object_id = None main_object_index = self.getSelectedRow() if main_object_index != -1: main_object_id = self._model.map_object_indexes_to_ids( [self.convertRowIndexToModel(main_object_index)])[0] if main_object_id != self._prev_main_selected_object_id: Application.get_instance().execute( SetDomainDictValueCommand(self._get_domain_dict_type(), 'main_object_id', main_object_id)) self._prev_main_selected_object_id = main_object_id
def application(): complete = {} if request.method == 'POST': result = request.form for key, value in result.items(): if key != 'csrf_token': if key != 'submit': complete[key] = value now = unicode(datetime.datetime.now()) complete['timestamp'] = now #print application app_obj = Application(complete['full_name']) process_form_results(complete, app_obj) app_obj.id = complete['full_name'] app_obj.grade = complete['grade'] app_obj.multiply(app_obj.qualifier) app_obj.expo_bloom(app_obj.qualifier, app_obj.raw_score) #print application application = json.dumps(app_obj.__dict__) with open("data/output.json", "a") as record: record.write('\n\n' + application) return render_template('ack.html', result=complete, object=app_obj) else: form = ApplicationForm() return render_template('application_form.html', title="Application", form=form, wtf=wtf)
def load_config(path_str, language_model): with open(path_str) as data_file: data = json.load(data_file) app_dict = {} for app in data[APPLICATIONS_TAG]: turn_on = bool(app[APPLICATION_TURN_ON]) if not turn_on: continue app_name = app[APPLICATION_NAME_TAG] description = app[APPLICATION_DESCRIPTION_TAG] type = app[APPLICATION_TYPE_TAG] URL = app.get(APPLICATION_ENDPOINT_URL_TAG, None) intents = [] for intent in app[APPLICATION_INTENTS_TAG]: intent_name = intent[INTENT_NAME_TAG] samples_list = intent.get(INTENT_SAMPLES_TAG, None) if samples_list is not None: samples_list = [get_lemmas(el, language_model) for el in samples_list] key_phrases_list = intent.get(INTENT_KEY_PHRASES_TAG, EMPTY_LIST) key_phrases_list = [x.lower() for x in key_phrases_list] parameters_list = [] param_description_list = intent.get(INTENT_PARAMETERS_TAG, EMPTY_LIST) for parameter in param_description_list: param_name = parameter[PARAMETER_NAME_TAG] param_data_type = parameter[PARAMETER_TYPE_TAG] param_data_type = DataType[param_data_type.upper()] param_obligatory = parameter[PARAMETER_OBLIGATORY_TAG] param_regexp = parameter.get(PARAMETER_REGEXP_TAG, None) param_regexp_group = parameter.get(PARAMETER_REGEXP_GROUP_TAG, None) param_question = parameter.get(PARAMETER_QUESTION_TAG, None) param_inst = Parameter(param_name, param_data_type, obligatory_bool=param_obligatory, question_str=param_question, regexp=param_regexp, regexp_group=param_regexp_group) parameters_list.append(param_inst) intent_desc = intent.get(INTENT_DESCRIPTION_TAG, None) intent_ints = Intent(intent_name, key_phrases_list, parameters_list, samples=samples_list, description=intent_desc) intents.append(intent_ints) app_inst = Application(app_name, description, intents, integration_type=IntegrationType[type], url=URL) clazz = app.get(APPLICATION_IMPLEMENTATION, None) if clazz is not None: app_inst.set_impl(clazz) app_dict[app_name.lower()] = app_inst return app_dict
def execute_from_terminal(args): if len(args) == 1: print( "No parameters here! \nFor start this app use script\n\tpython startapp.py runserver" ) return -1 else: command = args[1] if command == "runserver": port = 5555 application = Application(port=port) cors = CORS(application.server) application.server.run(debug=True, port=port) elif command == "createsuperuser": create_superuser() elif command == "createtables": create_tables() elif command == "droptables": drop_all_tables() else: print( "Unsupported command! Use next commands:\n\t1. runserver\n\t2. createsuperuser\n\t3. createtables\n\t4. droptables" )
def actionPerformed(self, event): database_path = UIHelpers.choose_file() if database_path: if Application.get_instance().execute( SetDomainDictValueCommand( SetDomainDictValueCommand.TYPE_PERSISTENCE, 'database_path', database_path)): self._text_field.setText(database_path)
def app(request): # Before driver = webdriver.Chrome("/usr/local/bin/chromedriver") fixture = Application(driver) # request.addfinalizer(fixture.driver.close) # After def fin(): # driver.quit() pass request.addfinalizer(fin) return fixture
def main(): options.parse_command_line() config_file = options.config_file try: config = json.load(open(config_file)) db_conf = config['db'] rows_per_page = config.get('rows_per_page', 20), except BaseException as exc: logging.error("[x] Failed to load configuration. %s", str(exc)) return 1 logging.info('Starting main server') http_server = tornado.httpserver.HTTPServer( Application(db_conf, rows_per_page[0])) http_server.listen(options.application_port) tornado.ioloop.IOLoop.current().start()
EXIT_STATUS = -1 def stop(): ioloop = tornado.ioloop.IOLoop.instance() ioloop.add_callback(ioloop.stop) if __name__ == "__main__": import tornado from application.application import Application from application.controller.plugins_controller import PluginsController from webservice.webservice import WebService application = Application(path_data="wstest/data/", address='localhost', test=True) application.register(WebService(application, 3000)) application.start() controller = application.controller(PluginsController) for plugin_uri in controller.lv2_builder.plugins: print(plugin_uri) from _thread import start_new_thread start_new_thread(test_thread, ()) tornado.ioloop.IOLoop.current().start() application.stop() sys.exit(EXIT_STATUS)
def stop(): ioloop = tornado.ioloop.IOLoop.instance() ioloop.add_callback(ioloop.stop) if __name__ == "__main__": import tornado from application.application import Application from application.controller.plugins_controller import PluginsController from webservice.webservice import WebService application = Application(path_data="wstest/data/", address='localhost', test=True) application.register(WebService(application, 3000)) application.start() controller = application.controller(PluginsController) for plugin_uri in controller.lv2_builder.plugins: print(plugin_uri) from _thread import start_new_thread start_new_thread(test_thread, ()) tornado.ioloop.IOLoop.current().start() application.stop()
import pygame from application.application import Application, Camera application = Application("Agar.io", 800, 600, False) clock = pygame.time.Clock() FPS = 60 def main(): application.start() pause = False while application.is_running: clock.tick(FPS) for event in pygame.event.get(): if event.type == pygame.QUIT: application.shut_down() if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: application.shut_down() if event.key == pygame.K_p: pause = True if event.key == pygame.K_r: pause = False if pause == False: application.update() application.draw() pygame.quit() if __name__=="__main__": main()
def _is_pre_analyze_validation_pass(self, tool_flag): return Application.get_instance().execute( self._create_make_pre_analyze_validation_command(tool_flag))
def actionPerformed(self, event): Application.get_instance().execute(self._create_application_command( event.getActionCommand() ))
from application.application import Application import utils.updatechecker as upd import sys, os, time app = Application("Ultra", show_tabs=False) app.run()
def run(self): Application.get_instance().execute(self.command)
def itemStateChanged(self, event): Application.get_instance().execute( SetDomainDictValueCommand(self._get_domain_dict_type(), self._get_domain_dict_key(), self._check_box.isSelected()))
from application.application import Application from flask_cors import CORS from werkzeug.middleware.proxy_fix import ProxyFix application = Application(port=5555) cors = CORS(application.server) application.server.wsgi_app = ProxyFix(application.server.wsgi_app)
def _is_pre_process_validation_pass(self, request_info, response_info): return Application.get_instance().execute( self._create_make_pre_process_validation_command( request_info, response_info))
def __init__(self, checkpoint_path, model_name): self.chkpoint = checkpoint_path self.app = Application(load_path=checkpoint_path, model_name=model_name) self.datahelper = DataHelper()
import tornado.ioloop import tornado.options from tornado.options import define, options import first_module from application.application import Application from helper import config from util.log import logger from init import init port = config.ConfigHelper.get_server_port() define("port", default=port, help="run on the given port", type=int) if __name__ == "__main__": init() tornado.options.parse_command_line() Application().listen(options.port) tornado.ioloop.IOLoop.current().start()
def main(): """ Entry point for the application. """ app = Application() app.run()
import sys from application.application import Application if __name__ == '__main__': app = Application(sys.argv) sys.exit(app.run())
(If you don't have a configuration yet, create one with the CETONI Elements software first.)""" ) parser.add_argument('-v', '--version', action='version', version='%(prog)s ' + __version__) parser.add_argument( '-p', '--server-base-port', action='store', default=DEFAULT_BASE_PORT, help='The port number for the first SiLA server (default: %d)' % DEFAULT_BASE_PORT) return parser.parse_args() if __name__ == '__main__': logging_level = logging.DEBUG # or use logging.ERROR for less output LOGGING_FORMAT = '%(asctime)s [%(threadName)-12.12s] %(levelname)-8s| %(module)s.%(funcName)s: %(message)s' try: coloredlogs.install(fmt=LOGGING_FORMAT, level=logging_level) except NameError: logging.basicConfig(format=LOGGING_FORMAT, level=logging_level) parsed_args = parse_command_line() app = Application(parsed_args.config_path, int(parsed_args.server_base_port)) app.run()
# Copyright 2017 SrMouraSilva # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from application.application import Application from raspberry_p0.raspberry_p0 import RaspberryP0 application = Application(path_data="data/", address='localhost', test=True) p0 = RaspberryP0(application, configuration_file='config_test.ini') application.register(p0) application.start() application.stop()
def focusLost(self, event): Application.get_instance().execute( SetDomainDictValueCommand( self._get_domain_dict_type(), self._get_domain_dict_key(), InfrastructureHelpers.split(self._text_field.getText())))