def fetch_cities_json():
click.echo(hue.yellow('Fetching cities json...'))
json_url = 'https://raw.githubusercontent.com/michaeltcoelho/'\
'Municipios-Brasileiros/master/municipios_brasileiros.json'
http = urllib3.PoolManager()
response = http.request('GET', json_url)
data = json.loads(response.data.decode('utf-8-sig'))
click.echo(hue.yellow('Cities json fetched...'))
return data
def output_stats(self):
print("\t| {} {}".format(green("Player:"), self.name))
print("\t|\t {} {}, {} {}".format(yellow("Gold:"), self.gold,
orange("Infamy:"), self.infamy))
for unit in self.units:
print("\t|\t {}".format(unit))
print("\t| {} {}".format(red("Opponent:"), self.opponent.name))
print("\t|\t {} {}, {} {}".format(yellow("Gold:"), self.opponent.gold,
orange("Infamy:"),
self.opponent.infamy))
for unit in self.opponent.units:
print("\t|\t {}".format(unit))
def size(path, json=False, verbose=False):
'''
check size of a given path or directory
examples: \n\n
luz disk size /tmp \n
luz disk size /home --json (print output in JSON) \n
luz disk size /home -v (print names and size of all subfolders)
'''
#click.echo('\n'+cyan('%s disk size\n' % path))
payload = get_dir_size(json, verbose, path)
if payload == 'error':
return
if json:
if True in verbose:
click.echo(color(payload, bg='black', fg='white'))
else:
try:
#payload = ast.literal_eval(json.dumps(payload))
print(payload)
click.echo(yellow(json.dump(payload['total'])))
except AttributeError as e:
click.echo(red('error generating json, %s' % str(e)))
click.echo(yellow('total (kb): ' + str(payload['total']['kb'])))
else:
if True in verbose:
for d in payload['dirs']:
try:
click.echo(color(str(d), fg='yellow') + color(' {:,} bytes'.format(payload['dirs'][d]), fg='white'))
#click.echo(white('{:,} bytes'.format(payload['dirs'][d])))
#click.echo(yellow(str(d) + ': ' + str(payload['dirs'][d]) + ' b'))
except UnicodeEncodeError as e:
click.echo(red('error displaying sub directories %s' % str(e)))
#click.echo(yellow('total (b): ' + str(payload['total']['b'])))
#click.echo(yellow('total (kb): ' + str(payload['total']['kb'])))
# click.echo(yellow('total (mb): ' + str(payload['total']['mb'])))
#click.echo(yellow('total (gb): ' + str(payload['total']['gb'])))
else:
total_b = str(payload['total']['b'])
total_kb = str(payload['total']['kb'])
total_mb = str(payload['total']['mb'])
total_gb = str(payload['total']['gb'])
click.echo(yellow("disk space: {0}").format(path))
horizontal()
click.echo(white("{0} B\n{1} KB\n{2} MB\n{3} GB\n".format(total_b, total_kb, total_mb, total_gb)))
def colorize_option(chave, valor):
'''
Based on index type format and print out menu options.
'''
if type(chave) == int:
selector = yellow(' [') + bold(red('%s')) + yellow('] ')
suffix = yellow('%s')
return selector % chave + suffix % valor
if type(chave) == str:
pos = valor.lower().find(chave)
prefix, radical, suffix = valor.partition(valor[pos])
if prefix:
prefix = red('%s')
radical = yellow('[') + bold(red('%s' % radical)) + yellow(']')
return ' %s%s%s\n' % (prefix, radical, suffix)
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = SE_ResNeXt101FT(num_classes=340, pretrained=load_pretrained)
if not args.load_only_extractor:
return model
model.load_state_dict(
torch.load(
'extensions/qd/data/experiments/se_resnext_n01z3/checkpoints/se_resnext101_n.pth'
)['state_dict'])
# Extractor
feature_extractor = model.features
# Construct
num_classes = [int(x) for x in args.num_classes.split(',')]
predictor = nn.Sequential(
nn.Dropout(args.dropout_p),
MultiHead(in_features=2048, num_classes=num_classes))
model = BaseModel(feature_extractor, predictor)
return model
def _optimize_file(path):
tinify.key = get_api_key()
with yaspin(text="Optimizing", color="cyan") as spinner:
try:
before_size = getsize(path)
source = tinify.from_file(path)
source.to_file(path)
after_size = getsize(path)
# compare
if before_size == after_size:
before = before_size
after = after_size
else:
before = huepy.blue(before_size)
after = huepy.yellow(after_size)
log_msg = "{0} {1} → {2}"
msg = log_msg.format(os.path.basename(path), before, after)
log = logger.info(msg, flag=SUCCESS)
except (ClientError, ServerError, ConnectionError):
log = logger.error(os.path.basename(path), flag=FAILURE)
finally:
spinner.write(log)
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = sys.modules[__name__].__dict__[args.arch](
num_classes=1000, pretrained='imagenet' if load_pretrained else None)
num_classes = [int(x) for x in args.num_classes.split(',')]
# Extractor
feature_extractor = nn.Sequential(model.layer0, model.layer1, model.layer2,
model.layer3, model.layer4)
# Predictor
predictor = MultiHead(in_features=model.last_linear.in_features,
num_classes=num_classes)
# if args.dropout_p > 0:
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(feature_extractor, predictor)
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained'
if load_pretrained:
print(yellow(' - Loading a net, pretrained on ImageNet1k.'))
model = resnext.__dict__[args.arch](num_classes=1000,
pretrained=load_pretrained)
# Extractor
feature_extractor = nn.Sequential(model.conv1, model.bn1, model.relu,
model.maxpool, model.layer1,
model.layer2, model.layer3,
model.layer4)
# Predictor
predictor = MultiHead(
in_features=model.fc.in_features,
num_classes=[int(x) for x in args.num_classes.split(',')])
if args.dropout_p > 0:
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(feature_extractor, predictor, args.pooling)
return model
def __str__(self):
unit_name = "Ship" if self.ship_health else "Crew"
health = self.ship_health or self.crew_health
return "{} #{} ({} {}, {} {}, {} {})".format(
unit_name, self.id, yellow("Gold:"), self.gold, cyan("Health:"),
health, lightpurple("Crew:"), self.crew
)
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = polynet(num_classes=1000,
pretrained='imagenet' if load_pretrained else None)
feature_extractor = nn.Sequential(
model.stem,
model.stage_a,
model.reduction_a,
model.stage_b,
model.reduction_b,
model.stage_c,
)
num_classes = [int(x) for x in args.num_classes.split(',')]
# Predictor
predictor = MultiHead(in_features=model.last_linear.in_features,
num_classes=num_classes)
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(feature_extractor, predictor)
return model
def iterdata(self):
"""Yield each data from the output queue."""
try:
while self.output_queue.not_empty:
data = self.output_queue.get_nowait()
yield data
except queue.Empty:
print(hue.yellow('No more data available :)'))
def process(self, data):
print(hue.bold(hue.green("\n------ {} ------".format(datetime.now()))))
print(
hue.yellow("Full packet data: ") +
hue.italic(binascii.hexlify(data)))
# Checks if the 802.15.4 packet is valid
if makeFCS(data[:-2]) != data[-2:]:
print(hue.bad("Invalid packet"))
return
# Parses 802.15.4 packet
packet = Dot15d4FCS(data)
packet.show()
if packet.fcf_frametype == 2: # ACK
return
# Tries to match received packet with a known link
# configuration
matched = False
for link in self.link_configs:
if packet.dest_panid != link.dest_panid:
continue
if packet.fcf_srcaddrmode == 3: # Long addressing mode
if packet.src_addr != link.source.get_long_address():
continue
if packet.dest_addr != link.destination.get_long_address():
continue
else:
if packet.src_addr != link.source.get_short_address():
continue
if packet.dest_addr != link.destination.get_short_address():
continue
source = link.source
destination = link.destination
key = link.key
matched = True
if not matched:
if packet.fcf_srcaddrmode == 3:
source = Rf4ceNode(packet.src_addr, None)
destination = Rf4ceNode(packet.dest_addr, None)
else:
source = Rf4ceNode(None, packet.src_addr)
destination = Rf4ceNode(None, packet.dest_addr)
key = None
# Process RF4CE payload
frame = Rf4ceFrame()
try:
rf4ce_payload = bytes(packet[3].fields["load"])
frame.parse_from_string(rf4ce_payload, source, destination, key)
except Rf4ceException, e:
print(hue.bad("Cannot parse RF4CE frame: {}".format(e)))
return
def get_climatempo_city_link(self, url, page_source):
print(hue.blue(f'Scraping Google page at {url}'))
page = BeautifulSoup(page_source, 'html.parser')
css_selector = 'a[href*=/url?q=https://www.climatempo.com.br/climatologia/]'
climatempo_link_tag = page.select_one(css_selector)
if climatempo_link_tag is None:
print(hue.yellow(f'Climatempo link not found on Google at {url}'))
return ''
climatempo_link = self.get_climatempo_link_from_tag(
climatempo_link_tag)
print(
hue.green(
f'Climatempo link {climatempo_link} scraped on google at {url}'
))
return climatempo_link
def get_net(args):
load_pretrained = args.net_init == 'pretrained'
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = MobileNetV2(pretrained=load_pretrained,
return_features=args.return_features)
model.classifier = nn.Sequential(
nn.Dropout(args.dropout_p),
nn.Linear(model.last_channel, args.num_outputs),
)
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = se_resnext50(num_classes=1000, pretrained=load_pretrained)
# if not args.load_only_extractor:
# return model
# model.load_state_dict(torch.load('extensions/qd/data/experiments/se_resnext_n01z3/checkpoints/se_resnext101_n.pth')['state_dict'])
if args.num_input_channels != 3:
# if args.num_input_channels % 3 != 0:
# assert False
conv1_ = model.conv1
model.conv1 = torch.nn.Conv2d(args.num_input_channels,
conv1_.out_channels,
kernel_size=conv1_.kernel_size,
stride=conv1_.stride,
padding=conv1_.padding,
bias=False)
for i in range(int(args.num_input_channels / 3)):
model.conv1.weight.data[:, i * 3:(i + 1) *
3] = conv1_.weight.data / (int(
args.num_input_channels / 3))
if args.num_input_channels % 3 > 0:
model.conv1.weight.data[:, -(args.num_input_channels %
3):] = conv1_.weight.data[:, -(
args.num_input_channels % 3):]
feature_extractor = nn.Sequential(model.conv1, model.bn1, model.relu,
model.maxpool, model.layer1,
model.layer2, model.layer3, model.layer4)
num_classes = [int(x) for x in args.num_classes.split(',')]
predictor = nn.Sequential(
nn.Dropout(args.dropout_p),
MultiHead(in_features=2048, num_classes=num_classes))
model = BaseModel(feature_extractor, predictor)
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained'
if load_pretrained:
print(yellow(' - Loading a net, pretrained on ImageNet1k.'))
model = linknet.LinkNet(num_input_channels=args.num_input_channels,
num_output_channels=args.num_output_channels,
depth=args.resnet_depth,
pretrained=load_pretrained)
if args.freeze_basenet:
model.freeze_basenet()
else:
model.unfreeze_basenet()
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained'
if load_pretrained:
print(yellow(' - Loading a net, pretrained on ImageNet1k.'))
model = inception_v4.InceptionV4(num_classes=1001,
pretrained=load_pretrained)
num_classes = [int(x) for x in args.num_classes.split(',')]
predictor = MultiHead(in_features=1536, num_classes=num_classes)
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(model.features, predictor, args.pooling)
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained'
if load_pretrained:
print(yellow(' - Loading a net, pretrained on ImageNet1k.'))
resnet = torchvision.models.__dict__[args.arch](
pretrained=load_pretrained)
# If an image has different number of channelss
if args.num_input_channels != 3:
if args.num_input_channels % 3 != 0:
assert False
conv1_ = resnet.conv1
resnet.conv1 = torch.nn.Conv2d(args.num_input_channels,
conv1_.out_channels,
kernel_size=conv1_.kernel_size,
stride=conv1_.stride,
padding=conv1_.padding,
bias=False)
for i in range(int(args.num_input_channels / 3)):
resnet.conv1.weight.data[:, i * 3:(i + 1) *
3] = conv1_.weight.data / 3
# Extractor
feature_extractor = nn.Sequential(resnet.conv1, resnet.bn1,
resnet.relu, resnet.maxpool,
resnet.layer1, resnet.layer2,
resnet.layer3, resnet.layer4)
# Predictor
predictor = MultiHead(
in_features=resnet.fc.in_features,
num_classes=[int(x) for x in args.num_classes.split(',')])
if args.dropout_p > 0:
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(feature_extractor, predictor)
return model
def disp_exp(options):
if all(i.startswith(('1', '2', '3', '4', '5', '6')) for i in options.exp):
options.include = options.exp
for b in get_recommendations(options):
if b[2]:
profileServer = 'Level ' + str(b[2]) + ' Server'
else:
profileServer = 'N/A'
if b[3]:
profileWorkstation = 'Level ' + str(b[3]) + ' Workstation'
else:
profileWorkstation = 'N/A'
exp = '{:<9}|{:<10}|{:<14}|{:<19}|'.format(
b[0], 'Scored' if b[1] else 'Not Scored', profileServer, profileWorkstation) + b[4]
if b[1]:
print(bold(green(exp)))
else:
print(bold(yellow(exp)))
exit()
def destruct_response(cls, response: ty.Dict[str, ty.Any]) -> VKAPIError:
"""Разбирает ответ от вк про некорректный API запрос
на части и инициализирует сам объект исключения
Args:
response: ty.Dict[str:
ty.Any]:
response: ty.Dict[str:
Returns:
"""
status_code = response["error"].pop("error_code")
description = response["error"].pop("error_msg")
request_params = response["error"].pop("request_params")
request_params = {
item["key"]: item["value"]
for item in request_params
}
pretty_exception_text = (huepy.red(f"\n[{status_code}]") +
f" {description}\n\n" +
huepy.grey("Request params:"))
for key, value in request_params.items():
key = huepy.yellow(key)
value = huepy.cyan(value)
pretty_exception_text += f"\n{key} = {value}"
# Если остались дополнительные поля
if response["error"]:
pretty_exception_text += (
"\n\n" + huepy.info("There are some extra fields:\n") +
str(response["error"]))
return cls(
pretty_exception_text=pretty_exception_text,
description=description,
status_code=status_code,
request_params=request_params,
extra_fields=response["error"],
)
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
feature_extractor = ResidualNet('ImageNet',
args.depth,
1000,
args.att_type,
pretrained=load_pretrained)
num_classes = [int(x) for x in args.num_classes.split(',')]
predictor = MultiHead(in_features=feature_extractor.fc.in_features,
num_classes=num_classes)
predictor = nn.Sequential(nn.Dropout(args.dropout_p), predictor)
feature_extractor.fc = None
model = BaseModel(feature_extractor, predictor)
return model
def get_net(args):
load_pretrained = args.net_init == 'pretrained' and args.checkpoint == ""
if load_pretrained:
print(yellow('Loading a net, pretrained on ImageNet1k.'))
model = inceptionresnetv2(num_classes=1000, pretrained='imagenet' if load_pretrained else None)
feature_extractor = nn.Sequential(
model.conv2d_1a,
model.conv2d_2a,
model.conv2d_2b,
model.maxpool_3a,
model.conv2d_3b,
model.conv2d_4a,
model.maxpool_5a,
model.mixed_5b,
model.repeat,
model.mixed_6a,
model.repeat_1,
model.mixed_7a,
model.repeat_2,
model.block8,
model.conv2d_7b,
)
num_classes = [int(x) for x in args.num_classes.split(',')]
# Predictor
predictor = MultiHead(in_features = model.last_linear.in_features, num_classes=num_classes)
predictor = nn.Sequential( nn.Dropout(args.dropout_p), predictor)
# Construct
model = BaseModel(feature_extractor, predictor)
return model
def horizontal():
''' prints a horizontal line separator '''
return (click.echo(yellow('----------------------')))
with open(file_path, 'w', newline='') as csvfile:
csvwriter = writer(csvfile, dialect='excel')
csvwriter.writerow(
['Recommendation Number', 'Message', 'Result', 'Explanation', 'Time'])
length = len(recommendations)
score = 0
passed = 0
if options.verbose:
# printing the legend for verbose output
print('Done. Here\'s the legend for the test results:')
print(bold(green('Green Text indicates tests that have PASSED')))
print(bold(red('Red Text indicates tests that have FAILED')))
if options.score == None:
print(bold(yellow('Yellow Text indicates tests that are NOT SCORED')))
print('\n\nPerforming ' + str(length) + ' tests now...\n')
else:
print('Done. Performing ' + str(length) + ' tests now...\n\n')
# progressbar format
bar_format = u'{count:03d}/{total:03d}{percentage:6.1f}%|{bar}| ' + \
bold(green('pass')) + u':{count_0:{len_total}d} ' + \
bold(red('fail')) + u':{count_1:{len_total}d} ' + \
bold(yellow('chek')) + u':{count_2:{len_total}d} ' + \
u'[{elapsed}<{eta}, {rate:.1f}{unit_pad}{unit}/s]'
passd = manager.counter(total=length,
unit='tests',
color='white',
bar_format=bar_format)
faild = passd.add_subcounter('white')
def get_net(self, args, train_dataloader, criterion):
model = self.net_wrapper.get_net(args)
model = model.to(args.device)
if args.fp16:
model = FP16Model(model)
# Load checkpoint
if args.checkpoint is not None and args.checkpoint != Path('.'):
checkpoint_path = self.get_checkpoint_path(args)
model = self.load_state(args, checkpoint_path, model)
else:
model = self.init_weights(args, model, train_dataloader)
if not args.fancy_stuff:
return model
# Some other stuff
if hasattr(model, 'feature_extractor'):
value = not args.fix_feature_extractor
set_param_grad(model.feature_extractor,
value=value,
set_eval_mode=False)
if args.freeze_bn:
print(yellow(' - Freezing BN'))
def freeze_bn(m):
if isinstance(m, torch.nn.BatchNorm2d):
m.training = False
def nop(*args, **kwargs):
pass
m.train = nop
model.apply(freeze_bn)
if args.merge_model_and_loss:
model = ModelAndLoss(model, criterion)
if args.use_all_gpus and args.device == 'cuda' and torch.cuda.device_count(
) > 1:
print(yellow(' - Using all GPU\'s!'))
model = torch.nn.DataParallel(model)
if args.bn_momentum != -1:
def freeze_bn1(m):
if isinstance(m, torch.nn.BatchNorm2d):
m.momentum = args.bn_momentum
# def nop(*args, **kwargs):
# pass
# m.train = nop
model.apply(freeze_bn1)
return model
# Process stages
if 'stages' not in vars(args):
args.stages = {'main': {}}
if args.stage is not None:
if args.stage != 'none':
args.stages = {args.stage: args.stages[args.stage]}
else:
args.stages = {'main': {}}
# Run
for stage_num, (stage_name, stage_args_) in enumerate(args.stages.items()):
print (yellow(f' - Starting stage "{stage_name}"!'))
stage_args = munchify({**vars(args), **stage_args_ })
if hasattr(model, 'module') and hasattr(model.module, 'feature_extractor'):
#stage_args.fix_feature_extractor:
set_param_grad(model.module.feature_extractor, value=not stage_args.fix_feature_extractor, set_eval_mode=False)
# set_param_grad(model.module.feature_extractor[-1], value=True, set_eval_mode=False)
optimizer = get_optimizer(stage_args, model)
scheduler = get_scheduler(stage_args, optimizer)
if args.fp16:
import apex
# Load saver
# saver = get_saver('DummySaver')
# def set_param_grad(model, value, set_eval_mode=True):
# for param in model.parameters():
# param.requires_grad = value
# if set_eval_mode:
# model.eval()
# Run
for stage_num, (stage_name,
stage_args_) in enumerate(config['stages'].items()):
print(yellow(f' - Starting stage "{stage_name}"!'))
stage_args = munchify({**stage_args_, **config['train_args']})
optimizers = train_factory.make_optimizers(stage_args, pipeline)
schedulers = train_factory.make_schedulers(stage_args, optimizers,
pipeline)
print('schedulers', schedulers.keys())
train_factory.set_trainable(stage_args, pipeline)
criterions = train_factory.make_criterions(stage_args)
print('criterions', criterions.keys())
if stage_args.parallel:
pipeline = nn.DataParallel(pipeline)
print('este script só é portado para Linux')
exit()
resultado = None
DadosArray = []
func = (lambda x: x * '-=-')
translate = Translator(service_urls = [
'translate.google.com'
])
print(yellow('''_ __
_ _ __ _ _ _| | __ / | __ __
/ ` |/ _ \ / _ \ / _` | |/ _ \ | / _ \ \/ /
| (| | () | () | (| | | _/ _| () > <
\_, |\_/ \_/ \, ||\__|| \__//\_\
|_/ |_/
# Telegram: @Foxxer_SA
# Se inscreve lá @AcervoHackerBR!!!
# GitHub: @foxx3r'''))
print(func(10))
print('\033[1;41mEvite utilizar acentos, ainda estamos trabalhando nisso!!!\033[0;0m')
sleep(1)
print(func(10))
while True:
opcao = int(input('1) detectar idioma\n2) traduzir\n3) listar linguagens\n4) ler dados de um arquivo\n5) ler um conjunto\n6) sair\n-> '))
print(func(10))
if opcao == 1:
detectar = str(input('digite algo -> '))
