def __init__(self, callback, options={}, attrs={}, choices=(), fk_field_name=None): self.fk_field_name = fk_field_name self.options = None self.callback = callback self.attrs = {'autocomplete': 'off'} if len(options) > 0: self.options = JSONEncoder().encode(options) self.attrs.update(attrs) self.choices = list(choices)
def exclusion_note(self, metrics_in_error: dict, git: GitUtils, logger: Logger): logger.info( 'Please consult the above warnings and errors concerning discrepancies in your build compared to ' 'latest build.') answer = input('Do you want to accept the violations (Yes/No)? [No]: ') if not answer.upper() == 'YES': logger.info('I am treating this as a No (you typed: "%s").' % answer) logger.error('Failing because of metrics increase.') return Callable.do_not_proceed reason = '' while not reason.strip(): reason = input( 'Provide a nonempty commit message (reason) for the increase [""]: ' ) username = '******' % (git.get_config_by_key('user.name'), git.get_config_by_key('user.email')) metrics = {} for key, value in metrics_in_error.items(): metrics[key] = value['is'] exclusion = { 'reason': reason, 'committer': username, 'exclusion': metrics } note = JSONEncoder().encode(exclusion) if git.put_notes(note, STATS_EXCLUSION_REF_NAME, 'HEAD') != Callable.success: logger.error( 'Error encountered while setting note. Consult above messages if any.' ) return Callable.do_not_proceed if git.push_notes(STATS_EXCLUSION_REF_NAME) != Callable.success: logger.error( 'Error encountered while pushing notes. Consult above messages if any.' ) return Callable.do_not_proceed logger.info('The exclusion note has been pushed.') logger.warn( 'Remember to push your commit. DO NOT rebase (use merge instead) or the exclusion will be lost.' ) return Callable.success
def client_left_session(self): try: self.client.call(JSONEncoder().encode({ "method": "client_left_session", "params": { "session_id": self.__session_id, "client_id": self.__client_id } })) self.__session_id = None self.__broadcast_receiver.session_id = None return {} except Exception as e: return {'error': e}
def load_dataset(dataset_dir: Path, as_numpy: bool = False): dataset_dir = Path(dataset_dir) train_annotations_file = dataset_dir / 'digitStruct.json' digits_struct_file = dataset_dir / 'digitStruct.mat' dataset_pkl_file = dataset_dir / (dataset_dir.name + ".pkl") if dataset_pkl_file.exists(): dataset_np = pickle.load(dataset_pkl_file.open("rb")) print( f"Loaded {dataset_pkl_file.name} dataset from existing pickle file. N={len(dataset_np)}" ) else: if not digits_struct_file.exists(): raise FileExistsError(f"Cannot open {digits_struct_file}") if not train_annotations_file.exists(): print(f"Parsing {digits_struct_file}, this may take a while") dsf = DigitStructFile(str(digits_struct_file)) annotations = dsf.load() fout = open(train_annotations_file, 'w') fout.write(JSONEncoder(indent=True).encode(annotations)) fout.close() else: print( f"Loading existing JSON annotations from {train_annotations_file}" ) with open(train_annotations_file, 'r') as file: annotations = json.load(file) print(f"Loaded annotations for {len(annotations)} images") print(f"Loading images ... ") images = { Path(p).name: np.array(Image.open(p)) for p in tqdm(glob(f"{dataset_dir}/*.png")) } dataset_np = prepare_dataset(images, annotations, dataset_pkl_file) num_examples = len(dataset_np) if as_numpy: return dataset_np, num_examples def dataset_generator(svhn_dataset): for element in svhn_dataset: yield element dataset = tf.data.Dataset.from_generator( lambda: dataset_generator(dataset_np), ImageData.dataset_dtypes(), ImageData.dataset_shapes()) return dataset, num_examples
def get_business_by_id(business_id): """ Locate a business by its business_id. :param business_id: String :return: Http Response """ app.logger.info("get_business_by_id with business_id: {}".format(business_id)) # First check that we have a valid JWT token if we don't send a 400 error with authorisation failure if request.headers.get('authorization'): jwt_token = request.headers.get('authorization') if not validate_scope(jwt_token, 'ps.read'): res = Response(response="Invalid token/scope to access this Microservice Resource", status=400, mimetype="text/html") return res else: res = Response(response="Valid token/scope is required to access this Microservice Resource", status=400, mimetype="text/html") return res # if not validate_uri(business_id, 'business'): # res = Response(response="Invalid URI", status=404, mimetype="text/html") # return res try: app.logger.debug("Querying DB in get_business_by_id") app.logger.debug("Querying DB with business_id:{}".format(business_id)) object_list = [[rec.business_ref, rec.party_id, rec.name, rec.trading_name, rec.enterprise_name, rec.contact_name, rec.address_line_1, rec.address_line_2, rec.address_line_3, rec.city, rec.postcode, rec.telephone, rec.employee_count, rec.facsimile, rec.fulltime_count, rec.legal_status, rec.sic_2003, rec.sic_2007, rec.turnover] for rec in Business.query .filter(Business.party_id == business_id)] except exc.OperationalError: app.logger.error("DB exception: {}".format(sys.exc_info()[0])) response = Response(response="Error in the Party DB.", status=500, mimetype="text/html") return response if not object_list: app.logger.info("Object list is empty for get_business_by_id") response = Response(response="Business(es) not found", status=404, mimetype="text/html") return response jobject_list = JSONEncoder().encode(object_list) response = Response(response=jobject_list, status=200, mimetype="collection+json") return response
def __init__(self, proto, env): """Overloaded constructor.""" # Link protocol self.protocol = proto self.env = env # Init server data self.clients = [] self.named_clients = {} self.games = {} # Init decoders self.json_decoder = JSONDecoder() self.json_encoder = JSONEncoder() # Init configs serverfuncts.configLog(self.env.log_path + '/server.log')
def get_json_item(cls_name, mtd_name, args): """ json item 为一个json格式的解密对象。 包含id、className、methodName、arguments。 模拟器/手机会通过解析这个对象进行解密。 """ item = { 'className': cls_name, 'methodName': mtd_name, 'arguments': args } item['id'] = hashlib.sha256( JSONEncoder().encode(item).encode('utf-8')).hexdigest() return item
def __init__( self, client, version=None, decoder=JSONDecoder(), encoder=JSONEncoder(), ): """ Create a client for talking to json. :param decoder: :type json.JSONDecoder: An instance of json.JSONDecoder :param encoder: :type json.JSONEncoder: An instance of json.JSONEncoder """ # Set the module commands' callbacks self.MODULE_CALLBACKS = { "JSON.CLEAR": int, "JSON.DEL": int, "JSON.FORGET": int, "JSON.GET": self._decode, "JSON.MGET": bulk_of_jsons(self._decode), "JSON.SET": lambda r: r and nativestr(r) == "OK", "JSON.NUMINCRBY": self._decode, "JSON.NUMMULTBY": self._decode, "JSON.TOGGLE": self._decode, "JSON.STRAPPEND": self._decode, "JSON.STRLEN": self._decode, "JSON.ARRAPPEND": self._decode, "JSON.ARRINDEX": self._decode, "JSON.ARRINSERT": self._decode, "JSON.ARRLEN": self._decode, "JSON.ARRPOP": self._decode, "JSON.ARRTRIM": self._decode, "JSON.OBJLEN": self._decode, "JSON.OBJKEYS": self._decode, "JSON.RESP": self._decode, "JSON.DEBUG": self._decode, } self.client = client self.execute_command = client.execute_command self.MODULE_VERSION = version for key, value in self.MODULE_CALLBACKS.items(): self.client.set_response_callback(key, value) self.__encoder__ = encoder self.__decoder__ = decoder
def wrapper(self, *args, **kwds): """Decorator wrapper""" cherrypy.response.headers['Content-Type'] = "application/json" func._cp_config = {'response.stream': True} head, data = func(self, *args, **kwds) yield json.dumps(head)[:-1] # do not yield } yield ', "data": [' if isinstance(data, dict): for chunk in JSONEncoder().iterencode(data): yield chunk elif isinstance(data, list) or isinstance(data, types.GeneratorType): sep = '' for rec in data: if sep: yield sep for chunk in JSONEncoder().iterencode(rec): yield chunk if not sep: sep = ', ' else: msg = 'jsonstreamer, improper data type %s' % type(data) raise Exception(msg) yield ']}'
def add_quest(): from services.content_manager import create_quest name = request.form["name"] quest_type = request.form["quest_type"] public_accessibility = int(request.form["public_accessibility"]) cid = request.form["cid"] try: code = create_quest(session.get('uid'), name, quest_type, public_accessibility, cid) except Exception: code = 500 abort(500) response = {'code': code} return JSONEncoder().encode(response)
def process_game_move(self, move): try: self.client.call(JSONEncoder().encode({ "method": "process_game_move", "params": { "session_id": self.__session_id, "client_id": self.__client_id, "move": move } })) return {} except Exception as e: print(e) return {'error': e}
def sync_renren_status(did, page, new_latest): d = DataSource.objects.get(pk=did) info = JSONDecoder().decode(d.auth_info) sig_calc = u"access_token=%scount=1000format=jsonmethod=status.getspage=%suid=%sv=1.0%s" % ( info['access_token'], page, info['user']['id'], RENREN_SECRET) sig = calc_md5(sig_calc) statues_url = "http://api.renren.com/restserver.do?method=status.gets&v=1.0&access_token=%s&count=1000&format=json&page=%s&uid=%s&sig=%s" % ( info['access_token'], page, info['user']['id'], sig) statues = JSONDecoder().decode(urllib2.urlopen(statues_url, "").read()) if statues: if (page == 1): new_latest = statues[0]['status_id'] for status in statues: if info.has_key('latest_status' ) and status['status_id'] == info['latest_status']: info['latest_status'] = new_latest d.auth_info = JSONEncoder().encode(info) d.save(force_update=True) sync_renren_status.apply_async(args=[did, 1, None], countdown=84600) sync_renren_albums.apply_async(args=[d.id, 1], countdown=1) break p = Paw.objects.create(source=d,\ type="renren status",\ content=status['message'],\ create_time=datetime.strptime(status['time'], "%Y-%m-%d %H:%M:%S")) if not (info.has_key('latest_status') and status['status_id'] == info['latest_status']): sync_renren_status.apply_async(args=[did, page + 1, new_latest], countdown=60) else: if new_latest is not None: info['latest_status'] = new_latest d.auth_info = JSONEncoder().encode(info) d.save(force_update=True) sync_renren_status.apply_async(args=[did, 1, None], countdown=84600) sync_renren_albums.apply_async(args=[d.id, 1], countdown=1)
def generate(self): """ :return: `None`. """ configuration = app.Configuration(self) try: with ldap3.Connection( configuration.server, read_only=True, raise_exceptions=True, user=configuration.credentials.username, password=configuration.credentials.password) as connection: attribute_names = app.get_normalized_attribute_names( self.attrs, connection, configuration) entry_generator = connection.extend.standard.paged_search( search_base=self.basedn, search_filter=self.search, search_scope=self.scope, attributes=self.attrs, paged_size=configuration.paged_size) encoder = JSONEncoder(ensure_ascii=False, separators=(',', ':')) time_stamp = time() serial_number = 0 for entry in entry_generator: attributes = app.get_attributes(self, entry) if attributes: dn = entry['dn'] yield LdapSearchCommand._record( serial_number, time_stamp, connection.server.host, dn, attributes, attribute_names, encoder) serial_number += 1 if self.limit and serial_number == self.limit: break pass pass except ldap3.LDAPException as error: self.error_exit(error, app.get_ldap_error_message(error, configuration)) return
def command(self, cmd, block=False, test=lambda: True, timeout=0.0, args=None): """ Raw command call to directly control gripper. @type cmd: str @param cmd: string of known gripper commands @type block: bool @param block: command is blocking or non-blocking [False] @type test: func @param test: test function for command validation @type timeout: float @param timeout: timeout in seconds for command evaluation @type args: dict({str:float}) @param args: dictionary of parameter:value """ ee_cmd = EndEffectorCommand() ee_cmd.id = self.hardware_id() ee_cmd.command = cmd ee_cmd.sender = self._cmd_sender % (cmd,) ee_cmd.sequence = self._inc_cmd_sequence() ee_cmd.args = '' if args != None: ee_cmd.args = JSONEncoder().encode(args) seq_test = lambda: (self._state.command_sender == ee_cmd.sender and (self._state.command_sequence == ee_cmd.sequence or self._state.command_sequence == 0)) self._cmd_pub.publish(ee_cmd) if block: finish_time = rospy.get_time() + timeout cmd_seq = baxter_dataflow.wait_for( test=seq_test, timeout=timeout, raise_on_error=False, body=lambda: self._cmd_pub.publish(ee_cmd) ) if not cmd_seq: seq_msg = (("Timed out on gripper command acknowledgement for" " %s:%s") % (self.name, ee_cmd.command)) rospy.logdebug(seq_msg) time_remain = max(0.5, finish_time - rospy.get_time()) return baxter_dataflow.wait_for( test=test, timeout=time_remain, raise_on_error=False, body=lambda: self._cmd_pub.publish(ee_cmd) ) else: return True
def Format(root, lang='en', output_dir='.'): """Format the messages as JSON.""" yield '{\n' encoder = JSONEncoder() format = (' "%s": {\n' ' "message": %s%s\n' ' }') placeholder_format = (' "%i": {\n' ' "content": "$%i"\n' ' }') first = True for child in root.ActiveDescendants(): if isinstance(child, message.MessageNode): id = child.attrs['name'] if id.startswith('IDR_') or id.startswith('IDS_'): id = id[4:] translation_missing = child.GetCliques()[0].clique.get( lang) is None if (child.ShouldFallbackToEnglish() and translation_missing and lang != constants.FAKE_BIDI): # Skip the string if it's not translated. Chrome will fallback # to English automatically. continue loc_message = encoder.encode(child.ws_at_start + child.Translate(lang) + child.ws_at_end) # Replace $n place-holders with $n$ and add an appropriate "placeholders" # entry. Note that chrome.i18n.getMessage only supports 9 placeholders: # https://developer.chrome.com/extensions/i18n#method-getMessage placeholders = '' for i in range(1, 10): if loc_message.find('$%d' % i) == -1: break loc_message = loc_message.replace('$%d' % i, '$%d$' % i) if placeholders: placeholders += ',\n' placeholders += placeholder_format % (i, i) if not first: yield ',\n' first = False if placeholders: placeholders = ',\n "placeholders": {\n%s\n }' % placeholders yield format % (id, loc_message, placeholders) yield '\n}\n'
def updateFromWMSpec(self, spec): # currently only update priority and siteWhitelist and output dataset # complex field needs to be JSON encoded # assuming all the toplevel tasks has the same site white lists #priority is priority + user priority + group priority fields = { 'priority': spec.priority(), 'site_white_list': spec.getTopLevelTask()[0].siteWhitelist(), 'outputdatasets': spec.listOutputDatasets() } return self.couchDB.updateDocument( spec.name(), self.couchapp, 'generalFields', fields={'general_fields': JSONEncoder().encode(fields)})
def activesubCandidates(): pg = request.params[support.FieldDict['PAGE']] sortFilter = request.params[support.FieldDict['SEARCHMODE']] sortOrder = request.params[support.FieldDict['SORTORDER']] sortOn = request.params[support.FieldDict['SORTON']] sortData = None if support.FieldDict['SORTDATA'] in request.params: sortData = request.params[support.FieldDict['SORTDATA']] reqObj = { support.FieldDict['PAGE']: int(pg), support.FieldDict['SEARCHMODE']: int(sortFilter), support.FieldDict['SORTORDER']: int(sortOrder), support.FieldDict['SORTON']: int(sortOn) } if sortData is not None: reqObj[support.FieldDict['SORTDATA']] = sortData adid = request.get_header(support.FieldHeaderDict['ADID'], None) if adid is None: return None #userId = request.get_header(support.FieldDict['MODELID'], None) #if userId is None: # return None data = JSONEncoder().encode(reqObj) print data msg = JSONEncoder().encode({ support.FieldDict['APIMETHOD']: support.ApiMethods1.Api_ActiveSubCandidates.value - 1, support.FieldDict['ADID']: adid, support.FieldDict['DATA']: data }) token = msgMgr.send(msg) print token return token
def __init__(self, exception_object): if AppfluxException.before != []: for before_callback in AppfluxException.before: before_callback(exception_object, exception_object.global_attributes) json_response = exception_object.process_default_exception_data() json_response['app_id'] = exception_object.app_id if AppfluxException.after != []: for after_callback in AppfluxException.after: after_callback(exception_object, exception_object.global_attributes) self.send(JSONEncoder().encode(json_response))
def basic_risks_run(): valuation_time = datetime.now() pricing_environment = PE_DEFAULT_INTRADAY headers = utils.login(ip, login_body) r = utils.get_redis_conn(ip) position_result = r.get(INTRADAY_BASIC_POSITIONS) positions = JSONDecoder().decode(bytes.decode(position_result)) expiring_result = r.get(INTRADAY_BASIC_EXPIRING) expirings = JSONDecoder().decode(bytes.decode(expiring_result)) risk = basic_risks.get_risks([positions, expirings], pricing_environment, valuation_time, ip, headers)[0] risk_result = JSONEncoder().encode(risk) r.set(INTRADAY_BASIC_RISKS, str(risk_result)) print('Basic Risk Data Has Save To Redis')
def default(self, o): if hasattr(o, 'to_json'): return getattr(o, 'to_json')() elif isinstance(o, set): return sorted(list(o)) elif isinstance(o, timedelta): return o.seconds # Convert generators to list try: iterable = iter(o) except TypeError: pass else: return list(iterable) return JSONEncoder().default(o)
def getMiProximoColectivoController(): start = datetime.datetime.now() params = request.args.get('bbox') url = 'https://miproximocolectivo.sanluis.gob.ar/MiProximoColectivo/GetMapMovilRecorrido?bbox=%s,%s,%s,%s' % ( params[0], params[1], params[2], params[3]) headers = {'Content-type': 'application/json'} response = requests.get(url, headers=headers) result = response.text end = datetime.datetime.now() final = end - start buses = filter(result) bs = parseObject(buses) print("time -> getMiProximoColectivoController: %s" % final) return JSONEncoder().encode(bs)
def discovery(data): """Converts a Python dict into a Zabbix LLD JSON string""" from json import JSONEncoder lld_data = { 'data': [] } for item in data: lld_item = {} for key, val in item.items(): if val: lld_item[macro_name(key)] = str(val) if lld_item: lld_data['data'].append(lld_item) return JSONEncoder().encode(lld_data)
def callback(self): try: #TODO support jinja template to format callback payload self.callback_payload = JSONEncoder().encode({ "timestamp": int(time()), "name": self.name, "triggering_payload": self.triggering_payloads }) logging.info('Triggered rule \'' + self.name + '\'') self.mqtt_client.publish(self.output_topic, self.callback_payload) except Exception as e: logging.error('Error in Rule.callback: ' + str(e))
def __init__(self, addr): """ :param Tuple[str, int] addr: """ self.acceptor = None self.addr = addr # TODO move to executor? self.encoder = JSONEncoder(separators=(',', ':'), default=lambda x: x.as_json_object()) dependencies = get_dependencies() dependencies.update({T.__name__: T for T in (ExternalException, )}) self.decoder = JSONDecoder( object_hook=self._get_object_hook_handler(dependencies))
def parseResults(results): numRes = results.total titles = [] paths = [] contents = [] if numRes >= 0: for hit in results: title = hit["title"].encode('utf-8') path = hit["path"].encode('utf-8') content = hit.highlights("content").encode('utf-8') titles.append(title) paths.append(path) contents.append(content) normTitles = JSONEncoder().encode(titles) normPaths = JSONEncoder().encode(paths) normContents = str( JSONEncoder().encode(contents) ) ##Not sure if str() is necessary. JSONEncoder() may return other formats # print normPaths # normTitles=', '.join(['"{}"'.format(value) for value in titles]) # normPaths=', '.join(['"{}"'.format(value) for value in paths]) # normContents=str(contents) numPages = results.pagecount resPerPage = results.pagelen currentPage = results.pagenum runtime = results.results.runtime resObj = '{"NumResults":' + str(numRes) + ', "NumPages":' + str( numPages) + ', "Runtime":' + str( runtime) + ', "ResPerPage":' + str( resPerPage) + ', "CurrentPage":' + str(currentPage) + '}' return '{"Titles":' + normTitles + ',"Paths":' + normPaths + ',"Contents":' + normContents + ', "Result":' + resObj + '}'
def get_active_users(request): """ Retrieves a list of active users which is returned as plain JSON for easier manipulation with JavaScript. """ if request.is_ajax(): active = Visitor.objects.active().reverse() now = timezone.now() # we don't put the session key or IP address here for security reasons try: data = { 'users': [ { 'id': v.id, #'user': uc(v.user), 'user_agent': uc(v.user_agent), 'referrer': uc(v.referrer), 'url': uc(v.url), 'page_views': v.page_views, 'geoip': v.geoip_data_json, 'last_update': (now - v.last_update).seconds, 'friendly_time': ', '.join(friendly_time( (now - v.last_update).seconds)), } for v in active ] } except: log.error( 'There was a problem putting all of the visitor data together:\n%s\n\n%s' % (traceback.format_exc(), locals())) return HttpResponse(content='{}', mimetype='text/javascript') response = HttpResponse(content=JSONEncoder().encode(data), mimetype='text/javascript') response['Content-Length'] = len(response.content) return response # if the request was not made via AJAX, raise a 404 raise Http404
def runTest(self): #Create an object and set some values test1 = CounterTestContainer(None) test1id = test1.id self.dc.AddDocumentObject(test1) test1.testcounter.add(1) self.assertEqual(test1.testcounter.get(), 1) olddc = self.dc sharedcurrentnode = test1.currentnode #Simulate sending the object to another user via conversion to JSON and emailing jsontext = self.dc.asJSON() #Simulate making local conflicting changes test1.testcounter.subtract(1) self.assertEqual(test1.testcounter.get(), 0) #Simulate the other user (who received the email with the edges) getting the document and loading it into memory self.dc = DocumentCollection() self.dc.Register(CounterTestContainer) self.dc.LoadFromJSON(jsontext) self.assertEqual(jsontext, self.dc.asJSON()) tpo1s = self.dc.GetByClass(CounterTestContainer) self.assertEqual(len(tpo1s), 1) test2 = tpo1s[0] self.assertEqual(sharedcurrentnode, test2.currentnode) #The second user makes some changes and sends them back to the first test2.testcounter.add(1) self.assertEqual(test2.testcounter.get(), 2) edgenext = test2.history.edgesbyendnode[test2.currentnode] #Simulate the first user received the second users changes out of order #the second edge is received first. Test it is right self.dc = olddc self.dc.LoadFromJSON(JSONEncoder().encode({ "history": [edgenext.asTuple()], "immutableobjects": [] })) test2s = self.dc.GetByClass(CounterTestContainer) self.assertEqual(len(test2s), 1) test2 = test2s[0] #print "test2 edges=",[str(edge) for edge in test2.history.GetAllEdges()] self.assertEqual(test2.testcounter.get(), 1)
def real_time_pnl_pd_run(): r = utils.get_redis_conn(redis_ip) risk_result = r.get(INTRADAY_BASIC_RISKS) risk = pd.read_msgpack(risk_result) underlyer_position_result = r.get(INTRADAY_BASIC_UNDELRYER_POSITION) underlyer_position = pd.read_msgpack(underlyer_position_result) list_position_result = r.get(INTRADAY_BASIC_LISTED_OPTION_POSITION) list_position = pd.read_msgpack(list_position_result) cash_flow_today_result = r.get(INTRADAY_BASIC_CASH_FLOW_TODAY) cash_flow_today = pd.read_msgpack(cash_flow_today_result) live_position_index_result = r.get(INTRADAY_BASIC_POSITION_INDEX) live_position_index = pd.read_msgpack(live_position_index_result) today_terminated_position_index_result = r.get( INTRADAY_BASIC_TERMINATED_POSITION_INDEX) today_terminated_position_index = pd.read_msgpack( today_terminated_position_index_result) now_date = datetime.now().date() yst_date = now_date + timedelta(days=-1) yst_params = { 'reportName': POSITION_REPORT, 'valuationDate': str(yst_date) } headers = utils.login(ip, login_body) yst_position = utils.call_request(ip, 'report-service', 'rptLatestPositionReportByNameAndDate', yst_params, headers)['result'] yst_params['reportName'] = HST_PNL_REPORT yst_historical_pnl = utils.call_request( ip, 'report-service', 'rptLatestPnlHstReportByNameAndDate', yst_params, headers)['result'] yst_position = pd.DataFrame(yst_position) yst_historical_pnl = pd.DataFrame(yst_historical_pnl) pe_description = utils.get_pricing_env_description(PE_DEFAULT_INTRADAY, ip, headers) reports = intraday_daily_pnl_by_underlyer_report_pd.intraday_daily_pnl_by_underlyer_report( risk, cash_flow_today, underlyer_position, list_position, live_position_index, today_terminated_position_index, yst_position, yst_historical_pnl, pe_description) reports = utils.remove_nan_and_inf(reports.to_dict(orient='records')) pnl_result = JSONEncoder().encode(reports) r.set(PNL_QUEUE, str(pnl_result)) r.publish(PNL_QUEUE, str(pnl_result))
def callback(ch, method, properties, body): #config = argv[1] if len(argv) > 1 else '{"duration":10}' params = JSONDecoder().decode(body) duration = params["duration"] # initialize BPF b = BPF(text = bpf_text()) # read events b["ipv4_events"].open_perf_buffer(capture_ipv4_event) start_time = time() while ((time() - start_time) < duration): b.kprobe_poll(timeout=100) doc = JSONEncoder().encode(events) send_msg(doc)
def json_settings(): from json import JSONEncoder def _default(self, obj): if type(obj) in [ datetime.datetime, datetime.timedelta,datetime.date ]: return serialize_time(obj) if isinstance(obj,unittest.mock.MagicMock): return str(obj) try: ret=getattr(obj.__class__, "__serialize__", _default.default)(obj) except TypeError as e: raise JsonSerializerError(e,obj) from None return ret _default.default = JSONEncoder().default JSONEncoder.default = _default