def run(self):
Report().begin("NativeGen")
for cls in SymbolTable().get_classes():
self.gen_class(cls)
Report().end()
def process_stocks(args):
parser = StockParser()
content = get_content()
rows = get_result_table(content)
print 'Getting upcoming results. It may take a while.'
if args["days"]:
upcoming_results = get_upcoming_result(rows, args['days'])
else:
upcoming_results = get_upcoming_result(rows)
quarterly_record = []
print 'Fetching upcoming stocks data.'
for stock in upcoming_results:
for company_name, stock_info in stock.iteritems():
try:
if "stock_page" in stock_info and stock_info["stock_page"]:
stock_data = parser.get_stock_data(
stock_info["stock_page"])
stock_info.update({"company_name": company_name})
stock_info.update(stock_data)
quarterly_record.append(stock_info)
except Exception as e:
pass
if len(quarterly_record):
if 'r' in args and args['r'] is not None:
generate_recommendation(quarterly_record, args)
if 'f' in args and args['f']:
report = Report(quarterly_record, file_name=args['f'])
else:
report = Report(quarterly_record,
file_name='overall_quarterly_result.csv')
report.generate()
def run(self):
Report().begin("Translate")
for cls in SymbolTable().get_classes():
Report().report('translate {}'.format(cls),
lambda: self.translate(cls))
Report().end()
Option().nodes = {}
def run(self):
Report().begin("ControlFlowAnalyse")
for cls in SymbolTable().get_classes():
Report().report('analyse {}'.format(cls))
for method in cls.methods + cls.static_methods:
self.analyse(method)
Report().end()
def DrawShapefile(self, shapelygeoms, projection):
Report("loading")
geomstofeature = cartopy.feature.ShapelyFeature(
geometries=shapelygeoms, crs=projection)
Report("drawing")
self.ax.add_feature(geomstofeature,
facecolor="pink",
edgecolor='green')
self.ax.figure.canvas.draw()
def run(self):
Report().begin("RuntimeGen")
table = SymbolTable()
self.classes = sorted(table.get_classes(),
key=lambda c: c.qualified_name)
self.packages = sorted(table.get_packages(),
key=lambda pkg: pkg.qualified_name)
self.gen_global()
Report().end()
def run(self):
Report().begin("Enter member")
for cls in SymbolTable().get_classes():
ctx: PlayParser.ClassDeclarationContext = Option().nodes[cls]
for member in ctx.memberDeclaration():
if member.methodDeclaration():
self.enter_method(cls, member.methodDeclaration())
else:
self.enter_field(cls, member.fieldDeclaration())
if not list(filter(lambda m: m.name == '<init>', cls.methods)):
cls.methods.append(
Method('<init>', cls, parameters=[], body=Block([])))
Report().end()
def run(self):
Report().begin("Parsing")
for src in Option().source_locations:
if not src.endswith('/'):
src += '/'
for root, dirs, files in os.walk(src):
for file in files:
if not file.endswith('.play'):
continue
path = os.path.join(root, file)
Report().report("parse {}".format(path),
lambda: self.parse(path, path[len(src):]))
Report().end()
def output_summary(self, label, market, outfile):
summary = self.summarize_inventory(market)
report = Report(outfile)
report.start()
report.output_value_table(summary['inventory'], label)
report.end()
def addReport():
log('Called add-report')
user = flask.request.form['userBy']
log(user)
plate = flask.request.form['plate']
log(plate)
space = flask.request.form['space']
log(space)
dateOccured = flask.request.form['dateOccured']
log(dateOccured)
description = flask.request.form['description']
log(description)
dateReported = flask.request.form['dateSubmitted']
log(description)
garage = flask.request.form['garage']
log(garage)
log(garage)
log('adding report for ' + dateOccured)
json_result = {}
try:
reportData.createReport(Report(user, description, plate, garage, space, dateReported, dateOccured ))
json_result['ok'] = True
except Exception as exc:
log('EXCEPTION')
log(str(exc))
json_result['error'] = str(exc)
return flask.Response(json.dumps(json_result), mimetype='application/json')
def process_messages():
print("Process message")
for msg in consumer:
print(msg)
msg_str = msg.value.decode('utf-8')
msg = json.loads(msg_str)
if msg['type'] == 'request':
print("what is this", msg['payload'])
session = DB_SESSION()
rq = Request(msg['payload']['name'], msg['payload']['location'],
msg['payload']['destination'], msg['payload']['time'],
msg['payload']['notes'])
session.add(rq)
session.commit()
session.close()
elif msg['type'] == 'report':
session = DB_SESSION()
rp = Report(msg['payload']['name'], msg['payload']['customer'],
msg['payload']['pickup'], msg['payload']['dropoff'],
msg['payload']['pickuptime'],
msg['payload']['dropofftime'],
msg['payload']['rating'], msg['payload']['notes'])
session.add(rp)
session.commit()
session.close()
def __init__(self):
super(Main, self).__init__(load_config, NAME_FILE_CONFIG_PATH, NAME_FILE_LOG_PATH, NAME_FILE_CSV_PATH)
self.loading_args()
self.log_configuration()
# General variable
self.config = self.loading_file_config()
self.errors = []
self.fields_csv = self.config.get("GENERAL", "fields_csv").split(",")
list_links = parser_cvs(self.args.csv, self.fields_csv)
http = Downloader()
report = Report()
for data in list_links:
download = http.download(data["link"])
report.add_elements(download)
report.print_report()
logging.info("Script Completado.")
def _check_duplicate_filename(album, photo):
report = None
if photo.filename != photo.title.text:
print "Duplicate photo '%s' de-duplicated to '%s'" % (photo.title.text,
photo.filename)
report = Report(Report.DUPLICATE_FILENAME, album=album, photo=photo)
return report
def generate_reports(self, task_dir='./', no_file=False):
for user in self.users:
report = Report(str(f'{task_dir}{user["username"]}.txt.tmp'))
# готовим содержимое файла в виде списка.
if not report.prepare_content(user, self.tasks):
continue
# если отключен дебажный флаг
if not no_file:
if not os.path.exists(task_dir):
try:
os.makedirs(task_dir)
except Exception as err:
print(f'{err} Report cannot be saved.')
break
# сохраняем временный файл
if not report.write_temp_file(report.file_name):
break
# валидируем временный файл
if report.validate_output_file(report.file_name):
# сохраняем изменения, переименовывая старый отчет
report.commit()
else:
print("Report validation error. Changes not accepted.")
# удаляем временный файл
report.rollback()
def cv(X, y, clf):
'''
交叉验证 Cross-validation
:param X: 训练集特征
:param y: 目标label
:param clf: 分类器
:return: 交叉验证过程中的最佳模型
'''
model = None
max_p = 0 # 记录实验中最好的模型
reporter = Report('train') # 定义评价器
for i in range(1, 10): # 10
logger.info("Folder {}".format(i))
x_train, x_test, y_train, y_test = train_test_split(X,
y,
test_size=0.3,
random_state=21 +
i)
if config.DEBUG:
logger.info("Train x data: ({}, {}), Train y data: {}".format(
len(x_train), len(x_train[0]), Counter(y_train)))
logger.info("Test x data: ({}, {}), Test y data: {}".format(
len(x_test), len(x_test[0]), Counter(y_test)))
clf.fit(x_train, y_train) # 训练过程
predict_proba = clf.predict_proba(x_test) # 返回每个类别的概率值
# TODO 随机 看结果对比submission结果
p = reporter.report_one_folder(y_test, predict_proba, threshold=0.5)
if p > max_p:
max_p = p
logger.info("Max result: {:.4f}".format(p))
model = clf
reporter.report_final_result()
return model, reporter
def _attack(self, army, report):
if report:
rep = Report()
else:
rep = None
selfiter = iter(self)
armyiter = iter(army)
ours = advance_iter(selfiter)
theirs = advance_iter(armyiter)
while ours is not None and theirs is not None:
if report:
rep.start_round(ours, theirs)
left1, left2 = ours.fight_with(theirs)
if report:
rep.end_round(left1, left2)
if left1 == 0:
ours = advance_iter(selfiter)
if left2 == 0:
theirs = advance_iter(armyiter)
return (self.get_real_len() > army.get_real_len(), rep)
async def IdRoutine(self, websocket, path):
async for message in websocket:
server = 'http://0.0.0.0:4003/'
message = json.loads(message)
if message['type'].upper() == 'HANDSHAKE':
# if self.flag:
# reply = Report(server, 'new_client')
exists = False
client = [(i, x) for i, x in self.ConnectedClients.items()
if x['IpAddr'] == message['IpAddr']
and x['port'] == message['port']]
# print("GODDAMN", client)
if len(client):
client = client[0]
exists = True
msg = {'id': client[0], 'LoN': self.ConnectedClients}
msg = json.dumps(msg)
await websocket.send(msg)
# server = 'http:/' + node.NodeIPAddr + ':5000'
if not exists:
client_id, client_pub = self.generateId(
message['IpAddr'], message['port'], message['Uri'],
message['allocate'])
print("New Client {}:{} added with ID = {}".format(
message['IpAddr'], message['port'], client_id))
a = {'id': client_id, 'LoN': self.ConnectedClients}
# print(self.ConnectedClients)
try:
a = json.dumps(a)
except TypeError as e:
print('Cleaning Client data')
for client in self.ConnectedClients:
if 'websocket' in client:
del client['websocket']
a = json.dumps(a)
await websocket.send(a)
del self.ConnectedClients[client_id]['private_key']
msg = {
'type': 'NewNode',
'id': client_id,
'Uri': message['Uri'],
'info': self.ConnectedClients[client_id]
}
m = {
'total_clients': len(self.ConnectedClients),
'id': client_id,
'clients_info': self.ConnectedClients[client_id]
}
# print(m)
Report(server, 'client', m)
# if len(self.ConnectedClients) > 2:
# Report(server, 'check_clients', {'lol':'lol'})
# await self.BroadCastNewNode(message, msg)
# await BroadCast(message['IpAddr'], message['port'], self.ConnectedClients, msg)
Multicast('224.1.1.1', 8766, msg)
def get_report(self, config={}):
report = Report()
report.title = 'no config or report type requested'
if self.CONFIG_REPORT_TYPE in config:
report_section = {}
if config[self.CONFIG_REPORT_TYPE] == self.REPORT_TERM_SUIT:
report.title = self.REPORT_TITLE_SUITS
chart = self.get_suit_chart(config)
report_section['comments'] = ['Distribution of suits.']
report_section['media'] = chart
report.make_section(
report_section) # return {'message': message}
elif config[self.CONFIG_REPORT_TYPE] == self.REPORT_TERM_REVERSE:
report.title = self.REPORT_TITLE_REVERSE
rev_chart = self.get_reverse_chart(config)
report_section['comments'] = [
'Distribution of reverse v upright cards.'
]
report_section['media'] = rev_chart
report.make_section(report_section)
elif config[self.
CONFIG_REPORT_TYPE] == self.REPORT_TERM_SUIT_RANK_DATE:
report.title = self.REPORT_TITLE_SUIT_RANK_DATE
srd_chart = self.get_suit_rank_date_chart(config)
report_section['comments'] = [
'Distribution of suits over time.'
]
report_section['media'] = srd_chart
report.make_section(report_section)
else:
report.title = 'report type ' + config[
self.CONFIG_REPORT_TYPE] + ' not found'
return report
def __init__(self, request, client_address, server):
self.routing = {
"/":
"/ack",
"/ack":
Ack(),
"/myacks":
MyAcks(),
"/report":
Report(),
"/favicon.ico":
functools.partial(self.serve_file, "image/x-icon", "favicon.ico"),
"/question-mark.png":
functools.partial(self.serve_file, "image/x-png",
"question-mark.png"),
"/site.css":
functools.partial(self.serve_file, "text/css", "site.css"),
"/test.html":
functools.partial(self.serve_file, "text/html", "test.html"),
"/auth.js":
functools.partial(self.serve_file, "application/javascript",
"auth.js"),
"/common.js":
functools.partial(self.serve_file, "application/javascript",
"common.js"),
"/del.png":
functools.partial(self.serve_file, "image/png", "del.png"),
"/check.png":
functools.partial(self.serve_file, "image/png", "check.png"),
}
super(BaseHTTPRequestHandler, self).__init__(request, client_address,
server)
def check_ansible_loop(run_list):
"""Checks on running tests and re-launces them required number of times"""
# Initialize report
report_file = config.get('General', 'report', fallback='report.csv')
report = Report(run_list, report_file)
# Good thing to keep in mind:
# iteration - Currently running iteration
# (as opposed to completed ones)
# failures - Number of failed iterations.
# Therefore marked after test completes
while run_list:
# filter out only tests which are running
running_tests = filter(lambda x: x['runner'], run_list)
for test in running_tests:
if test['runner'].status == 'successful':
report.add_result(test['test_name'], successful=True)
relaunch_test(run_list, test)
elif test['runner'].status == 'running' or test[
'runner'].status == 'starting':
if debug:
print("{}Running : {} - {} :{}: iteration {}{}".format(
ANSI_COLORS['cyan'], test['test_name'],
test['runner'].status, test['test_type'],
test['iteration'], ANSI_COLORS['reset']))
else:
report.add_result(test['test_name'], successful=False)
run_list[run_list.index(test)]['failures'] += 1
relaunch_test(run_list, test)
time.sleep(2)
def __init__(self, logfile, prefs, lock_file,
ignore_offset=0, first_time=0,
noemail=0, daemon=0):
self.__denied_hosts = {}
self.__prefs = prefs
self.__lock_file = lock_file
self.__first_time = first_time
self.__noemail = noemail
self.__report = Report(prefs.get("HOSTNAME_LOOKUP"), is_true(prefs['SYSLOG_REPORT']))
self.__daemon = daemon
self.__sync_server = prefs.get('SYNC_SERVER')
self.__sync_upload = is_true(prefs.get("SYNC_UPLOAD"))
self.__sync_download = is_true(prefs.get("SYNC_DOWNLOAD"))
r = Restricted(prefs)
self.__restricted = r.get_restricted()
info("restricted: %s", self.__restricted)
self.init_regex()
try:
self.file_tracker = FileTracker(self.__prefs.get('WORK_DIR'),
logfile)
except Exception, e:
self.__lock_file.remove()
die("Can't read: %s" % logfile, e)
def __init__(self, origin, max_x, max_y, o_window, jugador):
self.reportes = Report("")
self.foo = open("true_snake_debug.txt", "w+")
self.score = Lista()
self.sh, self.sw = o_window.getmaxyx()
self.w = o_window
self.w.keypad(1)
self.w.timeout(100)
self.snake = origin
self.food = Lista(self.sh / 2, self.sw / 2)
self.key = curses.KEY_RIGHT
self.level = 0
self.is_poison = False
self.food_symbol = "+"
self.obstacles = Lista()
self.player = jugador
self.difficulty = 80
self.thereshold = 15
try:
fu = open("config.ren", "r")
f1 = fu.readlines()
c = 0
for content in f1:
if (c == 0):
self.difficulty = int(content.strip())
elif (c == 1):
self.thereshold = int(content.strip())
c += 1
except:
self.difficulty = 80
def migrate_playlist(user_key, playlist):
print u'\nMigrating playlist: %s' % playlist['name']
name = playlist['name']
if playlist['ownerKey'] != user_key:
name += u' (by %s)' % playlist['owner']
description = u'Imported from Rdio playlist %s\n' % playlist['shortUrl']
play_track_ids = []
failed = []
tracks = rdio.playlist_tracks(playlist)
if tracks is None:
print u'Can\'t get tracks for playlist "%s" - it might be private.' % playlist[
'name']
return
with Report('playlist-%s.html' % playlist['key'], name) as report:
for match in match_tracks(tracks, len(tracks), pm):
report.add_match(match)
if match.matched():
play_track_ids.append(match.play.id)
else:
failed.append(match)
if failed:
description += 'Failed to import: '
for match in failed:
description += u'%s (%s / %s / %s)' % (
match.rdio.url, match.rdio.name, match.rdio.artist,
match.rdio.album)
playlist_id = pm.create_playlist(name, description, play_track_ids)
print u'Imported to %s' % pm.playlist_url(playlist_id)
def test_post_report(make_stubber, monkeypatch, error_code):
ses_client = boto3.client('ses')
ses_stubber = make_stubber(ses_client)
report = Report(None, None, ses_client)
post_args = {
'sender': 'test-sender', 'recipient': 'test-recipient',
'subject': 'test-subject', 'message': 'test-message',
'analysis_labels': [
f'label{index}-1,label{index}-2,label{index}-3' for index in range(3)]}
text_body = f"{post_args['message']}\n\n" + '\n'.join(post_args['analysis_labels'])
mock_parser = MagicMock(
name='mock_parser', return_value=MagicMock(parse_args=MagicMock(
return_value=post_args)))
monkeypatch.setattr(reqparse, 'RequestParser', mock_parser)
html_body = 'test-html'
monkeypatch.setattr('report.render_template', MagicMock(return_value=html_body))
ses_stubber.stub_send_email(
post_args['sender'], {'ToAddresses': [post_args['recipient']]},
post_args['subject'], text_body, html_body, 'test-id', error_code=error_code)
_, result = report.post()
if error_code is None:
assert result == 200
else:
assert result == 400
def submitReport():
if request.method == 'POST':
reportData = request.get_json()
product = reportData['productName']
company = reportData['companyName']
class_ = reportData['class_']
setup = reportData['setup']
data = reportData['dataLocation']
standard = reportData['standard']
equipment = {'SpecA': reportData['specA'], 'LISN': reportData['lisn']}
print(reportData['productName'])
print(reportData['companyName'])
print(reportData['dataLocation'])
print(reportData['standard'])
print(reportData['setup'])
print(reportData['power'])
print(reportData['class_'])
print(reportData['lisn'])
print(reportData['specA'])
output = '/Users/jadonbull/Documents/EMC Hub Output/EMC Reports/' + product + '.docx'
report = Report(product,
company,
class_,
setup,
data,
standard,
equipment,
output,
PLCE=PLCE)
report.reportOutput()
return 'Finished'
async def handle_dm(self, message):
# Handle a help message
print("top of handle dm")
if message.content == Report.HELP_KEYWORD:
reply = "Use the `report` command to begin the reporting process.\n"
reply += "Use the `cancel` command to cancel the report process.\n"
await message.channel.send(reply)
return
author_id = message.author.id
responses = []
# Only respond to messages if they're part of a reporting flow
if author_id not in self.reports and not message.content.startswith(
Report.START_KEYWORD):
print("not part of a reporting flow")
return
# If we don't currently have an active report for this user, add one
if author_id not in self.reports:
print("adding to part of concurrent reports")
self.reports[author_id] = Report(self)
# Let the report class handle this message; forward all the messages it returns to us
responses = await self.reports[author_id].handle_message(message)
for r in responses:
await message.channel.send(r)
# If the report is complete or cancelled, remove it from our map
if await self.reports[author_id].report_complete():
self.reports.pop(author_id)
def main():
data = get_data()
months, types, accounts = get_all_month_types(data)
for month in months:
month_transaction = filter_by_date(data, month)
report = Report(month, month_transaction, accounts, types)
report.print_report()
def main():
print banner(version.__version__)
args = parse_args()
init_logging(args['args'].verbose, args['args'].debug, args['args'].log)
config = Config(args['args'], args['parser'])
creds = load_creds(config)
s = None
if config.mkcred:
schema.mkcred()
quit()
if config.contributors:
print_contributors(creds)
quit()
if config.dump:
print_creds(creds)
quit()
if not config.validate:
s = ScanEngine(creds, config)
try:
s.scan()
except IOError:
logging.getLogger('changeme').debug('Caught IOError exception')
report = Report(s.found_q, config.output)
report.print_results()
if config.output:
report.render_csv()
return s
def report(self):
r = Report()
r.student = self.student
r.type_analysis = self.type_analysis
r.period = self.period
r.session = self.stud_session
r.header_table = self.table_header
r.body_table = self.result
r.group = self.group
name = "Студент: " + self.student + "/" + self.type_analysis + "/" + self.group
if self.type_analysis == "Средняя оценка по итогам сессии":
control = Control()
proportional_result: np.ndarray = control.analysis_student_proportional(self.session, self.student, self.stud_session,
self.period)
r.proportional_result = proportional_result
r.name = name
list_of_report_object.append(r)
list_of_report_name.append(name)
msg = QMessageBox()
msg.setIcon(QMessageBox.Critical)
msg.setText("Отчет сформирован")
msg.setInformativeText('Ваш отчет сформирован.')
msg.setWindowTitle("Отчет сформирован")
msg.exec_()
def test_get_report(make_stubber, stub_runner, error_code, stop_on_method):
s3_resource = boto3.resource('s3')
s3_stubber = make_stubber(s3_resource.meta.client)
rekognition_client = boto3.client('rekognition')
rekognition_stubber = make_stubber(rekognition_client)
bucket = s3_resource.Bucket('test-bucket')
report = Report(bucket, rekognition_client, None)
photos = [f'photo-{index}' for index in range(3)]
labels = {}
for index, photo in enumerate(photos):
label = MagicMock(confidence=index, instances=[], parents=[])
label.name = f'label-{index}'
labels[photo] = [label]
with stub_runner(error_code, stop_on_method) as runner:
runner.add(s3_stubber.stub_list_objects, bucket.name, photos)
for photo, label in zip(photos, labels):
runner.add(
rekognition_stubber.stub_detect_labels,
{'S3Object': {'Bucket': bucket.name, 'Name': photo}}, None,
labels[photo], raise_and_continue=True)
got_report, result = report.get()
if error_code is None:
assert got_report[1:] == [
','.join((photo, label[0].name, str(label[0].confidence)))
for photo, label in labels.items()]
assert result == 200
elif stop_on_method == 'stub_list_objects':
assert result == 400
