def wrap_todo_name(self, underline=False):
"""wrap todo's name"""
name = self.todo.name
if name:
wrapped_name = colored(name, 'orange')
if underline:
wrapped_name += '\n' + colored(len(name) * '-', 'gray')
return wrapped_name
return None
def get_CpG_colored_string(self):
nucs = []
for nuc, meth in zip(self.seq, self.methylation):
if meth == 'z':
nucs.append(colored(' ', 'grey'))
elif meth == 'Z':
nucs.append(colored(' ', 'red'))
return ''.join(nucs)
def register_players():
players_list = []
tokens = []
taken_names = game_names
index = 1
while True:
name = input(
utils.colored(f"Jogador {index}, vai jogar? Qual seu nome? §y"))
name_lower = name.lower()
if not name_lower in taken_names:
tokens_input = input(
utils.colored(f"§0Quantas fichas você tem, {name}? §g"))
tokens_amount = 0
if tokens_input:
int_tokens = int(tokens_input)
if int_tokens > 0:
tokens_amount = int_tokens
else:
utils.print_colored(
"§0Não é possível entrar no jogo sem fichas!\n")
continue
taken_names.append(name_lower)
players_list.append(name)
tokens.append(tokens_amount)
utils.print_success(
f"{name} entrou no jogo com {tokens_amount} fichas!")
index += 1
elif name_lower in exit_names:
utils.print_colored(f"§0Fim da entrada de jogadores.")
break
else:
utils.print_colored(f"§0Não é possível usar esse nome!\n")
if players_list:
players_list.append("Banco")
tokens.append("∞")
utils.print_success(f"Banco entrou no jogo com infinitas fichas!")
else:
system.game_over()
return (players_list, tokens)
def wrap_task(self, task, index=None):
"""wrap task to colored str"""
if task.done:
state = colored('✓', 'green')
else:
state = colored('✖', "red")
content = colored(task.content, "gray")
wrapped_task = state + " " + content
if index:
wrapped_task = colored(str(index)+'.', 'gray') + ' ' + wrapped_task
return wrapped_task
def format(self, record):
message = record.getMessage()
mapping = {
'CRITICAL': 'bgred',
'ERROR': 'red',
'WARNING': 'yellow',
'SUCCESS': 'green',
'INFO': 'cyan',
'DEBUG': 'bggrey',
}
color = mapping.get(record.levelname, 'white')
level = colored('%-8s' % record.levelname, color)
time = colored(datetime.now().strftime("(%H:%M:%S)"), 'magenta')
return " ".join([level, time, message])
def show(self, serie_filter=None):
serie_filter = fix_name(serie_filter) if serie_filter else None
series = self.__get_filtered(serie_filter)
if not series:
return
longest_len = len(sorted(series.keys(), key=len)[-1])
now = datetime.date.today()
for serie in sorted(series.values(), key=attrgetter("name")):
line = []
line.append("%*s %s" % (longest_len, serie.name, serie.current))
line.append("%-24s" % colored(serie.desc["message"], serie.desc["color"]))
line.append("%s" % colored((abs(serie.desc["days"]) * ("+" if serie.desc["days"] >= 0 else "-")), serie.desc["color"]))
print(" | ".join(line))
print("%i serie%s" % (len(series), "s" if len(series) > 1 else ""))
def eligible(self, age=21, mins=200, goals=0, v=True):
col = 'green' if self.age <= age else 'red'
print '\tAge', ':', utils.colored(str(self.age), col)
if self.age > age:
return False
col = 'green' if self.sesGoals >= goals else 'red'
print '\tGoals', ':', utils.colored(str(self.sesGoals), col)
if self.sesGoals < goals:
return False
col = 'green' if self.get_stat('mins') >= mins else 'red'
print '\tMinutes', ':', utils.colored(str(self.get_stat('mins')), col)
if self.get_stat('mins') < mins:
return False
return True
def format(self, record):
message = record.getMessage()
mapping = {
'CRITICAL': 'bgred',
'ERROR': 'red',
'WARNING': 'yellow',
'SUCCESS': 'green',
'INFO': 'cyan',
'DEBUG': 'bggrey',
}
color = mapping.get(record.levelname, 'white')
level = colored('%-8s' % record.levelname, color)
time = colored(datetime.now().strftime("(%H:%M:%S)"), "magenta")
return " ".join([level, time, message])
def __get_age(self):
try:
age = re.findall('([\d]{2}) years', str(self.tag))[0]
return int(age)
except:
print '\t' + utils.colored('No age data available', 'red')
return 500
def show(self, serie_filter=None):
serie_filter = fix_name(serie_filter) if serie_filter else None
series = self.__get_filtered(serie_filter)
if not series:
return
longest_len = len(sorted(series.keys(), key=len)[-1])
now = datetime.date.today()
for serie in sorted(series.values(), key=attrgetter("name")):
line = []
line.append("%*s %s" % (longest_len, serie.name, serie.current))
line.append("%-24s" %
colored(serie.desc["message"], serie.desc["color"]))
line.append("%s" % colored(
(abs(serie.desc["days"]) *
("+" if serie.desc["days"] >= 0 else "-")),
serie.desc["color"]))
print(" | ".join(line))
print("%i serie%s" % (len(series), "s" if len(series) > 1 else ""))
def __ext_tag(self, tag, stat_name):
stats = tag
stat_class = getattr(self, stat_name + 'Class')
stat_tag = stats.find('td', stat_class)
num_val = utils.get_string(stat_tag)
try:
return int(num_val)
except:
# shown on soccerwiki as "?"
print '\t' + utils.colored('Stats not available yet', 'red')
return 0
def ask_bet_bid(input_message, player_tokens):
while True:
bet_bid_input = input(utils.colored(input_message))
if bet_bid_input:
bet_bid = int(bet_bid_input)
if bet_bid < 0 or bet_bid > player_tokens:
utils.print_colored("§0Não é possível apostar essa quantia!")
else:
return bet_bid
else:
return False
def colored_test():
print(colored('green', 'green'))
print(colored('red', 'red'))
print(colored('yellow', 'yellow'))
print(colored('blue', 'blue'))
try:
colored('test', 'black') # This should raise exception.
print('Test did not pass.')
except Exception as e:
print(f'Unknown color: {e}')
def __str__(self):
size_formatted = utils.format_size(self.get_size())
filepath = utils.colored(self.original_filepath, 'green')
size_formatted = utils.colored(f'{size_formatted}', 'blue')
return f'{filepath} {size_formatted}'
return n, page
else:
return n, api.LeaguePage(new_url)
# =========================================================================
#
# UI
#
# =========================================================================
league, nat_num, league_num = [None] * 3
try:
nat_num, nation_URL = choose_nation()
league_num, league = choose_league(nation_URL)
except:
print utils.colored('Working internet connection required', 'red')
exit(0)
league_name = league.get_name()
league_nation = league.get_nation()
table = league.get_table()
# =========================================================================
#
# LOGGING
#
# =========================================================================
time_remaining = utils.time_till_next_download(league_name, weeks_between_downloads)
if time_remaining > 0 and not new_session:
msg = "\nToo soon to download again.\n"
msg += "You should wait at least {} days more".format(time_remaining)
msg += " to get some useful new data."
sorting.add_argument('-m', '--mins', help='sort by minutes', action=minsAction)
sorting.add_argument('-a', '--age', help='sort by age', action=ageAction)
args = parser.parse_args()
for s in [args.goals, args.age, args.mins]:
sort_option = s
if sort_option is not None: break
else: sort_option = ['mins', 0]
svar, least = sort_option
show_all_leagues = args.all
user_requested_leagues = args.leagues
if len(all_leagues_data) == 0:
print utils.colored("Download some data first")
sys.exit(0)
if args.list:
print 'Data available for :'
for lg, natn in available_leagues.items():
print utils.colored('\t{}( {} )'.format(lg, natn), 'blue')
sys.exit(0)
leagues_data = utils.get_closest_names(user_requested_leagues,
all_leagues_data)
if leagues_data == [] or show_all_leagues:
if not show_all_leagues:
print '''No leagues specified (-l option).
Show data for all leagues? (yes / no)'''
def ask_bets(players_names, players_tokens):
players_names_tokens = list(zip(players_names, players_tokens))
players_bets = []
leavers = []
for player_name_tokens in players.get_real_players(players_names_tokens):
playername, tokens = player_name_tokens
player_bet = []
bet_bid = ask_bet_bid(
f"§0Quanto você aposta nesta rodada, {playername}? (Ou saia sem apostar) §g",
tokens)
if bet_bid:
player_bet.append(bet_bid)
while True:
bet_what = input(
utils.colored(
f"§0Jogador, banco ou empate. Em que você aposta {bet_bid} fichas, {playername}? §b"
))
bet_what_lower = bet_what.lower()
if bet_what_lower in ["jogador", "j"]:
player_bet.append("player")
while True:
bet_who = input(
utils.colored(
f"§0Em qual jogador você aposta {bet_bid} fichas, {playername}? §y"
))
bet_player = players.get_playername(
bet_who, players_names)
bet_leaver = players.get_playername(bet_who, leavers)
if bet_player and not bet_leaver and bet_who.lower(
) != playername.lower():
player_bet.append(bet_player)
utils.print_success(
f"{playername} apostou {bet_bid} fichas em {bet_player}!"
)
break
else:
utils.print_colored(
"§0Não é possível apostar nesse jogador!")
break
elif bet_what_lower in ["banco", "b"]:
player_bet.append("bank")
utils.print_success(
f"{playername} apostou {bet_bid} fichas no Banco!")
break
elif bet_what_lower in ["empate", "e"]:
player_bet.append("tie")
utils.print_success(
f"{playername} apostou {bet_bid} fichas por um empate no jogo!"
)
break
else:
utils.print_colored(
"§0Não é possível realizar esse tipo de aposta!")
else:
leavers.append(playername)
utils.print_info(f"{playername} saiu do jogo com {tokens} fichas!")
players_bets.append(player_bet)
# Bank bet
players_bets.append([])
# Update players, removing who didn't bet
players_names, players_tokens, players_bets = get_betting_players(
players_names, players_tokens, players_bets)
if not players.has_players(players_names):
system.game_over()
return (players_names, players_tokens, players_bets)
import requests
from queue import Queue, Empty
from threading import Thread
from collections import defaultdict
from funcx import FuncXClient
from funcx.serialize import FuncXSerializer
from utils import colored, endpoint_name
from transfer import TransferManager
from strategies import init_strategy
from predictors import init_runtime_predictor, TransferPredictor, \
ImportPredictor
logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter(colored("[SCHEDULER] %(message)s",
'yellow')))
logger.addHandler(ch)
FUNCX_API = 'https://funcx.org/api/v1'
HEARTBEAT_THRESHOLD = 75.0 # Endpoints send regular heartbeats
CLIENT_ID = 'f06739da-ad7d-40bd-887f-abb1d23bbd6f'
BLOCK_ERRORS = [ModuleNotFoundError, MemoryError]
class CentralScheduler(object):
def __init__(self,
endpoints,
strategy='round-robin',
runtime_predictor='rolling-average',
last_n=3,
train_every=1,
import os
import uuid
import time
import logging
from threading import Thread
import globus_sdk
from fair_research_login import NativeClient, JSONTokenStorage
from utils import colored, endpoint_name, MAX_CONCURRENT_TRANSFERS
logger = logging.getLogger(__name__)
ch = logging.StreamHandler()
ch.setFormatter(logging.Formatter(colored("[TRANSFER] %(message)s", 'red')))
logger.addHandler(ch)
TOKEN_LOC = os.path.expanduser('~/.funcx/credentials/scheduler_tokens.json')
CLIENT_ID = 'f06739da-ad7d-40bd-887f-abb1d23bbd6f'
class TransferManager(object):
# TODO: move TransferPredictor into this class and update prediction model
# every time a tranfer finishes
def __init__(self, endpoints, sync_level='exists', log_level='INFO'):
transfer_scope = 'urn:globus:auth:scope:transfer.api.globus.org:all'
native_client = NativeClient(client_id=CLIENT_ID,
app_name="FuncX Continuum Scheduler",
token_storage=JSONTokenStorage(TOKEN_LOC))
