def statistic_page():
stats = Statistics(app.config['dsn'])
aths = Athletes(app.config['dsn'])
if request.method == 'GET':
now = datetime.datetime.now()
statlist = stats.get_statisticlist()
athlist = aths.get_athletlist()
return render_template('statistics.html', StatisticList = statlist,AthletList = athlist, current_time=now.ctime())
elif 'statistics_to_delete' in request.form:
id_statistics = request.form.getlist('statistics_to_delete')
for id_statistic in id_statistics:
stats.delete_statistic(id_statistic)
return redirect(url_for('statistic_page'))
elif 'statistics_to_add' in request.form:
id_athletes = request.form.getlist('statistics_to_add')
for id_athlete in id_athletes:
stats.add_statistic(request.form['distance'], request.form['time'],id_athlete)
return redirect(url_for('statistic_page'))
elif 'statistics_to_update' in request.form:
stats.update_statistic(request.form['distance'], request.form['time'],request.form['id_statistic'])
return redirect(url_for('statistic_page'))
elif 'statistics_to_search' in request.form:
searchList = stats.search_statistic(request.form['name']);
now = datetime.datetime.now()
statlist = stats.get_statisticlist()
athlist = aths.get_athletlist()
return render_template('statistics.html', StatisticList = statlist, SearchList = searchList,AthletList = athlist, current_time=now.ctime())
def get(self):
ip = self.request.remote_addr
uid = 'notfound'
url = self.request.uri
user_agent = self.request.headers.get('User-Agent','none')
new = Statistics(uid=uid,url=url,user_agent = user_agent, ip=ip,mtime=datetime.datetime.utcnow())
new.put()
self.redirect('https://www.google.com')
def do_stats(self, fp, records):
stats = Statistics([StatisticsAuthorNameColumn('Name', lambda x : x.author)])
stats.process_records(records.comments, [
StatisticsCountColumn('Comments', lambda x : x.timestamp)
])
stats.process_records(records.technical_comments, [
StatisticsCountColumn('Technical', lambda x : x.timestamp)
])
stats.process_records(records.votes, [
StatisticsCountColumn('Votes', lambda x : x.timestamp)
])
stats.print_stats(fp, sort_by='Comments')
def step3(self):
resultDir = self.createDir(str(3))
(match, no_match) = self.createResultFile(resultDir)
success = 0
failed = 0
for element in self.table1.find({'ji': {'$ne': ""}}):
ji = element['ji']
gongLiNian = int(element['gongLiNian'])
gongLiNianScope = [str(gongLiNian-1), str(gongLiNian), str(gongLiNian+1)]
res = self.table2.find_one({'guanZhi' : element['guanZhi'],
'gongLiNian' : {'$in': gongLiNianScope},
'name' : element['name'],
'minZu' : element['minZu']})
if res and (len(ji) > 0) and (Statistics.convertJi(self, res['ji']) in self.jiScope(ji)) and (element['qiFen'] == res['qiFen'] or element['qiFen'] == res['qiFenHuo']):
match.write(self.formatElement(element))
success += 1
else:
no_match.write(self.formatElement(element))
failed += 1
failed = self.total - success
result = (success, success/self.total, failed, failed/self.total)
self.logResult(3, result)
return result
def __init__(self, dbName1, dbName2, rootDir=None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = self.table1.count()
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, r"3.数据库1、2与数据库3的比对")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, r"2.数据库2与数据库3对比")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger('CompareDB2AndDB3')
def getter(self):
ans = Statistics.by_id(self.data['statistics_id'])
if ans is None:
ans = Statistics()
self.data['statistics_id'] = ans._id
return ans, True
return ans
def __init__(self, dbName1, dbName2, rootDir = None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = self.table1.count()
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.不考虑公历年")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"1.不考虑季节")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger(u'不考虑季')
def get(self):
sta = Statistics.all()
# sta.order("-mtime")
for s in sta:
if not s.addr:
s.addr = addr.ip2addr(s.ip)
s.put()
self.response.headers['Content-Type'] = 'text/plain'
self.response.write('ok')
def get(self):
ip = self.request.remote_addr
user_agent = self.request.headers.get('User-Agent','none')
try:
url = self.request.query_string
logging.info(url)
uid, url = url.split('&', 1)
except Exception as e:
logging.error(e)
uid = 'err'
new = Statistics(uid=uid,url=url,user_agent = user_agent, ip=ip,mtime=datetime.datetime.utcnow())
url = 'https://www.google.com'
else:
new = Statistics(uid=uid,url=url,user_agent = user_agent, ip=ip,mtime=datetime.datetime.utcnow())
new.put()
if not url.startswith('http'):
url = 'http://' + url
self.redirect(str(url))
def create_banks(self):
"""
Creates bank objects, stores them in self.banks, and registers them in a self.bank_to_id.
A part of all banks follows a Pareto distribution, all others a log-normal distribution, in asset size.
All created banks are registered in the dictionary self.id_to_bank.
:rtype : None
"""
for n in xrange(0, NUMBER_OF_BANKS_LOGNORMAL):
bank_size = Statistics.generate_lognormal_number(LOGNORMAL_MEAN, LOGNOMRAL_STDEV)
bank = Bank(bank_size)
self.banks.append(bank)
self.id_to_bank[id(bank)] = bank
for n in xrange(0, NUMBER_OF_BANKS_PARETO):
bank_size = Statistics.generate_pareto_number(PARETO_SCALE, PARETO_SHAPE)
bank = Bank(bank_size)
self.banks.append(bank)
self.id_to_bank[id(bank)] = bank
def main():
config = Configuration()
config.load("config/config.json")
emailFiles = listEmailFiles(config.gmailRoot)
stats = Statistics()
progress = ProgressBar(
widgets=["Parsing Mail: ", Percentage(), " ", Bar(), " ", ETA()], maxval=len(emailFiles)
).start()
for filename in emailFiles:
progress.update(progress.currval + 1)
updateStatistics(stats, config, filename)
progress.finish()
stats.save()
def do_stats(self, fp, records):
stats = Statistics([StatisticsAuthorNameColumn('Name', lambda x : x.author)])
stats.process_records(records.change_activity, [
StatisticsCountColumn('Created', lambda x : x.created_on),
StatisticsCountColumn('Merged', lambda x : x.merged_on),
StatisticsCountColumn('Abandoned', lambda x : x.abandoned_on),
StatisticsCountColumn('Both', lambda x : x.created_on and x.closed_on)
])
stats.process_records(records.comments, [
StatisticsDistinctCountColumn('Commented', lambda x : x.change if x.timestamp else None)
])
stats.process_records(records.votes, [
StatisticsDistinctCountColumn('Voted', lambda x : x.change if x.timestamp else None)
])
stats.print_stats(fp, sort_by='Voted')
async def handle_1_TV_raffle(type, num, real_roomid, raffleid):
await asyncio.sleep(random.uniform(0, min(num, 30)))
response2 = await bilibili().get_gift_of_TV(type, real_roomid, raffleid)
Printer().printer(f"参与了房间 {real_roomid} 的广播抽奖", "Lottery", "cyan")
json_response2 = await response2.json(content_type=None)
Printer().printer(f"房间 {real_roomid} 广播道具抽奖状态: {json_response2['msg']}", "Lottery", "cyan")
if json_response2['code'] == 0:
Statistics().append_to_TVlist(raffleid, real_roomid)
else:
print(json_response2)
def do_stats(self, fp, records):
stats = Statistics([StatisticsAuthorNameColumn('Name', lambda x : x.author)])
stats.process_records(records.open_changes, [
StatisticsCountColumn('Open', lambda x : True),
StatisticsCountColumn('RFC/WIP', lambda x : x.is_rfc_wip),
StatisticsCountColumn('-Verified',
lambda x : not x.is_rfc_wip and not x.is_verified),
StatisticsCountColumn('-Review',
lambda x : not x.is_rfc_wip and x.is_verified and x.is_downvoted),
StatisticsCountColumn('Approved',
lambda x : not x.is_rfc_wip and x.is_verified and x.is_approved),
StatisticsCountColumn('+Review',
lambda x : not x.is_rfc_wip and x.is_verified and not x.is_approved and x.is_upvoted),
StatisticsCountColumn('Comments',
lambda x : not x.is_rfc_wip and x.is_verified and not x.is_upvoted and not x.is_downvoted and x.has_comments),
StatisticsCountColumn('Nothing',
lambda x : not x.is_rfc_wip and x.is_verified and not x.has_comments)
])
stats.print_stats(fp, sort_by='Open')
def __init__(self):
# Load data
parse_start = time.perf_counter_ns()
self.storage = GazPointStorageJson("data.json")
parse_end = time.perf_counter_ns()
load_start = time.perf_counter_ns()
self.gaz_data = GazPointData(self.storage.load_gaz_points())
load_end = time.perf_counter_ns()
stats_start = time.perf_counter_ns()
self.statistics = Statistics(self.gaz_data)
self.viz = Visualisation()
stats_end = time.perf_counter_ns()
print("Json parsing time : {}".format(parse_end-parse_start))
print("Data loading time : {}".format(load_end-load_start))
print("Stats loading time : {}".format(stats_end-stats_start))
def do_stats(self, fp, records):
stats = Statistics([StatisticsAuthorNameColumn('Name', lambda x : x.author)])
stats.process_records(records.open_comments, [
StatisticsDistinctCountColumn('Commented', lambda x : x.change)
])
stats.process_records(records.open_votes, [
StatisticsDistinctCountColumn('Voted', lambda x : x.change)
])
stats.print_stats(fp, sort_by='Commented')
def __init__(self, genome):
""" The GPopulation Class creator """
if isinstance(genome, GPopulation):
self.oneSelfGenome = genome.oneSelfGenome
self.internalPop = []
self.internalPopRaw = []
self.popSize = genome.popSize
self.sortType = genome.sortType
self.sorted = False
self.minimax = genome.minimax
self.scaleMethod = genome.scaleMethod
self.allSlots = [self.scaleMethod]
self.internalParams = genome.internalParams
self.multiProcessing = genome.multiProcessing
self.statted = False
self.stats = Statistics()
return
log.debug("New population instance, %s class genomes.",
genome.__class__.__name__)
self.oneSelfGenome = genome
self.internalPop = []
self.internalPopRaw = []
self.popSize = 0
self.sortType = constants.CDefPopSortType
self.sorted = False
self.minimax = constants.CDefPopMinimax
self.scaleMethod = FunctionSlot("Scale Method")
self.scaleMethod.set(constants.CDefPopScale)
self.allSlots = [self.scaleMethod]
self.internalParams = {}
self.multiProcessing = (False, False, None)
# Statistics
self.statted = False
self.stats = Statistics()
def __init__(self, genome):
""" The GPopulation Class creator """
if isinstance(genome, GPopulation):
self.oneSelfGenome = genome.oneSelfGenome
self.internalPop = []
self.internalPopRaw = []
self.popSize = genome.popSize
self.sortType = genome.sortType
self.sorted = False
self.minimax = genome.minimax
self.scaleMethod = genome.scaleMethod
self.allSlots = [self.scaleMethod]
self.internalParams = genome.internalParams
self.multiProcessing = genome.multiProcessing
self.statted = False
self.stats = Statistics()
return
log.debug("New population instance, %s class genomes.", genome.__class__.__name__)
self.oneSelfGenome = genome
self.internalPop = []
self.internalPopRaw = []
self.popSize = 0
self.sortType = constants.CDefPopSortType
self.sorted = False
self.minimax = constants.CDefPopMinimax
self.scaleMethod = FunctionSlot("Scale Method")
self.scaleMethod.set(constants.CDefPopScale)
self.allSlots = [self.scaleMethod]
self.internalParams = {}
self.multiProcessing = (False, False, None)
# Statistics
self.statted = False
self.stats = Statistics()
def train(args):
# Init gym env
env = Environment(args)
agent = Q_Agent(env, args)
stats = Statistics(None, agent, env, args)
if not args.load_model.isspace(): agent.loadModel(args.load_model)
# Train agent
try:
for epoch in range(args.epochs):
print 'Epoch #%d' % (epoch + 1)
if args.test_eps > 0:
print 'Testing for %d steps' % args.test_eps
agent.test(args.test_eps, render=args.render)
stats.log()
print 'Done'
except KeyboardInterrupt:
print 'Caught keyboard interrupt, stopping run...'
class TestStatistics(unittest.TestCase):
def setUp(self):
self.statistics = Statistics(PlayerReaderStub())
def test_search_returns_a_player(self):
player = self.statistics.search("Semenko")
self.assertEqual(player.__str__(), "Semenko EDM 4 + 12 = 16")
def test_search_returns_None_if_no_such_player(self):
player = self.statistics.search("Kukko Pärssinen")
self.assertEqual(player, None)
def test_team_search_returns_valid_team(self):
team = self.statistics.team("PIT")
self.assertEqual(team[0].__str__(), "Lemieux PIT 45 + 54 = 99")
def test_top_scorers_first_is_the_most_points(self):
scorers = self.statistics.top_scorers(1)
self.assertEqual(scorers[0].points, 124)
self.assertEqual(scorers[0].__str__(), "Gretzky EDM 35 + 89 = 124")
class TestStatistics(unittest.TestCase):
def setUp(self):
# annetaan Statistics-luokan oliolle "stub"-luokan olio
self.statistics = Statistics(PlayerReaderStub())
def test_konstruktori_luo_statistiikat(self):
edmonton = self.statistics.team("EDM")
sizeofedmonton = len(edmonton)
self.assertAlmostEqual(sizeofedmonton, 3)
def test_search_palauttaa_pelaajat(self):
self.assertAlmostEqual(str(self.statistics.search("Kurri")),
"Kurri EDM 37 + 53 = 90")
def test_search_palauttaa_None_jos_ei_pelaajaa_loydy(self):
self.assertAlmostEqual(str(self.statistics.search("Mari")), "None")
def test_sort_by_points_palauttaako(self):
pistemiehet = self.statistics.top_scorers(4)
self.assertAlmostEqual(str(pistemiehet[1]), "Lemieux PIT 45 + 54 = 99")
class BestAssetTest:
def __init__(self, period):
self.period = period
self.statistics = Statistics(default="USDT")
self.exchange = Exchange(default="USDT")
self.current_asset_symbol = None
self.buyPrice = 0
def best_asset(self):
try:
ticker_range = ["BTC", "ETH", "NEO", "BNB", "LTC", "BCH"]
best_asset_symbol = self.statistics.get_best_asset(
self.period, ticker_range)
if best_asset_symbol != self.current_asset_symbol:
if self.current_asset_symbol is not None:
current_price = self.exchange.get_asset_price(
self.current_asset_symbol)
print(current_price)
percentage = (float(current_price) - float(
self.buyPrice)) / float(self.buyPrice) * 100
print(
"Selling asset %s at %s with percentage %s" %
(self.current_asset_symbol, current_price, percentage))
file_name = "output_%s.csv" % self.period.value
file = open(file_name, 'a')
try:
writer = csv.writer(file)
writer.writerow(
(self.current_asset_symbol, self.buyPrice,
current_price, percentage))
finally:
file.close()
if best_asset_symbol is not None:
self.buyPrice = self.exchange.get_asset_price(
best_asset_symbol)
print("Buying asset %s at %s" %
(best_asset_symbol, self.buyPrice))
# Set new current asset
self.current_asset_symbol = best_asset_symbol
except Exception as e:
print(e)
pass
def run(self):
print("[TEST] Strategy Best Asset %s" % self.period.value)
while True:
self.best_asset()
time.sleep(10) # Sleep 10 seconds
async def handle_1_TV_raffle(num, real_roomid, raffleid):
# print('参与')
await asyncio.sleep(random.uniform(0.5, min(30, num * 1.3)))
json_response2 = await bilibili.get_gift_of_TV(real_roomid, raffleid)
Printer().printlist_append(
['join_lottery', '小电视', 'user', f'参与了房间{real_roomid:^9}的小电视抽奖'], True)
Printer().printlist_append([
'join_lottery', '小电视', 'user', "# 小电视道具抽奖状态: ", json_response2['msg']
])
# -400不存在
# -500繁忙
if not json_response2['code']:
Statistics.append_to_TVlist(raffleid, real_roomid)
return True
elif json_response2['code'] == -500:
print('# -500繁忙，稍后重试')
return False
else:
print(json_response2)
return True
def __init__(self, dbName1, dbName2, rootDir = None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = Statistics.numberOfGongLiNianEqual(self)
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.不考虑公历年")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.考虑季节")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"ͬ3.连续2季")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger('TwoJi')
def DanMuraffle(self, dic):
cmd = dic['cmd']
if cmd == 'SPECIAL_GIFT':
if 'data' in dic and '39' in dic['data'] and dic['data']['39'][
'action'] == 'start':
printer.info([f'房间号{self.roomid}有节奏风暴'], True)
rafflehandler.Rafflehandler.Put2Queue(
(self.target, self.roomid, dic['data']['39']['id']),
rafflehandler.handle_1_room_storm)
Statistics.append2pushed_raffle('节奏风暴', 1)
if cmd == 'GUARD_MSG':
if 'buy_type' in dic and dic['buy_type'] != 1:
# print(dic)
printer.info([f'{self.area_id}号弹幕监控检测到{self.roomid:^9}的提督/舰长'],
True)
rafflehandler.Rafflehandler.Put2Queue(
(self.target, self.roomid),
rafflehandler.handle_1_room_guard)
Statistics.append2pushed_raffle('提督/舰长', area_id=self.area_id)
def __init__(self, root):
self.root = root
self.root.title("Minesweeper")
self.frame = Frame(root)
self.frame.grid()
self.size = (9,) * 2
self.num_mines = 10
self.stats = Statistics()
self.buttons = {}
self.add_menu_bar()
self.add_header()
self.new_game()
def main():
Helper.init()
totalTime = 0
duration = args.duration
if args.nosetup:
itopod_setup = True
else:
itopod_setup = False
while True:
if not args.notitans:
if args.verbose:
print('getting available titans')
titans = Adventure.getTitans()
if titans:
# after this needs to reset loadout and diggers and e/m
Adventure.turnIdleOff()
print('calling killTitans with args.snipe {args.snipe}')
Adventure.killTitans(titans,
verbose=args.verbose,
snipe=args.snipe)
itopod_setup = False
if not itopod_setup:
Setup.setup(args.setup)
itopod_setup = True
Navigation.menu('adventure')
if not args.nobeast:
if not Statistics.checkPixelColor(*coords.BEAST_MODE_ON,
coords.BEAST_MODE_COLOR):
Helper.click(*coords.BEAST_MODE)
print('*' * 30)
Itopod.itopodExperimental(duration=duration,
optimal_floor=args.optimal)
totalTime += duration
print(f'total exp: {Itopod.EXP_gained}')
print(f'total ap: {Itopod.AP_gained}')
print(f'kills: {Itopod.kills}')
print(f'total time: {totalTime} minutes')
print('*' * 30)
Navigation.menu('inventory')
if Inventory.getEmptySlots() < 20:
invManagement(boost=0, merge=0)
if not args.noygg:
Yggdrasil.harvestAll()
def __init__(self, dbName1, dbName2, rootDir=None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = self.table1.count()
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, r"3.数据库1、2与数据库3的比对")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, r"2.数据库2与数据库3对比")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger('CompareDB2AndDB3')
self.condition10to30 = self.extractData(-10, 30)
self.condition20to40 = self.extractData(-20, 40)
self.condition30to50 = self.extractData(-30, 50)
def main():
parser = OptionParser()
parser.add_option("-p",
"--db_path",
type="string",
help="Path to sqlite database with logs")
opts, _ = parser.parse_args()
if not opts.db_path:
parser.error("Set the db path as argument")
Statistics(opts.db_path).calculate_statistics()
async def check_winner(self, i, g, start_time):
# 开奖5s后检查是否中奖
await asyncio.sleep(
time.mktime(time.strptime(start_time, '%Y-%m-%d %H:%M:%S')) -
time.time() + 5)
response2 = await bilibili().get_winner_info(i, g)
json_response2 = await response2.json(content_type=None)
for winner in json_response2["data"]["winnerList"]:
if winner["uid"] == bilibili().dic_bilibili['uid']:
Printer().printer(f'实物抽奖中中奖: {winner["giftTitle"]}', "Lottery",
"cyan")
Statistics().add_to_result(winner["giftTitle"], 1)
def test_add_wrong_answer(self):
"""Проверка правильности работы статистики при добавлении неверного ответа"""
# Получаем текущие значения количества верных и неверных ответов
old_right_answers_count = Statistics(
user_id=self.user_id).get_right_answers_count()
old_wrong_answers_count = Statistics(
user_id=self.user_id).get_wrong_answers_count()
# Добавление в статистику неправильного ответа
Statistics(user_id=self.user_id).add_wrong_answer()
# Получение новых значений количества верных и неверных ответов
new_right_answers_count = Statistics(
user_id=self.user_id).get_right_answers_count()
new_wrong_answers_count = Statistics(
user_id=self.user_id).get_wrong_answers_count()
# Количество верных ответов должно увеличиться на 1
self.assertEqual(old_right_answers_count, new_right_answers_count)
# Количество неверных ответов должно остаться неизменным
self.assertEqual(old_wrong_answers_count + 1, new_wrong_answers_count)
def calculateErrorTypeI(scenarios, data, index, rejectAlpha):
results = []
for numberOfEvents in scenarios:
statistics = runStudy(data, index, numberOfEvents)
errorsTypeI = {
statisticType: Statistics.errorTypeI(statistic, rejectAlpha,
statisticType)
for statisticType, statistic in statistics.items()
}
results.append(errorsTypeI)
return results
def __init__(self, dbName1, dbName2, rootDir = None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
#self.total = self.table1.find({'ji': {'$ne': ""}}).count()
self.total = Statistics.numberOfGongLiNianEqual(self)
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.不考虑公历年")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.考虑季节")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"ͬ4.连续3季")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger('ThreeJi')
def text(self):
for name_text in self.__file_list:
self.name_text = name_text
print('Файл: ' + name_text)
file = self.__path + name_text
self.__encod = self.__encodingDefinition(file)
with open(file, encoding=self.__encod) as text:
self.__natural_text = text.read()
if len(self.__natural_text) > 100:
self.__natural_text = self.__tokenize(self.__natural_text)
print('Длина текста: ' + str(len(self.__natural_text)))
print('Длина словаря натурального текста: ' +
str(len(self.__natural_dictionary)))
print(self.__natural_dictionary)
print('Длина словаря сгенерированного текста: ' +
str(len(self.__generated_dictionary)))
print(self.__generated_dictionary)
graph = Graph.createGraph(self.__natural_dictionary,
self.__natural_text)
natural_statistics = Statistics(graph,
len(self.__natural_text))
graph = []
graph = Graph.createGraph(self.__generated_dictionary,
self.__generated_text)
gen_statistics = Statistics(graph, len(self.__generated_text))
graph = []
self.plot.statisticsComp(natural_statistics, gen_statistics)
self.__generated_text = []
self.__natural_dictionary = []
self.__generated_dictionary = []
self.plot.createPlots()
self.plot.createPlotsAV()
self.plot.createPlotsSTD()
self.plot.createPlotsSTDmean()
self.plot = BuildPlot(len(self.__file_list))
def get(self):
statistics = Statistics(Utils.general_stats_cache_path)
x = statistics.readCachedStatistics()
if x != '':
return json.loads(x)
csv_file = open(Utils.train_file_path, "r")
csv_reader = csv.reader(csv_file, delimiter=',')
first = True
data = Model_Statistics()
for row in csv_reader:
if first == True:
first = False
continue
data.push(row[0], row[1], row[2], row[3], row[4], row[5], row[6],
row[7], row[8], row[9])
dataDictionary = data.getArrayForKeys()
del dataDictionary['dataCount']
dataDictionaryKeys = dataDictionary.keys()
response = jsonify(
statistics.buildDictionaryStats(dataDictionary,
dataDictionaryKeys))
statistics.writeStatisticsCache(response.get_data(as_text=True))
return response
class RestaurantDataTestCase(unittest.TestCase):
connection_string = "host='localhost' dbname='motordb' user='******' password='******'"
conn = psycopg2.connect(connection_string)
def setUp(self):
with self.conn.cursor() as cursor:
setup_queries = open('load_data.sql', 'r').read()
cursor.execute(setup_queries)
self.conn.commit()
self.service = lookupdata(self.connection_string)
self.service = Statistics(self.connection_string)
def tearDown(self):
self.service = None
def query(self, query, parameters=()):
cursor = self.conn.cursor()
cursor.execute(query, parameters)
return cursor.fetchall()
def test_connectivity(self):
self.assertEqual(True, self.service.check_connectivity())
def test_find_recipe(self):
recipes = self.service.find_recipe('ham')
self.assertEqual(len(recipes), 3)
self.assertTrue(
list(map(lambda r: r['name'], recipes)).index('Hamburger') >= 0)
recipes = self.service.find_recipe('sandwich')
self.assertEqual(len(recipes), 2)
recipes = self.service.find_recipe(
"';DROP TABLE recipe_ingredient;COMMIT;")
self.assertEqual(len(recipes), 0)
self.assertEqual(
22,
self.query("select count(*) from recipe_ingredient")[0][0])
def handle_danmu(self, body):
dic = json.loads(body.decode('utf-8'))
cmd = dic['cmd']
if cmd == 'PREPARING':
printer.info([f'{self._area_id}号弹幕监控房间下播({self._room_id})'], True)
return False
elif cmd == 'NOTICE_MSG':
# 1 《第五人格》哔哩哔哩直播预选赛六强诞生！
# 2 全区广播：<%user_name%>送给<%user_name%>1个嗨翻全城，快来抽奖吧
# 3 <%user_name%> 在 <%user_name%> 的房间开通了总督并触发了抽奖，点击前往TA的房间去抽奖吧
# 4 欢迎 <%总督 user_name%> 登船
# 5 恭喜 <%user_name%> 获得大奖 <%23333x银瓜子%>, 感谢 <%user_name%> 的赠送
# 6 <%user_name%> 在直播间 <%529%> 使用了 <%20%> 倍节奏风暴，大家快去跟风领取奖励吧！(只报20的)
# 8 全区广播：主播<%红莉栖魔王喵%>开启了“任意门”，点击前往TA的房间去抽奖吧！
msg_type = dic['msg_type']
msg_common = dic['msg_common']
real_roomid = dic['real_roomid']
msg_common = dic['msg_common'].replace(' ', '')
msg_common = msg_common.replace('”', '')
msg_common = msg_common.replace('“', '')
if msg_type == 2 or msg_type == 8:
str_gift = msg_common.split('%>')[-1].split('，')[0]
if '个' in str_gift:
raffle_num, raffle_name = str_gift.split('个')
elif '了' in str_gift:
raffle_num = 1
raffle_name = str_gift.split('了')[-1]
else:
raffle_num = 1
raffle_name = str_gift
broadcast = msg_common.split('广播')[0]
printer.info(
[f'{self._area_id}号弹幕监控检测到{real_roomid:^9}的{raffle_name}'],
True)
rafflehandler.Rafflehandler.Put2Queue(
(real_roomid, ), rafflehandler.handle_1_room_TV)
broadcast_type = 0 if broadcast == '全区' else 1
Statistics.add2pushed_raffle(raffle_name, broadcast_type)
elif msg_type == 3:
raffle_name = msg_common.split('开通了')[-1][:2]
printer.info(
[f'{self._area_id}号弹幕监控检测到{real_roomid:^9}的{raffle_name}'],
True)
rafflehandler.Rafflehandler.Put2Queue(
(real_roomid, ), rafflehandler.handle_1_room_guard)
broadcast_type = 0 if raffle_name == '总督' else 2
Statistics.add2pushed_raffle(raffle_name, broadcast_type)
elif msg_type == 6:
raffle_name = '二十倍节奏风暴'
printer.info(
[f'{self._area_id}号弹幕监控检测到{real_roomid:^9}的{raffle_name}'],
True)
rafflehandler.Rafflehandler.Put2Queue(
(real_roomid, ), rafflehandler.handle_1_room_storm)
Statistics.add2pushed_raffle(raffle_name)
return True
def main():
current_path = os.path.dirname(os.path.abspath(__file__))
os.chdir(current_path)
dirs, xlsx_files = find_excel()
xlsx_files = exclude_done(dirs, xlsx_files)
if len(xlsx_files) == 0:
print('XLSX FILE NOT FOUND OR ALREADY DONE')
exit()
else:
# length = len(xlsx_files)
# threads = [None] * length
# for i in range(0, length):
# statistics = Statistics()
# threads[i] = Thread(target=statistics.count(),
# args=[xlsx_files[i]])
# threads[i].start()
for xlsx_file in xlsx_files:
statistics = Statistics()
os.chdir(current_path)
statistics.count(xlsx_file)
print('STATISTICS DONE: {}'.format(os.path.splitext(xlsx_file)[0]))
async def handle_1_TV_raffle(num, real_roomid, raffleid):
#print('参与')
await asyncio.sleep(random.uniform(1, min(30, num * 1.5)))
response2 = await bilibili().get_gift_of_TV(real_roomid, raffleid)
Printer().printlist_append(['join_lottery', '小电视', 'user', "参与了房间{:^9}的小电视抽奖".format(real_roomid)], True)
json_response2 = await response2.json()
Printer().printlist_append(
['join_lottery', '小电视', 'user', "# 小电视道具抽奖状态: ", json_response2['msg']])
# -400不存在
if json_response2['code'] == 0:
Statistics().append_to_TVlist(raffleid, real_roomid)
else:
print(json_response2)
def __init__(self, dbName1, dbName2, year, rootDir = None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = self.table1.find({'ji': {'$ne': ""}}).count()
rootDir = os.path.join(os.path.dirname(__file__), u"数据库1_1")
if not os.path.exists(rootDir):
os.mkdir(rootDir)
if year < 0:
rootDir = os.path.join(rootDir, "提前{}year".format(abs(year)))
elif year > 0:
rootDir = os.path.join(rootDir, "延后{}year".format(abs(year)))
else:
rootDir = os.path.join(rootDir, "同一年year")
if not os.path.exists(rootDir):
os.mkdir(rootDir)
self.rootDir = rootDir
self.year = year
self.logger = logging.getLogger('Statistics1_1')
self.logger.info("totol record: {}".format(self.total))
def __init__(self, dbName1, dbName2, rootDir = None):
Statistics.__init__(self, dbName1, dbName2, rootDir)
self.total = self.table1.find({'ji': {'$ne': ""}}).count()
#self.total = Statistics.numberOfGongLiNianEqual(self)
self.rootDir = os.path.join(self.rootDir, u"步骤三数据库数据的匹配程度")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"2.不考虑公历年")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"3.考虑公历年")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.rootDir = os.path.join(self.rootDir, u"4.连续4年+3")
if not os.path.exists(self.rootDir):
os.mkdir(self.rootDir)
self.logger = logging.getLogger('TwoYear')
self.logger.info("totol record: {}".format(self.total))
def enabled_stats(self):
"""Return all enabled statistics as a list of string names."""
if not self.enabled_statistics:
json_enabled_stats_dict = self.config.get(
'enabled_stats',
{stat_name: True
for stat_name in list(Statistics)})
self.enabled_statistics = [
Statistics.from_string(stat_name)
for stat_name, stat_enabled in json_enabled_stats_dict.items()
if stat_enabled
]
return self.enabled_statistics
def getExamStatistics(self, attemp=0):
sample = []
for userid, g in groupby(self.track.values(), key=lambda r: r.userName):
## !!!! check if have more than one for filter the attemp
data = sorted(g, key=lambda x: x.timeStamp)[attemp] # filter the attemp
if data.data['evaluation.scored']:
sample.append(data.data['evaluation.score'])
if not sample:
sample = [0]
return Statistics(sample)
def test_simulation_run():
print("### test_simulation_run() ###")
universe = Universe(2, 5, 0.4, debug=True)
stats = Statistics()
print("Start:")
print_environment(universe)
print("Agent stats:")
for agent in universe.agents:
agent.print_stats()
while not universe.is_finished():
universe.update(stats)
print_environment(universe)
class Comparer:
"""
Class compares two playlists and contains information about their comparison
Relevant Instance Variables defined in __init__ :
playlist1 = playlist of user 1
playlist2 = playlist of user 2
comparison = tuple (sharedSongs, sharedArtists, artistsCount) of type (Playlist, Set, Int)
see playlist.compare() for more info
similarity = similarity score for playlist1 and playlist2 of type float
"""
def __init__(self, playlist1, playlist2):
self.playlist1 = playlist1
self.playlist2 = playlist2
self.comparison = playlist1.compare(playlist2)
self.calculator = Statistics()
self.similarity = self.setSimilarity()
def printCommonSongs(self):
"""Prints songs shared between both profiles"""
print(self.comparison[0])
def setSimilarity(self):
"""should not be used outside class, instead access Comparer.similarity"""
plen1 = len(self.playlist1.songs)
plen2 = len(self.playlist2.songs)
sharedlen = len(self.comparison[0].songs)
artistslen = self.comparison[2]
similarity = self.calculator.similarityMetric(plen1, plen2, sharedlen,
artistslen)
return similarity
def isSimilar(self, minSimilarity):
return self.similarity >= minSimilarity
def getMissingSongs(self, profile=0):
"""Returns: playlist with songs in playlist2 and not in playlist1 if param==0, songs in playlist1 not in playlist2 else"""
if profile == 0:
missingSongs = Playlist("missing from User 1", [])
for song in self.playlist2.songs:
if song in self.playlist1.songs:
continue
missingSongs.add(song)
return missingSongs
missingSongs = Playlist("missing from User 2", [])
for song in self.playlist1.songs:
if song in self.playlist2.songs:
continue
missingSongs.add(song)
return missingSongs
async def handle_1_TV_raffle(type, num, real_roomid, raffleid):
await asyncio.sleep(random.uniform(0.5, min(10, num * 1)))
response2 = await bilibili().get_gift_of_TV(type, real_roomid, raffleid)
Printer().printlist_append([
'join_lottery', '广播道具', 'user', "参与了房间{:^9}的广播抽奖".format(real_roomid)
], True)
json_response2 = await response2.json()
Printer().printlist_append(
['join_lottery', '广播道具', 'user', "广播道具抽奖状态: ", json_response2['msg']],
True)
if json_response2['code'] == 0:
Statistics().append_to_TVlist(raffleid, real_roomid)
else:
print(json_response2)
def __init__(self):
self.friendly_prob = 0.25
self.sim_speed = 0
self.init = 1
self.turretCounter = 0
self.planeCounter = 0
self.clear_messages_counter = 10 #Clears all messages when planeCounter exceeds this threshold
self.sim_stop = 100 #Number of resets of simulation
self.numPlanes = 1
self.numTurrets = 3
self.turret_range = 4
self.model = Model()
self.model.turret_enemy_threshold = 1 #Number of turrets that need to identify a plane as enemy before any of the turrets start to shoot
self.statistics = Statistics(self.model)
# self.demospeed = SPEED
self.paused = True
self.step = False
self.running = True
self.show_statistics = False
self.get_kb = False
self.show_messages = False
self.simulation = 0
class TestStatistics(unittest.TestCase):
def setUp(self):
# annetaan Statistics-luokan oliolle "stub"-luokan olio
self.statistics = Statistics(PlayerReaderStub())
def test_top_scorers_one(self):
topscorer = self.statistics.top_scorers(0)
self.assertEqual(len(topscorer), 1)
self.assertEqual(topscorer[0].name, "Gretzky")
def test_team_players(self):
teamplayers = self.statistics.team("PIT")
self.assertEqual(len(teamplayers), 1)
self.assertEqual(teamplayers[0].name, "Lemieux")
def test_search(self):
result = self.statistics.search("Kurri")
self.assertEqual(result.name, "Kurri")
self.assertEqual(result.team, "EDM")
def test_search_notfound(self):
result = self.statistics.search("Nobody")
self.assertIsNone(result)
async def get_results(message: types.Message):
r = Statistics(db).get_statistics()[:3]
message_text = "Congratulations to today's winners:\n"
prizes = ['🥇', '🥈', '🥉']
counter = 1
db.reset()
for i in r:
message_text += f"{prizes[counter - 1]} - <b>{i.username}</b>\n"
i.rank = prizes[counter - 1]
db.update(i)
counter += 1
await message.reply(message_text, parse_mode='html')
async def handle_1_TV_raffle(type, raffleid, time_wait, time_limit, num,
real_roomid):
Statistics().append_to_TVlist(raffleid, time_limit)
await asyncio.sleep(
min(
max(0, time_wait) + random.uniform(0, min(num, 30)),
time_limit - 1))
response2 = await bilibili().get_gift_of_TV(type, real_roomid, raffleid)
# Printer().printer(f"参与了房间 {real_roomid} 的广播抽奖 {raffleid}", "Lottery", "cyan")
json_response2 = await response2.json(content_type=None)
# Printer().printer(f"参与房间 {real_roomid} 广播道具抽奖 {raffleid} 状态: {json_response2['msg']}", "Lottery", "cyan")
if json_response2['code'] == 0:
data = json_response2["data"]
Printer().printer(
f"房间 {real_roomid} 广播道具抽奖 {raffleid} 结果: {data['award_name']}X{data['award_num']}",
"Lottery", "cyan")
Statistics().add_to_result(data['award_name'], int(data['award_num']))
else:
# {"code":-403,"data":null,"message":"访问被拒绝","msg":"访问被拒绝"}
Printer().printer(
f"房间 {real_roomid} 广播道具抽奖 {raffleid} 结果: {json_response2['message']}",
"Lottery", "cyan")
print(json_response2)
async def handle_1_activity_raffle(num, giftId, text1, text2, raffleid):
#print('参与')
await asyncio.sleep(random.uniform(1, min(30, num * 1.5)))
response1 = await bilibili().get_gift_of_events_app(text1, text2, raffleid)
pc_response = await bilibili().get_gift_of_events_web(
text1, text2, raffleid)
Printer().printlist_append([
'join_lottery', '', 'user', "参与了房间{:^9}的{}活动抽奖".format(
text1,
bilibili().get_giftids_raffle(str(giftId)))
], True)
json_response1 = await response1.json()
json_pc_response = await pc_response.json()
if json_response1['code'] == 0:
Printer().printlist_append([
'join_lottery', '', 'user', "# 移动端活动抽奖结果: ",
json_response1['data']['gift_desc']
])
Statistics().add_to_result(
*(json_response1['data']['gift_desc'].split('X')))
else:
print(json_response1)
Printer().printlist_append([
'join_lottery', '', 'user', "# 移动端活动抽奖结果: ",
json_response1['message']
])
Printer().printlist_append([
'join_lottery', '', 'user', "# 网页端活动抽奖状态: ",
json_pc_response['message']
])
if json_pc_response['code'] == 0:
Statistics().append_to_activitylist(raffleid, text1)
else:
print(json_pc_response)
def allocate_degrees(self):
"""
First sort banks by asset size, then match them with sorted degree list.
Node degrees are governed by a power law.
:rtype : None
"""
self.banks.sort(key=lambda _bank: _bank.balance.assets)
degrees = [math.floor(Statistics.draw_from_powerlaw(POWERLAW_EXPONENT_OUT_DEGREE, 1.0) + 0.6748)
for degree in xrange(0, len(self.banks))]
for i in xrange(0, len(degrees)):
if degrees[i] > MAX_K_OUT:
degrees[i] = MAX_K_OUT
degrees.sort()
for n in xrange(0, len(self.banks)):
self.banks[n].out_degree = degrees[n]
def __init__(self):
font = sf.Font.from_file("media/fonts/UbuntuMono-R.ttf")
self.statistics = Statistics(font)
window_settings = sf.window.ContextSettings()
window_settings.antialiasing_level = 8
self.window = sf.RenderWindow(
sf.VideoMode(width, height),
"Steering Behaviors For Autonomous Characters",
sf.Style.DEFAULT, window_settings)
self.window.vertical_synchronization = False
self.entities = []
self.grid = CollisionGrid(width, height, cell_size)
self.collision = 0
def __init__(self, samplesFile, batchSize, binSize, stdDevThreshold, windowSize, recurrentThreshold):
CFGBuilder.__init__(self)
self.stat = Statistics(binSize, stdDevThreshold)
self.ifb = InputFileBuffer(50000, samplesFile)
self.batchSize = batchSize
self.binSize = binSize
self.stdDevThreshold = stdDevThreshold
self.samplesFile = samplesFile
self.windowSize = windowSize
self.recurrentThreshold = recurrentThreshold
self.targets = dict()
self.bbr = BBRepository()
self.cfg = CFG()
self.numMerge = 0
self.highStdevEdges = 0
self.numHighStdevTries = 0
self.numHighStdevOK = 0
def get(self):
ip = self.request.remote_addr
user = users.get_current_user()
if not user or not users.is_current_user_admin():
self.redirect(users.create_login_url(self.request.uri))
template_values = {'user': user,}
sta = Statistics.all()
sta.order("-mtime")
uids = []
for s in sta.fetch(100):
if not s.addr:
s.addr = addr.ip2addr(s.ip)
s.put()
uids.append({'uid':s.uid,'ip':s.ip,'mtime':s.mtime+datetime.timedelta(hours=8),
'url':s.url,'user_agent':s.user_agent,'addr':s.addr})
template_values.update({'statistics':uids})
template = JINJA_ENVIRONMENT.get_template('admin.html')
self.response.write(template.render(template_values))
def __init__(self, window, population, maze, stats_height=160, **kwagrs):
# TODO ability to handle hiding statistics
super(ExperimentMode, self).__init__()
self.paused = False
self.window = window
self.width = window.width
self.height = window.height
self.groups = BatchGroup()
grid_size = (self.height-stats_height) // GRID_SCALE, self.width // GRID_SCALE
maze = maze if maze is not None else Walls(grid_size)
env = Environment(maze, GRID_SCALE, FOOD_INIT_PROB)
env.set_stats(Statistics.for_shape(self.width))
env.set_population(population)
# split window
self.env_view = EnvironmentView(env, self.width, self.height-stats_height, **kwagrs)
self.stats_view = StatsView(env.stats, 0, self.height-stats_height,
self.width, stats_height, **kwagrs)
self.groups.add_objects([self.env_view, self.stats_view])
def step1(self):
resultDir = self.createDir(str(1))
(match, no_match) = self.createResultFile(resultDir)
success = 0
failed = 0
for element in self.table1.find({'ji': {'$ne': ""}}):
res = self.table2.find_one({'guanZhi' : element['guanZhi'],
'gongLiNian' : element['gongLiNian'],
'name' : element['name']})
if res and (len(res['ji']) > 0) and (Statistics.convertJi(self, res['ji']) == int(element['ji'])):
match.write(self.formatElement(element))
success += 1
else:
no_match.write(self.formatElement(element))
failed += 1
failed = self.total - success
result = (success, success/self.total, failed, failed/self.total)
self.logResult(1, result)
return result
def __init__(self, auto_mode=False, send_email=False, skip_compilation=False):
build_dir = get_build_dir()
self.bb = Bitbake(build_dir)
try:
self.base_env = self.bb.env()
except EmptyEnvError as e:
import traceback
E( " %s\n%s" % (e.message, traceback.format_exc()))
E( " Bitbake output:\n%s" % (e.stdout))
exit(1)
self._set_options(auto_mode, send_email, skip_compilation)
self._make_dirs(build_dir)
self._add_file_logger()
self.email_handler = Email(settings)
self.statistics = Statistics()
def __init__(self, clients, games, authManager, reactor):
self.id = Client.nextId
Client.nextId += 1
self.logger = logging.getLogger("client-%d" % self.id)
self.logger.info("client initialized")
self.clients = clients
self.games = games
self.authManager = authManager
self.reactor = reactor
# not yet logged in
self.loggedIn = False
self.name = None
# no own game yet
self.game = None
# not ready to start yet
self.readyToStart = False
# no UDP handler yet connected to the client
self.udpHandler = None
# statistics
self.statistics = Statistics()
# set up the handlers
self.handlers = {
TcpPacket.LOGIN: self.handleLogin,
TcpPacket.ANNOUNCE: self.handleAnnounce,
TcpPacket.LEAVE_GAME: self.handleLeave,
TcpPacket.JOIN_GAME: self.handleJoin,
TcpPacket.DATA: self.handleData,
TcpPacket.READY_TO_START: self.handleReadyToStart,
TcpPacket.GET_RESOURCE_PACKET: self.handleGetResource,
TcpPacket.KEEP_ALIVE_PACKET: self.handleKeepAlivePacket,
}
def initialize(self):
self.verbose = True
self.statistics = Statistics()
self.statistics.initialize(self)
self.knowledge = Knowledge()
self.knowledge.initialize(self)
#todo: make this more generic,
# i.e. allow for an arbitrary number of roles
# load all rule bases
self.loadMetaRules()
self.loadAttackerRules()
self.loadDefenderRules()
self.loadCatcherRules()
# distribute the roles to the bots
roleList = self.metaScript.runDynamicScript([len(self.game.team.members),self.statistics])
if(roleList != None):
self.distributeRoles(roleList)
else: #If none of the rules apply, use a mixed team.
self.distributeRoles(metaRules.mixedAttackers(len(self.game.team.members)))
# and generate the corresponding scripts
self.initializeRoles()
self.initializeBotStats()
