def test_lalalalalala2():
sut = Analyser()
sut.analyse("ustawienia auto Space")
result = sut.analyse(
"alias spacja to do równe cudzysłów vim spacja tylda kropka ukośnik to do cudzysłów"
)
assert 'alias todo=\"vim ~./todo\"' == "".join(result)
def test_lalalala7():
sut = Analyser()
sut.analyse('ustawienia capital wyłącz')
assert 'dzień dobry, nazywam się czesio. lubię jeść muchy' == ''.join(
sut.analyse(
"Dzień dobry przecinek nazywam się Czesio kropka lubię jeść muchy")
)
def test_shouldUseAutoCapitalLettersAfterDots():
sut = Analyser()
sut.analyse('ustawienia capital Auto')
assert 'Dzień dobry, nazywam się Czesio. Lubię jeść muchy... Troche to dziwne.' == ''.join(
sut.analyse(
"duża dzień dobry przecinek nazywam się Czesio kropka lubię jeść muchy kropka kropka kropka troche to dziwne kropka"
))
def test_shoundUseCapitalLetters():
sut = Analyser()
sut.analyse('ustawienia auto space')
sut.analyse('ustawienia capital włącz')
assert 'DZIEŃ DOBRY, NAZYWAM SIĘ CZESIO. CHCIAŁEM SPRAWDZIĆ JESZCZE, CZY DZIAŁA "CAPSLOCK" CUDZYSŁÓW.' == ''.join(
sut.analyse(
"dzień spacja dobry przecinek spacja nazywam spacja się spacja Czesio kropka spacja chciałem spacja sprawdzić spacja jeszcze przecinek spacja czy spacja działa spacja cudzysłów capslock cudzysłów spacja dosłownie cudzysłów kropka"
))
def analise(request):
if request.method == 'POST':
a = Analyser(1,2)
content = show_reviews(request)
a.analyse(content['reviews'])
return render(request, 'respostas.html',content)
elif request.method == 'GET':
return render(request,'home.html',{})
def analise(request):
if request.method == 'POST':
a = Analyser(1, 2)
content = show_reviews(request)
a.analyse(content['reviews'])
return render(request, 'respostas.html', content)
elif request.method == 'GET':
return render(request, 'home.html', {})
def analyse():
input_json = request.get_json()
# print("## INPUT JSON ##\n" + str(input_json))
if "filters" not in input_json:
filters_dict = {}
else:
filters_dict = input_json["filters"]
for k, v in filters_dict.items():
del filters_dict[k]
filters_dict[int(k)] = v
category = input_json['category']
# print("filters_dict:\n" + str(filters_dict))
# print("category: " + str(category))
coefs, intercept, coefs_indexes, null_columns = Analyser.analyse(
filters_dict, category, ds)
result = coefs.tolist()
# result.append(intercept.tolist()) # append intercept
# print("Coeficientes: " + str(coefs))
# print("coef type:" + str(type(coefs)))
output = {
"coefs": result,
"intercept": intercept.tolist(),
"coefs_indexes": coefs_indexes,
"null_types": null_columns
}
return json.dumps(output)
def test_lalalalala3():
sut = Analyser()
text = "ustawienia auto Space"
assert ["Ala", " ", "ma", " ", "kota"] == sut.analyse("Ala ma kota")
sut.analyse(text)
assert ["Ala", "ma", "kota"] == sut.analyse("Ala ma kota")
sut.analyse(text)
assert ["Ala", " ", "ma", " ", "kota"] == sut.analyse("Ala ma kota")
class Stages:
def __init__(self, db):
self.db = db
self.analyser = Analyser(self.db)
def on_get(self, req, resp, user_id, date):
data_from_db = self.db.sleep_phase[user_id].find_one({'_id': date})
if data_from_db is None or data_from_db[
'ver'] != arith.SLEEP_STAGE_ALGORI_VERSION: # 判断是否是读取数据库缓存还是直接进行计算。
self.analyser.analyse(user_id,
date) # analyser 进行分析，然后就分析的数据写入到数据库中去
data_from_db = self.db.sleep_phase[user_id].find_one({'_id': date})
sleep_stages = data_from_db.get('data', [])
for item in sleep_stages:
item['time'] = item['time'].isoformat()
# get the status of sleep;time range from date 20.00 to
result = {'result': sleep_stages}
resp.body = json.dumps(result)
resp.status = falcon.HTTP_200
def main():
"""
Analyse the emails of the user and obtain the style metrics.
Returns
-------
None.
"""
if not(os.getcwd() in sys.path):
sys.path.append(os.getcwd())
#Creation of a Gmail resource
service = build('gmail', 'v1',
credentials = auth.get_credentials(config.SCOPES, config.CREDS))
anls = None
nextPageToken = None
usu = input('Introduce the user name: ')
if (yes_no_question('Were there a previous execution with the same credentials?')):
q = int(input('Introduce the remaining quota units: '))
if (yes_no_question('Was it with the same user?')):
ext = yes_no_question('Was the previously executed by extracting messages?')
nextPageToken = input('Introduce NextPageToken: ')
num_res = int(input('How many Gmail resources were extracted? '))
anls = Analyser(service, usu, q, ext, num_res)
else:
anls = Analyser(service, usu, q)
else:
anls = Analyser(service, usu)
if (yes_no_question('Has the user an email signature?')):
print('Introduce the signature and finish it with the word "STOP".\n')
entr = input()
sign = ''
while (entr != 'STOP'):
sign += entr + '\n'
entr = input()
anls.analyse(nextPageToken, sign)
else:
anls.analyse(nextPageToken)
def test_lalalalala2():
sut = Analyser()
result = sut.analyse("alias to")
result += sut.analyse("do")
result += sut.analyse("równe")
result += sut.analyse("cudzysłów")
result += sut.analyse("vim tylda")
result += sut.analyse("kropka")
result += sut.analyse("ukośnik")
result += sut.analyse("to")
result += sut.analyse("do")
result += sut.analyse("cudzysłów")
assert 'alias todo=\"vim ~./todo\"' == "".join(result)
class AudioManager(threading.Thread):
def __init__(self, state):
super().__init__()
self.daemon = True
self.audio_converter = None
self.analyser = Analyser(state)
self.fake_keyboard = FakeKeyboard()
self.responses = None
def set_up(self):
self.audio_converter = AudioConverter()
self.audio_converter.start()
self.responses = []
def run(self):
self.set_up()
while True:
if self.audio_converter.recorder.err_no_net:
# hold this loop until connected
self.try_connect_to_network(probe_period=3)
self.set_up()
if not self.audio_converter.response_queue.is_response_available():
# no more resources to analyse
continue
response_sentence = self.audio_converter.get_response()
self.responses.extend(response_sentence)
analyzed_keys = self.analyser.analyse(' '.join(self.responses))
self.fake_keyboard.simulate(analyzed_keys)
self.responses.clear()
@staticmethod
def try_connect_to_network(probe_period):
"""Check connection every `probe_period` seconds."""
# TODO display notification connection lost
while True:
# Execution of the main loop does not make a sense when
# we can't connect to the internet. Stay in this loop
# until the connection is established.
try:
socket.setdefaulttimeout(3)
socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect(("8.8.8.8", 53))
logger.info("Connection probe succeeded: Back to online")
# TODO display notification connection back
return
except socket.error:
logger.info("Connection probe failed: No internet")
time.sleep(probe_period)
def intercept():
input_json = request.get_json()
# print("## INPUT JSON ##\n" + str(input_json))
if "filters" not in input_json:
filters_dict = {}
else:
filters_dict = input_json["filters"]
for k, v in filters_dict.items():
del filters_dict[k]
filters_dict[int(k)] = v
category = input_json['category']
# print("filters_dict:\n" + str(filters_dict))
# print("category: " + str(category))
coefs, intercept = Analyser.analyse(filters_dict, category, ds)
# print("Coeficientes: " + str(coefs))
# print("coef type:" + str(type(coefs)))
return json.dumps(intercept.tolist())
class StatisticsForMonth:
def __init__(self, db):
self.db = db
self.analyser = Analyser(self.db)
self.statistics = Statistics(self.db)
self.sleep_statForMonth = {}
self.DaysValidity = 0 # 用于计算各种分数的有效天数
self.statMonth_analyser = StatMonthAnalyser(db)
# 初始化接口参数
def init_param(self, date):
month_range = calendar.monthrange(date.year, date.month) # 获取当前月的总天数
self.DaysValidity = month_range[1]
self.sleep_statForMonth['score'] = [0] * int(
month_range[1] + 1) # 声明 每日得分 list的大小
self.sleep_statForMonth['sleepTime'] = [0] * int(
month_range[1] + 1) # 声明实际睡眠时间 list的大小
self.sleep_statForMonth['offBedFrequency'] = [0] * int(
month_range[1] + 1) # 声明 离床次数 list的大小
self.sleep_statForMonth['offBedTime'] = [
[] for i in range(int(month_range[1]))
]
# [0] * # 声明 离床时间 list的大小
# {'offbed_time': '', 'offbed_range': ''}
self.sleep_statForMonth['onBedTime'] = [0] * int(
month_range[1] + 1) # 声明在床时间 list 的大小
self.sleep_statForMonth['firstAwakeLight'] = [0] * int(
month_range[1] + 1) # 声明 入睡时间 list的大小
self.sleep_statForMonth['deepSleepTime'] = [0] * int(
month_range[1] + 1) # 声明深睡时间 list 的大小
self.sleep_statForMonth['heartbeat'] = [0] * int(
month_range[1] + 1) # 声明心率（次/分） list 的大小
self.sleep_statForMonth['breath'] = [0] * int(
month_range[1] + 1) # 声明呼吸频率（次/分） list 的大小
return month_range
# 初始化data_from_db
def init_date_from_db(self, user_id, date):
data_from_db = self.db.sleep_stat[user_id].find_one({'_id': date})
if data_from_db is None or data_from_db[
'ver'] != arith.SLEEP_STAT_ALGORI_VERSION:
self.analyser.analyse(user_id,
date) # analysis 计算date天的睡眠状态数据 和分析数据
data_from_db = self.db.sleep_stat[user_id].find_one({'_id': date})
return data_from_db
# 提取数据不可用的天数，对不可用数据统一设置
def set_param_invalid(self, day):
self.sleep_statForMonth['score'][day] = 0
self.sleep_statForMonth['sleepTime'][day] = 0
self.sleep_statForMonth['offBedFrequency'][day] = 0
self.sleep_statForMonth['onBedTime'][day] = 0
self.sleep_statForMonth['deepSleepTime'][day] = 0
self.sleep_statForMonth['heartbeat'][day] = 0
self.sleep_statForMonth['breath'][day] = 0
self.sleep_statForMonth['firstAwakeLight'][day] = 0
# method: 封装获取指定date的score
# 指定day的 score : self.sleep_statForMonth['score'][day]
# 指定day的 sleep_time（有效睡眠时间）: self.sleep_statForMonth['sleep_time'][day]
# 指定day的 offBedFrequency（离床次数）: self.sleep_statForMonth['offBedFrequency'][day]
# 指定day的 onBedTime（在床时间）: self.sleep_statForMonth['onBedTime'][day]
# 指定day的 deepSleepTime（深睡时间）: self.sleep_statForMonth['deepSleepTime'][day]
# 指定day的 heartbeat（声明心率（次/分））: self.sleep_statForMonth['heartbeat'] [day]
# 指定day的 breath（呼吸频率（次/分））: self.sleep_statForMonth['breath'] [day]
# 指定day的 firstAwakeLight（入睡时间）: self.sleep_statForMonth['firstAwakeLight'][day]
def get_day_score(self, user_id, date, date_from_db):
day = parse(date).day # 获取参数day
sleep_stat_for_day = date_from_db.get('data')
if sleep_stat_for_day is None or sleep_stat_for_day[
'validity'] is False: # 根据该月的有效天数获取score ，判断字段：validity
self.DaysValidity -= 1
sleep_stat_for_day['score'] = 0
self.set_param_invalid(day)
return
sleep_stat_for_day['validity'] = True
# 将秒换算为分钟
sleep_stat_for_day['awake'] = sleep_stat_for_day['awake'] / 60
sleep_stat_for_day['light'] = sleep_stat_for_day['light'] / 60
sleep_stat_for_day['deep'] = sleep_stat_for_day['deep'] / 60
record_time = sleep_stat_for_day['awake'] + sleep_stat_for_day[
'light'] + sleep_stat_for_day['deep'] # 记录在床时间
if record_time < 3 * 60:
sleep_stat_for_day['validity'] = False
self.DaysValidity -= 1
self.set_param_invalid(day)
return
if sleep_stat_for_day.get('firstAwakeLight') is not None:
sleep_stat_for_day[
'firstAwakeLight'] = sleep_stat_for_day['firstAwakeLight'] / 60
self.sleep_statForMonth['firstAwakeLight'][
day] = sleep_stat_for_day['firstAwakeLight']
sleep_stat_for_day['score'], sleep_stat_for_day[
'sleepEval'] = self.statistics.get_sleep_assess(
sleep_stat_for_day['offbed'],
sleep_stat_for_day['firstAwakeLight'],
sleep_stat_for_day['awake'], sleep_stat_for_day['light'],
sleep_stat_for_day['deep'])
# 有效数据设置
self.sleep_statForMonth['score'][day] = sleep_stat_for_day['score']
self.sleep_statForMonth['sleepTime'][
day] = sleep_stat_for_day['light'] + sleep_stat_for_day['deep']
self.sleep_statForMonth['offBedFrequency'][
day] = sleep_stat_for_day['offbed']
self.sleep_statForMonth['onBedTime'][day] = sleep_stat_for_day['light'] + sleep_stat_for_day['deep'] + \
sleep_stat_for_day['awake'] + sleep_stat_for_day[
'firstAwakeLight']
self.sleep_statForMonth['deepSleepTime'][day] = sleep_stat_for_day[
'deep']
self.sleep_statForMonth['heartbeat'][day] = sleep_stat_for_day[
'heartbeat']
self.sleep_statForMonth['breath'][day] = sleep_stat_for_day[
'breath']
else:
sleep_stat_for_day['score'] = None
sleep_stat_for_day['sleepEval'] = ['数据无效,无法进行评价']
self.set_param_invalid(day)
if sleep_stat_for_day['duration']:
sleep_stat_for_day['duration'][0] = str(
sleep_stat_for_day['duration'][0])
sleep_stat_for_day['duration'][1] = str(
sleep_stat_for_day['duration'][1])
# 拿到每月中每天的睡眠的有效时间，然后再得到对应的标准差和平均值，设定正常睡眠范围
def get_sleep_range(self):
sleep_range = numpy.std(self.statMonth_analyser.get_valid_values(
self.sleep_statForMonth['sleepTime']),
ddof=0) # 由于样本容量较小，故用有偏标准差进行计算。
sleep_average_time = sum(
self.sleep_statForMonth['sleepTime']) / self.DaysValidity
self.sleep_statForMonth['sleepRange'] = [0] * int(
2) # 声明 score list的大小
if self.sleep_statForMonth['sleepRange']:
self.sleep_statForMonth['sleepRange'][0] = str(sleep_average_time -
sleep_range)
self.sleep_statForMonth['sleepRange'][1] = str(sleep_average_time +
sleep_range)
# 获取月报数据
def get_sleep_statForMonth(self, user_id, date):
date = parse(date)
month_range = self.init_param(date)
first_day = parse(str(date.year) + '-' + str(date.month) + '-01')
days_validity = month_range[1]
for i in range(0, days_validity):
node_day = first_day + timedelta(days=i)
node_day = node_day.strftime('%Y-%m-%d') # 格式化日期格式
date_from_db = self.init_date_from_db(user_id,
node_day) # 初始化data_from_db
self.statistics.date = node_day
self.get_day_score(user_id, node_day,
date_from_db) # 根据每一天获取每一天的score ，算出平均值，为月报的分数
self.sleep_statForMonth['offBedTime'][
i] = self.statMonth_analyser.get_offbed_time(
user_id, node_day) # 离床时间
# 综合评分
self.sleep_statForMonth['averScore'] = sum(
self.sleep_statForMonth['score']) / self.DaysValidity # 月报平均得分
# 睡眠总时间段
self.get_sleep_range() # 获取月睡眠时间段
self.sleep_statForMonth['LargestOffBedFrequency'] = max(
self.sleep_statForMonth['offBedFrequency']) # 获取最大离床次数
# 深夜离床次数
self.sleep_statForMonth['AverOffBedFrequency'] = sum(
self.statMonth_analyser.get_valid_values(
self.sleep_statForMonth['offBedFrequency'])
) / self.DaysValidity # 获取平均离床次数
# 平均入睡时间
self.sleep_statForMonth['AverFirstAwakeLight'] = sum(
self.statMonth_analyser.get_valid_values(
self.sleep_statForMonth['firstAwakeLight'])
) / self.DaysValidity # 获取平均离床次数
# 睡眠效率: 实际睡眠时间和在床时间的比值 (即 (deep_sleep+ light_sleep)/(light+firstAwakeLight+deep+awake))
self.sleep_statForMonth['sleepEfficiency'] = str(
round(((sum(self.sleep_statForMonth['sleepTime']) * 1.0) /
(sum(self.sleep_statForMonth['onBedTime']) * 1.0)), 4) *
100) + '%'
# 深睡效率：深睡时间与实际睡眠时间的比值 (即 deep_sleep/deep_sleep+ light_sleep)
self.sleep_statForMonth['deepSleepEfficiency'] = str(
round(((sum(self.sleep_statForMonth['deepSleepTime']) * 1.0) /
(sum(self.sleep_statForMonth['sleepTime']) * 1.0)), 4) *
100) + '%'
# 平均心率
self.sleep_statForMonth['averHeartbeat'] = sum(
self.sleep_statForMonth['heartbeat']) / self.DaysValidity
# 平均呼吸频率
self.sleep_statForMonth['averBreath'] = sum(
self.sleep_statForMonth['breath']) / self.DaysValidity
for item in self.sleep_statForMonth['offBedTime']:
for item_offbed in item:
item_offbed['offbed_time'] = item_offbed[
'offbed_time'].isoformat()
return self.sleep_statForMonth
def on_get(self, req, resp, user_id, date):
self.statistics.user_id = user_id
self.sleep_statForMonth = self.get_sleep_statForMonth(user_id, date)
resp.body = json.dumps(self.sleep_statForMonth)
resp.status = falcon.HTTP_200
#!/usr/bin/env python3
from analyser import Analyser
from printer import Printer
from question import Question
import queries
dsn = 'dbname=news'
analyser = Analyser(dsn, Printer(), 'Logs Analysis')
analyser.add_question(
Question('What are the most popular three articles of all time?',
queries.MOST_TREE_POPULAR_ARTICLES,
lambda result: '{}: {} views'.format(result[0], result[1])))
analyser.add_question(
Question('Who are the most popular article authors of all time?',
queries.MOST_POPULAR_ARTICLE_AUTHORS,
lambda result: '{}: {} views'.format(result[0], result[1])))
analyser.add_question(
Question('On which days did more than 1% of requests lead to errors?',
queries.ERROR_DAYS,
lambda result: '{}: {}% errors'.format(result[0],
result[1])))
analyser.analyse()
def test_shoundUseCapitalLettersfdsafdasfdasfdasfdsa():
sut = Analyser()
assert 'Duża' == ''.join(sut.analyse("duża dosłownie duża"))
class StatMonthAnalyser:
def __init__(self, db):
self.db = db
self.stage_analyser = StageAnalyser()
self.analyser = Analyser(self.db)
self.stage_regularity_analyser = StageRegularityAnalyser(self.db)
self.time_array = [] # 设置分隔为30分钟的时间段判定
self.dict_time_point = {} # 设置以时间段为key的记录时间点次数的dict
self.offbed_time_array = [] # 所有睡眠期间离床时间集合
self.divide_time()
# 将时间进行分隔,为选择时间段做准备
def divide_time(self):
"""
分隔时间段，为确定离床集中的时间点设置assembly
:return: 时间段array
"""
start_time = '1900-01-01 00:00:00'
start_time = datetime.datetime.strptime(start_time,
'%Y-%m-%d %H:%M:%S')
end_time = '1900-01-01 23:59:59'
end_time = datetime.datetime.strptime(end_time, '%Y-%m-%d %H:%M:%S')
self.time_array = []
self.time_array.append(start_time)
while True:
if start_time >= end_time:
break
else:
start_time += datetime.timedelta(hours=0.5)
self.time_array.append(start_time)
self.time_array.pop() # 将第二天的0:00清除
# 将得到的每天睡眠的时间中的非零的进行舍弃
def get_valid_values(self, values):
values_temp = []
for temp in values:
if temp != 0:
values_temp.append(temp)
return values_temp
# 获取每日的离床时间
def get_offbed_time(self, user_id, date):
"""
通过睡眠状态接口的生成逻辑（暂认为睡眠状态所检测的时间段为真实的有效睡眠时间段），获取睡眠期间的离床时间段。
:param user_id:用户Id
:param date:日期
:return:睡眠时间段的list[dict {offbed_time: time,offbed_range:timeRange}]
"""
# 异常数据 2017-12-16 完成后查看。
offbed_time = {}
offbed_times = []
# datestr = '2017-12-03'
data_from_db = self.db.sleep_phase[user_id].find_one({'_id': date})
if data_from_db is None or data_from_db[
'ver'] != arith.SLEEP_STAGE_ALGORI_VERSION: # 判断是否是读取数据库缓存还是直接进行计算。
self.analyser.analyse(user_id,
date) # analyser 进行分析，然后就分析的数据写入到数据库中去
data_from_db = self.db.sleep_phase[user_id].find_one({'_id': date})
sleep_stages = data_from_db.get('data', [])
for i in range(len(sleep_stages) - 1): # 把最后面的offbed数据进行抹除
# 判断离床是否是睡后离床还是正常离床；需要统计的是睡后离床
if sleep_stages[i][
'state'] == 'offbed' and 'afterSleep' in sleep_stages[
i].keys():
offbed_time['offbed_time'] = sleep_stages[i]['time']
offbed_time['offbed_range'] = (sleep_stages[i + 1]['time'] -
sleep_stages[i]['time']).seconds
offbed_times.append(offbed_time.copy())
return offbed_times
# 获取平均离床时间段、最长离床时间
def get_aver_large_offbed_time(self, offbed_times):
"""
获取平均离床时间段、最长离床时间
:param offbed_times:
:return: {aver_offbed_time:value,large_offbed_time:value}
"""
sum_offbed_times = 0
count = 0
large_offbed_time = 0
for item in offbed_times:
max_current_offbed_time = 0
for item_offbed in item:
self.offbed_time_array.append(item_offbed['offbed_range'])
sum_offbed_times += item_offbed['offbed_range']
max_current_offbed_time += item_offbed['offbed_range']
count += 1
if large_offbed_time < max_current_offbed_time:
large_offbed_time = max_current_offbed_time
aver_offbed_time = round((sum_offbed_times * 1.0) / (count * 1.0), 4)
dict_aver_large_offbed_time = {
'aver_offbed_time': aver_offbed_time,
'large_offbed_time': large_offbed_time
}
return dict_aver_large_offbed_time
def get_offbed_time_point(self, offbed_times):
"""
获取离床主要集中的时间段（此处离床为睡眠期间离床，而非日常离床）
离床主要集中的时间段计算方式： 算出平均离床时间段、标准差，算出离床范围；
根据离床范围确定离床集中的时间点；（选择根据离床范围作为过滤原因 ： 默认不在离床范围内的数据为可用性低的数据）
时间点进行模糊处理，interval 为30 minutes；时间匹配方式为向前匹配
:param offbed_times: 一个月的睡眠时间段的离床时间
:return: []
"""
for i in range(len(self.time_array)):
key = self.time_array[i].strftime(
'%Y-%m-%d %H:%M:%S') # 时间point作为key
self.dict_time_point[key] = 0
dict_aver_large_offbed_time = self.get_aver_large_offbed_time(
offbed_times)
aver_offbed_time = dict_aver_large_offbed_time['aver_offbed_time']
offbed_time_std = numpy.std(self.get_valid_values(
self.offbed_time_array),
ddof=0)
# 由于样本容量较小，故用有偏标准差进行计算。
offbed_time_range = [0] * int(2) # 声明 score list的大小
if offbed_time_range: # 获取离床时间范围
offbed_time_range[0] = str(aver_offbed_time -
offbed_time_std) # 单位为 s
offbed_time_range[1] = str(aver_offbed_time + offbed_time_std)
for item in offbed_times:
for item_offbed in item:
if float(offbed_time_range[0]) <= item_offbed['offbed_range'] and float(item_offbed['offbed_range']) <= \
offbed_time_range[1]:
get_time = item_offbed[
'offbed_time'] # datetime.datetime.strptime(, '%Y-%m-%d %H:%M:%S.%Z')
for i in range(len(self.time_array) - 1):
if get_time.hour == self.time_array[i].hour:
if get_time.minute >= self.time_array[
i].minute and get_time.minute < self.time_array[
i + 1].minute:
key = self.time_array[i].strftime(
'%Y-%m-%d %H:%M:%S') # 时间point作为key
self.dict_time_point[key] += 1
break
if len(self.dict_time_point) >= arith.MONTH_OFFBED_POINT_TIMES:
keys = sorted(self.dict_time_point,
key=lambda x: self.dict_time_point[x],
reverse=True)[0:arith.MONTH_OFFBED_POINT_TIMES]
else:
keys = sorted(self.dict_time_point,
key=lambda x: self.dict_time_point[x],
reverse=True)[0:len(self.dict_time_point)]
result_final = {'offbed_time_range': offbed_time_range} # 夜间平均离床时间范围
result = {} # 睡眠期间离床前三多时间段及对应次数
# 时间点前的默认的date数据清除
for i in range(len(keys)):
result[keys[i]] = self.dict_time_point[keys[i]]
date_temp = datetime.datetime.strptime(
keys[i], '%Y-%m-%d %H:%M:%S') # str transform to datetimea
time_temp = datetime.time(date_temp.hour, date_temp.minute,
date_temp.second)
result[time_temp.strftime('%H:%M:%S')] = result.pop(keys[i])
result_final['offbed_time_point'] = result
result_final['offbed_time_std'] = offbed_time_std
return result_final
# 判断月作息规律性
def calc_sleep_month_regularity(self, user_id, date):
pass
from analyser import Analyser analyser = Analyser() analyser.analyse(['id', '+', 'id', '*', 'id', '$'])
import openCorporaDictFromPreparedFile
from analyser import Analyser
dictionary = openCorporaDictFromPreparedFile.dictionary
lemmas = openCorporaDictFromPreparedFile.lemmas
myanalyser = Analyser(dictionary, lemmas)
#text = 'Стала стабильнее экономическая и политическая обстановка, предприятия вывели из тени зарплаты сотрудников. Все Гришины одноклассники уже побывали за границей, он был чуть ли не единственным, кого не вывозили никуда дальше Красной Пахры.'
file2parse = open('dataset_37845_1.txt', 'r', encoding='utf8')
result_file = open('result.txt', 'w', encoding='utf8')
for line in file2parse:
result = myanalyser.analyse(line.strip('\n'))
result_file.write(result + '\n')
file2parse.close()
result_file.close()
#text = 'виновный посол напомнил после о столе'
#text = 'мой друг говорит с сестрой о море'
#result = myanalyser.analyse(text)
#print(result)
def test_shoud_correctly_set_service():
text = "Ala ma kota"
sut = Analyser()
assert ["Ala", " ", "ma", " ", "kota"] == sut.analyse(text)
class Statistics:
def __init__(self, db):
self.db = db
self.user_id = None
self.date = None
self.analyser = Analyser(self.db)
self.stage_regularity_analyser = StageRegularityAnalyser(self.db)
self.assess_text = {
'score': {
'best': '恭喜! 您的总体睡眠质量相当不错',
'good': '您的总体睡眠质量尚可',
'normal': '您的总体睡眠质量不佳，需要改善',
'bad': '您的总体睡眠质量较差，需要改善'
},
'sleep_time': {
'best': '您的有效睡眠时间为 {sleep_time_hour} 小时，处于正常范围之内',
'good': '您的有效睡眠时间为 {sleep_time_hour} 小时，成年人至少应保持每天 7 个小时的睡眠',
'normal': '您的有效睡眠时间为 {sleep_time_hour} 小时，成年人至少应保持每天 7 个小时的睡眠',
'bad': '您的有效睡眠时间仅为 {sleep_time_hour} 小时，成年人至少应保持每天 7 个小时的睡眠',
'error': '404'
},
'sleep_efficiency': {
'good': '',
'normal': '同时，您的睡眠效率不高，请注意改善',
'bad': '同时，您的睡眠效率不高，请注意改善',
'error': '404'
},
'first_light_time': {
'good': '您的入睡时间为 {first_light_time_minute} 分钟，属正常',
'normal':
'您的入睡时间为 {first_light_time_minute} 分钟，是轻度失眠的体现。建议您入睡前可适当做睡前体操放松，减轻大脑兴奋状态',
'bad':
'您的入睡时间为 {first_light_time_minute} 分钟，是中度失眠的体现。可咨询医师帮助改善',
'error': '404'
},
'deep_sleep_account': {
'best':
'您的深睡时间为 {deep_time_hour} 小时，约占有效睡眠时间的 {deep_sleep_percet}% ，属正常',
'good':
'您的深睡时间为 {deep_time_hour} 小时，约占有效睡眠时间的 {deep_sleep_percet}% ，属正常',
'normal':
'您的深睡时间为 {deep_time_hour} 小时，约占有效睡眠时间的 {deep_sleep_percet}% ，属不佳',
'bad':
'您的深睡时间为 {deep_time_hour} 小时，仅约占有效睡眠时间的 {deep_sleep_percet}% ，属不佳',
'error': '404'
},
'off_bed_times': {
'good': '',
'normal': '',
'bad': '此外，您夜间起床多于 5 次，属不佳',
'error': '404'
}
}
self.assess_level = {
'score': {
(90, None): ('best'),
(80, 90): ('good'),
(70, 80): ('normal'),
(0, 70): ('bad')
},
'offbed': {
(0, 3): ('good', 10),
(3, 6): ('normal', 8),
(6, None): ('bad', 2),
(None, 0): ('error', 0)
},
'first_light_time': {
(0, 60): ('good', 15),
(60, 90): ('normal', 10),
(90, None): ('bad', 5),
(None, 0): ('error', 0)
},
'sleep_time': {
(7 * 60, None): ('best', 20),
(5 * 60, 7 * 60): ('good', 15),
(3 * 60, 5 * 60): ('normal', 10),
(0, 3 * 60): ('bad', 5),
(None, 0): ('error', 0)
},
'deep_sleep_account': {
(1, None): ('error', 0),
(0.45, 1): ('best', 30),
(0.35, 0.45): ('good', 25),
(0.2, 0.35): ('normal', 15),
(0, 0.2): ('bad', 5),
(None, 0): ('error', 0)
},
'sleep_efficiency': {
(1, None): ('error', 0),
(0.8, 1): ('good', 15),
(0.6, 0.8): ('normal', 10),
(0, 0.6): ('bad', 5),
(None, 0): ('error', 0)
}
}
def get_assess_level(self, title, input_value):
for key, value in self.assess_level[title].iteritems():
if (key[0] is None):
if input_value < key[1]:
return value
elif (key[1] is None):
if input_value >= key[0]:
return value
elif key[0] <= input_value < key[1]:
return value
# 时间均以分钟记录 获取date天的评分和评价。
def get_sleep_assess(self, off_bed_times, first_light_time, awake_time,
light_time, deep_time):
# moving_score 为浮动得分
moving_score = 10
(off_bed_times_level,
off_bed_times_score) = self.get_assess_level('offbed', off_bed_times)
off_bed_times_eval = self.assess_text['off_bed_times'][
off_bed_times_level]
(first_light_time_level, first_light_time_score) = \
self.get_assess_level('first_light_time', first_light_time)
first_light_time_eval = \
self.assess_text['first_light_time'][first_light_time_level].format(
first_light_time_minute=first_light_time)
sleep_time = light_time + deep_time
record_time = light_time + deep_time + awake_time
(sleep_time_level,
sleep_time_score) = self.get_assess_level('sleep_time', sleep_time)
sleep_time_eval = self.assess_text['sleep_time'][
sleep_time_level].format(
sleep_time_hour=round(sleep_time * 1.0 / 60, 2))
# 排除睡眠时间是0的情况
if sleep_time > 0:
deep_sleep_account = round(deep_time * 1.0 / sleep_time, 2)
else:
deep_sleep_account = 0
(deep_sleep_account_level, deep_sleep_score) = \
self.get_assess_level('deep_sleep_account', deep_sleep_account)
deep_sleep_eval = self.assess_text['deep_sleep_account'][
deep_sleep_account_level].format(
deep_time_hour=round(deep_time * 1.0 / 60, 2),
deep_sleep_percet=int(deep_sleep_account * 100))
# 排除记录时间是0的情况
if record_time > 0:
sleep_efficiency = round(sleep_time * 1.0 / record_time, 2)
else:
sleep_efficiency = 0
(sleep_efficiency_level, sleep_efficiency_score) = \
self.get_assess_level('sleep_efficiency', sleep_efficiency)
score = sleep_time_score + sleep_efficiency_score + first_light_time_score + \
deep_sleep_score + off_bed_times_score + moving_score
score_level = self.get_assess_level('score', score)
sleep_score_eval = self.assess_text['score'][score_level].format(
total=score)
sleepEval = [
sleep_score_eval, sleep_time_eval, first_light_time_eval,
deep_sleep_eval, off_bed_times_eval
]
return score, sleepEval
# 获取日报数据
def get_sleep_stat(self, resp, user_id, date):
data_from_db = self.db.sleep_stat[user_id].find_one({'_id': date})
if data_from_db is None or data_from_db[
'ver'] != arith.SLEEP_STAT_ALGORI_VERSION:
self.analyser.analyse(user_id,
date) # analysis 计算date天的睡眠状态数据 和分析数据
data_from_db = self.db.sleep_stat[user_id].find_one({'_id': date})
sleep_stat = data_from_db.get('data')
if sleep_stat is None or sleep_stat['validity'] is False:
resp.body = json.dumps({'validity': False, 'score': 0})
resp.status = falcon.HTTP_200
return
sleep_stat['validity'] = True
# 将秒换算为分钟
sleep_stat['awake'] = sleep_stat['awake'] / 60
sleep_stat['light'] = sleep_stat['light'] / 60
sleep_stat['deep'] = sleep_stat['deep'] / 60
record_time = sleep_stat['awake'] + sleep_stat['light'] + sleep_stat[
'deep']
if record_time < 3 * 60:
sleep_stat['validity'] = False
resp.body = json.dumps({'validity': False, 'score': 0})
resp.status = falcon.HTTP_200
return
if sleep_stat.get('firstAwakeLight') is not None:
sleep_stat['firstAwakeLight'] = sleep_stat['firstAwakeLight'] / 60
sleep_stat['score'], sleep_stat[
'sleepEval'] = self.get_sleep_assess(
sleep_stat['offbed'], sleep_stat['firstAwakeLight'],
sleep_stat['awake'], sleep_stat['light'],
sleep_stat['deep'])
else:
sleep_stat['score'] = None
sleep_stat['sleepEval'] = ['数据无效,无法进行评价']
if sleep_stat['duration']:
sleep_stat['duration'][0] = str(sleep_stat['duration'][0])
sleep_stat['duration'][1] = str(sleep_stat['duration'][1])
return sleep_stat
def on_get(self, req, resp, user_id, date):
self.date = date
self.user_id = user_id
sleep_stat = self.get_sleep_stat(resp, user_id, date)
resp.body = json.dumps(sleep_stat)
resp.status = falcon.HTTP_200
def test_lalalalala1():
text = "dosłownie cudzysłów cudzysłów"
sut = Analyser()
sut.analyse("ustawienia capital off")
assert ['cudzysłów', ' ', '\"'] == sut.analyse(text)
def test_lalalalala2():
text = "dosłownie cudzysłów cudzysłów 12 dosłownie 12 dosłownie dosłownie"
sut = Analyser()
assert [
'cudzysłów', ' ', '\"', ' ', 'dwanaście', ' ', '12', ' ', 'dosłownie'
] == sut.analyse(text)
def test_lalalalala5():
sut = Analyser()
sut.analyse("ustawienia auto Space")
assert [(Key.alt, Key.f4)] == sut.analyse("komenda zamknij")
