def check_one(selected, auto_flag = False, argv_flag = False):
# Check a single item
tools.os_clear_screen(sysstr)
print("\n=== Checking now, results will be shown below...\n")
print(roms.get_name(selected) + ":\n")
if argv_flag:
checking = "check_update." + selected
else:
checking = "check_update." + roms.check_list[selected]
temp2 = eval(checking)(False, bs4_parser)
if temp2:
if argv_flag:
checked = selected
else:
checked = roms.check_list[selected]
tools.check_for_update(checked, temp2, term_cols)
tools.save_to_json(temp2, "save.json")
print("\n%s\n"%("*" * term_cols))
if temp2:
print("=== Check completed!")
check_res = ("\n*** Press the Enter key ")
exit_st = 0
else:
print("=== Check Failed!")
check_res = ("\n*** Enter \"0\" to try again, enter other ")
exit_st = 1
if auto_flag:
return input("\n*** Press the Enter key to continue: ")
if argv_flag:
return
return input(check_res + "to return to the main interface: "), exit_st
def getdata(name):
EXP_FILENAME = (os.path.join(EXP_FOLDERNAME, name + '.json'))
EXP_TIME_SECOND = 10
handler = SerialHandler('/dev/ttyACM3', 115200)
#handler.current_state = {'time': 0}
#current_state = handler.current_state
handler.start()
handler.wait_until_alive()
start_time = time.time()
value = []
g = []
while True:
value.append(handler.current_state)
time.sleep(0.01)
if (time.time() - start_time) > EXP_TIME_SECOND:
break
handler.stop()
handler.join()
results = {}
results['value'] = value
tools.save_to_json(results, EXP_FILENAME)
return value
def start_polling(updateUrl, max_results):
data = s.get(avia_url + updateUrl).json()
# время на опрос, если больше этого количества секунд пройдет, просто вернем то, что уже есть
time_to_polling = 10
# хитрая магия - на самом деле просто разжевываем, что нам яндекс ответил
while (data == None or int(data['progress']['current']) < int(
data['progress']['all'])) and (time_to_polling > 0) and (int(
data['progress']['current']) < max_results):
#2017-12-02T19:35:07
form = '%Y-%m-%dT%H:%M:%S'
timeobj = {'time': datetime.now().strftime(form)}
# превращаем timeobj в строку вида 'time=2017-12-02T19%3A35%3A07'
timeobj = urlencode(timeobj, quote_via=quote_plus)
# склеиваем url для запроса (почему так? - так яндекс хочет)
url = avia_url + updateUrl + '?' + timeobj + '&cont=1'
try:
# делаем запрос, пытаемся распарсить json
data = s.get(url).json()
except:
# в случае экзепшена ничего не делаем, живем дальше
pass
tools.log(data['progress']['current'], 'from', data['progress']['all'])
# интервал запросов к яндексу для обновления результатов поиска в секундах
polling_interval = 1
# спим столько секунд
time.sleep(polling_interval)
# уменьшаем оставшееся время
time_to_polling -= polling_interval
# если в итоге у нас ничего не получилось получить от яндекса в качестве результатов поиска,
# или там что-то странное и нет поля 'progress'
# то просто возвращаем None
if data is None or 'progress' not in data:
tools.log('SEARCH ENDED WITH EMPTY RESULTS OR EXCEPTION')
return None
# для отладки сохраняем то, что нам яндекс вернул, как результаты поиска
tools.save_to_json(data, '_data.json')
# если по каким-то причинам не нашлось билетов, то вернем пустой dictionary
if data['progress'] == 0:
return {}
return data
def get_suggests(query):
# пример: из объекта {'query':'мос'} получится строка 'query=%D0%BC%D0%BE%D1%81'
q = urlencode({'query': query}, quote_via=quote_plus)
# код языка, на котором будут подсказки
lang_code = 'en'
# url для запроса подсказок мест по имени
url = 'https://suggests.avia.yandex.ru/v2/avia?format=tickets&lang=' + lang_code + '&national_version=ru&avia=true&need_country=true&have_airport_field=true&hidden_field=true&' + q
# GET запрос, сразу парсим json в объект
data = s.get(url).json()
# для отладки сохраняли когда-то ответ сервера в файлик
#tools.save_to_json(data, '_suggests.json')
# трансформируем эту штуку, полученную от яндекса в массив дикшинари вида
res = [{'name': x[1], 'info': x[2]} for x in data[1]]
# кэшируем места по их point_key в дикшинари places
for p in res:
places[p['info']['point_key']] = p
# тут же сохраняем places в файл
tools.save_to_json(places, 'placesCache.json')
'''
каждый объект массива res перед return'ом это такой дикшинари
{
'name': 'Домодедово',
'info': {
'country_title': 'Россия',
'point_code': 'DME',
'city_title': 'Москва',
'hidden': 0,
'have_airport': 1,
'point_key': 's9600216',
'added': 0,
'region_title':
'Москва и Московская область',
'missprint': 0
}
}
'''
# возвращаем только три первых подсказки из массива
return res[:3]
def getdata(name):
EXP_FILENAME =(os.path.join(EXP_FOLDERNAME, name + '.json'))
EXP_TIME_SECOND = 20
if __name__ == '__main__':
handler = SerialHandler('/dev/ttyACM3', 115200)
handler.current_state = {'time': 0}
current_state = handler.current_state
handler.start()
start_time = time.time()
timestamps = []
while True:
## check if received new data
if current_state['time'] != handler.current_state['time']:
elasped = time.time() - start_time
timestamps.append(elasped)
print(elasped)
current_state = handler.current_state
time.sleep(0.0001)
if (time.time() - start_time) > EXP_TIME_SECOND:
break
handler.stop()
handler.join()
import numpy as np
mean_latency=np.mean(np.diff(timestamps))
freq.append(1/mean_latency)
results = {}
results['timestamps'] = timestamps
tools.save_to_json(results, EXP_FILENAME)
getdata('photosensor')
# In[54]:
getdata('photoresistor')
# In[55]:
getdata('RGB_sensor')
# In[57]:
calculated_data={}
calculated_data['data frequency'] =freq
tools.save_to_json(calculated_data,experimental_data)
# In[56]:
freq
class DiskUsage:
"""
Personalize and visualize the disk space usage in the terminal
"""
def __init__(self,
path: str = "",
exclude: list = None,
details: bool = False,
every: bool = False) -> None:
self.path = path
self.exclude = []
if exclude:
self.exclude = exclude
self.details = details
self.every = every
self._platform = platform.system(
) # Check on which platform vizex operates
def print_charts(self, options: Options = None) -> None:
"""
Prints the charts based on user selection type
Args:
options (Options): colors and symbols for printing
"""
if not options:
options = Options()
if self.path:
parts = self.grab_specific(self.path[0])
else:
parts = self.grab_partitions(exclude=self.exclude,
every=self.every)
chart = HorizontalBarChart(options)
for partname in parts:
self.print_disk_chart(chart, partname, parts[partname])
def print_disk_chart(self, ch: Chart, partname: str, part: dict) -> None:
"""Prints the disk data as a chart
Args:
ch (Chart): to print
partname (str): partition title
part (dict): partition data to be visualized
"""
pre_graph_text = self.create_stats(part)
footer = None
if self.details:
footer = self.create_details_text(part)
maximum = part["total"]
current = part["used"]
post_graph_text = create_usage_warning(part['percent'], 80, 60)
ch.chart(
post_graph_text=post_graph_text,
title=partname,
pre_graph_text=pre_graph_text,
footer=footer,
maximum=maximum,
current=current,
)
print()
def grab_root(self) -> dict:
"""
Grab the data for the root partition
return:
(dict) with column titles as keys
"""
return {
"total": psutil.disk_usage("/").total,
"used": psutil.disk_usage("/").used,
"free": psutil.disk_usage("/").free,
"percent": psutil.disk_usage("/").percent,
"fstype": psutil.disk_partitions(all=False)[0][2],
"mountpoint": "/",
}
def grab_partitions(self, exclude: list, every: bool) -> dict:
"""Grabs data for all the partitions.
Args:
exclude (list): of partitions to exclude
every (bool): if all the partitions should be grabbed
"""
disks = {}
# If we don't need every part we grab root separately
if not every and self._platform != 'Windows':
disks['root'] = self.grab_root()
disk_parts = psutil.disk_partitions(all=every)
for disk in disk_parts[1:]:
# Exclude mounpoints created by snap
if disk.device.startswith("/dev/loop"):
continue
# Check that tmp is not slipping as partition
if disk.mountpoint.startswith("/tmp"):
continue
# Check that part name is not in the excluded list
if self.exclude and disk[1].split("/")[-1] in exclude:
continue
try:
if psutil.disk_usage(disk[1]).total > 0:
disks[disk[1].split("/")[-1]] = {
"total": psutil.disk_usage(disk[1]).total,
"used": psutil.disk_usage(disk[1]).used,
"free": psutil.disk_usage(disk[1]).free,
"percent": psutil.disk_usage(disk[1]).percent,
"fstype": disk.fstype,
"mountpoint": disk.mountpoint,
}
except Exception as e:
print(e)
continue
return disks
def grab_specific(self, disk_path: str) -> dict:
"""
Grabs data for the partition of the user specified path
Args:
disk_path (str): to the partition to grab
"""
disks = {
disk_path: {
"total": psutil.disk_usage(disk_path).total,
"used": psutil.disk_usage(disk_path).used,
"free": psutil.disk_usage(disk_path).free,
"percent": psutil.disk_usage(disk_path).percent,
"fstype": "N/A",
"mountpoint": "N/A",
}
}
return disks
def create_details_text(self, disk: dict) -> str:
"""
Creates a string representation of a disk
Args:
disk (dict): text to print
"""
return f"fstype={disk['fstype']}\tmountpoint={disk['mountpoint']}"
def create_stats(self, disk: dict) -> str:
"""
Creates statistics as string for a disk
Args:
disk (dict): stats to print
"""
r = ints_to_human_readable(disk)
return f"Total: {r['total']}\t Used: {r['used']}\t Free: {r['free']}"
def save_data(self, filename: str) -> None:
"""
Outputs disks/partitions data as a CSV file
Args:
filename (str): for the saved file
"""
data = self.grab_partitions(self.exclude, self.every)
if (file_type := filename.split(".")[-1].lower()) == 'csv':
save_to_csv(data, filename)
elif file_type == 'json':
save_to_json(data, filename)
def check_all_auto(argv_flag = False):
# Automatically check all
'''
This mode does not perform the operation of downloading the MD5 file
to obtain the hash check value (fast_flag is True)
to improve the checking speed.
(Will not block the hash that can be taken directly from the page)
'''
# Read saved Rom update status dictionary from json file
saved = tools.read_from_json("save.json")
if not saved:
saved = {}
# ~ Some URLs are not accessible right now
# ~ (At least in my area is like this).
# ~ such as: aex
# ~ But I will not ignore them anymore.
# ~ If you don't want to output these check failure messages,
# ~ Please write the corresponding function name in this tuple.
skip_tuple = ("mokee")
temp3 = failed_list = {}
j = 1
check_2nd = ""
while True:
tools.os_clear_screen(sysstr)
print("\n=== Automatically check all Rom updates, "
"please wait...")
print("\n=== Checking %s of %s %s...\n"
%(j, len(roms.check_list), check_2nd))
print(roms.get_name(str(j)) + ":\n")
new_flag = False
checking = "check_update." + roms.check_list[str(j)]
temp2 = eval(checking)(True, bs4_parser)
if temp2:
checked = roms.check_list[str(j)]
new_flag = tools.check_for_update(checked, temp2, term_cols)
# Merging dictionaries
# (this method is limited to Python version 3.5 and above)
temp3 = {**temp3, **temp2}
# Other ways of :
# 1.Dictionary analysis
# (the most stupid, the slowest, most reliable method):
# ~ for key,value in temp2.items():
# ~ temp3[key] = value
# 2.element stitching
# (Python3 can not be omitted "dictionary to list" step):
# ~ temp3 = dict(list(temp3.items()) + list(temp2.items()))
elif roms.check_list[str(j)] not in skip_tuple:
if check_2nd == "(Second check)":
failed_list[str(j)] = roms.check_list[str(j)]
else:
check_2nd = "(Second check)"
continue
check_2nd = ""
if new_flag:
print("\n%s\n"%("*" * term_cols))
temp = input("*** Enter \"0\" to view details, "
"enter other to continue: ")
if temp == "0":
check_one(str(j), auto_flag = True)
j+=1
if j > len(roms.check_list):
saved = {**saved, **temp3}
tools.save_to_json(saved, "save.json")
tools.os_clear_screen(sysstr)
print("\n%s\n"%("*" * term_cols))
print("=== Check completed!\n")
if len(failed_list) != 0:
print("*** Check failed items:")
for key,value in failed_list.items():
print("\n*** === %s. %s"
%(key, roms.list_all[value]))
print()
else:
print("=== No error occurred during the check.\n")
if not argv_flag:
input("*** Press the Enter key to "
"return to the main interface: ")
break
def start_search(chat, params=None, caption=None, callback_query_id=None):
'''
метод для запуска поиска
'''
# если ждем капчу, не запускаем поиск
if chat.captcha is not None:
return False
# если поиск уже идет, то говорим пользователю, что это так и не запускаем новый
if chat.searching_now:
# если есть на что отвечать, если кнопку нажали и колбэк пришел,
# айди которого передано в callback_query_id, то отвечаем на него
if callback_query_id is not None:
global tg
tg.answerCallbackQuery(callback_query_id,
'Another search is performing')
if caption is not None:
# значит поиск был запущен из Subscription
# ждем, пока текущий поиск завершится
while chat.searching_now:
time.sleep(1)
else:
# не запускаем поиск
return False
# ставим флаг, что сейчас идет поиск
chat.searching_now = True
# если конкретных параметров не передали, подтягиваем параметры чата
if params is None:
params = chat.params
# запоминаем строку параметров поиска
query_str = params.query_str()
# если с параметрами что-то не так, говорим об этом пользователю
if not params.is_ready_for_search():
chat.send_message("Configure search parameters first.")
# поиск завершился без результатов
return search_done(chat, None, query_str)
# если что-то там хотим отправить перед поиском, то отправляем (caption - просто строка)
if caption is not None:
chat.send_message(caption)
data = None
try:
# пытаемся получить результаты поиска в переменную data
data = yandexAvia.get_flights(
params.origin,
params.destination,
params.date_for_search(),
on_search_started=on_search_started,
on_search_started_args=(callback_query_id, chat, params))
except Exception as ex:
# логаем экзепшен, если он вылез
tools.log("EXCEPTION:\n", ex)
# если yandexAvia.get_flights() вернул None или был какой-то экзепшен
if data is None:
# говорим пользователю, что что-то не так пошло
chat.send_message(
"For some mysterious reasons I couldn't start search.")
tools.log("COULDN'T START SEARCH")
# поиск завершился без результатов
return search_done(chat, None, query_str)
# если yandexAvia.get_flights() вернул что-то типа { 'captcha' : { ... } }
if 'captcha' in data:
# запоминаем капчу для этого чата
chat.captcha = data['captcha']
# докидываем в объект капчи строку параметров поиска, для которого она вылезла
chat.captcha['search_parameters'] = params
# отправляем картиночку капчи пользователю с просьбой разгадать ее
url = chat.captcha['src']
tg.sendPhoto(chat.chatId, url,
'I\'m sorry for this but you have to submit captcha')
# поиск завершился без результатов
return search_done(chat, None, query_str)
if not data: # equals to empty dict
# поиск завершен с пустыми результатами
return search_done(chat, {}, query_str)
# трансформируем структуру данных, которые вернул яндекс, в структуру, которую хотим видеть мы
# fares - массив билетов (каждый билет может содержать несколько перелетов)
fares = data['variants']['fares']
# каждый из вариантов билетов трансформируем
formatted = [format_fare(f, data) for f in fares]
#закоменчен фильтр для поиска только прямых рейсов (с одним полетом)
#formatted = filter(lambda x: len(x['flights']) == 1, formatted)
# сортируем билеты по возрастанию цены
formatted = sorted(formatted,
key=lambda elem: elem['price']['tariff']['value'])
# сохраним то, что получилось в файлик, чтобы можно было посмотреть при желании
tools.save_to_json(formatted, '_formatted.json')
# вызываем метод о завершении поиска
return search_done(chat, formatted, query_str, params.searching_message_id)
'''