def __init__(self, logger, env, packageName, jobName, endpoint, jobMetaData, ocpCertFile, sendToKafka, parameters, protocolType, protocols, shellConfig=None): """Initialize supporting variables for job execution (I/O and status). Arguments: logger : handler for the client log jobName (str) : name of the discovery/integration job endpoint (str) : target endpoint for client jobMetaData (dict) : input parameters for the job sendToKafka (dict) : function for sending results to kafka topic """ self.jobStatus = 'UNKNOWN' ## value in statusEnums self.statusEnums = { 1: 'SUCCESS', 2: 'WARNING', 3: 'FAILURE', 4: 'UNKNOWN', 5: 'INFO' } self.jobMessages = set() ## set instead of list, avoids duplicate msgs self.setupComplete = False self.startTime = datetime.datetime.now() self.packageName = packageName self.jobName = jobName self.results = Results(jobName, realm=jobMetaData.get('realm', 'default')) self.endpoint = endpoint self.env = env self.jobMetaData = jobMetaData self.ocpCertFile = ocpCertFile self.parameters = parameters self.protocolType = protocolType self.protocols = protocols self.shellConfig = shellConfig self.clearMessages() self.endTime = None self.sendToKafka = sendToKafka ## Create a log utility that in addition to standard log functions, will ## conditionally report messages based on the setting of a job parameter self.logger = jobParameterizedLogger( logger, self.parameters.get('printDebug', False)) if self.jobMetaData.get('updateParameters', False): ## Update parameters for endpoint (globals, config group, OS type) self.setParameters() self.setupComplete = True
def matrixRepresentation(): if request.method == 'POST': r = Results(c.circuit) try: matrix = r.matrixRepresentation(decimals=4) matrix = c.reversedMatrix(matrix, c.num_qubits) return jsonify({"error": False, "matrixRepresentation": matrix}) except Exception: return jsonify({"error": True})
def conditionalLoop(self, column, index): r = Results(self.circuit) newInitialization = Normalization.buildLoopCond( self.num_qubits, column, r.reversedStatevector) if all(ele == 0 for ele in newInitialization): raise Exception("conditional loop at column " + str(index) + " will never be satisfied (infinite loop)") self.circuit = QuantumCircuit(self.num_qubits, self.num_qubits) self.circuit.initialize(newInitialization, list(range(self.num_qubits - 1, -1, -1)))
def build(self): sm = ScreenManager() sm.add_widget(Login(name='login')) sm.add_widget(MainMenu(name='main_menu')) sm.add_widget(Profile(name='profile')) sm.add_widget(Results(name='results')) sm.add_widget(Tests(name='tests')) return sm
def test_results_sorting(driver): driver.maximize_window() driver.get("https://shop.by/") actions = ActionChains(driver) laptops = get_catalog_item(driver, COMPUTERS_MENU_ITEM, LAPTOP_SUBMENU_ITEM) actions.move_to_element(laptops).click().perform() actions.reset_actions() if "noutbuki" not in driver.current_url: raise Exception("Redirect to /%s page doesn't happened" % "noutbuki") set_price_range(driver, min_price, max_price) manufacture_filter = BaseFilterMenu(driver, MANUFACTURE_EXPAND_XPATH) manufacture_filter.expand() manufacture_filter.click_on_items(MANUFACTORY_LIST) time.sleep(COMMON_TIMEOUT) display_size_filter = BaseFilterMenu(driver, DISPLAY_SIZE_EXPAND_XPATH) display_size_filter.expand() display_size_filter.click_on_items(DISPLAY_SIZE_LIST) time.sleep(COMMON_TIMEOUT) filter_url = driver.current_url apply_button = driver.find_element_by_class_name(SHOW_RES_BUTTON) apply_button.click() if driver.current_url == filter_url: raise Exception("Redirect on result page is not happened.") sorter = SortMenu(driver, SORTER_XPATH, SORTER_ITEMS) sorter.select("price_asc") results = Results(driver, RESULTS_XPATH) assert results, "Got empty result list" print("%s results on the page" % len(results)) flink = result_item_link(results[0]) sorter.select("price_desc") time.sleep(3) paginator = Paginator(driver, PAGINATOR_XPATH) paginator.move_to_the_last() time.sleep(COMMON_TIMEOUT) llink = result_item_link(results[-1]) print(flink) print(llink) assert flink == llink, "First item in results sorted by price ascending is not equal " \ "to the latest item in results sorted by price descending"
def search_concept_predicate_object(self, concept, predication, object): concept_node = self.graph.get_node_by_name(concept) object_node = self.graph.get_node_by_name(object) self.graph.get_edge_by_predication(concept_node, predication, object_node) self.graph.load_nodes_from_source(object_node, max_level=1) self.graph.load_source_edges(object_node) self.graph.load_source_edges(concept_node) # Get the results results = Results(self.config, self.graph) results.create_table(concept_node) return results
def __init__( self, ideology_low, ideology_high, no_party ): #Maybe make ideology modular so it could be multi dimminesional self.ideology_low = ideology_low self.ideology_high = ideology_high self.no_agent = 169 self.no_party = no_party #self.agent = [] self.party = [] #store in environment self.environment = None self.results = Results()
def is_receptacle_overloaded(self, receptacle_id): receptacle = self.e_model.get_receptacle_by_id(receptacle_id) total_amp_load = receptacle.get_amp_load() amp_rating = receptacle.get_amp_rating() res = (total_amp_load > amp_rating) if True == DEBUG: print('Support.is_receptacle_overloaded() total_amp_load:{0} > amp_rating:{1} => {2}'.format(total_amp_load, amp_rating, res)) r = Results() r.set_object_id(res) return r
def __init__(self, data_set='ny'): self.data_set = data_set if data_set[0] == '.': self.data = DataSet(pat=data_set[1:]) else: self.data = DataSet(data_set) self.results = Results() self.tests = {} self.end = 0 self.first = None self.snd = None
def test_get_results_paginated_endpoint_one_page(self, get_mock): self.assertEqual(Results([{ 'a': 1 }, { 'b': 2 }]), TVmaze.get_results('shows')) self.assertEqual(2, get_mock.call_count) get_mock.assert_has_calls([ call('http://api.tvmaze.com/shows?page=0'), call('http://api.tvmaze.com/shows?page=1'), ], any_order=False)
def is_light_string_overloaded(self, light_string_id): ls = self.e_model.get_light_string_by_id(light_string_id) res = False if None != ls: total_amp_load = ls.get_amp_load() amp_rating = ls.get_amp_rating() res = (total_amp_load > amp_rating) if True == DEBUG: print('Support.is_light_string_overloaded() total_amp_load:{0} > amp_rating:{1} => {2}'.format(total_amp_load, amp_rating, res)) r = Results() r.set_object_id(res) return r
def bt(self, s): """ Main method for backtesting. :return: Results object """ print('Launching backtest') # Initialization for st in self.strats: st.prices = PU.get_prices(st, s) st.ind, st.signals = st.get_ind_and_signals() [earliest_start, latest_end] = self.timespan() bt_timespan = pd.date_range(s.start_dt_utc, latest_end, freq=s.freq) results = Results(self.strats, bt_timespan) schedules = [] if s.instr != 'crypto': for st in self.strats: schedules.append(st.cal.schedule(earliest_start, latest_end)) print('Backtest started!') now = dt.datetime.now() # Signal algos for st in self.strats: for algo in s.signal_algos: st.signals = algo.treat_signal(st, s) # Proper backtest bars for bar in bt_timespan: if s.lb.do_lb: self.lb_bt() for st_index, st in enumerate(self.strats): signal = 0 try: signal = st.signals[bar] except KeyError: signal = 0 finally: trade = self.get_trade(signal, bar, st_index, s) if trade != "No trade": self.dashboard.update_trade(trade) results.update_trade(trade) self.dashboard.update_bar(self.strats, bar) results.update_bar(self.dashboard, self.strats, bar) time = dt.datetime.now() - now print('Backtest performed. Computation time: ' + str(time)) print('Backtest contained ' + str(len(self.strats)) + ' strategies.') return results
def ASTAR(self): # Time how long it takes to get a path results = Results() start = time.clock() results.path = self.__ASTAR(results) end = time.clock() # Determine results results.runningTime = end - start if results.path: results.problemsSolved = 1 results.avgPathLen = self.getPathDistance(results.path) return results
def get_results(cls, endpoint: Union[None, str], data_file_path: Union[None, str]=None) -> Results: '''Returns an instance of Results fetched from either the specified endpoint or file. Note that exactly one of (`endpoint`, `data_file_path`) must be a string and the other must be None.''' # Do we want to load the data from a file instead of downloading it? if data_file_path is not None: assert endpoint is None return cls.get_results_from_file(data_file_path) assert endpoint is not None sanitized_endpoint = cls._sanitize_endpoint(endpoint) uri = f'{cls.API_BASE_URL}/{sanitized_endpoint}' # This is the only paginated API endpoint. if endpoint == 'shows': return Results(cls._get_paginated_results(uri)) # Endpoint is not paginated. results_page = cls._get_results_page(uri) if not results_page.is_found: # TODO: Use a more appropriate exception name or define a custom one. raise ValueError(f'Resource "{uri}" not found') return Results(results_page.results)
def search(self, criteria): """ ElasticSearch simple search (only query lesser than 10000 results) :params string criteria: simple query criterias :returns: objects in elasticsearch result """ results = Results(self.logger, current=str(inspect.stack()[0][1]) + "." + str(inspect.stack()[0][3])) result = self.es.search(index=self.index, q=criteria, request_timeout=self.timeout) results.add_success(result) return [result, results.results]
def is_outlet_overloaded(self, outlet_id): o = self.e_model.get_outlet_by_id(outlet_id) total_amp_load = o.get_amp_load() amp_rating = (0.8 * o.get_amp_rating()) max_amp_load = o.get_max_receptacle_amp_load() too_much_total_amp_load = (total_amp_load > amp_rating) too_much_amp_load_one_receptacle = (max_amp_load > amp_rating) res = too_much_total_amp_load or too_much_amp_load_one_receptacle if True == DEBUG: print('Support.is_outlet_overloaded() total_amp_load:{0}, max_amp_load:{1}, amp_rating:{2} => {3}'.format(total_amp_load, max_amp_load, amp_rating, res)) r = Results() r.set_object_id(res) return r
def alter(building, location, standard): sys.stdout.write('%s, %s, %s\n' % (building, location, standard)) row = Row.objects.get(set=set, building=building, standard=standard, location=location) costs = row.costs.all() new = min(map(residual, costs)) sys.stdout.write('\t') for cost in costs: r = Results(building, standard, location, cost.period, carbon, '0.03') old = r.base_residual.cost() cost.lifecycle_cost -= old cost.lifecycle_cost += new cost.save() sys.stdout.write('%d,' % int(cost.period.item())) sys.stdout.write('Success\n')
def update(self,data,item_id,dtype="doc",parent=None): """ Update existing object :params dic data: object data to update :params string item_id: id of object to update :params string dtype: object type **source** or **doc** :params string parent: parent unic identifier (mandatory for type doc, it's source id) :returns: elasticsearch updated object """ results=Results(self.logger,1,str(inspect.stack()[0][1])+"."+str(inspect.stack()[0][3])) #When you have a parent child relationship, you need to specify the parent in the URL each time you try to access it a child, since routing now depends on the parent. #json serialize with special date parser otherwise ES index fail result=self.es.update(index=self.index,doc_type=dtype,id=item_id,parent=parent,routing=parent,body=json.dumps(data,default=self.serializer.to_json),ignore=400) results.add_success(result["_id"]) return results.results
def __init__(self, config_element): pysage.Arena.__init__(self, config_element) self.exploitation_rate = 1 if config_element.attrib.get( "exploitation_rate") is None else float( config_element.attrib["exploitation_rate"]) self.timestep_length = 0.5 if config_element.attrib.get( "timestep_length") is None else float( config_element.attrib.get("timestep_length")) self.integration_step = 0.001 if config_element.attrib.get( "integration_step") is None else float( config_element.attrib.get("integration_step")) self.size_radius = 0.7506 if config_element.attrib.get( "size_radius") is None else float( config_element.attrib.get("size_radius")) self.results_filename = "CRWLEVY" if config_element.attrib.get( "results") is None else config_element.attrib.get("results") self.results = Results() # initialise num runs from the configuration file nnruns = config_element.attrib.get("num_runs") if nnruns is not None: self.num_runs = int(nnruns) else: self.num_runs = 1 # size_radius ssize_radius = config_element.attrib.get("size_radius") if ssize_radius is not None: self.dimensions_radius = float(ssize_radius) elif ssize_radius is None: self.dimensions_radius = float(self.dimensions.x / 2.0) # initialise targets from the configuration file self.targets = [] self.num_targets = 0 for target_element in config_element.iter("target"): # python 2.7 num_targets_to_configure = 1 if target_element.attrib.get( "num_elements") is None else int( target_element.attrib.get("num_elements")) for i in range(num_targets_to_configure): new_target = Target(target_element) self.targets.append(new_target) new_target.id = self.num_targets self.num_targets += 1 print "Initalised target", new_target.id, "(quality value:", new_target.value, ")"
def get(self,item_id,parent=None): """ get object from it's elasticsearch id :params string item_id: unique identifier string :returns: elasticsearch object """ results=Results(self.logger,1,str(inspect.stack()[0][1])+"."+str(inspect.stack()[0][3])) if parent is not None: result=self.es.get(index=self.index,doc_type='_all',routing=parent,id=item_id,ignore=[400,404]) results.add_success({"id":result["_id"]}) else: result=self.es.get(index=self.index,doc_type='_all',id=item_id,ignore=[400,404]) results.add_success({"id":result["_id"]}) results.finish() return [result,results.results]
def __init__(self, logger, redisHost, redisPort): """ Class constructor. :param logger logger: the logger :param str redis_host: Redis host where the Redis Q is running :param int redis_port: Redis port where the Redis Q is running """ self.logger = logger self.config = Config() self.redis_host = redisHost self.redis_port = redisPort self.results = Results(logger, redisHost, redisPort) self.workloadTracker = WorkloadTracker(self.logger)
def bulk(self, doc_list): """ Simple elasticsearch bulk wrapper :params doc doc_list of elasticsearch docs to update :returns: elasticsearch bulk result """ results = Results( self.logger, len(doc_list), str(inspect.stack()[0][1]) + "." + str(inspect.stack()[0][3])) ready_doc_list = [] for doc in doc_list: if "origin" in doc: doc['_routing'] = doc['origin'] doc['_parent'] = doc['origin'] if "_index" not in doc: doc['_index'] = self.index if "_type" not in doc: doc['_type'] = 'doc' if "_id" not in doc: if "link" in doc: result_uuid = self.generate_uuid(doc) doc['_id'] = result_uuid[0] results.add_success(result_uuid[0]) else: result_uuid = self.generate_uuid(doc["doc"]) doc['_id'] = result_uuid[0] results.add_success(result_uuid[0]) if "doc" in doc: #json serialize date with special date parser otherwise ES index fail doc["_source"] = json.loads( json.dumps(doc["doc"], default=self.serializer.to_json)) #remove source from doc doc.pop("doc") ready_doc_list.append(doc) try: for result in helpers.parallel_bulk(self.es, ready_doc_list): if int(result[1]["index"]["status"]) >= 200 and int( result[1]["index"]["status"]) < 300: results.add_success(result) else: results.add_fail(result) except Exception as e: results.add_error(e) del ready_doc_list, doc_list results.finish() gc.collect() return results.results
def main(argv): long_option_list = ['plec=', 'srednia=', 'zdawalnosc', 'najlepsze=', 'regresja', 'wojewodztwo=', 'lokalne'] try: options, args = getopt.getopt(argv, 'p:s:zn:rw:x:y:l', long_option_list) except getopt.GetoptError as err: print(err) options = [] cmd_args_dic = {} local_data = False data = [] for opt, arg in options: if opt in ('-p', '--plec'): cmd_args_dic['gender'] = arg if opt in ('-s', '--srednia'): cmd_args_dic['average'] = arg if opt in ('-z', '--zdawalnosc'): cmd_args_dic['pass_rate'] = '' if opt in ('-n', '--najlepsze'): cmd_args_dic['best'] = arg if opt in ('-r', '--regresja'): cmd_args_dic['regression'] = '' if opt in ('-w', '--wojewodztwo'): cmd_args_dic['state'] = arg if opt in '-x': cmd_args_dic['state1'] = arg if opt in '-y': cmd_args_dic['state2'] = arg # choose local or remote data if opt in ('-l', '--lokalne'): local_data = True if os.path.isfile('matura.db'): data = Data.load_from_local_db() else: data_obj = Data() data_obj.load_to_local_db() data = data_obj.load_from_local_db() if not local_data: data = Data().data_dicts Results(data, cmd_args_dic)
def query(self,criteria): """ Elasticsearch complex query (manage results over 10000 results) :params string criteria: complex query criterias :returns: objects in elasticsearch result """ global_results=Results(self.logger,current=str(inspect.stack()[0][1])+"."+str(inspect.stack()[0][3])) limit=self.limit max_retry=10 header_criteria=criteria.copy() header_criteria['size']=0 results=self.es.search(index=self.index,body=header_criteria,request_timeout=self.timeout) if "size" in criteria: query_size=criteria["size"] else: query_size=results['hits']['total'] global_results.set_total(query_size) #init loop variables results_status=0 current_retry=0 current_timeout=self.timeout timeout_exit=False #work around for nested it seems to not work properly with helpers # ES Error while using helpers.scan nested: SearchParseException[failed to parse search source # Issue opened https://github.com/elastic/elasticsearch-py/issues/466 self.logger.debug("storage.query es.search:"+json.dumps(criteria)) if query_size<limit or ("topics.score" in json.dumps(criteria)): results=self.es.search(index=self.index,body=criteria,request_timeout=self.timeout,size=query_size) global_results.set_total(1) global_results.add_success(criteria) else: self.logger.debug("storage.query helpers.scan:"+json.dumps(criteria)) #org.elasticsearch.search.query.QueryPhaseExecutionException: Batch size is too large, size must be less than or equal to: [10000]. Scroll batch sizes cost as much memory as result windows so they are controlled by the [index.max_result_window] index level setting. results_gen=helpers.scan(self.es,query=criteria,scroll=self.config['ES_SEARCH_CACHING_DELAY'],preserve_order=True,request_timeout=self.timeout,size=1000,raise_on_error=False) global_results.add_success(criteria) # for result in results_gen: results['hits']['hits'].append(results_gen) # global_results.add_success({'id':result['_id']}) # del results_gen # gc.collect() return [results,global_results]
def __init__(self,config_element ): pysage.Arena.__init__(self,config_element) self.decision_quorum = 1 if config_element.attrib.get("decision_quorum") is None else float(config_element.attrib["decision_quorum"]) self.timestep_length = 0.5 if config_element.attrib.get("timestep_length") is None else float(config_element.attrib.get("timestep_length")) self.time_scale = 0.008 if config_element.attrib.get("time_scale") is None else float(config_element.attrib.get("time_scale")) self.decision_step = 100 if config_element.attrib.get("decision_step") is None else int(config_element.attrib.get("decision_step")) self.size_radius = 0.7506 if config_element.attrib.get("size_radius") is None else float(config_element.attrib.get("size_radius")) # self.steps_run = int(config_element.attrib["steps_run"]) self.time_incr = float(config_element.attrib["time_incr"]) # is the experiment finished? self.has_converged = False self.convergence_time = float('nan') self.save_num = 0 self.results_filename = "CRWLEVY.dat" if config_element.attrib.get("results") is None else config_element.attrib.get("results") self.results = Results(config_element) # initialise targets from the configuration file self.targets = [] self.num_targets = 0 for target_element in config_element.iter("target"): # python 2.7 new_target = Target(target_element) self.targets.append(new_target) self.num_targets += 1 print "Initalised target", new_target.id, "(quality value:", new_target.value, ")" # initialise num runs from the configuration file nnruns = config_element.attrib.get("num_runs") if nnruns is not None: self.num_runs = int(nnruns) else: self.num_runs = 1 # size_radius ssize_radius = config_element.attrib.get("size_radius"); if ssize_radius is not None: self.dimensions_radius = float(ssize_radius) elif ssize_radius is None: self.dimensions_radius = float(self.dimensions.x/2.0)
def test_get_results_paginated_endpoint_two_pages(self, get_mock): self.assertEqual(Results([{ 'b': 2 }, { 'd': 6 }, { 'cc': 5, 'E': 11 }]), TVmaze.get_results('shows')) self.assertEqual(3, get_mock.call_count) get_mock.assert_has_calls([ call('http://api.tvmaze.com/shows?page=0'), call('http://api.tvmaze.com/shows?page=1'), call('http://api.tvmaze.com/shows?page=2'), ], any_order=False)
def search(self, search_terms, page_size=25, **kwargs): """Perform a search and get back a results object """ url = self.description.get_best_template() query = Query(url) # set up initial values query.searchTerms = search_terms query.count = page_size # add any additional parameters to the query for name, value in kwargs.items(): setattr(query, name, value) # run the results return Results(query, agent=self.agent)
def is_splitter_overloaded(self, splitter_id): sp = self.e_model.get_splitter_by_id(splitter_id) res = False if None != sp: amp_rating = (0.8 * sp.get_amp_rating()) total_amp_load = sp.get_amp_load() max_amp_load = sp.get_max_receptacle_amp_load() too_much_total_amp_load = (total_amp_load > amp_rating) too_much_amp_load_one_receptacle = (max_amp_load > amp_rating) res = too_much_total_amp_load or too_much_amp_load_one_receptacle if True == DEBUG: print('Support.is_splitter_overloaded() total_amp_load:{0}, max_amp_load:{1}, amp_rating:{2} => {3}'.format(total_amp_load, max_amp_load, amp_rating, res)) r = Results() r.set_object_id(res) return r
def put(self, data, item_id=None, type="doc", source=None): """ add an object to storage "link" field inside "data" object is used to generate "Unique Idenfifier" for the object. This field is mandatory for all objects of any types put in the index. :params dic data: data for object creation :params string item_id: unique identifier for the object :params string type: type of object **source** or **doc****source** or **doc** :params string source: parent unique identifier (mandatory for type doc, it's source id) :returns: elasticsearch object """ results = Results( self.logger, 1, str(inspect.stack()[0][1]) + "." + str(inspect.stack()[0][3])) if item_id is None: result_uuid = self.generate_uuid(data) item_id = result_uuid[0] results.add_success(result_uuid[1]) try: if source is not None: data['origin'] = source result = self.es.index(index=self.index, doc_type=type, id=item_id, parent=source, body=json.dumps( data, default=self.serializer.to_json), ignore=[400, 404, 409]) results.add_success(result) else: result = self.es.index(index=self.index, doc_type=type, id=item_id, body=json.dumps( data, default=self.serializer.to_json), ignore=[400, 404, 409]) results.add_success(result) except (TransportError, ConnectionError, ConnectionTimeout, RequestError) as e: results.add_error(e) results.finish() return results.results
def subCircuitCustomGate(): if request.method=='POST': receivedDictionary=request.get_json() c2=Circuit() c2.gatesObjects=c.gatesObjects c2.subCircuitSetter(receivedDictionary) try: circuit=c2.createDraggableCircuit() except Exception as e: return jsonify({"conditionalLoopError":str(e)}) r=Results(circuit) matrix=r.matrixRepresentation() complexMatrix=f.strToComplex(matrix) isUnitary=is_unitary_matrix(complexMatrix) if isUnitary: c.gatesObjects[receivedDictionary["gateName"]]=f.matrixToGateObject(complexMatrix,receivedDictionary["gateName"]) return jsonify({"isUnitary":isUnitary})