def test_stop_and_persist_no_dict_or_options(self):
"""Test if options is not dict or required options in stop_and_persist.
"""
with self.assertRaises(TypeError):
spinner = Halo()
spinner.start()
spinner.stop_and_persist('not dict')
def get_accounts(hi_api_key, hi_api_url):
spinner = Halo(text="Fetching account via Hi-iQ api ..",
spinner='dots',
text_color="grey")
spinner.start()
headers = {"Authorization": "ematic-admin-apikey=" + hi_api_key}
try:
res = requests.get(hi_api_url + "/account", headers=headers, timeout=5)
except requests.Timeout:
print("Timeout occured. You should reset your network")
return -1, [], []
if res.status_code != 200:
print("Request to our Hi-iQ api went to errors!")
print("Response status code: ", res.status_code)
return -1, [], []
account_list = {}
default_list = {}
for account in res.json()['account']:
if account['espId'] == 10 and account['active']:
# print("account: ", account)
account_list[account['name']] = account['espAPIKey']
default_list[account['name']] = account['espList']
spinner.stop_and_persist(symbol=LogSymbols.SUCCESS.value,
text="Done fetching account via Hi-iQ api")
return 1, account_list, default_list
def doDaka(username, password, logger):
print("\n[Time] %s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
logger.info("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
logger.info('正在新建打卡实例...')
dk = DaKa(username, password)
spinner.succeed('已新建打卡实例')
logger.info('已新建打卡实例')
spinner.start(text='登录到浙大统一身份认证平台...')
logger.info('登录到浙大统一身份认证平台...')
dk.login()
spinner.succeed('已登录到浙大统一身份认证平台')
logger.info('已登录到浙大统一身份认证平台')
spinner.start(text='正在获取个人信息...')
logger.info('正在获取个人信息...')
dk.get_info()
spinner.succeed('%s 同学, 你好~' % (dk.name))
logger.info('%s 同学, 你好~' % (dk.name))
spinner.start(text='正在为您打卡打卡打卡')
logger.info('正在为您打卡打卡打卡')
res = dk.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'), text='已为您打卡成功！')
logger.info('已为您打卡成功！')
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'), text=res['m'])
logger.info(res['m'])
def spinner(spin_txt: str,
function: callable,
url: str = None,
*args,
name: str = None,
spinner: str = "dots",
debug: bool = False,
**kwargs) -> Any:
name = name or spin_txt.replace(" ", "_").rstrip(".").lower()
if not name.startswith("spinner_"):
name = f"spinner_{name}"
spin = None
if sys.stdin.isatty():
# If a spinner is already running, update that spinner vs creating new
active_spinners = [
t for t in threading.enumerate()[::-1]
if t.name.startswith("spinner")
]
if active_spinners:
spin = active_spinners[0]._target.__self__
if debug:
spin.stop()
else:
log.warning(
f"A Spinner was already running '{spin.text}' updating to '{spin_txt}'"
)
spin.text == spin_txt
spin.spinner == "dots12" if spin.spinner == spinner else spinner
elif not debug:
spin = Halo(text=spin_txt, spinner=spinner)
spin.start()
threading.enumerate()[-1].name = spin._spinner_id = name
if url:
args = (url, *args)
r = function(*args, **kwargs)
if spin:
# determine pass if request successful
_spin_fail_msg = spin_txt
ok = None
if hasattr(r, "ok"):
ok = r.ok
if "refreshToken" in str(function):
ok = r is not None
if hasattr(r, "json"):
_spin_fail_msg = f"spin_text\n {r.json().get('error_description', spin_txt)}"
if ok is True:
spin.succeed()
elif ok is False:
spin.fail(_spin_fail_msg)
else:
spin.stop_and_persist()
return r
def end_notification(spinner: Halo, success=True):
mark = '✔' if success else '✘'
if sys.stdout.isatty(): # pragma: no-cover
if success:
spinner.succeed()
else:
mark = colored_frame(mark, 'red')
spinner.stop_and_persist(mark)
else:
print(mark, end='')
def download_files(folder_title: str, LINKS: List[str], args: argparse.Namespace):
"""
Download files when the given URL is parsed
"""
ROOT_PATH = Path.cwd()
links_len = len(LINKS)
if args.name:
dir_path = ROOT_PATH / args.name
else:
dir_path = ROOT_PATH / folder_title
# Create folder
spinner = Halo(text="Creating folder", spinner="dots")
spinner.start()
try:
dir_path.mkdir()
except FileExistsError as _:
pass
spinner.stop_and_persist(symbol="✅".encode("utf-8"), text="Folder Created")
print(f"Total files: {links_len}")
print(f"Download Path: {dir_path}")
# Start download
for index, url in enumerate(LINKS):
r = requests.get(url, stream=True, headers={"Accept-Encoding": None})
total_size = int(r.headers.get("Content-Length"))
spinner.text = f"Downloading {index + 1}/{links_len} file"
spinner.spinner = "arrow3"
spinner.start()
time.sleep(1)
spinner.stop()
file = url.split("/")[-1]
file = (file[:50] + "...") if len(file) > 50 else file
with open(dir_path / file, "wb") as f:
with tqdm(
total=total_size,
desc=f"{file:<53}",
unit="B",
unit_scale=True,
bar_format="{l_bar}{bar:20}{r_bar}{bar:-10b}",
) as pbar:
for chunk in r.iter_content(chunk_size=1024):
if chunk:
f.write(chunk)
pbar.update(len(chunk))
spinner.spinner = "monkey"
spinner.start()
time.sleep(2)
spinner.stop_and_persist(symbol="🔥".encode("utf-8"), text="All files downloaded.")
def doDaka(username, password, logger):
print("\n[Time] %s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
logger.info("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
logger.info('正在新建打卡实例...')
dk = DaKa(username, password)
spinner.succeed('已新建打卡实例')
logger.info('已新建打卡实例')
spinner.start(text='登录到浙大统一身份认证平台...')
logger.info('登录到浙大统一身份认证平台...')
try:
dk.login()
spinner.succeed('已登录到浙大统一身份认证平台')
logger.info('已登录到浙大统一身份认证平台')
except Exception as err:
spinner.fail(str(err))
logger.info(str(err))
return
spinner.start(text='正在获取个人信息...')
logger.info('正在获取个人信息...')
try:
dk.get_info()
spinner.succeed('%s %s同学, 你好~' % (dk.info['number'], dk.info['name']))
logger.info('%s %s同学, 你好~' % (dk.info['number'], dk.info['name']))
except Exception as err:
spinner.fail('获取信息失败，请手动打卡，更多信息: ' + str(err))
logger.info('获取信息失败，请手动打卡，更多信息: ' + str(err))
return
spinner.start(text='正在为您打卡打卡打卡')
logger.info('正在为您打卡打卡打卡')
try:
res = dk.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text='已为您打卡成功！')
logger.info('已为您打卡成功！')
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text=res['m'])
logger.info(res['m'])
except:
spinner.fail('数据提交失败')
logger.info('数据提交失败')
return
def main():
init() #initialize colorama
print(Back.BLUE + Fore.RED + " halo spinner example ")
#create the Halo spinner
spinner = Halo(text='What is taking so long..',
text_color='cyan',
color='green')
#start the spin simulation
spinner.start()
#sleep
time.sleep(5)
#stop and print the final message
spinner.stop_and_persist(symbol='✔ '.encode('utf-8'), text='Done!')
def submit_job(code_url, cpus, memory_mb, max_runtime_secs):
job_spec = {
"code_url": code_url,
# TODO: Later, when we add support for resource_requirements, test some real values for this
"resource_requirements": {
"cpus": cpus,
"memory_mb": memory_mb,
"max_runtime_secs": max_runtime_secs
}
}
print("Submitting job...")
res = requests.post(submit_job_url, json=job_spec)
if res.status_code != 200:
print("Could not submit job!")
sys.exit(1)
resp = res.json()
if not resp.get("success", False):
print("Could not submit job!")
sys.exit(1)
job_id = resp['job_id']
job_status_code = None
spinner = Halo(text="Waiting for job updates", spinner='dots')
spinner.start()
while True:
try:
new_job_status_code = get_job_status(job_id)
if new_job_status_code != job_status_code:
if new_job_status_code in ("UNASSIGNED", "ASSIGNED"):
spinner.info(STATUS_CODE_MESSAGES[new_job_status_code])
spinner.start("Waiting for job updates")
elif new_job_status_code == "FAILED":
spinner.fail(STATUS_CODE_MESSAGES[new_job_status_code])
spinner.start("Waiting for job updates")
else:
# the job has succeeded
spinner.stop_and_persist(
symbol='🦄'.encode('utf-8'),
text=STATUS_CODE_MESSAGES[new_job_status_code])
break
job_status_code = new_job_status_code
time.sleep(JOB_STATUS_POLL_INTERVAL_SECS)
except (KeyboardInterrupt, SystemExit):
spinner.stop()
break
def main(username, password):
"""Hit card process
Arguments:
username: (str) 浙大统一认证平台用户名（一般为学号）
password: (str) 浙大统一认证平台密码
"""
global final_return_text
print("\n[Time] %s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
dk = DaKa(username, password)
spinner.succeed('已新建打卡实例')
spinner.start(text='登录到浙大统一身份认证平台...')
try:
dk.login()
spinner.succeed('已登录到浙大统一身份认证平台')
except Exception as err:
spinner.fail(str(err))
return
spinner.start(text='正在获取个人信息...')
try:
dk.get_info()
spinner.succeed('%s %s同学, 你好~' % (dk.info['number'], dk.info['name']))
except Exception as err:
spinner.fail('获取信息失败，请手动打卡，更多信息: ' + str(err))
final_return_text = "获取信息失败，请手动打卡。错误信息：" + str(err)
return
spinner.start(text='正在为您打卡打卡打卡')
try:
res = dk.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text='已为您打卡成功！')
final_return_text = "🦄 已为您打卡成功！"
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text=res['m'])
final_return_text = '🦄 ' + res['m']
except:
final_return_text = '❌数据提交失败'
spinner.fail('数据提交失败')
return
def test_closing_stream_before_persistent(self):
"""Test no I/O is performed on streams closed before stop_and_persist is called
"""
stream = io.StringIO()
spinner = Halo(text='foo', stream=stream)
spinner.start()
time.sleep(0.5)
# no exception raised after closing the stream means test was successful
try:
stream.close()
time.sleep(0.5)
spinner.stop_and_persist('done')
except ValueError as e:
self.fail('Attempted to write to a closed stream: {}'.format(e))
def main(username, password):
"""Hit card process
Arguments:
username: (str) 浙大统一认证平台用户名（一般为学号）
password: (str) 浙大统一认证平台密码
"""
print("\n[Time] %s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
hit_carder = HitCarder(username, password)
spinner.succeed('已新建打卡实例')
spinner.start(text='登录到浙大统一身份认证平台...')
try:
hit_carder.login()
spinner.succeed('已登录到浙大统一身份认证平台')
except Exception as err:
spinner.fail(str(err))
return
spinner.start(text='正在获取个人信息...')
try:
hit_carder.get_info()
spinner.succeed('%s %s同学, 你好~' %
(hit_carder.info['number'], hit_carder.info['name']))
except Exception as err:
spinner.fail('获取信息失败，请手动打卡，更多信息: ' + str(err))
return
spinner.start(text='正在为您打卡...')
try:
res = hit_carder.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text='已为您打卡成功！')
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text=res['m'])
except Exception as err:
spinner.fail('数据提交失败 ' + str(err))
return
def run():
# Prompt input
while True:
service_name = input("Service name: ").strip().replace(" ", "-")
if service_name:
break
else:
print("Please enter a service name")
root_dir = input("Root directory (blank for current directory): ")
service = Service(service_name, root_dir)
# Create file structure
spinner = Halo(text="Creating file structure")
spinner.start()
service.create_tree()
spinner.succeed()
# Generate venv
spinner.start("Generating virtual environment")
service.generate_venv()
spinner.succeed()
# Activate venv and install requirements
spinner.start("Installing requirements")
service.install_requirements()
spinner.succeed()
# Initialize git
spinner.start("Initializing git repository")
service.initialize_git()
spinner.succeed()
# Personalize
spinner.start("Personalizing")
service.personalize()
spinner.succeed()
# Done!
spinner.stop_and_persist("🎂".encode("utf-8"), "All done!")
print("Your new project is located in:", service.cwd, sep="\t")
def main(username, password, eai_sess, UUkey):
print("\n[Time] %s" % datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
dk = DaKa(username, password, eai_sess, UUkey)
spinner.succeed('已新建打卡实例')
spinner.start(text='登录到中南大学信息门户...')
dk.login()
spinner.succeed('已登录到中南大学信息门户')
spinner.start(text='正在获取个人信息...')
dk.get_info()
spinner.succeed('%s %s同学, 你好~' % (dk.info['number'], dk.info['name']))
spinner.start(text='正在为您打卡打卡打卡')
res = dk.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'), text='已为您打卡成功！')
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'), text=res['m'])
def check_db_status():
spinner = Halo(text='Populating Database', spinner='dots')
spinner.start()
if not os.path.exists(DB_PATH):
table_sql = """CREATE TABLE IF NOT EXISTS questions (
id text PRIMARY KEY,
q_text text NOT NULL,
answer text,
category text
);"""
create_DB(DB_PATH)
create_table(table_sql)
BASE_QUESTIONS_PATH = root_dir_path + '/data/base_questions.csv'
if os.path.exists(BASE_QUESTIONS_PATH):
df = pd.read_csv(BASE_QUESTIONS_PATH, header=0)
df = df.dropna()
for index, row in df.iterrows():
# print ('{} -> {}'.format(type(row['Question']), type(row['Answer'])))
q = Question(row['Question'])
q.create_question()
q.answer_question(row['Answer'])
spinner.stop_and_persist(symbol='✅ '.encode('utf-8'),
text='Populated/Loaded Database')
class CLIConnectionRecovery(ConnectionRecovery):
"""
CLI Connection recovery class.
"""
def __init__(self, access_address, channel_map=None, crc=None, hop_interval=None, devices=None, baudrate=115200, hijack=False, jamming=False, output=None, debug=False, verbose=False):
super().__init__(
access_address,
channel_map=channel_map,
crc=crc,
hop_interval=hop_interval,
devices=devices,
baudrate=baudrate
)
self.output = output
self.debug = debug
self.verbose = verbose
self._jamming = jamming
self._hijack = hijack
self._pt = None
# Display sniffers version
major,minor = [int(v) for v in VERSION.split('.')]
versions = self.interface.get_version()
print('[i] Detected sniffers:')
for i, version in enumerate(versions):
print(' > Sniffer #%d: fw version %d.%d' % (i, version[0], version[1]))
if (major == version[0] and (minor > version[1])) or (major > version[0]):
print(' -!!!- You must update the firmware of this sniffer -!!!-')
raise SnifferUpgradeRequired()
print('')
print('[i] Synchronizing with connection 0x%08x ...' % access_address)
#self.spinner = Spinner('Computing CRCInit value')
if crc is None:
self.spinner = Halo(text='Computing CRCInit value', spinner='line')
elif channel_map is not None:
print('✓ CRCInit: 0x%006x' % crc)
print('✓ Channel map is provided: 0x%010x' % self.chm)
self.spinner = Halo(text='Computing hop interval', spinner='line')
else:
print('✓ CRCInit: 0x%006x' % crc)
self.spinner = Halo(text='Determining channel map', spinner='line')
self.spinner.start()
self.access_address = access_address
def on_verbose(self, packet):
"""
Called when a verbose packet is received from the sniffer.
"""
if self.verbose:
print('@> '+ str(packet.message))
def on_debug(self, packet):
"""
Called when a debug packet is received from the sniffer.
"""
print('D:'+str(packet))
def on_crc(self, crc):
"""
Connection CRC has been recovered.
"""
self.crc = crc
self.spinner.stop_and_persist(
symbol='✓'.encode('utf-8'),
text='CRCInit = 0x%06x'%crc
)
if self.chm_provided:
print('✓ Channel map is provided: 0x%010x' % self.chm)
self.spinner.text = 'Computing hop interval'
self.spinner.start()
self.interface.recover_hop(self.access_address, self.crc, self.chm)
else:
self.spinner.text = 'Determining channel map'
self.spinner.start()
def on_chm(self, chm):
"""
Channel map has been recovered.
"""
self.chm = chm
self.spinner.stop_and_persist(
symbol='✓'.encode('utf-8'),
text='Channel Map = 0x%010x'%chm
)
if self.hop_provided:
print('✓ Hop interval is provided: %d' % self.hop_interval)
self.spinner.text = 'Computing hop increment'
self.spinner.start()
else:
self.spinner.text = 'Computing hop interval'
self.spinner.start()
self.interface.recover_hop(self.access_address, self.crc, self.chm)
def on_hopinterval(self, interval):
"""
Hop interval has been recovered.
"""
self.spinner.stop_and_persist(
symbol='✓'.encode('utf-8'),
text='Hop interval = %d'%interval
)
self.spinner.text = 'Computing hop increment'
self.spinner.start()
def on_hopincrement(self, increment):
"""
Hop increment has been recovered.
"""
self.spinner.stop_and_persist(
symbol='✓'.encode('utf-8'),
text='Hop increment = %d'%increment
)
if self._hijack:
print('[i] Synchronized, hijacking in progress ...')
self.hijack()
elif self._jamming:
print('[i] Synchronized, jamming in progress ...')
self.jam()
else:
print('[i] Synchronized, packet capture in progress ...')
def on_ll_packet(self, packet):
"""
A BLE LL packet has been captured.
"""
if self._pt is not None:
self._pt.on_ll_packet(packet)
else:
timestamp = time()
ts_sec = int(timestamp)
ts_usec = int((timestamp - ts_sec)*1000000)
if self.output is not None:
self.output.write_packet(ts_sec, ts_usec, self.access_address, packet.data)
pkt_hex = ' '.join(['%02x' % c for c in packet.data[10:]])
print('LL Data: ' + pkt_hex)
def on_hijacking_success(self):
"""
Hijacking was successful, hijacker now owns this connection.
"""
print('[i] Connection successfully hijacked, it is all yours \o/')
self._pt = PromptThread(self)
self._pt.start()
def on_hijacking_failed(self):
"""
Could not hijack this connection.
"""
print('[!] Hijack failed.')
def hijack_done(self):
"""
Hijack terminated callback
"""
#raise ForcedTermination()
def on_packet_received(self, packet):
if self._pt is not None and self._pt.canceled:
self._pt.join()
raise ForcedTermination()
else:
super().on_packet_received(packet)
def on_connection_lost(self):
"""
Connection lost.
"""
# if we were hijacking, close PromptThread
if self._pt is not None:
# Kill prompt thread and wait for its termination.
self._pt.cancel()
self._pt.join()
# Okay, we exit here.
print('[!] Connection lost.')
raise ForcedTermination()
class ScrapeTaskABC(ABC):
data_set: DataSet
url_tracker: UrlTracker
def __init__(self, app, db_job):
self.app = app
self.config = app.config
self.db_session = app.db_session
self.scraped_data = app.scraped_data
self.db_job = db_job
self.start_date = None
self.end_date = None
self.season = self.db_job.season
self.total_days = self.db_job.total_days
self.scrape_condition = self.app.get_current_setting(
"SCRAPE_CONDITION", self.data_set)
self.spinner = Halo(color=JOB_SPINNER_COLORS[self.data_set],
spinner="dots3")
@property
def date_range(self):
return get_date_range(self.start_date, self.end_date)
def execute(self, start_date=None, end_date=None):
self.start_date = start_date
self.end_date = end_date
if not start_date:
self.start_date = self.db_job.start_date
if not end_date:
self.end_date = self.db_job.end_date
result = (self.initialize().on_success(
self.identify_needed_urls).on_success(
self.retrieve_scraped_html).on_success(
self.scrape_missing_html).on_success(
self.parse_scraped_html))
self.spinner.stop()
if result.failure:
return result
self.url_tracker.remove_scraped_html()
return Result.Ok()
def initialize(self):
if self.scrape_condition == ScrapeCondition.NEVER:
return Result.Fail("skip")
signal(
SIGINT,
partial(user_cancelled, self.db_session, self.db_job,
self.spinner))
self.spinner.text = "Building URL List..."
self.spinner.start()
self.url_tracker = UrlTracker(self.db_job, self.data_set,
self.scraped_data)
result = self.url_tracker.create_url_set(self.start_date,
self.end_date)
return result if result.failure else Result.Ok(
) if self.url_tracker.total_urls else Result.Fail("skip")
def identify_needed_urls(self):
self.spinner.text = self.url_tracker.identify_html_report
for game_date, urls in self.url_tracker.all_urls.items():
result = self.check_prerequisites(game_date)
if result.failure:
return result
result = self.check_current_status(game_date)
if result.failure:
if "skip" not in result.error:
return result
self.url_tracker.skip_urls.extend(urls)
else:
self.url_tracker.need_urls.extend(urls)
self.spinner.text = self.url_tracker.identify_html_report
return Result.Ok()
def retrieve_scraped_html(self):
self.spinner.text = self.url_tracker.retrieve_html_report
if not self.url_tracker.need_urls:
return Result.Fail("skip")
for url in self.url_tracker.need_urls[:]:
self.scraped_data.get_html(self.data_set, url.url_id)
if not url.html_was_scraped:
self.url_tracker.missing_urls.append(url)
else:
self.url_tracker.cached_urls.append(url)
self.url_tracker.need_urls.remove(url)
self.spinner.text = self.url_tracker.retrieve_html_report
return Result.Ok()
def scrape_missing_html(self):
while not self.url_tracker.html_scraping_complete:
self.spinner.text = self.url_tracker.scrape_html_report
self.spinner.stop_and_persist(self.spinner.frame(), "")
result = self.invoke_nodejs_script()
self.spinner.text = self.url_tracker.save_html_report
self.spinner.start()
for url in self.url_tracker.missing_urls[:]:
if not url.scraped_html_is_valid:
continue
result = self.scraped_data.save_html(self.data_set, url.url_id,
url.html)
if result.failure:
return result
self.url_tracker.completed_urls.append(url)
self.url_tracker.missing_urls.remove(url)
self.spinner.text = self.url_tracker.save_html_report
return Result.Ok()
def invoke_nodejs_script(self):
missing_urls_filepath = self.url_tracker.create_missing_urls_json_file(
)
script_args = self.config.get_nodejs_script_args(
self.data_set, missing_urls_filepath)
result = execute_nodejs_script(NODEJS_SCRIPT, script_args)
missing_urls_filepath.unlink()
return result
def parse_scraped_html(self):
parsed = 0
self.spinner.text = self.url_tracker.parse_html_report(parsed)
for urls_for_date in self.url_tracker.all_urls.values():
for url_details in urls_for_date:
if url_details.url_id not in self.url_tracker.parse_url_ids:
continue
result = self.parse_html(url_details)
if result.failure:
if ("Unable to parse any game data" in result.error
or "will be completed at a later date"
in result.error):
continue
return result
parsed_data = result.value
result = self.scraped_data.save_json(self.data_set,
parsed_data)
if result.failure:
return result
result = self.update_status(parsed_data)
if result.failure:
return result
self.db_session.commit()
parsed += 1
self.spinner.text = self.url_tracker.parse_html_report(parsed)
return Result.Ok()
@abstractmethod
def check_prerequisites(self, game_date):
pass
@abstractmethod
def check_current_status(self, game_date):
pass
@abstractmethod
def parse_html(self, url_details):
pass
@abstractmethod
def update_status(self, parsed_data):
pass
resolved_circuit = circuit.with_parameters_resolved_by(resolver)
print('Resulting parameterized symbolic circuit:\n{}'.format(resolved_circuit))
spinner = Halo(text='Sweeping across the circuit', spinner='simpleDots')
spinner.start()
sweep_size = 10
sweep = (cirq.Linspace(key='alpha', start=0.0, stop=1.0, length=10) *
cirq.Linspace(key='beta', start=0.0, stop=1.0, length=10) *
cirq.Linspace(key='gamma', start=0.0, stop=1.0, length=10))
results = simulator.run_sweep(circuit, params=sweep, repetitions=100)
obj_min = None
min_params = None
spinner.stop_and_persist('✓')
spinner.start('Solving Objective Function')
for result in results:
value = obj_func(result)
if obj_min is None or value < obj_min:
obj_min = value
min_params = result.params
pass
pass
pass
spinner.stop_and_persist('✓')
print('Minimum objective value is {}.'.format(obj_min))
# find the editing location of the source file
tag = main_index.find('div', {'class': 'wrapper'})
tag.insert(0, body)
# save the new edited source file
with open(os.path.join(message.file_dir, '../index.html'),
'w') as file:
file.write(str(main_index))
spinner = Halo(text='Creating post...',
spinner='pong',
text_color='magenta')
spinner.start()
time.sleep(4)
spinner.stop_and_persist(
text="New post successfully created and appended to the index",
symbol='✔ ') # ✔
if answers['item'] == "edit post":
# filter files
places = [y[0] for x, y in post_data.items()]
post = {
'type': 'list',
'name': 'item',
'message': 'Which post?',
'choices': places,
}
# file selected
answer = prompt(message.post, style=message.style)['item']
# print ([round(y, 2) for y in y_hat])
print(
'Most Similar Question is: {0} -- [Probability: {1}]'.format(
data['question1'][idx]), y_hat[idx])
return y_hat
if __name__ == '__main__' and getpass.getuser() != "jonahadler":
start = time.time()
check_db_status()
spinner = Halo(
text='Loading Question Matching Engine (could take up to 5 minutes)',
spinner='dots')
spinner.start()
load_models()
spinner.stop_and_persist(symbol='✅ '.encode('utf-8'),
text='Loaded Question Matching Model')
end = time.time()
print(
'Finished initalization steps in {0:.2f} minutes, ready to handle questions'
.format((end - start) / 60))
process = psutil.Process(os.getpid())
print('Current using {0:.2f}% of the process\' memory'.format(
process.memory_percent()))
# input_q = input('What is your question?\n')
# input_q = 'Can you used piped text in a Web Service?'
# input_q = 'What should I do to be a great geologist?'
while True:
input_q = input('What is your question?\n')
if input_q == 'q' or input_q == 'quit':
# -*- coding: utf-8 -*-
"""Example for doge spinner ;)
"""
from __future__ import unicode_literals
import os
import sys
import time
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from halo import Halo
spinner = Halo(text='Such Spins', spinner='dots')
try:
spinner.start()
time.sleep(2)
spinner.text = 'Much Colors'
spinner.color = 'magenta'
time.sleep(2)
spinner.text = 'Very emojis'
spinner.spinner = 'hearts'
time.sleep(2)
spinner.stop_and_persist({
'symbol': '🦄 '.encode('utf-8'),
'text': 'Wow!'
})
except (KeyboardInterrupt, SystemExit):
spinner.stop()
def main(username, password):
"""Hit card process
Arguments:
username: (str) 浙大统一认证平台用户名（一般为学号）
password: (str) 浙大统一认证平台密码
"""
try:
scheduler.remove_job('checkin_ontime')
except JobLookupError as e:
pass
print("\n[Time] %s" %
datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
print("🚌 打卡任务启动")
spinner = Halo(text='Loading', spinner='dots')
spinner.start('正在新建打卡实例...')
ci = CheckIn(username, password)
spinner.succeed('已新建打卡实例')
spinner.start(text='登录到浙大统一身份认证平台...')
try:
ci.login()
spinner.succeed('已登录到浙大统一身份认证平台')
except Exception as err:
spinner.fail(str(err))
return
spinner.start(text='正在获取个人信息...')
try:
ci.get_info()
spinner.succeed('%s %s同学, 你好~' % (ci.info['number'], ci.info['name']))
except Exception as err:
spinner.fail('获取信息失败，请手动打卡，更多信息: ' + str(err))
return
spinner.start(text='正在为您打卡打卡打卡')
try:
res = ci.post()
if str(res['e']) == '0':
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text='已为您打卡成功！')
else:
spinner.stop_and_persist(symbol='🦄 '.encode('utf-8'),
text=res['m'])
# Random time
random_time = random.randint(0, 60) + hour * 60 + minute
random_hour = random_time // 60
random_minute = random_time % 60
weekday = (datetime.datetime.now().weekday() + 1) % 7
# Schedule task
scheduler.add_job(main,
'cron',
id='checkin_ontime',
args=[username, password],
day_of_week=weekday,
hour=random_hour,
minute=random_minute)
print('⏰ 已启动定时程序，明天 %02d:%02d 为您打卡' %
(int(random_hour), int(random_minute)))
print('Press Ctrl+{0} to exit'.format('Break' if os.name ==
'nt' else 'C'))
except:
spinner.fail('数据提交失败')
return
# -*- coding: utf-8 -*-
"""Example for doge spinner ;)
"""
from __future__ import unicode_literals
import os
import sys
import time
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from halo import Halo
spinner = Halo(text='Such Spins', spinner='dots')
try:
spinner.start()
time.sleep(2)
spinner.text = 'Much Colors'
spinner.color = 'magenta'
time.sleep(2)
spinner.text = 'Very emojis'
spinner.spinner = 'hearts'
time.sleep(2)
spinner.stop_and_persist(symbol='🦄'.encode('utf-8'), text='Wow!')
except (KeyboardInterrupt, SystemExit):
spinner.stop()
def _aux_min_func(self, arch_param_vec):
"""
Auxiliary minimisation function for the architecture picker.
:return:
"""
# print('\n---------------------:',xVecArch, '\n---------------------:')
arch_vec = self._conv_net_vec(arch_param_vec)
nb_nerons, nb_layers, act_fct = arch_vec[0], arch_vec[1], arch_vec[2]
arch_str = f'N{nb_nerons}_L{nb_layers}_{act_fct}'
res_loss_sum = 0
param_loss = np.inf
# de_loss_list = []
fill_str = '-' * 50
print('\n' + fill_str +
f' {self.name}:: Averaging over training for {arch_str} ' +
fill_str)
spinner = Halo(text=f'Starting Test 0 for {arch_str}', spinner='dots')
spinner.start()
tf.keras.backend.clear_session()
spinner.text = 'Finished Clearing TF session. Training model nb 0'
for try_nb in range(self.avg_nb):
stat_str = f"Test: {try_nb + 1}/{self.avg_nb} || Trying {arch_str} with" \
f" a MSize:{self.mb_size} for {self.epochs} Epochs. "
# ---------- Initialise and train the new network ----------
net_inst = DeepNetBonanza(nb_nerons,
nb_layers,
train_dict=self.train_dict,
drop_rate=0.2,
verbose=self.verbose,
name=self.name)
train_hist = net_inst.train_net(nb_epochs=self.epochs,
mb_size=self.mb_size)
# ---------- Get and return the DE evolution loss ----------
res_loss_part, param_loss, loss_dict = self.get_de_loss(
net_inst.model, train_hist)
# ---------- Update the statistics string ----------
stat_str += ' ---> '
for loss_key in loss_dict:
stat_str += f'{loss_key} : {loss_dict[loss_key]:.4E} | '
stat_str += f'Comb DE Loss: {res_loss_part * param_loss:.4E}'
spinner.text = stat_str
# de_loss_list.append(de_loss_part)
res_loss_sum += res_loss_part
# print(stat_str)
tf.keras.backend.clear_session()
spinner.text = 'Finished Clearing TF session'
del net_inst
de_loss_avg = res_loss_sum / self.avg_nb
de_loss_avg = de_loss_avg * param_loss
spinner.stop_and_persist(symbol='та┐', text=stat_str)
del spinner
# de_loss_arr = np.array(de_loss_list)
#
# de_hist, de_bins = np.histogram(de_loss_arr, density=True, bins='auto')
# mid_bin = de_bins[:-1] + np.diff(de_bins) / 2
# hist_mean = np.average(mid_bin, weights=de_hist)
# print(f'{Fore.RED}HIST_MEAN:{Fore.GREEN}{fill_str} Arch {arch_str}'
# f' Comb DE Loss {hist_mean:.4f} {fill_str}{Style.RESET_ALL}')
log_loss = {
arch_str: [nb_nerons, nb_layers, act_fct, de_loss_avg, param_loss]
}
dat_frame = pd.DataFrame.from_dict(log_loss, orient='index')
dat_frame.to_csv(self.log_file_path, mode='a', header=False)
print(dat_frame)
del dat_frame, log_loss
print(
f'{Fore.RED}MEAN:{Fore.GREEN}{fill_str} {self.name}:: Arch {arch_str}'
f' Comb DE Loss {de_loss_avg:.4E} {fill_str}{Style.RESET_ALL}')
return de_loss_avg
sys.exit(1)
job_id = resp['job_id']
job_status_code = None
spinner = Halo(text="Waiting for job updates", spinner='dots')
spinner.start()
while True:
try:
new_job_status_code = get_job_status(job_id)
if new_job_status_code != job_status_code:
if new_job_status_code in ("UNASSIGNED", "ASSIGNED"):
spinner.info(STATUS_CODE_MESSAGES[new_job_status_code])
spinner.start("Waiting for job updates")
elif new_job_status_code == "FAILED":
spinner.fail(STATUS_CODE_MESSAGES[new_job_status_code])
spinner.start("Waiting for job updates")
else:
# the job has succeeded
spinner.stop_and_persist(
symbol='🦄'.encode('utf-8'),
text=STATUS_CODE_MESSAGES[new_job_status_code])
break
job_status_code = new_job_status_code
time.sleep(JOB_STATUS_POLL_INTERVAL_SECS)
except (KeyboardInterrupt, SystemExit):
spinner.stop()
break
class BumbleSpeech():
def __init__(self, speech_mode='voice'):
self.spinner = Halo(spinner='dots')
self.speech_modes = ['silent', 'voice']
self.speech_mode = speech_mode
self.engine = pyttsx3.init()
self.engine.setProperty('voice',
'com.apple.speech.synthesis.voice.tessa')
self.engine.setProperty('rate', 210)
self.input_queue = deque()
self.YES_TERMS = [
"yes",
"sure",
"yhup",
"yup",
"ye",
"yeah",
]
self.NO_TERMS = [
"no",
"nope",
"nah",
"nay",
]
self.CANCEL_TERMS = ["stop", "cancel", "abort"]
def change_voice(self):
'''Function to change voice of the voice engine'''
# TODO
return
def change_speech_rate(self):
'''Function to change the speaking rate'''
# TODO
return
def set_input_queue(self, input_list: list):
'''
Function to set the input queue to be used to simulate user responses
to Bumblebee. This is useful for programatically answering prompts when
a feature is being run in a routine.
Note: The input queue should have fewer or as many items as hear calls
that the feature has. This will prevent items set by one feature to be
encountered by other features which are called afterwards.
'''
self.input_queue = deque(input_list)
def set_speech_mode(self, mode: str):
'''Function to set speech mode.'''
if not isinstance(mode, (str)):
raise Exception(f'{mode} is not a string.')
mode = mode.lower()
if mode in self.speech_modes:
self.speech_mode = mode
else:
raise Exception(f'Could not find {mode} mode.')
return 0
def infinite_speaking_chances(func):
'''
Wrapper for bumblebee hear function.
This wrapper gives the user a chance to repeat
when bumblebee doesn't hear properly.
'''
def wrapper(*args, **kwargs):
input_text = ''
while input_text == '':
input_text = func(*args, **kwargs)
return input_text
return wrapper
@infinite_speaking_chances
def hear(self):
'''
Function to capture requests/questions.
'''
# If there are items in the input queue, use the queue to provide
# input to the feature which is seeking for input.
if (len(self.input_queue) > 0):
return self.input_queue.popleft()
# For silent mode.
if self.speech_mode == self.speech_modes[0]:
input_text = console.input("[white]type your response here: ")
return input_text
# For voice mode.
elif self.speech_mode == self.speech_modes[1]:
self.spinner.start(text=(Fore.RED +
"Wait for beep to start talking..."))
recognizer = sr.Recognizer()
with sr.Microphone() as source:
spoken_text = ''
# breifly adjust for ambient noise
recognizer.adjust_for_ambient_noise(source, duration=1)
playsound.playsound(bumblebee_root + 'sounds/tone-beep.wav',
True)
self.spinner.stop()
self.spinner.start(text='Listening')
audio = recognizer.listen(source)
self.spinner.stop()
try:
self.spinner.start('Recognizing')
spoken_text = recognizer.recognize_google(audio)
self.spinner.stop()
console.print('[white]You said, ' + spoken_text)
except sr.UnknownValueError:
self.spinner.stop()
self.respond('Sorry I did not hear you, please repeat.')
except sr.RequestError:
# This happens when there is no internet connection.
self.spinner.stop()
self.respond('No internet connection found.')
self.respond('Starting silent mode.')
self.set_silent_mode(True)
return spoken_text
def respond(self, output):
''' Respond to requests/questions.'''
# If we are in silent mode or the input queue is being used.
if self.speech_mode == self.speech_modes[0] or \
len(self.input_queue) > 0:
console.print("[yellow]" + output)
return
# Voice mode
elif self.speech_mode == self.speech_modes[1]:
self.spinner.start(text=(Fore.YELLOW + output))
self.engine.say(output)
self.engine.runAndWait()
self.spinner.stop_and_persist()
return
def interrupt_check(self, input_text):
'''Check for cancel command from user.'''
# TODO: use cancel terms here.
if "stop" in input_text or "cancel" in input_text:
self.respond("Okay.")
return True
def approve(self, question):
'''
Seek approval from user.
e.g. user says yes/no to confirm question.
Arguments: question i.e. the question to be approved by the user.
Returns: True if the user approves
False if the user disapproves
'''
self.respond(question)
while True:
answer = self.hear()
if self.interrupt_check(answer):
return False
if answer in self.YES_TERMS:
return True
elif answer in self.NO_TERMS:
return False
else:
self.respond("Please say yes or no.")
def ask_question(self, question):
'''
Ask the user a question and get a response from them.
Returns 0 if the answer to the question expresses desire
to cease the operation. Otherwise, return the answer to
the question.
'''
self.respond(question)
answer = self.hear()
if self.interrupt_check(answer):
return 0
return answer
def choice_prompt(self, prompt: str, choices: list, default: str):
'''
Asks the user a prompt and loops until the response is within the list
of choices.
'''
answer = Prompt.ask(prompt, choices=choices, default=default)
if self.interrupt_check(answer):
return 0
return answer
import time
from colorama import init, Fore, Back
from halo import Halo
init()
print(Back.BLUE + Fore.RED + " halo spinner example ")
spinner = Halo(text='What is taking so long..',
text_color='cyan',
color='green')
spinner.start()
time.sleep(5)
spinner.stop_and_persist(symbol='✔ '.encode('utf-8'), text='Done!')
"""Example for persisting spinner
"""
from __future__ import unicode_literals
import os
import sys
import time
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from halo import Halo
success_message = 'Loading success'
failed_message = 'Loading failed'
unicorn_message = 'Loading unicorn'
spinner = Halo(text=success_message, spinner='dots')
try:
spinner.start()
time.sleep(1)
spinner.succeed()
spinner.start(failed_message)
time.sleep(1)
spinner.fail()
spinner.start(unicorn_message)
time.sleep(1)
spinner.stop_and_persist(symbol='🦄'.encode('utf-8'),
text=unicorn_message)
except (KeyboardInterrupt, SystemExit):
spinner.stop()
from __future__ import unicode_literals
import os
import sys
import time
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from halo import Halo
success_message = 'Loading success'
failed_message = 'Loading failed'
unicorn_message = 'Loading unicorn'
spinner = Halo(text=success_message, spinner='dots')
try:
spinner.start()
time.sleep(1)
spinner.succeed()
spinner.start(failed_message)
time.sleep(1)
spinner.fail()
spinner.start(unicorn_message)
time.sleep(1)
spinner.stop_and_persist({
'symbol': '🦄 '.encode('utf-8'),
'text': unicorn_message
})
except (KeyboardInterrupt, SystemExit):
spinner.stop()
class Output:
DEFAULT_COLOR = 'white'
INFO_COLOR = 'blue'
WARNING_COLOR = 'yellow'
ERROR_COLOR = 'red'
SUCCESS_COLOR = 'green'
def __init__(self):
self.types_colors = {
'default': self.DEFAULT_COLOR,
'info': self.INFO_COLOR,
'warning': self.WARNING_COLOR,
'error': self.ERROR_COLOR,
'success': self.SUCCESS_COLOR
}
self.sp = Halo()
def start_spinner(self, message: str, color: str = None):
self.sp.text_color = color if color else self.DEFAULT_COLOR
self.sp.start(text=message)
def spinner_success(self,
message: str = None,
color: str = None,
message_color: str = None):
self.sp.text_color = color if color else self.SUCCESS_COLOR
self.sp.succeed()
if message:
self.sp.text_color = message_color if message_color else self.INFO_COLOR
self.sp.stop_and_persist(text=message)
def spinner_fail(self, message: str = None, color: str = None):
self.sp.text_color = color if color else self.ERROR_COLOR
self.sp.fail()
if message:
self.sp.stop_and_persist(text=message)
def title(self, message: str, color: str = None):
if not color:
color = self.DEFAULT_COLOR
message = '\n * {} \n{}'.format(message.upper(), '=' * 60)
cprint(message, color=color, attrs=['bold'])
def success(self, message: str):
self.write(message, 'success', '✔')
def warning(self, message: str):
self.write(message, 'warning', '⚠')
def info(self, message: str):
self.write(message, 'info', 'ℹ')
def error(self, message: str):
self.write(message, 'error', '✗')
def write(self,
message: str,
message_type: str = 'default',
symbol: str = ''):
color = self.types_colors[message_type]
if symbol:
symbol = '{} '.format(symbol)
print('')
cprint('{}{}'.format(symbol, message), color=color, attrs=['bold'])
print('')
