def resolve_positions(symbol): logger.info('Resolve positions') # Cancel open orders. logger.info('Cancel all orders') try: bitmex_client.Order.Order_cancelAll(symbol=symbol) except Exception: logger.error(traceback2.format_exc()) return # Close open positions. logger.info('Query positions to close') try: positions = bitmex_client.Position.Position_get(filter=json.dumps({"symbol": "XBTUSD"})).result() except Exception: logger.error(traceback2.format_exc()) return for pos in positions[0]: # Skip over flat positions. if pos['currentQty'] == 0: continue # Unwind position by multiplying currentQty by -1. symbol = pos['symbol'] order_qty = -1 * pos['currentQty'] place_order(symbol, order_qty)
def place_order(symbol, quantity, decision_px, position=None): logger.info(f'Place order: symbol:{symbol} quantity:{quantity}') # DO NOT use API method Order.Order_newBulk() to post both the new order and the new stop-limit order. # Oddly, the API for bulk orders fails when the ordType differs between orders. # Support up to 5 retries in case Bitmex rejects our order due to load-shedding policy. attempts, new_order = 0, None while attempts < 5 and not new_order: logger.info(f'Attempt to place order on attempt:{attempts}') try: new_order = bitmex_client.Order.Order_new( symbol=symbol, orderQty=quantity, ordType='Market').result() break except bravado.exception.HTTPServiceUnavailable: # XXX we should check the error message to be sure the "overloaded" condition happened. logger.error(traceback2.format_exc()) except Exception: logger.error(traceback2.format_exc()) break # Bitmex has rejected order due to load-shedding policy. Per docs, wait 500 ms, then retry. Note: this is a blocking sleep(). sleep(0.5) attempts += 1 if not new_order: failure_message = 'from overload condition' if attempts >= 1 else None broadcast_order_failure(symbol, quantity, decision_px, position=position, failure_message=failure_message) return StatusCode.ERROR # Persist new order to data store. create_timestamp = new_order[0]['timestamp'].timestamp() insert_order(new_order[0]['orderID'], new_order[0]['symbol'], new_order[0]['price'], new_order[0]['side'], new_order[0]['orderQty'], 'Market', create_timestamp, decision_px) # Register realized P&L only when a position is closed. realized_pnl = None if position: realized_pnl = (1.0 / position['avgEntryPrice'] - 1.0 / new_order[0]['avgPx']) * abs(quantity) realized_pnl *= (1.0 - position['commission']) # Message interested parties about trade. Include trade-price if order filled. broadcast_message(symbol, quantity, new_order[0]['avgPx'], decision_px=decision_px, realized_pnl=realized_pnl, ord_status=new_order[0]['ordStatus']) # Initiate stop order if we are not closing a position. if not position: entry_px = float(new_order[0]['avgPx']) place_stop_order(symbol, -quantity, entry_px, decision_px) return StatusCode.OK
def insert_fill_conditionally(trade): logger.info(f"Determine if trade already exists: execID:{trade['execID']}") already_exists = False try: with connection.cursor() as cursor: sql = "SELECT exec_id FROM fills WHERE exec_id = %s" cursor.execute(sql, (trade['execID'])) exec_id = cursor.fetchone() already_exists = not exec_id == None except Exception: logger.error(traceback2.format_exc()) return if already_exists: return logger.info(f"Inserting fill: execID:{trade['execID']} orderID:{trade['orderID']} symbol:{trade['symbol']} side:{trade['side']} price:{trade['price']} orderQty:{trade['orderQty']} ordType:{trade['ordType']} ordStatus:{trade['ordStatus']} lastPx:{trade['lastPx']} lastQty:{trade['lastQty']} leavesQty:{trade['leavesQty']} cumQty:{trade['cumQty']} avgPx:{trade['avgPx']}") tx_time = trade['transactTime'].timestamp() try: with connection.cursor() as cursor: sql = "INSERT INTO `fills` (`transaction_dt`, `exec_id`, `order_id`, `symbol`, `side`, `price`, `order_qty`, `order_type`, `order_status`, `last_px`, `last_qty`, `leaves_qty`, `cum_qty`, `avg_px`, `created_dt`) VALUES (FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, NOW())" cursor.execute(sql, (tx_time, trade['execID'], trade['orderID'], trade['symbol'], trade['side'], trade['price'], trade['orderQty'], trade['ordType'], trade['ordStatus'], trade['lastPx'], trade['lastQty'], trade['leavesQty'], trade['cumQty'], trade['avgPx'])) connection.commit() except Exception: logger.error(traceback2.format_exc()) return
def reconcile_fills_and_positions(): logger.info('Reconciling fills and positions') now = datetime.utcnow().timestamp() start_time = now - 60*60 # one hour ago start_time_dt = datetime.fromtimestamp(start_time) start_time_str = start_time_dt.strftime("%Y-%m-%d %H:%M") # Look back 1 hour. The pitfall here is that there is network outage longer than that. # The count of 64 for results should capture all trades, most of which usually will have # already been persisted to our backend. logger.info('Query trade history') try: trade_history = bitmex_client.Execution.Execution_getTradeHistory(symbol='XBTUSD', count=64, reverse=True, filter=json.dumps({"execType": "Trade", "startTime": start_time_str})).result() except Exception: logger.error(traceback2.format_exc()) return for trade in trade_history[0]: insert_fill_conditionally(trade) logger.info('Query positions to persist') try: positions = bitmex_client.Position.Position_get(filter=json.dumps({'symbol': 'XBTUSD'})).result() except Exception: logger.error(traceback2.format_exc()) return for pos in positions[0]: insert_position(pos)
def reconcile_fills_and_positions(): logger.info('Reconciling fills and positions') # Scan trade history up to 1 minute ago, as we should call this method each minute. now = datetime.utcnow().replace(tzinfo=timezone.utc).timestamp() start_time = now - 60 start_time_dt = datetime.fromtimestamp(start_time, tz=timezone.utc) start_time_str = start_time_dt.strftime("%Y-%m-%d %H:%M") # Look back 1 minute. The pitfalls here are (a) that there is network outage longer than that, # or (b) that a trade executes during the small window between 1 minute ago and when the # trade-history query was last done (which might well be more than 1 minute ago). # The count of 64 for results is arbitrary and conceivably could miss some fills. logger.info('Query trade history') try: trade_history = bitmex_client.Execution.Execution_getTradeHistory( symbol='XBTUSD', count=64, reverse=True, filter=json.dumps({ "execType": "Trade", "startTime": start_time_str })).result() except Exception: logger.error(traceback2.format_exc()) return for trade in trade_history[0]: insert_fill_conditionally(trade) # Broadcast status of Stop orders if (i) order was completely filled or (ii) order was cancelled. case1 = trade['ordStatus'] == 'Filled' and trade['cumQty'] == trade[ 'orderQty'] case2 = trade['ordStatus'] == 'Canceled' if trade['ordType'] == 'Stop' and (case1 or case2): # Use negative quantity for sell-side trades. quantity = trade['cumQty'] if trade[ 'side'] == 'Buy' else -trade['cumQty'] broadcast_message(trade['symbol'], quantity, trade['avgPx'], stop_px=trade['stopPx'], ord_status=trade['ordStatus']) logger.info('Query positions to persist') try: positions = bitmex_client.Position.Position_get( filter=json.dumps({'symbol': 'XBTUSD'})).result() except Exception: logger.error(traceback2.format_exc()) return for pos in positions[0]: insert_position(pos)
def check_proof(item, *, rewrite): if item.steps: context.set_context(None, vars=item.vars) state = server.parse_init_state(item.prop) history = state.parse_steps(item.steps) if rewrite: with global_setting(unicode=True): item.proof = state.export_proof() for step in history: if 'error' in step: return { 'status': 'Failed', 'err_type': step['error']['err_type'], 'err_str': step['error']['err_str'], 'trace': step['error']['trace'] } try: state.check_proof() except Exception as e: return { 'status': 'Failed', 'err_type': e.__class__.__name__, 'err_str': str(e), 'trace': traceback2.format_exc() } # Otherwise OK return { 'status': 'OK' if len(state.rpt.gaps) == 0 else 'Partial', 'num_steps': len(item.steps), } elif item.proof: try: context.set_context(None, vars=item.vars) state = server.parse_proof(item.proof) state.check_proof(no_gaps=True) except Exception as e: return { 'status': 'ProofFail', 'err_type': e.__class__.__name__, 'err_str': str(e), 'trace': traceback2.format_exc() } return { 'status': 'ProofOK' } else: return { 'status': 'NoSteps' }
async def on_ready(self): try: print(f"Logged in to {bot.user}") if self.user.id == 644065524879196193: await self.get_channel(info["ERROR_CHANNEL"]).send("Logged in") if platform.system() != "Windows": import uvloop, nest_asyncio if not discord.opus.is_loaded(): try: discord.opus.load_opus("heroku-buildpack-libopus") except: pass nest_asyncio.apply() uvloop.install() loop = asyncio.get_event_loop() self.loop.add_signal_handler( signal.SIGTERM, lambda: loop.run_until_complete(self.on_sigterm())) database_channel = self.get_channel(736538898116902925) database_msg = await database_channel.fetch_message( database_channel.last_message_id) database_file = database_msg.attachments[0] db_byte = await database_file.read() db_dict = json.loads(db_byte) self.ADMIN = db_dict["role"]["ADMIN"] self.BAN = db_dict["role"]["BAN"] self.Contributor = db_dict["role"]["Contributor"] self.database = db_dict["user"] self.global_chat = db_dict["global_chat"] self.api_index = db_dict["system"]["api_index"] self.maintenance = db_dict["system"]["maintenance"] self.save_database.start() except: print(traceback2.format_exc())
async def global_chat(self, ctx): try: text = ctx.message.content.split(" ", 1) channel_id: int if len(text) == 1: channel_id = ctx.channel.id else: result = re.search(self.channel_match, text[1]) if result is None: return await ctx.send("チャンネルを検出できませんでした") else: matched_channel_id = int(result["channel_id"]) channel = discord.utils.get(ctx.guild.text_channels, id=matched_channel_id) if channel is None: return await ctx.send("チャンネルを検出できませんでした") channel_id = channel.id if channel_id in self.bot.global_chat["general"]: return await ctx.send("すでにグローバルチャットに登録されているチャンネルです") self.bot.global_chat["general"].append(channel_id) with open("./GLOBAL_CHAT.json", 'w') as db: json.dump(self.bot.global_chat, db, indent=2) await ctx.send(f"<#{channel_id}>チャンネルをグローバルチャットに追加しました.") except: await ctx.send(traceback2.format_exc())
async def _probe_site(self, site: HttpWebSite): self.logger.debug( "[%s] Running site probes...", site.name ) scout = HttpScout( verify_ssl=site.verify_ssl, request_timeout=site.request_timeout, limit_sim_conn=self.get_config_param( None, 'limit_sim_conn', 5 ), basic_usr=site.basic_user, basic_pwd=site.basic_pass ) try: self.logger.debug( "[%s] Creating session...", site.name ) await scout.create_session() futures = [] # Create the list of future for every resource for resource in site.get_resources(): future = asyncio.ensure_future( scout.probe_resource(site, resource) ) futures.append(future) await asyncio.ensure_future( asyncio.gather( *futures, return_exceptions=True ) ) # Create futures of the probe results and send # messages to kafka brokers. probes = [] for future in futures: probe_result = future.result() probes.append(probe_result.pack()) msg = { 'site': site.get_name(), 'probes': probes, } await self._send2topic(msg, site.topic) except Exception as exc: # pylint: disable=broad-except self.logger.error( '[%s] Unexpected error: %s\n%s', site.name, exc, '\n'.join(traceback2.format_exc().splitlines()) if self.debug else '' ) finally: await scout.cleanup()
def __split(self, url, job): try: pool = Pool(max_gevents) lock = Lock() with open(job['path'], (exists(job['path']) and 'rb+') or 'wb') as file: with requests.Session() as sess: list_set = set(job['queue']) left, right = (-1, -1) while right < job['length'] - 1: left, right = (right + 1, min(right + range_size, job['length'] - 1)) if not (left, right) in list_set: pool.spawn(self.__download, url, job, left, right, sess, file, lock) pool.join() if len(job['queue']) < int(ceil(1.0 * job['length'] / range_size)): job['status'] = 'miss' controler.miss() logger.debug(url + ' miss') else: job['status'] = 'done' controler.success() logger.debug(url + ' done') print(url + ' done') controler.dict_list.add(url, job) except Exception as e: logger.error(format_exc())
async def get(self): try: data = json.loads(await self.request.read()) cnt = await execute('delete from list where path=%s', (data, )) return web.json_response(data=cnt) except: logger.error(format_exc())
def parse(self, data): self.name = data['name'] try: self.type = parser.parse_type(data['type']) self.cname = theory.thy.get_overload_const_name( self.name, self.type) for rule in data['rules']: with context.fresh_context(defs={self.name: self.type}): prop = parser.parse_term(rule['prop']) # Test conclusion of the prop _, concl = prop.strip_implies() f, _ = concl.strip_comb() if f != Const(self.name, self.type): raise ItemException( "Inductive %s: wrong head of conclusion" % self.name) self.rules.append({'name': rule['name'], 'prop': prop}) except Exception as error: self.type = data['type'] self.rules = data['rules'] self.error = error self.trace = traceback2.format_exc()
def parse(self, data): self.name = data['name'] try: self.type = parser.parse_type(data['type']) self.cname = theory.thy.get_overload_const_name( self.name, self.type) for rule in data['rules']: with context.fresh_context(defs={self.name: self.type}): prop = parser.parse_term(rule['prop']) # prop should be an equality if not prop.is_equals(): raise ItemException("Fun %s: rule is not an equality" % self.name) f, args = prop.lhs.strip_comb() if f != Const(self.name, self.type): raise ItemException("Fun %s: wrong head of lhs" % self.name) lhs_vars = set(v.name for v in prop.lhs.get_vars()) rhs_vars = set(v.name for v in prop.rhs.get_vars()) if not rhs_vars.issubset(lhs_vars): raise ItemException( "Fun %s: extra variables in rhs: %s" % (self.name, ", ".join(v for v in rhs_vars - lhs_vars))) self.rules.append({'prop': prop}) except Exception as error: self.type = data['type'] self.rules = data['rules'] self.error = error self.trace = traceback2.format_exc()
def parse(self, data): self.name = data['name'] try: with context.fresh_context(vars=data['vars']): self.vars = context.ctxt.vars self.prop = parser.parse_term(data['prop']) # theorem does not already exist if theory.thy.has_theorem(self.name): raise ItemException("Theorem %s: theorem already exists") # prop should not contain extra variables self_vars = set(self.vars.keys()) prop_vars = set(v.name for v in self.prop.get_vars()) if not prop_vars.issubset(self_vars): raise ItemException( "Theorem %s: extra variables in prop: %s" % (self.name, ", ".join(v for v in prop_vars - self_vars))) except Exception as error: self.vars = data['vars'] self.prop = data['prop'] self.error = error self.trace = traceback2.format_exc() if 'attributes' in data: self.attributes = data['attributes']
async def _parse_topic_messages(self, tp, messages): try: site_events_map = {} for message in messages: jmsg = json.loads(str(message.value.decode('ascii'))) self.msgs_counter += 1 self.logger.info( "[%s/%d/%d] [%s] Received message %s", tp.topic, tp.partition, message.offset, str(uuid.UUID(bytes=message.key)), str(message.value.decode('ascii')) if self.debug else 'with %d events' % len(jmsg['probes'])) # Organize messages for site if jmsg['site'] not in site_events_map: site_events_map[jmsg['site']] = [jmsg] else: site_events_map[jmsg['site']].append(jmsg) futures = [] for site in site_events_map: events = site_events_map[site] futures.append( asyncio.ensure_future( self._process_site_events(site, tp.topic, events))) await asyncio.gather(*futures, return_exceptions=True) except Exception as exc: # pylint: disable=broad-except self.logger.error( 'Unexpected error or parse topic messages: %s\n%s', exc, '\n'.join(traceback2.format_exc().splitlines()) if self.debug else '')
async def get(self): try: session = await get_session(self.request) name = self.request.match_info.get('name') if not self.request.headers.get('Range'): headers = {'content-type': 'text/html charset = utf-8'} return web.Response(status='200', headers=headers, body='hello world!') ll, rr = self.request.headers['Range'].replace('bytes=', '').split('-') left = int(ll) right = int(rr) path = share_home + name if not exists(path): return web.Response(status='404') else: headers = {} headers[ 'Content-Range'] = 'bytes ' + ll + '-' + rr + '/' + str( getsize(path)) with open(path, 'rb') as f: f.seek(left) body = f.read(right - left + 1) return web.Response(status='206', headers=headers, body=body) except: logger.error(format_exc())
def create_cache(self, data): self.username = data['username'] self.theory_name = data['theory_name'] self.thm_name = data['thm_name'] self.vars = data['vars'] self.prop = data['prop'] self.steps = data['steps'] if self.thm_name != '': limit = ('thm', self.thm_name) else: limit = None context.set_context(self.theory_name, limit=limit, username=self.username, vars=self.vars) state = server.parse_init_state(self.prop) self.history = [] self.states = [copy.copy(state)] self.error = None for step in self.steps: self.history.extend(state.parse_steps([step])) self.states.append(copy.copy(state)) try: state.check_proof() except Exception as e: self.error = { 'err_type': e.__class__.__name__, 'err_str': str(e), 'trace': traceback2.format_exc() }
def main(self, parse_cmdline_opts=True): ans = 0 if parse_cmdline_opts: self.parse_cmd_line() try: self.init_thread_pool(size=self.get_config_param( 'general', 'thread_pool_size', 20, )) self.add_signal_handler() self.loop.run_until_complete( asyncio.ensure_future(self._async_main())) except KeyboardInterrupt: pass except CancelledError: pass except Exception as exc: # pylint: disable=broad-except self.logger.error( 'Unexpected error: %s\n%s', exc, '\n'.join(traceback2.format_exc().splitlines()) if self.debug else '') ans = 1 # Running closing operation of the producer self.loop.run_until_complete(self._cleanup()) self.logger.info("Instance %s stopped.", self.name) self.loop.close() return ans
def validate_taxonomy(request): logging.info('In validate taxonomy') logging.info(request) logging.info(request.POST.get('file_input')) out_data = request.POST.get('out_data') if out_data is None or len(out_data) == 0: return render(request, 'detection/display_tax_results.html', {'error': 'Please specify the out dataset name'}) handle_uploaded_file(request.FILES['file_input']) kwargs_mimic = dict() kwargs_mimic['type'] = 'taxonomy_to_tsv' kwargs_mimic['input'] = op.join(get_qd_root(), 'visualization/taxonomy/') kwargs_mimic['data'] = out_data kwargs_mimic['datas'] = [ s.strip() for s in request.POST.get('str_datas').split(',') ] if len(kwargs_mimic['datas']) <= 0 or \ len(kwargs_mimic['datas']) == 1 and kwargs_mimic['datas'][0] == '': return render(request, 'detection/display_tax_results.html', {'error': 'Please specify at least one data source'}) try: build_taxonomy_impl(kwargs_mimic['input'], **kwargs_mimic) except Exception, e: print str(e) context = dict() context['files'] = [] if str(e) == "": context['error'] = 'Taxonomy successfully verified' files = return_download_list( op.join(get_qd_root(), 'data/{}/'.format(out_data))) context['files'] = files else: trace = (traceback.format_exc()) context['error'] = trace return render(request, 'detection/display_tax_results.html', context)
def fill_gaps(horizon=21*24*60*60): now = datetime.utcnow().replace(tzinfo=timezone.utc).timestamp() logger.info(f'Fill gaps in trade buckets through {now}') max_timestamp_dt = get_max_timestamp_of_trade_buckets() if max_timestamp_dt == None: logger.info('Could not find max(timestamp_dt) for trade buckets. Default to now.') max_timestamp_dt = now twenty_one_days_ago = now - horizon start_time = min(twenty_one_days_ago, max_timestamp_dt) + 60 while start_time <= now: # start_time_str should have format "2020-01-02 18:03", understood to be in UTC timezone. start_time_dt = datetime.fromtimestamp(start_time, tz=timezone.utc) start_time_str = start_time_dt.strftime("%Y-%m-%d %H:%M") # Query 2 hours of trades at a time. That's a 120 samples per API query (hence, count=120). try: trades = bitmex_client.Trade.Trade_getBucketed(symbol="XBTUSD", binSize="1m", partial=False, reverse=False, count=120, filter=json.dumps({"startTime": start_time_str})).result() logger.info(f'start_time_str:{start_time_str} ntrades:{len(trades[0])}') except Exception: logger.error(traceback2.format_exc()) trades = None # Archive historical trades, if any. Advance the clock 2 hours, but only if the last API request succeeded. if trades: for k in range(0, len(trades[0])): insert_trade_bucket(trades[0][k]) start_time = start_time + 2*60*60 # Sleep to avoid API rate limit violations. time.sleep(2) # Update NOW in order to capture any trade buckets that may have completed since we started filling gaps. now = datetime.utcnow().replace(tzinfo=timezone.utc).timestamp()
def stop(self): try: self.__downloader_with_206.stop() self.__downloader_without_206.stop() controler.stop() except Exception as e: logger.error(format_exc())
def call_func(*args, **kwargs): try: result = func(*args, **kwargs) except Exception as e: sender = emailSender receivers = emailReceiver message = MIMEMultipart() message['From'] = Header(u"定时任务", 'utf-8') message['To'] = Header("", 'utf-8') subject = u"定时任务" + os.path.split(__file__)[1] message['Subject'] = Header(subject, 'utf-8') errorinfo = u'异常信息:\n' + str(traceback2.format_exc()) message.attach(MIMEText(errorinfo, 'plain', 'utf-8')) for i in range(100): try: smtpObj = smtplib.SMTP_SSL(senderServer, 465) smtpObj.login(senderUsername, senderPassword) smtpObj.sendmail(sender, receivers, message.as_string()) logging.info(u"邮件发送成功") break except smtplib.SMTPException as e: logging.error(e) logging.error(errorinfo) exit(0) return result
def start(self, home_i=home): try: controler.init(self.__queue.qsize()) while not self.__queue.empty(): self.__allocation(self.__queue.get(), home_i) except Exception as e: logger.error(format_exc())
def parse_steps(self, steps): """Parse and apply a list of steps to self. Return the output from the list of steps. """ history = [] for step in steps: with global_setting(unicode=True, highlight=True): step_output = method.output_step(self, step) history.append({ 'step_output': step_output, 'goal_id': step['goal_id'], 'fact_ids': step.get('fact_ids', []) }) try: method.apply_method(self, step) self.check_proof(compute_only=True) except Exception as e: history[-1]['error'] = { 'err_type': e.__class__.__name__, 'err_str': str(e), 'trace': traceback2.format_exc() } return history
def _call( jyzd ): try: _jyzd = AttrDict( initd = jyzd , kword = None , nocopy = True ) _tps.errLog( _tps.DEBUG , '交易字典内容输出:%s' % _jyzd , _tps.RPT_TO_LOG ) # # 校验流水是否已登记 # if not _jyzd.LSBZ: # ins_lsz( lsh = _jyzd.SYS_XTLSH, jyrq = _jyzd.SYS_JYRQ, jysj = _jyzd.SYS_XTSJ, jym = _jyzd.SYS_JYBM, jgdm = _jyzd.JYJGM, gyh = _jyzd.CZGY ) # _jyzd.LSBZ = '1' r = func( _jyzd ) # 校验交易字典中的值,确定全部转换为str类型 for k , v in jyzd.items(): #v = jyzd[ k ] if type(v) != str: _tps.errLog( _tps.WARNING, '>>>>>>>>>>>>>>>>>>>[%s]类型错误[%s][%s]'%(k, type(v), repr(v)), _tps.RPT_TO_LOG ) if v == None: jyzd[ k ] = '' else: jyzd[ k ] = str( v ) if r < 0: _tps.errLog( _tps.ERROR , '>>>>>>>>>>>>>>>>>>>函数返回:%s,%s' % ( _jyzd.SYS_RspCode , _jyzd.SYS_RspInfo ) , _tps.RPT_TO_LOG ) return r except: msg = traceback2.format_exc( show_locals = True ) _tps.errLog( _tps.ERROR , msg , _tps.RPT_TO_LOG ) jyzd['SYS_RspCode'] = 'TS0004' jyzd['SYS_RspInfo'] = msg return -1
async def get(self): try: headers = {'content-type': 'text/html charset = utf-8'} return web.Response(status='200', headers=headers, body='hello world!') except: logger.error(format_exc())
async def get(self): try: name = self.request.match_info.get('name') result = await search('select * from list where name like %s', ('%' + name + '%', )) return web.json_response(data=result) except: logger.error(format_exc())
def __init__(self): try: self.__downloader_with_206 = downloader_with_206() self.__downloader_without_206 = downloader_whithout_206() self.__queue = Queue(max_works) self.host = '' except Exception as e: logger.error(format_exc())
async def on_global_message(self, message): try: if message.author.id in self.bot.BAN: return new_filter = Filter(self.filter, self.black_link_filter, self.white_link_filter) return_code = await new_filter.execute_filter(message.content) if return_code == 1: return await message.add_reaction("🚫") else: await message.add_reaction("✅") self.bot.global_chat_log[message.id] = { "sender": str(message.author), "sender_id": message.author.id, "guild": message.guild.id, "channel": message.channel.id, "content": message.content, "attachments": [], "attachments_count": 0, "webhooks": [] } files = [] for attachment in message.attachments: attached_file = await attachment.to_file() files.append(attached_file) self.bot.global_chat_log[message.id]["attachments"].append( attachment.proxy_url) self.bot.global_chat_log[message.id]["attachments_count"] = len( files) for global_channel_id in self.bot.global_chat["general"]: if global_channel_id == message.channel.id: continue global_channel = self.bot.get_channel(global_channel_id) if global_channel is None: self.bot.global_chat["general"].remove(global_channel_id) with open("./GLOBAL_CHAT.json", 'w') as db: json.dump(self.bot.global_chat, db, indent=2) continue channel_webhooks = await global_channel.webhooks() webhook = discord.utils.get(channel_webhooks, name="muffin-webhook") if webhook is None: webhook = await global_channel.create_webhook( name="muffin-webhook") files = [] for attachment in message.attachments: attached_file = await attachment.to_file() files.append(attached_file) msg_obj = await webhook.send( message.content, username=message.author.name, avatar_url=message.author.avatar_url, files=files, wait=True) self.bot.global_chat_log[message.id]["webhooks"].append( msg_obj) except: await message.channel.send(traceback2.format_exc())
def insert_order(order_id, symbol, price, side, quantity, created_dt): logger.info(f'Inserting order: order_id:{order_id} symbol:{symbol} price:{price} side:{side} quantity:{quantity} created_dt:{created_dt}') try: with connection.cursor() as cursor: sql = "INSERT INTO `orders` (`order_id`, `symbol`, `price`, `side`, `quantity`, `created_dt`) VALUES (%s, %s, %s, %s, %s, FROM_UNIXTIME(%s))" cursor.execute(sql, (order_id, symbol, price, side, quantity, created_dt)) connection.commit() except Exception: logger.error(traceback2.format_exc())
def check_traceback_format(self, cleanup_func=None): try: if issubclass(six.binary_type, six.string_types): # Python 2.6 or other platform where the interpreter # is likely going to be spitting out bytes, which will # then fail with io.StringIO(), so we skip the cross- # checks with the C API there. Note that _testcapi # is included in (at least) Ubuntu CPython packages, which # makes the import check less effective than desired. raise ImportError from _testcapi import traceback_print except ImportError: traceback_print = None try: self.some_exception() except KeyError: type_, value, tb = sys.exc_info() if cleanup_func is not None: # Clear the inner frames, not this one cleanup_func(tb.tb_next) traceback_fmt = u('Traceback (most recent call last):\n') + \ u('').join(traceback.format_tb(tb)) if traceback_print is not None: file_ = StringIO() traceback_print(tb, file_) python_fmt = file_.getvalue() # Call all _tb and _exc functions with captured_output("stderr") as tbstderr: traceback.print_tb(tb) tbfile = StringIO() traceback.print_tb(tb, file=tbfile) with captured_output("stderr") as excstderr: traceback.print_exc() excfmt = traceback.format_exc() excfile = StringIO() traceback.print_exc(file=excfile) else: self.fail("unable to create test traceback string") # Make sure that Python and the traceback module format the same thing if traceback_print is not None: self.assertEqual(traceback_fmt, python_fmt) # Now verify the _tb func output self.assertEqual(tbstderr.getvalue(), tbfile.getvalue()) # Now verify the _exc func output self.assertEqual(excstderr.getvalue(), excfile.getvalue()) self.assertEqual(excfmt, excfile.getvalue()) # Make sure that the traceback is properly indented. tb_lines = traceback_fmt.splitlines() self.assertEqual(len(tb_lines), 5) banner = tb_lines[0] location, source_line = tb_lines[-2:] self.assertTrue(banner.startswith('Traceback')) self.assertTrue(location.startswith(' File')) self.assertTrue(source_line.startswith(' raise'))
def test_issue(encoding): expected = u"Всё очень плохо" try: foo() except Exception as e: text2 = traceback.format_exc() text3 = text(text2, encoding) print(u"EXCEPTION-TEXT: %s" % text3) print(u"text2: "+ text2) assert_that(text3, contains_string(u"AssertionError: Всё очень плохо"))
def exception( logname , *args , **kwargs ): if logname: logger = init_log( logname ) exc_msg = traceback2.format_exc( show_locals = True ) args = list( args ) if args: args[0] += '\n%s' else: args.append( '%s' ) args.append( exc_msg ) logger.error( _fmt_msg( *args , **kwargs ) ) return ''
def initialise(self, config, name): """ Setup and start sensors :param config: the config to use when making the instrument :param name: a name for the instrument :return: """ try: _default_log_dir = '/var/log/corr' config_file_dict = parse_ini_file(config) log_file_dir = config_file_dict.get('FxCorrelator').get('log_file_dir', _default_log_dir) assert os.path.isdir(log_file_dir) start_time = str(time.time()) ini_filename = os.path.basename(config) log_filename = '{}_{}_sensor_servlet.log'.format(ini_filename, start_time) self.instrument = fxcorrelator.FxCorrelator( 'dummy fx correlator for sensors', config_source=config, mass_inform_func=self.mass_inform, getLogger=getKatcpLogger, log_filename=log_filename, log_file_dir=log_file_dir) self.instrument.initialise(program=False, configure=False, require_epoch=False, mass_inform_func=self.mass_inform, getLogger=getKatcpLogger, log_filename=log_filename, log_file_dir=log_file_dir) #disable manually-issued sensor update informs (aka 'kcs' sensors): sensor_manager = sensors.SensorManager(self, self.instrument,kcs_sensors=False, mass_inform_func=self.mass_inform, log_filename=log_filename, log_file_dir=log_file_dir) self.instrument.sensor_manager = sensor_manager sensors_periodic.setup_sensors(sensor_manager,enable_counters=False) # Function created to reassign all non-conforming log-handlers loggers_changed = reassign_log_handlers(mass_inform_func=self.mass_inform, log_filename=log_filename, log_file_dir=log_file_dir, instrument_name=self.instrument.descriptor) except Exception as exc: stack_trace = traceback.format_exc() return self._log_stacktrace(stack_trace, 'Failed to initialise sensor_servlet.')
def test_issue(encoding): """ with encoding=UTF-8: File "/Users/jens/se/behave_main.unicode/tests/issues/test_issue0453.py", line 31, in problematic_step_impl raise Exception(u"по русски") Exception: \u043f\u043e \u0440\u0443\u0441\u0441\u043a\u0438 with encoding=unicode_escape: File "/Users/jens/se/behave_main.unicode/tests/issues/test_issue0453.py", line 31, in problematic_step_impl raise Exception(u"по ÑÑÑÑки") Exception: по русски """ context = None text2 = "" expected_text = u"по русски" try: problematic_step_impl(context) except Exception: text2 = traceback.format_exc() text3 = text(text2, encoding) print(u"EXCEPTION-TEXT: %s" % text3) assert_that(text3, contains_string(u'raise Exception(u"по русски"')) assert_that(text3, contains_string(u"Exception: по русски"))