def command(self,command):
"""
#执行命令模块
"""
#print (command)
stdin,stdout,stderr = self.s.exec_command(command)
a = stderr.read().decode()
if 'already exists' in a:
ret = True
else:
ret = False
if len(a) == 0 or ret:
print (self.remote_host_address,':OK')
out = stdout.read()
try:
print (out.decode())
except UnicodeDecodeError:
print (out.decode('gb2312'))
msg = "[%s] exec command [%s] success" % (self.remote_host_address,command)
logger.info(msg)
else:
print (self.remote_host_address,':')
print (stderr.read().decode())
logger.error(stderr.read().decode())
print (a)
print ('Somethings is Wrong,Please sure.')
self.s.close()
def add_cart(self, card):
if self.len_hand >= MAX_COUNT_CARD_IN_ARM:
logger.warning('Max count card in arm!')
return
if card:
logger.info(f'To hand {self.name}, add card: {card.name}')
card.change_scale(BASE_CARD_WIDTH, BASE_CARD_HEIGHT)
self.__hand.add(card)
def login(uid):
(session, login_uid) = wblogin(uid)
if login_uid == uid:
logger.info('uid [%s] login success!' % uid)
return (session, True)
else:
logger.info('uid [%s] login failed!' % uid)
return (session, False)
def first_bot_turn(self):
logger.info(
f'Bot move, his cards in hand: {self.__player_turn.cards_in_hand}')
turn_card = self.bot_first_turn()
self.add_card_in_game_deck(turn_card)
self.__player_turn.remove_card(turn_card)
self.__last_card = turn_card
self.__player_turn.made_turn = True
def check_existance_optionals(self, name: str, value: str):
logger.info("Checking the existance of ['%s']" % value)
available = self.get_available(name)
if value not in available:
logger.error(
"The {name} [{metric}] do not exist. The available one are [{metrics}]"
.format(**locals()))
return False
return True
def request_matches(replace=False):
logger.info('request_matches() ')
session = Database.get_session()
seasons = SeasonController(session).list()
args = [(s, replace) for s in seasons]
pool = mp.Pool(mp.cpu_count())
pool.map(_request_matches, args)
def insert_metrics(conn: connection, metrics: List[dict]):
if not metrics:
return
logger.info('Write messages ...')
with conn.cursor() as cursor:
extras.execute_batch(cursor, SQL_INSERT_METRICS, metrics)
conn.commit()
def check_existance(self, name: str, value: str):
logger.info("Checking the existance of ['%s']" % value)
available = self.get_available(name)
if value not in available:
logger.error(
"The {name} [{value}] do not exist. The available one are [{available}]"
.format(**locals()))
self.__del__()
sys.exit(1)
def request_seasons(replace=False):
logger.info('request_seasons() ')
session = Database.get_session()
championships = ChampionshipController(session).list()
args = [(c, replace) for c in championships]
pool = mp.Pool(mp.cpu_count())
pool.map(_request_season, args)
def reset_database():
logger.info('reset_database() ')
session = Database.get_session()
ChampionshipController(session).drop()
SeasonController(session).drop()
MatchController(session).drop()
PerformanceController(session).drop()
def _create_matches(season):
logger.info('create_matches(): ' + str(season))
session = Database.open_new_session()
MatchController(session).create_matches(season)
SeasonController(session).update_summary_fields(season)
MatchController(session).process_results(season)
MatchController(session).update_rounds(season)
def clear_game_deck(self):
"""
Сбросить игровую колоду в отбой
"""
for card in self.game_deck:
self.__clear_cards.add(card)
self.__game_deck = pygame.sprite.Group()
self.check_cards_in_hands()
logger.info('Drop game deck')
def sendPacket(self, outPort, pkt):
"""Forward the packet to the its respective output
Args:
outPort (int): the output port packet is being sent through
pkt (Packet): the packet to be forwarded
"""
logger.info(f"[Packet {pkt.pktId}] : Sent from Space Switch {self.spaceSwitchId}")
outSwitch = self.network.stageThreeAWGRs[outPort]
outSwitch.receive(self.spaceSwitchId, pkt)
def set_trump_card(self):
self.__trump_card = self.deck.get_card
if RANK_INDEX_NAME[self.__trump_card.rank] == 'ace':
logger.warning(f'Ace for trump card: {self.trump_card.name}')
self.deck.return_card_in_deck(self.trump_card)
# todo: fix me
self.__trump_card = self.deck.get_card
logger.warning(f'New trump card: {self.trump_card.name}')
logger.info(f'Set trump card: {self.trump_card.name}')
self.deck.return_card(self.__trump_card)
def request_seasons(replace=False):
logger.info('Service: request_seasons()')
session = Database.get_session()
champs = list(ChampionshipController(session).list())
args = [(champs[idx], replace) for idx, item in enumerate(champs)]
p = mp.Pool(mp.cpu_count())
p.map(_requests_season, args)
def onPacketArrival(self, pkt):
"""Communicate with the controller and schedule the packet
Args:
pkt (Packet): the incoming packet
"""
logger.info(
f"[Packet {pkt.pktId}] : Arrived at Transmitter {self.transmitterId}"
)
self.network.controller.enqueue_scheduler(pkt)
def request_matches(replace=False):
logger.info('Service: request_matches()')
session = Database.get_session()
seasons = list(SeasonController(session).list())
args = [(seasons[i], replace) for i, item_a in enumerate(seasons)]
p = mp.Pool(mp.cpu_count())
p.map(_request_matches, args)
def create_odds(replace=False):
logger.info('Service: extract_odds()')
session = Database.SESSION
seasons = list(SeasonController(session).list())
if replace:
OddsController(session).reset()
p = mp.Pool(mp.cpu_count())
p.map(_create_odds, seasons)
def check_cards_in_hands(self):
"""
Добавляем карты в руку если их меньше константы.
:return:
"""
for player in self.__players:
if player.len_hand < COUNT_START_CARD:
logger.info(
f'Player: {player.name} have {player.len_hand} in hand')
for i in range(COUNT_START_CARD - player.len_hand):
player.add_cart(self.deck.get_card)
def downloadAndForwardAttachable(bill_dict, bill_in_qb):
attachableName = bill_dict.get('BILL PDF') if len(bill_dict.get(
'BILL PDF')) else bill_in_qb.get('Bill').get('DocNumber') + ".pdf"
downloadFileFromLink(attachableName, bill_dict.get('BILL PDF LINK'))
s3AttachableName = "bill_attachments/" + attachableName
s3_link = upload_file(s3AttachableName, file_root_path + attachableName,
True)
attachNoteToEntity(s3_link, bill_in_qb.get('Bill').get('Id'), 'Bill')
deleteAttachemnt(attachableName)
logger.info(
'downloadAndForwardAttachable | pushed to s3 | bill: {0}'.format(
bill_dict))
def create_matches(replace=False):
logger.info('create_matches() ')
session = Database.get_session()
MatchController(session).initialize()
if replace:
MatchController(session).drop()
seasons = SeasonController(session).list()
pool = mp.Pool(mp.cpu_count())
pool.map(_create_matches, seasons)
def receive(self, inPort, pkt):
"""Receive scheduled packets from the Stage One AWGRs and pass them to
Stage Three AWGRs
Args:
inPort (int): the port on which packet is being received
pkt (Packet): the packet to be received
"""
logger.info(f"[Packet {pkt.pktId}] : Reached Space Switch {self.spaceSwitchId}")
slotData = self.getSlotData(pkt.dispatchSlot)
outPort = slotData.finalState[inPort]
self.sendPacket(outPort, pkt)
def create_matches(replace=False):
logger.info('Service: create_matches()')
session = Database.SESSION
if replace:
MatchController(session).drop()
MatchController(session).initialize()
seasons = list(SeasonController(session).list())
p = mp.Pool(mp.cpu_count())
p.map(_create_matches, seasons)
def qbwebhook(request):
if request.method == 'POST':
try:
body_unicode = request.body.decode('utf-8')
signature = request.headers.get('Intuit-Signature')
verifier_token = settings.QBO_WEBHOOK_VERIFIER
logger.info("QB webhook received: {0}, {1}".format(
body_unicode, signature))
process_qb_webhook.delay(signature, body_unicode, verifier_token)
return HttpResponse(
"Hello, world. You're at the quickbooks webhook.")
except Exception as e:
print('qbwebhook error') # TODO:get stacktrace log
return HttpResponseBadRequest(e)
def get(self,rpath,lpath):
"""
#下载文件目录，调用get_dirs
"""
self.get_dirs(rpath,lpath)
print (self.remote_host_address)
error_num = self.error_count(-1)
msg_ok = 'Get Total files number: %s' % self.sucess_count(-1)
msg_error = 'Get Error files number: %s' % error_num
logger.info('%s %s %s' % (self.remote_host_address,rpath,msg_ok))
if error_num > 0:
logger.error('%s %s %s' % (self.remote_host_address,rpath,msg_error))
print (msg_ok)
print (msg_error)
def predict_time_left(x : np.ndarray, y : np.ndarray, name : str, mode : str = "BAYESIAN") -> int:
functions = {
"OLS":OLS,
"RANSAC":RANSAC,
"BAYESIAN":BAYESIAN
}
# Reshape the array as a single feature array for the predictors
x = x.reshape(-1, 1)
if mode in functions.keys():
logger.info("Predicting using the mode [%s]"%mode)
with Timer("The prediction took {time}s"):
m, q, p = functions[mode](x, y)
logger.info("The coefficents predicted are m [{m}] q[{q}]".format(**locals()))
if m <= 0:
logger.info("The predicted line is not growing so it will never reach the max")
return "inf", p
time_predicted = (1 - q)/m
delta = time_predicted - x[-1]
if delta > MAX_TIME:
logger.info(f"The predicted time [{delta}] is over [{MAX_TIME}] so it's casted to [inf]")
return "inf", p
return delta[0], p
logger.error("Mode [%s] not found, the available ones are %s"%(mode, functions.keys()))
return None, 0
def deleteBillFromQB(tv_bill_id):
bill = BillExpenseReference().getBillExpenseReferanceByTvId(
bill_id=tv_bill_id)
if not bill:
logger.error(
"deleteBillFromQB: No bill found for {0}".format(tv_bill_id))
return
deleteBillInQB(bill.qb_id)
bill.delete()
bill.save()
logger.info('deleted bill from qb: {0}'.format(bill.qb_id))
def get_company_map():
try:
data = request.get_json()
if not data:
'''
content-type:
'''
logger.warning({
"isSuccess": False,
"msg": "请使用 application/json 传递参数"
})
response = Response(json.dumps({
"isSuccess": False,
"msg": "请使用 application/json 传递参数"
}),
mimetype='application/json')
return response
except BadRequest:
logger.warning({"isSuccess": False, "msg": "JSON 格式错误"})
response = Response(json.dumps({
"isSuccess": False,
"msg": "JSON 格式错误"
}),
mimetype='application/json')
return response
if not data.get('company_name'):
logger.warning({"isSuccess": False, "msg": "缺少必要参数"})
response = Response(json.dumps({
"isSuccess": False,
"msg": "缺少必要参数"
}),
mimetype='application/json')
return response
company_name = data.get('company_name')
data = get_company_base_info(company_name)
if data.get('isSuccess'):
company_map = EnterpriseGenealogy()
logger.info('正在构建 {} 企业族谱.'.format(company_name))
genealogy = company_map.make_company_map(data)
remove_company_code(genealogy)
response = make_response(genealogy)
else:
response = make_response(data)
logger.info(data)
return response
def onSchedule(self, pkt):
"""Recieve scheduled packets from the Controller and do further
processing
Args:
pkt (Packet): the incoming packet
"""
logger.info(
f"[Packet {pkt.pktId}] : Scheduled for dispatch from Transmitter {self.transmitterId}"
)
if pkt.dispatchSlot in self.transmissions.keys():
self.transmissions[pkt.dispatchSlot] += 1
else:
self.transmissions[pkt.dispatchSlot] = 1
self.sendPacket(pkt)
def tvwebhook(request):
if request.method == 'GET':
try:
table_id = request.GET.get('tableId')
view_id = request.GET.get('viewId')
record_id = request.GET.get('recordId')
event_type = request.GET.get('eventType')
logger.info("TV webhook received: {0}, {1}, {2}, {3}".format(
table_id, view_id, record_id, event_type))
process_tv_webhook.delay(table_id, view_id, record_id, event_type)
return HttpResponse(
"Hello, world. You're at the trackvia integrations.")
except Exception as e:
print('tvwebhook error') # TODO:get stacktrace
return HttpResponseBadRequest(e)
def set_theme(theme):
''' Set theme '''
global color_light_ground, color_light_wall, \
color_dark_wall, color_dark_ground, \
color_wall_highlight, color_ground_highlight, \
color_accent
# Setting colors to the absence of colors is kind of hard. Let's not do that.
if theme is not None:
logger.info('Theme set: ' + theme)
# Set all the colors here
# Yes, I know. It goes over the proper line wrapping length.
# The other way is 10x less readable, so I am not wrapping it.
try:
color_light_ground = get_color(color_data[theme]['ground']['light'])
color_dark_ground = get_color(color_data[theme]['ground']['dark'])
color_light_wall = get_color(color_data[theme]['wall']['light'])
color_dark_wall = get_color(color_data[theme]['wall']['dark'])
color_wall_highlight = get_color(color_data[theme]['highlight']['wall'])
color_ground_highlight = get_color(color_data[theme]['highlight']['ground'])
color_accent = get_color(color_data[theme]['accent']['light'])
except KeyError as e:
logger.severe("KeyError({0}): {1}".format(e.errno, e.strerror))
default_colors()
logger.write('----- STACK TRACE: -----')
logger.write(traceback.extract_stack())
logger.write('------------------------')
# Simple assertion testing to make sure all the colors loaded properly
try:
assert color_light_ground is not None
assert color_dark_ground is not None
assert color_light_wall is not None
assert color_dark_wall is not None
assert color_wall_highlight is not None
assert color_ground_highlight is not None
assert color_accent is not None
except AssertionError as e:
logger.severe("AssertionError ({0}): {1}".format(e.errno, e.strerror))
default_colors()
logger.write('----- STACK TRACE: -----')
logger.write(traceback.extract_stack())
logger.write('------------------------')
else:
logger.warn('No theme passed to set_theme()!')
logger.info('Defaulting theme...')
default_colors()
def event_trigger(self, ev):
""" Response function to handle special trigger events. Initiates the proper
response depending on the event.
Args:
ev(Event): the special trigger event
"""
if ev.category == "timeslot-end":
logger.info(f"[Timeslot {ev.slot_no}] : Timeslot ENDING....")
self.fault_tracking(self.current_slot)
self.allotSlots(ev.slot_no)
logger.info(
f"[Timeslot {ev.slot_no}] : Timeslot ENDED, Next Timeslot STARTING..."
)
elif ev.category == "eventset-end":
self.clearQueue(self.current_slot)
def get_available(self, name: str):
"""For a field it returns all the distinct values once the filter is applied
to the previous fields in order of insertion in the dictionary"""
# If it's measuremnets it's a special case because it's a different kind of query
if name == "measurement":
return self.get_measurements()
# Selectors must be valid and they have an order
elif name in self.query["selectors"].keys():
index = list(self.query["selectors"].keys()).index(name)
selectors_before_name = dict(
list(self.query["selectors"].items())[:index])
return self.get_distinct_values(name, selectors_before_name)
# Optionals do not have an order and only need the selectors on the WHERE
elif name in self.query["optionals"].keys():
return self.get_distinct_values(name, self.query["selectors"])
else:
logger.info("%s not found" % name)
def default_colors():
''' Sets the values used in the main file to hard-coded defaults
Should be used as a fallback in case something goes wrong and we cannot
load the colors from our theme file
'''
global color_light_ground, color_light_wall, \
color_dark_wall, color_dark_ground, \
color_wall_highlight, color_ground_highlight, \
color_accent
logger.info('Setting to default color scheme...')
color_light_ground = libtcod.Color(110, 109, 91)
color_light_wall = libtcod.Color(128, 127, 98)
color_dark_wall = libtcod.Color(51, 51, 51)
color_dark_ground = libtcod.Color(33, 33, 33)
color_wall_highlight = libtcod.Color(130, 110, 50)
color_ground_highlight = libtcod.Color(200, 180, 50)
color_accent = libtcod.Color(255, 255, 255)
def hex_to_color(inp):
''' Converts a hex string into a libtcod Color object '''
# Format the string for use
fhex = inp.replace('#', '').strip()
try:
# Get string slices for each hex bit and convert them to numbers
# NOTE: String slices are in base 16
red_bit = int(fhex[0:2], 16)
green_bit = int(fhex[2:4], 16)
blue_bit = int(fhex[4:6], 16)
logger.info('Color: (' + str(red_bit) + ', ' + str(green_bit) + ', ' + \
str(blue_bit) + ')')
return libtcod.Color(red_bit, green_bit, blue_bit);
# If the color sting is mal-formatted
except ValueError as e:
logger.error('Problem converting hex to color! Is it `rrggbb` formatted?')
return None
def put(self,lpath,rpath=None):
if not rpath:
print ('Please input remote file or dir')
else:
if os.path.isfile(lpath):
self.put_file(lpath,rpath)
else:
if re.match(r'd',str(self.sftp.stat(rpath))):
for l,r in self.put_dir(lpath, rpath):
self.put_file(l,r)
else:
print ('Remote path must be a dirname')
self.s.close()
print (self.remote_host_address)
error_num = self.error_count(-1)
msg_ok = 'Put Total files number: %s' % self.sucess_count(-1)
msg_error = 'Put Error files number: %s' % error_num
logger.info('%s %s %s' % (self.remote_host_address,rpath,msg_ok))
if error_num > 0:
logger.error('%s %s %s' % (self.remote_host_address,rpath,msg_error))
print (msg_ok)
print (msg_error)
