identifier
stringlengths 0
89
| parameters
stringlengths 0
399
| return_statement
stringlengths 0
982
⌀ | docstring
stringlengths 10
3.04k
| docstring_summary
stringlengths 0
3.04k
| function
stringlengths 13
25.8k
| function_tokens
sequence | start_point
sequence | end_point
sequence | argument_list
null | language
stringclasses 3
values | docstring_language
stringclasses 4
values | docstring_language_predictions
stringclasses 4
values | is_langid_reliable
stringclasses 2
values | is_langid_extra_reliable
bool 1
class | type
stringclasses 9
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Usu.__init__ | (self,
nome, sobrenome, idade, sexo, escolaridade, origem
) | Inicializando os atributos do método. | Inicializando os atributos do método. | def __init__(self,
nome, sobrenome, idade, sexo, escolaridade, origem
):
"""Inicializando os atributos do método."""
self.nome = nome
self.sobrenome = sobrenome
self.idade = idade
self.sexo = sexo
self.escolaridade = escolaridade
self.origem = origem
self.login_tentativas = 0 | [
"def",
"__init__",
"(",
"self",
",",
"nome",
",",
"sobrenome",
",",
"idade",
",",
"sexo",
",",
"escolaridade",
",",
"origem",
")",
":",
"self",
".",
"nome",
"=",
"nome",
"self",
".",
"sobrenome",
"=",
"sobrenome",
"self",
".",
"idade",
"=",
"idade",
"self",
".",
"sexo",
"=",
"sexo",
"self",
".",
"escolaridade",
"=",
"escolaridade",
"self",
".",
"origem",
"=",
"origem",
"self",
".",
"login_tentativas",
"=",
"0"
] | [
4,
4
] | [
14,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BaseDoc._only_digits | (self, doc: str = '') | return "".join([x for x in doc if x.isdigit()]) | Remove os outros caracteres que não sejam dígitos. | Remove os outros caracteres que não sejam dígitos. | def _only_digits(self, doc: str = '') -> str:
"""Remove os outros caracteres que não sejam dígitos."""
return "".join([x for x in doc if x.isdigit()]) | [
"def",
"_only_digits",
"(",
"self",
",",
"doc",
":",
"str",
"=",
"''",
")",
"->",
"str",
":",
"return",
"\"\"",
".",
"join",
"(",
"[",
"x",
"for",
"x",
"in",
"doc",
"if",
"x",
".",
"isdigit",
"(",
")",
"]",
")"
] | [
44,
4
] | [
46,
55
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
GameStats.reset_stats | (self) | Inicializa os dados estatísticos que podem mudar durante o jogo | Inicializa os dados estatísticos que podem mudar durante o jogo | def reset_stats(self):
"""Inicializa os dados estatísticos que podem mudar durante o jogo"""
self.ships_left = self.ai_settings.ship_limit
self.score = 0
self.level = 1 | [
"def",
"reset_stats",
"(",
"self",
")",
":",
"self",
".",
"ships_left",
"=",
"self",
".",
"ai_settings",
".",
"ship_limit",
"self",
".",
"score",
"=",
"0",
"self",
".",
"level",
"=",
"1"
] | [
19,
4
] | [
23,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Basics.configure_basics_in_routers | (self) | Adiciona os itens bascicos de basics.ios em cada roteador. | Adiciona os itens bascicos de basics.ios em cada roteador. | def configure_basics_in_routers(self):
"""Adiciona os itens bascicos de basics.ios em cada roteador."""
basics_script = Basics.get_script_file()
# Alteracao do nome e senha do router no script
basics_script = Basics.replace_vars(itter_list=basics_script, pattern='{%hostname%}', replace=self.router.nome)
basics_script = Basics.replace_vars(itter_list=basics_script, pattern='{%password%}', replace=Basics.get_default_password())
_path = f'router-config/cisco/{self.router.nome}.ios'
router_configfile = open(_path, 'w')
# Gravacao dos dados nos arquivos de cada router em cisco/
try:
for line in basics_script:
router_configfile.write(line)
return f'BASICS: Arquivo de configuracao de {self.router.nome} criado com sucesso em {_path}.'
except: f'BASICS: Erro na configuracao do arquivo de {self.router.nome} em {_path}!'
router_configfile.close() | [
"def",
"configure_basics_in_routers",
"(",
"self",
")",
":",
"basics_script",
"=",
"Basics",
".",
"get_script_file",
"(",
")",
"# Alteracao do nome e senha do router no script",
"basics_script",
"=",
"Basics",
".",
"replace_vars",
"(",
"itter_list",
"=",
"basics_script",
",",
"pattern",
"=",
"'{%hostname%}'",
",",
"replace",
"=",
"self",
".",
"router",
".",
"nome",
")",
"basics_script",
"=",
"Basics",
".",
"replace_vars",
"(",
"itter_list",
"=",
"basics_script",
",",
"pattern",
"=",
"'{%password%}'",
",",
"replace",
"=",
"Basics",
".",
"get_default_password",
"(",
")",
")",
"_path",
"=",
"f'router-config/cisco/{self.router.nome}.ios'",
"router_configfile",
"=",
"open",
"(",
"_path",
",",
"'w'",
")",
"# Gravacao dos dados nos arquivos de cada router em cisco/",
"try",
":",
"for",
"line",
"in",
"basics_script",
":",
"router_configfile",
".",
"write",
"(",
"line",
")",
"return",
"f'BASICS: Arquivo de configuracao de {self.router.nome} criado com sucesso em {_path}.'",
"except",
":",
"f'BASICS: Erro na configuracao do arquivo de {self.router.nome} em {_path}!'",
"router_configfile",
".",
"close",
"(",
")"
] | [
57,
4
] | [
79,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
unlex | (ctx, *, extension: str) | Descarrega uma extensão. | Descarrega uma extensão. | async def unlex(ctx, *, extension: str):
"""Descarrega uma extensão."""
try:
client.unload_extension(f"ext.{extension}")
except commands.ExtensionNotLoaded as ex:
await ctx.reply(f"A extensão `{ex.name}` não foi carregada ou não existe.")
return
await ctx.reply("Extensão descarregada :+1:")
| [
"async",
"def",
"unlex",
"(",
"ctx",
",",
"*",
",",
"extension",
":",
"str",
")",
":",
"try",
":",
"client",
".",
"unload_extension",
"(",
"f\"ext.{extension}\"",
")",
"except",
"commands",
".",
"ExtensionNotLoaded",
"as",
"ex",
":",
"await",
"ctx",
".",
"reply",
"(",
"f\"A extensão `{ex.name}` não foi carregada ou não existe.\")\r",
"",
"return",
"await",
"ctx",
".",
"reply",
"(",
"\"Extensão descarregada :+1:\")",
"\r"
] | [
433,
0
] | [
441,
50
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
check_events | (ai_settings, screen, stats, sb, play_button, ship, aliens, bullets) | Responde eventos de teclado e de mouse | Responde eventos de teclado e de mouse | def check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets):
"""Responde eventos de teclado e de mouse"""
for event in pygame.event.get():
# Jogador apertar o x de sair
if event.type == pygame.QUIT:
sys.exit()
# Jogador apertar a seta direita
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, ai_settings, screen, stats, sb, ship, aliens, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, ship) | [
"def",
"check_events",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"play_button",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"for",
"event",
"in",
"pygame",
".",
"event",
".",
"get",
"(",
")",
":",
"# Jogador apertar o x de sair",
"if",
"event",
".",
"type",
"==",
"pygame",
".",
"QUIT",
":",
"sys",
".",
"exit",
"(",
")",
"# Jogador apertar a seta direita",
"elif",
"event",
".",
"type",
"==",
"pygame",
".",
"KEYDOWN",
":",
"check_keydown_events",
"(",
"event",
",",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
"elif",
"event",
".",
"type",
"==",
"pygame",
".",
"KEYUP",
":",
"check_keyup_events",
"(",
"event",
",",
"ship",
")"
] | [
58,
0
] | [
68,
43
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
rejection_sampling | (X, e, bn, N) | return ProbDist(X, counts) | Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn, usando N amostras. [Figura 14.14]
Gera um ZeroDivisionError se todas as N amostras são rejeitadas,
I.e., inconsistente com e. | Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn, usando N amostras. [Figura 14.14]
Gera um ZeroDivisionError se todas as N amostras são rejeitadas,
I.e., inconsistente com e. | def rejection_sampling(X, e, bn, N):
"""Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn, usando N amostras. [Figura 14.14]
Gera um ZeroDivisionError se todas as N amostras são rejeitadas,
I.e., inconsistente com e."""
counts = {x: 0 for x in bn.variable_values(X)}
for j in range(N):
sample = prior_sample(bn)
if consistent_with(sample, e):
counts[sample[X]] += 1
return ProbDist(X, counts) | [
"def",
"rejection_sampling",
"(",
"X",
",",
"e",
",",
"bn",
",",
"N",
")",
":",
"counts",
"=",
"{",
"x",
":",
"0",
"for",
"x",
"in",
"bn",
".",
"variable_values",
"(",
"X",
")",
"}",
"for",
"j",
"in",
"range",
"(",
"N",
")",
":",
"sample",
"=",
"prior_sample",
"(",
"bn",
")",
"if",
"consistent_with",
"(",
"sample",
",",
"e",
")",
":",
"counts",
"[",
"sample",
"[",
"X",
"]",
"]",
"+=",
"1",
"return",
"ProbDist",
"(",
"X",
",",
"counts",
")"
] | [
432,
0
] | [
442,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
register_documents_renditions | (**kwargs) | Registra as manifestações de documentos processados na base de dados
do OPAC | Registra as manifestações de documentos processados na base de dados
do OPAC | def register_documents_renditions(**kwargs):
"""Registra as manifestações de documentos processados na base de dados
do OPAC"""
mongo_connect()
tasks = kwargs["ti"].xcom_pull(key="tasks", task_ids="read_changes_task")
renditions_to_get = itertools.chain(
Variable.get("orphan_renditions", default_var=[], deserialize_json=True),
(get_id(task["id"]) for task in filter_changes(tasks, "renditions", "get")),
)
orphans = try_register_documents_renditions(
renditions_to_get, fetch_documents_renditions, ArticleRenditionFactory
)
Variable.set("orphan_renditions", orphans, serialize_json=True) | [
"def",
"register_documents_renditions",
"(",
"*",
"*",
"kwargs",
")",
":",
"mongo_connect",
"(",
")",
"tasks",
"=",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_pull",
"(",
"key",
"=",
"\"tasks\"",
",",
"task_ids",
"=",
"\"read_changes_task\"",
")",
"renditions_to_get",
"=",
"itertools",
".",
"chain",
"(",
"Variable",
".",
"get",
"(",
"\"orphan_renditions\"",
",",
"default_var",
"=",
"[",
"]",
",",
"deserialize_json",
"=",
"True",
")",
",",
"(",
"get_id",
"(",
"task",
"[",
"\"id\"",
"]",
")",
"for",
"task",
"in",
"filter_changes",
"(",
"tasks",
",",
"\"renditions\"",
",",
"\"get\"",
")",
")",
",",
")",
"orphans",
"=",
"try_register_documents_renditions",
"(",
"renditions_to_get",
",",
"fetch_documents_renditions",
",",
"ArticleRenditionFactory",
")",
"Variable",
".",
"set",
"(",
"\"orphan_renditions\"",
",",
"orphans",
",",
"serialize_json",
"=",
"True",
")"
] | [
628,
0
] | [
645,
67
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
extstatus | (ctx) | Vê o status de todas as extensões do bot. | Vê o status de todas as extensões do bot. | async def extstatus(ctx):
"""Vê o status de todas as extensões do bot."""
schemes = []
for ext in get_all_extensions():
possible_extension = client.extensions.get(ext)
extension_status = "Carregado" if possible_extension is not None else "Descarregado"
schemes.append(f"`{ext}` - {extension_status}")
await ctx.reply("\n".join(schemes)) | [
"async",
"def",
"extstatus",
"(",
"ctx",
")",
":",
"schemes",
"=",
"[",
"]",
"for",
"ext",
"in",
"get_all_extensions",
"(",
")",
":",
"possible_extension",
"=",
"client",
".",
"extensions",
".",
"get",
"(",
"ext",
")",
"extension_status",
"=",
"\"Carregado\"",
"if",
"possible_extension",
"is",
"not",
"None",
"else",
"\"Descarregado\"",
"schemes",
".",
"append",
"(",
"f\"`{ext}` - {extension_status}\"",
")",
"await",
"ctx",
".",
"reply",
"(",
"\"\\n\"",
".",
"join",
"(",
"schemes",
")",
")"
] | [
456,
0
] | [
464,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
extract_all_data | (list_documents_pids: List[str]) | Extrai documentos XML a partir de uma lista de PIDS
de entrada | Extrai documentos XML a partir de uma lista de PIDS
de entrada | def extract_all_data(list_documents_pids: List[str]):
"""Extrai documentos XML a partir de uma lista de PIDS
de entrada"""
pids_to_extract, pids_extracteds, stage_path = files.fetch_stages_info(
list_documents_pids, __name__
)
jobs = [{"pid": pid, "stage_path": stage_path} for pid in pids_to_extract]
with tqdm(total=len(list_documents_pids)) as pbar:
def update_bar(pbar=pbar):
pbar.update(1)
DoJobsConcurrently(
get_and_write,
jobs=jobs,
max_workers=config.get("THREADPOOL_MAX_WORKERS"),
update_bar=update_bar,
) | [
"def",
"extract_all_data",
"(",
"list_documents_pids",
":",
"List",
"[",
"str",
"]",
")",
":",
"pids_to_extract",
",",
"pids_extracteds",
",",
"stage_path",
"=",
"files",
".",
"fetch_stages_info",
"(",
"list_documents_pids",
",",
"__name__",
")",
"jobs",
"=",
"[",
"{",
"\"pid\"",
":",
"pid",
",",
"\"stage_path\"",
":",
"stage_path",
"}",
"for",
"pid",
"in",
"pids_to_extract",
"]",
"with",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"list_documents_pids",
")",
")",
"as",
"pbar",
":",
"def",
"update_bar",
"(",
"pbar",
"=",
"pbar",
")",
":",
"pbar",
".",
"update",
"(",
"1",
")",
"DoJobsConcurrently",
"(",
"get_and_write",
",",
"jobs",
"=",
"jobs",
",",
"max_workers",
"=",
"config",
".",
"get",
"(",
"\"THREADPOOL_MAX_WORKERS\"",
")",
",",
"update_bar",
"=",
"update_bar",
",",
")"
] | [
46,
0
] | [
66,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
check_bullet_alien_collisions | (ai_settings, screen, stats, sb, ship, aliens, bullets) | Responde a colisões entre projéteis e alienigenas. | Responde a colisões entre projéteis e alienigenas. | def check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Responde a colisões entre projéteis e alienigenas."""
# Remove qualquer projétil e alienigena que tenham colidido
collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
if collisions:
for aliens in collisions.values():
stats.score += ai_settings.alien_points * len(aliens)
sb.prep_score()
check_high_score(stats, sb)
if len(aliens) == 0:
# Destroi os projéteis existentes, aumenta a velocidade do jogo, cria uma nova frota e aumenta o nivel.
bullets.empty()
ai_settings.increase_speed()
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()
# Toca o som de troca de fase
# Toca o som de explosão da nave
next_level = pygame.mixer.Sound('Sounds/ufo_lowpitch.wav')
pygame.mixer.Sound.set_volume(next_level, 0.3)
next_level.play()
# Aumenta o nivel
stats.level += 1
sb.prep_level() | [
"def",
"check_bullet_alien_collisions",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"# Remove qualquer projétil e alienigena que tenham colidido",
"collisions",
"=",
"pygame",
".",
"sprite",
".",
"groupcollide",
"(",
"bullets",
",",
"aliens",
",",
"True",
",",
"True",
")",
"if",
"collisions",
":",
"for",
"aliens",
"in",
"collisions",
".",
"values",
"(",
")",
":",
"stats",
".",
"score",
"+=",
"ai_settings",
".",
"alien_points",
"*",
"len",
"(",
"aliens",
")",
"sb",
".",
"prep_score",
"(",
")",
"check_high_score",
"(",
"stats",
",",
"sb",
")",
"if",
"len",
"(",
"aliens",
")",
"==",
"0",
":",
"# Destroi os projéteis existentes, aumenta a velocidade do jogo, cria uma nova frota e aumenta o nivel.",
"bullets",
".",
"empty",
"(",
")",
"ai_settings",
".",
"increase_speed",
"(",
")",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
"ship",
".",
"center_ship",
"(",
")",
"# Toca o som de troca de fase",
"# Toca o som de explosão da nave",
"next_level",
"=",
"pygame",
".",
"mixer",
".",
"Sound",
"(",
"'Sounds/ufo_lowpitch.wav'",
")",
"pygame",
".",
"mixer",
".",
"Sound",
".",
"set_volume",
"(",
"next_level",
",",
"0.3",
")",
"next_level",
".",
"play",
"(",
")",
"# Aumenta o nivel",
"stats",
".",
"level",
"+=",
"1",
"sb",
".",
"prep_level",
"(",
")"
] | [
162,
0
] | [
188,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Netpoint.clean | (self) | Validação de Patchpanel - Descomente os trechos abaixo para forçar o cadastro obrigatório de patchpanel e portas | Validação de Patchpanel - Descomente os trechos abaixo para forçar o cadastro obrigatório de patchpanel e portas | def clean(self):
t = self.pointtype
r = self.phone
# d = self.dist
# b = self.bloco
# p = self.par
# dg = self.dg
l = self.place
s = self.switch
ps = self.swport
pp = self.patchpanel
ppp = self.patchpanelport
rck = self.rack
points = Netpoint.objects.filter(phone=self.phone).exclude(pk=self.id)
if t == 'voz' or t == 'voip':
if points and self.phone != None:
raise ValidationError("Já existe um ponto de rede relacionado a este ramal")
if rck == None:
raise ValidationError("Ponto deve estar ligado a um rack")
""" Validação de Patchpanel - Descomente os trechos abaixo para forçar o cadastro obrigatório de patchpanel e portas """
# if pp == None:
# raise ValidationError("Ponto deve estar ligado a um patchpanel")
# if ppp == None:
# raise ValidationError("Ponto deve estar ligado a uma porta de patchpanel")
if t == 'desativado':
if l == None:
raise ValidationError("Preencha o local do ponto")
if r != None:
raise ValidationError("Pontos desativados não possuem ramal associado")
if s != None:
raise ValidationError("Pontos desativados não devem ter um switch associado.")
if ps != None:
raise ValidationError("Pontos desativados não devem ter uma porta de switch associada.")
if t == 'dados':
if r != None:
raise ValidationError("Ponto do tipo dados não possui ramal")
# if d != None:
# raise ValidationError("Ponto do tipo dados não possui campo dist")
# if b != None:
# raise ValidationError("Ponto do tipo dados não possui campo bloco")
# if p != None:
# raise ValidationError("Ponto do tipo dados não possui campo par")
# if dg != None:
# raise ValidationError("Ponto do tipo dados não possui campo dg")
""" Validação de Switch - Descomente os trechos abaixo para forçar o cadastro obrigatório de switch e porta de switch """
# if s == None:
# raise ValidationError("Pontos de dados devem ter um switch associado.")
# if ps == None:
# raise ValidationError("Pontos de dados devem ter uma porta de switch associada.")
if s != None:
if ps == None:
raise ValidationError("Porta de switch deve ser preenchida")
if ps.switch != s:
raise ValidationError("Esta porta de switch não pertence ao switch selecionado")
ponto = Netpoint.objects.filter(switch=s, swport=ps).exclude(pk=self.id)
if ponto:
raise ValidationError("A porta de switch selecionada já está ligada a outro ponto de rede")
# Checar e testar melhor verificaçoes abaixo
# if s != None:
# switchrack = self.switch.rack
# switchporta = self.swport.switch
# patchrack = self.patchpanelport.patchpanel.rack
# if switchrack != None:
# if patchrack != switchrack:
# raise ValidationError("Patchpanel da porta selecionada não está localizado no mesmo rack do switch.")
# if s != switchporta:
# raise ValidationError("Porta de switch cadastrada não está localizada no switch selecionado anteriormente.")
if t == 'voz':
if r == None:
raise ValidationError("Pontos de voz ativos devem ter um ramal associado.")
if s != None:
raise ValidationError("Pontos de voz não são ligados a switches.")
localramal = self.phone.place
if l != localramal:
raise ValidationError("Ramal selecionado não está localizado no mesmo local do ponto de rede.")
if t == 'voip':
# if d != None:
# raise ValidationError("Ponto do tipo VoIP não possui campo dist")
# if b != None:
# raise ValidationError("Ponto do tipo VoIP não possui campo bloco")
# if p != None:
# raise ValidationError("Ponto do tipo VoIP não possui campo par")
# if dg != None:
# raise ValidationError("Ponto do tipo VoIP não possui campo dg")
if r == None:
raise ValidationError("Pontos do tipo VoIP devem ter um ramal associado.")
if s == None:
raise ValidationError("Pontos do tipo VoIP devem ter um switch associado.")
if s != None:
switchrack = self.switch.rack
switchporta = self.swport.switch
patchrack = self.patchpanelport.patchpanel.rack
if switchrack != None:
if patchrack != switchrack:
raise ValidationError(
"Porta do patchpanel selecionada não está localizada no mesmo rack do switch.")
if s != switchporta:
raise ValidationError(
"Porta de switch cadastrada não está localizada no switch selecionado anteriormente.")
# pp -> patchpanel
if pp != None:
ponto = Netpoint.objects.all().filter(num=self.num, patchpanel=pp).exclude(pk=self.id)
if ponto:
raise ValidationError("Já exite um ponto de rede com este número cadastrado neste patchpanel.")
if l != None:
ponto = Netpoint.objects.all().filter(num=self.num, place=self.place).exclude(pk=self.id)
if ponto:
raise ValidationError("Já existe um ponto de rede com este número neste local.") | [
"def",
"clean",
"(",
"self",
")",
":",
"t",
"=",
"self",
".",
"pointtype",
"r",
"=",
"self",
".",
"phone",
"# d = self.dist",
"# b = self.bloco",
"# p = self.par",
"# dg = self.dg",
"l",
"=",
"self",
".",
"place",
"s",
"=",
"self",
".",
"switch",
"ps",
"=",
"self",
".",
"swport",
"pp",
"=",
"self",
".",
"patchpanel",
"ppp",
"=",
"self",
".",
"patchpanelport",
"rck",
"=",
"self",
".",
"rack",
"points",
"=",
"Netpoint",
".",
"objects",
".",
"filter",
"(",
"phone",
"=",
"self",
".",
"phone",
")",
".",
"exclude",
"(",
"pk",
"=",
"self",
".",
"id",
")",
"if",
"t",
"==",
"'voz'",
"or",
"t",
"==",
"'voip'",
":",
"if",
"points",
"and",
"self",
".",
"phone",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Já existe um ponto de rede relacionado a este ramal\")",
"",
"if",
"rck",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Ponto deve estar ligado a um rack\"",
")",
"# if pp == None:",
"# raise ValidationError(\"Ponto deve estar ligado a um patchpanel\")",
"# if ppp == None:",
"# raise ValidationError(\"Ponto deve estar ligado a uma porta de patchpanel\")",
"if",
"t",
"==",
"'desativado'",
":",
"if",
"l",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Preencha o local do ponto\"",
")",
"if",
"r",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos desativados não possuem ramal associado\")",
"",
"if",
"s",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos desativados não devem ter um switch associado.\")",
"",
"if",
"ps",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos desativados não devem ter uma porta de switch associada.\")",
"",
"if",
"t",
"==",
"'dados'",
":",
"if",
"r",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Ponto do tipo dados não possui ramal\")",
"",
"# if d != None:",
"# raise ValidationError(\"Ponto do tipo dados não possui campo dist\")",
"# if b != None:",
"# raise ValidationError(\"Ponto do tipo dados não possui campo bloco\")",
"# if p != None:",
"# raise ValidationError(\"Ponto do tipo dados não possui campo par\")",
"# if dg != None:",
"# raise ValidationError(\"Ponto do tipo dados não possui campo dg\")",
"\"\"\" Validação de Switch - Descomente os trechos abaixo para forçar o cadastro obrigatório de switch e porta de switch \"\"\"",
"# if s == None:",
"# raise ValidationError(\"Pontos de dados devem ter um switch associado.\")",
"# if ps == None:",
"# raise ValidationError(\"Pontos de dados devem ter uma porta de switch associada.\")",
"if",
"s",
"!=",
"None",
":",
"if",
"ps",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Porta de switch deve ser preenchida\"",
")",
"if",
"ps",
".",
"switch",
"!=",
"s",
":",
"raise",
"ValidationError",
"(",
"\"Esta porta de switch não pertence ao switch selecionado\")",
"",
"ponto",
"=",
"Netpoint",
".",
"objects",
".",
"filter",
"(",
"switch",
"=",
"s",
",",
"swport",
"=",
"ps",
")",
".",
"exclude",
"(",
"pk",
"=",
"self",
".",
"id",
")",
"if",
"ponto",
":",
"raise",
"ValidationError",
"(",
"\"A porta de switch selecionada já está ligada a outro ponto de rede\")",
"",
"# Checar e testar melhor verificaçoes abaixo",
"# if s != None:",
"# switchrack = self.switch.rack",
"# switchporta = self.swport.switch",
"# patchrack = self.patchpanelport.patchpanel.rack",
"# if switchrack != None:",
"# if patchrack != switchrack:",
"# raise ValidationError(\"Patchpanel da porta selecionada não está localizado no mesmo rack do switch.\")",
"# if s != switchporta:",
"# raise ValidationError(\"Porta de switch cadastrada não está localizada no switch selecionado anteriormente.\")",
"if",
"t",
"==",
"'voz'",
":",
"if",
"r",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos de voz ativos devem ter um ramal associado.\"",
")",
"if",
"s",
"!=",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos de voz não são ligados a switches.\")",
"",
"localramal",
"=",
"self",
".",
"phone",
".",
"place",
"if",
"l",
"!=",
"localramal",
":",
"raise",
"ValidationError",
"(",
"\"Ramal selecionado não está localizado no mesmo local do ponto de rede.\")",
"",
"if",
"t",
"==",
"'voip'",
":",
"# if d != None:",
"# raise ValidationError(\"Ponto do tipo VoIP não possui campo dist\")",
"# if b != None:",
"# raise ValidationError(\"Ponto do tipo VoIP não possui campo bloco\")",
"# if p != None:",
"# raise ValidationError(\"Ponto do tipo VoIP não possui campo par\")",
"# if dg != None:",
"# raise ValidationError(\"Ponto do tipo VoIP não possui campo dg\")",
"if",
"r",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos do tipo VoIP devem ter um ramal associado.\"",
")",
"if",
"s",
"==",
"None",
":",
"raise",
"ValidationError",
"(",
"\"Pontos do tipo VoIP devem ter um switch associado.\"",
")",
"if",
"s",
"!=",
"None",
":",
"switchrack",
"=",
"self",
".",
"switch",
".",
"rack",
"switchporta",
"=",
"self",
".",
"swport",
".",
"switch",
"patchrack",
"=",
"self",
".",
"patchpanelport",
".",
"patchpanel",
".",
"rack",
"if",
"switchrack",
"!=",
"None",
":",
"if",
"patchrack",
"!=",
"switchrack",
":",
"raise",
"ValidationError",
"(",
"\"Porta do patchpanel selecionada não está localizada no mesmo rack do switch.\")",
"",
"if",
"s",
"!=",
"switchporta",
":",
"raise",
"ValidationError",
"(",
"\"Porta de switch cadastrada não está localizada no switch selecionado anteriormente.\")",
"",
"# pp -> patchpanel",
"if",
"pp",
"!=",
"None",
":",
"ponto",
"=",
"Netpoint",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"num",
"=",
"self",
".",
"num",
",",
"patchpanel",
"=",
"pp",
")",
".",
"exclude",
"(",
"pk",
"=",
"self",
".",
"id",
")",
"if",
"ponto",
":",
"raise",
"ValidationError",
"(",
"\"Já exite um ponto de rede com este número cadastrado neste patchpanel.\")",
"",
"if",
"l",
"!=",
"None",
":",
"ponto",
"=",
"Netpoint",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"num",
"=",
"self",
".",
"num",
",",
"place",
"=",
"self",
".",
"place",
")",
".",
"exclude",
"(",
"pk",
"=",
"self",
".",
"id",
")",
"if",
"ponto",
":",
"raise",
"ValidationError",
"(",
"\"Já existe um ponto de rede com este número neste local.\")",
""
] | [
1167,
4
] | [
1312,
98
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
printC | (cor, texto) | Imprime de uma cor | Imprime de uma cor | def printC(cor, texto):
''' Imprime de uma cor '''
corDict = Color.__dict__
color = ''
codProc = '\x1b'
cor_default = ''
# precisa dividir
#if cor.count('[') == 1:
# color = list(corDict.keys())[list(corDict.values()).index(cor)]
#else:
corDividida = cor.split(codProc)
corDividida.pop(0)
#corDividida[0] = codProc + corDividida[0]
#corDividida[1] = codProc + corDividida[1]
for i in range(len(corDividida)):
corDividida[i] = codProc + corDividida[i]
color = list(corDict.keys())[list(corDict.values()).index(corDividida[i])]
if color[0] == "F":
cor_default = cor_default + Color.F_Default
else:
cor_default = cor_default + Color.B_Default
print (cor + texto + cor_default) | [
"def",
"printC",
"(",
"cor",
",",
"texto",
")",
":",
"corDict",
"=",
"Color",
".",
"__dict__",
"color",
"=",
"''",
"codProc",
"=",
"'\\x1b'",
"cor_default",
"=",
"''",
"# precisa dividir",
"#if cor.count('[') == 1:",
"# color = list(corDict.keys())[list(corDict.values()).index(cor)]",
"#else: ",
"corDividida",
"=",
"cor",
".",
"split",
"(",
"codProc",
")",
"corDividida",
".",
"pop",
"(",
"0",
")",
"#corDividida[0] = codProc + corDividida[0]",
"#corDividida[1] = codProc + corDividida[1]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"corDividida",
")",
")",
":",
"corDividida",
"[",
"i",
"]",
"=",
"codProc",
"+",
"corDividida",
"[",
"i",
"]",
"color",
"=",
"list",
"(",
"corDict",
".",
"keys",
"(",
")",
")",
"[",
"list",
"(",
"corDict",
".",
"values",
"(",
")",
")",
".",
"index",
"(",
"corDividida",
"[",
"i",
"]",
")",
"]",
"if",
"color",
"[",
"0",
"]",
"==",
"\"F\"",
":",
"cor_default",
"=",
"cor_default",
"+",
"Color",
".",
"F_Default",
"else",
":",
"cor_default",
"=",
"cor_default",
"+",
"Color",
".",
"B_Default",
"print",
"(",
"cor",
"+",
"texto",
"+",
"cor_default",
")"
] | [
204,
0
] | [
226,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
likelihood_weighting | (X, e, bn, N) | return ProbDist(X, W) | Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn. | Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn. | def likelihood_weighting(X, e, bn, N):
"""Estimar a distribuição de probabilidade da variável X dada
Evidência e em BayesNet bn."""
W = {x: 0 for x in bn.variable_values(X)}
for j in range(N):
sample, weight = weighted_sample(bn, e)
W[sample[X]] += weight
return ProbDist(X, W) | [
"def",
"likelihood_weighting",
"(",
"X",
",",
"e",
",",
"bn",
",",
"N",
")",
":",
"W",
"=",
"{",
"x",
":",
"0",
"for",
"x",
"in",
"bn",
".",
"variable_values",
"(",
"X",
")",
"}",
"for",
"j",
"in",
"range",
"(",
"N",
")",
":",
"sample",
",",
"weight",
"=",
"weighted_sample",
"(",
"bn",
",",
"e",
")",
"W",
"[",
"sample",
"[",
"X",
"]",
"]",
"+=",
"weight",
"return",
"ProbDist",
"(",
"X",
",",
"W",
")"
] | [
453,
0
] | [
460,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Geladeira.mostrar_comidas | (self, comida=None) | Imprime uma Comida em específico e sua quantidade, ou todos os alimentos na geladeira. | Imprime uma Comida em específico e sua quantidade, ou todos os alimentos na geladeira. | def mostrar_comidas(self, comida=None):
"""Imprime uma Comida em específico e sua quantidade, ou todos os alimentos na geladeira."""
if not comida:
print(self)
else:
f = self.alimentos[comida.nome]
print(f'{f[1]}x {f[0]}') | [
"def",
"mostrar_comidas",
"(",
"self",
",",
"comida",
"=",
"None",
")",
":",
"if",
"not",
"comida",
":",
"print",
"(",
"self",
")",
"else",
":",
"f",
"=",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]",
"print",
"(",
"f'{f[1]}x {f[0]}'",
")"
] | [
46,
4
] | [
52,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Certidao.validate | (self, doc: str = '') | return False | Método para validar a Certidão de Nascimento/Casamento/Óbito. | Método para validar a Certidão de Nascimento/Casamento/Óbito. | def validate(self, doc: str = '') -> bool:
"""Método para validar a Certidão de Nascimento/Casamento/Óbito."""
if not self._validate_input(doc, ['.', '-']):
return False
doc = self._only_digits(doc)
if len(doc) != 32:
return False
num = list(doc[:-2])
dv = doc[-2:]
expected_dv = self._generate_verifying_digit(num)
if dv == expected_dv:
return True
return False | [
"def",
"validate",
"(",
"self",
",",
"doc",
":",
"str",
"=",
"''",
")",
"->",
"bool",
":",
"if",
"not",
"self",
".",
"_validate_input",
"(",
"doc",
",",
"[",
"'.'",
",",
"'-'",
"]",
")",
":",
"return",
"False",
"doc",
"=",
"self",
".",
"_only_digits",
"(",
"doc",
")",
"if",
"len",
"(",
"doc",
")",
"!=",
"32",
":",
"return",
"False",
"num",
"=",
"list",
"(",
"doc",
"[",
":",
"-",
"2",
"]",
")",
"dv",
"=",
"doc",
"[",
"-",
"2",
":",
"]",
"expected_dv",
"=",
"self",
".",
"_generate_verifying_digit",
"(",
"num",
")",
"if",
"dv",
"==",
"expected_dv",
":",
"return",
"True",
"return",
"False"
] | [
10,
4
] | [
28,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
float2number | (numero, arredonda = -1) | return ret | Converte um número ou string '533.12341' para número normal | Converte um número ou string '533.12341' para número normal | def float2number(numero, arredonda = -1):
''' Converte um número ou string '533.12341' para número normal '''
fl = float(numero)
ret = fl
if arredonda == 0:
ret = round(fl)
elif arredonda >=1:
ret = round(fl, arredonda)
return ret | [
"def",
"float2number",
"(",
"numero",
",",
"arredonda",
"=",
"-",
"1",
")",
":",
"fl",
"=",
"float",
"(",
"numero",
")",
"ret",
"=",
"fl",
"if",
"arredonda",
"==",
"0",
":",
"ret",
"=",
"round",
"(",
"fl",
")",
"elif",
"arredonda",
">=",
"1",
":",
"ret",
"=",
"round",
"(",
"fl",
",",
"arredonda",
")",
"return",
"ret"
] | [
347,
0
] | [
355,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
receber_jogada | () | Lê uma jogada e confere se ela é válida | Lê uma jogada e confere se ela é válida | def receber_jogada():
""" Lê uma jogada e confere se ela é válida """
#Lista com as jogadas válidas
validas = ["a","s","d","w"]
while True:
#Conferindo se a jogada faz parte do conjunto
#de válidas
jogada = str(input("Digite a jogada :"))
if jogada in validas:
break
else:
print("Jogada inválida. ",end="") | [
"def",
"receber_jogada",
"(",
")",
":",
"#Lista com as jogadas válidas",
"validas",
"=",
"[",
"\"a\"",
",",
"\"s\"",
",",
"\"d\"",
",",
"\"w\"",
"]",
"while",
"True",
":",
"#Conferindo se a jogada faz parte do conjunto",
"#de válidas",
"jogada",
"=",
"str",
"(",
"input",
"(",
"\"Digite a jogada :\"",
")",
")",
"if",
"jogada",
"in",
"validas",
":",
"break",
"else",
":",
"print",
"(",
"\"Jogada inválida. \",",
"e",
"nd=",
"\"",
"\")",
""
] | [
5,
0
] | [
18,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
is_valid_attr | (dicts, key, minsize=None, maxsize=None, regex=None, instance=None, required=True) | Valida o atributo passado
@todo: arrumar doc
@param dicts: Dicionario de dados.
@param key: key do atributo
@param minsize: Min size of the value to be validated.
@param maxsize: Max size of the value to be validated.
@param regex: Regex of the value be validated.
@param instance: type instance of the value be validated.
@param required: Check if the value can be None.
| Valida o atributo passado | def is_valid_attr(dicts, key, minsize=None, maxsize=None, regex=None, instance=None, required=True):
"""Valida o atributo passado
@todo: arrumar doc
@param dicts: Dicionario de dados.
@param key: key do atributo
@param minsize: Min size of the value to be validated.
@param maxsize: Max size of the value to be validated.
@param regex: Regex of the value be validated.
@param instance: type instance of the value be validated.
@param required: Check if the value can be None.
"""
if required is True:
assert key in dicts
if key in dicts:
if minsize is not None:
assert len(dicts[key]) > minsize
if maxsize is not None:
assert maxsize < len(dicts[key])
if regex is not None:
pattern = re.compile(regex)
assert pattern.match(dicts[key])
if instance is not None:
assert isinstance(dicts[key], instance) | [
"def",
"is_valid_attr",
"(",
"dicts",
",",
"key",
",",
"minsize",
"=",
"None",
",",
"maxsize",
"=",
"None",
",",
"regex",
"=",
"None",
",",
"instance",
"=",
"None",
",",
"required",
"=",
"True",
")",
":",
"if",
"required",
"is",
"True",
":",
"assert",
"key",
"in",
"dicts",
"if",
"key",
"in",
"dicts",
":",
"if",
"minsize",
"is",
"not",
"None",
":",
"assert",
"len",
"(",
"dicts",
"[",
"key",
"]",
")",
">",
"minsize",
"if",
"maxsize",
"is",
"not",
"None",
":",
"assert",
"maxsize",
"<",
"len",
"(",
"dicts",
"[",
"key",
"]",
")",
"if",
"regex",
"is",
"not",
"None",
":",
"pattern",
"=",
"re",
".",
"compile",
"(",
"regex",
")",
"assert",
"pattern",
".",
"match",
"(",
"dicts",
"[",
"key",
"]",
")",
"if",
"instance",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"dicts",
"[",
"key",
"]",
",",
"instance",
")"
] | [
95,
0
] | [
129,
55
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
insert_ip_equipment | (ip_id, equip_id, user) | return ip_equipment | Insere o relacionamento entre o IP e o equipamento.
@param ip_id: Identificador do IP.
@param equip_id: Identificador do equipamento.
@param user: Usuário autenticado.
@return: O ip_equipamento criado.
@raise IpError: Falha ao inserir.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise IpNotFoundError: Ip não cadastrado.
@raise IpEquipamentoDuplicatedError: IP já cadastrado para o equipamento.
@raise EquipamentoError: Falha ao pesquisar o equipamento.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
| Insere o relacionamento entre o IP e o equipamento. | def insert_ip_equipment(ip_id, equip_id, user):
"""Insere o relacionamento entre o IP e o equipamento.
@param ip_id: Identificador do IP.
@param equip_id: Identificador do equipamento.
@param user: Usuário autenticado.
@return: O ip_equipamento criado.
@raise IpError: Falha ao inserir.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise IpNotFoundError: Ip não cadastrado.
@raise IpEquipamentoDuplicatedError: IP já cadastrado para o equipamento.
@raise EquipamentoError: Falha ao pesquisar o equipamento.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
"""
if not has_perm(user,
AdminPermission.IPS,
AdminPermission.WRITE_OPERATION,
None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None, u'Usuário não tem permissão para executar a operação.')
ip_equipment = IpEquipamento()
ip_equipment.create(user, ip_id, equip_id)
return ip_equipment | [
"def",
"insert_ip_equipment",
"(",
"ip_id",
",",
"equip_id",
",",
"user",
")",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"IPS",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"equip_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"raise",
"UserNotAuthorizedError",
"(",
"None",
",",
"u'Usuário não tem permissão para executar a operação.')",
"",
"ip_equipment",
"=",
"IpEquipamento",
"(",
")",
"ip_equipment",
".",
"create",
"(",
"user",
",",
"ip_id",
",",
"equip_id",
")",
"return",
"ip_equipment"
] | [
127,
0
] | [
155,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
voto | (ano = 0) | return condicao | def voto() quando chamada retornará a situação do indivíduo em reçalção ao voto. | def voto() quando chamada retornará a situação do indivíduo em reçalção ao voto. | def voto(ano = 0):
from datetime import date
idade = date.today().year - ano
print(f'Com {idade} anos: ',end=' ')
''' def voto() quando chamada retornará a situação do indivíduo em reçalção ao voto.'''
if ano <= 0 or ano > date.today().year:
condicao = 'ANO INVÁLIDO'
elif idade < 18:
condicao = 'VOTO NEGADO!'
elif idade < 65:
condicao = 'VOTO OBRIGATÓRIO!'
else:
condicao = 'VOTO OPCIONAL!'
return condicao | [
"def",
"voto",
"(",
"ano",
"=",
"0",
")",
":",
"from",
"datetime",
"import",
"date",
"idade",
"=",
"date",
".",
"today",
"(",
")",
".",
"year",
"-",
"ano",
"print",
"(",
"f'Com {idade} anos: '",
",",
"end",
"=",
"' '",
")",
"if",
"ano",
"<=",
"0",
"or",
"ano",
">",
"date",
".",
"today",
"(",
")",
".",
"year",
":",
"condicao",
"=",
"'ANO INVÁLIDO'",
"elif",
"idade",
"<",
"18",
":",
"condicao",
"=",
"'VOTO NEGADO!'",
"elif",
"idade",
"<",
"65",
":",
"condicao",
"=",
"'VOTO OBRIGATÓRIO!'",
"else",
":",
"condicao",
"=",
"'VOTO OPCIONAL!'",
"return",
"condicao"
] | [
4,
0
] | [
17,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Stack.__len__ | (self) | return self._size | Retorna o tamanho da lista | Retorna o tamanho da lista | def __len__(self):
""" Retorna o tamanho da lista"""
return self._size | [
"def",
"__len__",
"(",
"self",
")",
":",
"return",
"self",
".",
"_size"
] | [
29,
4
] | [
31,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
show_magicians | (nomes) | return magicians | Exibe uma lista de mágicos. | Exibe uma lista de mágicos. | def show_magicians(nomes):
"Exibe uma lista de mágicos."
magicians = nome.title()
return magicians | [
"def",
"show_magicians",
"(",
"nomes",
")",
":",
"magicians",
"=",
"nome",
".",
"title",
"(",
")",
"return",
"magicians"
] | [
7,
0
] | [
10,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
cadastrar_cliente | (request) | return render(request, "cadastrar_cliente.html", {"form": form}) | Cria formulário cliente. | Cria formulário cliente. | def cadastrar_cliente(request):
""" Cria formulário cliente."""
if request.method == "POST":
form = ClienteForm(request.POST)
if form.is_valid():
# novo = Cliente(**form.cleaned_data)
nome = form.cleaned_data['nome']
razao_social = form.cleaned_data['razao_social']
cpf_cnpj = form.cleaned_data['cpf_cnpj']
data_uso = form.cleaned_data['data_uso']
novo = Cliente(
nome=nome, razao_social=razao_social,
cpf_cnpj=cpf_cnpj, data_uso=data_uso
)
novo.save()
return redirect('list_clientes')
else:
form = ClienteForm()
return render(request, "cadastrar_cliente.html", {"form": form}) | [
"def",
"cadastrar_cliente",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"form",
"=",
"ClienteForm",
"(",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"# novo = Cliente(**form.cleaned_data)",
"nome",
"=",
"form",
".",
"cleaned_data",
"[",
"'nome'",
"]",
"razao_social",
"=",
"form",
".",
"cleaned_data",
"[",
"'razao_social'",
"]",
"cpf_cnpj",
"=",
"form",
".",
"cleaned_data",
"[",
"'cpf_cnpj'",
"]",
"data_uso",
"=",
"form",
".",
"cleaned_data",
"[",
"'data_uso'",
"]",
"novo",
"=",
"Cliente",
"(",
"nome",
"=",
"nome",
",",
"razao_social",
"=",
"razao_social",
",",
"cpf_cnpj",
"=",
"cpf_cnpj",
",",
"data_uso",
"=",
"data_uso",
")",
"novo",
".",
"save",
"(",
")",
"return",
"redirect",
"(",
"'list_clientes'",
")",
"else",
":",
"form",
"=",
"ClienteForm",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"cadastrar_cliente.html\"",
",",
"{",
"\"form\"",
":",
"form",
"}",
")"
] | [
35,
0
] | [
53,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Sabores.ver_lista | (self) | Exibe uma lista de sabores disponíveis na sorveteria. | Exibe uma lista de sabores disponíveis na sorveteria. | def ver_lista(self):
"""Exibe uma lista de sabores disponíveis na sorveteria."""
print("Os sabores disponíveis são:")
for sabor in self.lista_sabores:
print("\t" + sabor.title()) | [
"def",
"ver_lista",
"(",
"self",
")",
":",
"print",
"(",
"\"Os sabores disponíveis são:\")",
"",
"for",
"sabor",
"in",
"self",
".",
"lista_sabores",
":",
"print",
"(",
"\"\\t\"",
"+",
"sabor",
".",
"title",
"(",
")",
")"
] | [
63,
4
] | [
67,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OptimalControl.__init__ | (self, diff_state, diff_lambda, update_u, conv_comb_u = 0.5,
n_controls = 1, n_states = 1, **kwargs) | Resolve o problema de controle ótimo simples, com condição inicial
do estado e termo payoff linear. Os parâmetros do modelo devem ser
escritos como params['nome_do_parametro'], pois params deve ser um dicionário.
- diff_state: função com argumentos (t,x,u,params) que representa a
derivada do estado x.
- diff_lambda: função com argumentos (t,x,u,lambda, params) que representa a
derivada da função adjunta lambda.
- update_u: função com argumentos (t,x,lambda,params) que atualiza u através de H_u = 0.
- conv_comb_u: valor da combinação convexa para atualização de u,
0.5 por padrão.
- n_controls: número de controles, 1 por padrão.
- n_states: número de estados, 1 por padrão.
- kwargs: parâmetros adicionais
- diff_phi: função que determina a condição de transversalidade.
- bounds: limites sobre o controle. Deve ser uma lista de
tuplas, cada tupla para cada controle. Se são
parametrizados, devem ser passados na função solve.
- free_adj_final: estados com condições necessárias adicionais,
em que o lambda final deve ser estimado.
| Resolve o problema de controle ótimo simples, com condição inicial
do estado e termo payoff linear. Os parâmetros do modelo devem ser
escritos como params['nome_do_parametro'], pois params deve ser um dicionário.
- diff_state: função com argumentos (t,x,u,params) que representa a
derivada do estado x.
- diff_lambda: função com argumentos (t,x,u,lambda, params) que representa a
derivada da função adjunta lambda.
- update_u: função com argumentos (t,x,lambda,params) que atualiza u através de H_u = 0.
- conv_comb_u: valor da combinação convexa para atualização de u,
0.5 por padrão.
- n_controls: número de controles, 1 por padrão.
- n_states: número de estados, 1 por padrão.
- kwargs: parâmetros adicionais
- diff_phi: função que determina a condição de transversalidade.
- bounds: limites sobre o controle. Deve ser uma lista de
tuplas, cada tupla para cada controle. Se são
parametrizados, devem ser passados na função solve.
- free_adj_final: estados com condições necessárias adicionais,
em que o lambda final deve ser estimado.
| def __init__(self, diff_state, diff_lambda, update_u, conv_comb_u = 0.5,
n_controls = 1, n_states = 1, **kwargs):
'''Resolve o problema de controle ótimo simples, com condição inicial
do estado e termo payoff linear. Os parâmetros do modelo devem ser
escritos como params['nome_do_parametro'], pois params deve ser um dicionário.
- diff_state: função com argumentos (t,x,u,params) que representa a
derivada do estado x.
- diff_lambda: função com argumentos (t,x,u,lambda, params) que representa a
derivada da função adjunta lambda.
- update_u: função com argumentos (t,x,lambda,params) que atualiza u através de H_u = 0.
- conv_comb_u: valor da combinação convexa para atualização de u,
0.5 por padrão.
- n_controls: número de controles, 1 por padrão.
- n_states: número de estados, 1 por padrão.
- kwargs: parâmetros adicionais
- diff_phi: função que determina a condição de transversalidade.
- bounds: limites sobre o controle. Deve ser uma lista de
tuplas, cada tupla para cada controle. Se são
parametrizados, devem ser passados na função solve.
- free_adj_final: estados com condições necessárias adicionais,
em que o lambda final deve ser estimado.
'''
self.dx = diff_state
self.dadj = diff_lambda
self.update_u = update_u
self.coef_u = conv_comb_u
self.n_states = n_states
self.n_controls = n_controls
self.dphi = kwargs.get('diff_phi', lambda x, par: np.zeros(shape = (1, n_states)))
self.bounds = kwargs.get('bounds', [(-np.inf, np.inf) for i in range(n_controls)])
for b in self.bounds:
if b[0] >= b[1]:
raise Exception('O formato dos bounds deve ser (a,b), a < b')
self.free_adj_final = kwargs.get('free_adj_final', []) | [
"def",
"__init__",
"(",
"self",
",",
"diff_state",
",",
"diff_lambda",
",",
"update_u",
",",
"conv_comb_u",
"=",
"0.5",
",",
"n_controls",
"=",
"1",
",",
"n_states",
"=",
"1",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"dx",
"=",
"diff_state",
"self",
".",
"dadj",
"=",
"diff_lambda",
"self",
".",
"update_u",
"=",
"update_u",
"self",
".",
"coef_u",
"=",
"conv_comb_u",
"self",
".",
"n_states",
"=",
"n_states",
"self",
".",
"n_controls",
"=",
"n_controls",
"self",
".",
"dphi",
"=",
"kwargs",
".",
"get",
"(",
"'diff_phi'",
",",
"lambda",
"x",
",",
"par",
":",
"np",
".",
"zeros",
"(",
"shape",
"=",
"(",
"1",
",",
"n_states",
")",
")",
")",
"self",
".",
"bounds",
"=",
"kwargs",
".",
"get",
"(",
"'bounds'",
",",
"[",
"(",
"-",
"np",
".",
"inf",
",",
"np",
".",
"inf",
")",
"for",
"i",
"in",
"range",
"(",
"n_controls",
")",
"]",
")",
"for",
"b",
"in",
"self",
".",
"bounds",
":",
"if",
"b",
"[",
"0",
"]",
">=",
"b",
"[",
"1",
"]",
":",
"raise",
"Exception",
"(",
"'O formato dos bounds deve ser (a,b), a < b'",
")",
"self",
".",
"free_adj_final",
"=",
"kwargs",
".",
"get",
"(",
"'free_adj_final'",
",",
"[",
"]",
")"
] | [
9,
4
] | [
44,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
AtorTestes.teste_nao_colisao_entre_atores_distantes | (self) | Teste de que não há colisão entre atores distantes | Teste de que não há colisão entre atores distantes | def teste_nao_colisao_entre_atores_distantes(self):
'Teste de que não há colisão entre atores distantes'
self.assert_nao_colisao(Ator(2, 2), Ator(2, 4))
self.assert_nao_colisao(Ator(2, 2), Ator(3, 4))
self.assert_nao_colisao(Ator(2, 2), Ator(4, 2))
self.assert_nao_colisao(Ator(2, 2), Ator(3, 0))
self.assert_nao_colisao(Ator(2, 2), Ator(2, 0))
self.assert_nao_colisao(Ator(2, 2), Ator(0, 1))
self.assert_nao_colisao(Ator(2, 2), Ator(0, 2))
self.assert_nao_colisao(Ator(2, 2), Ator(0, 4)) | [
"def",
"teste_nao_colisao_entre_atores_distantes",
"(",
"self",
")",
":",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"2",
",",
"4",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"3",
",",
"4",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"4",
",",
"2",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"3",
",",
"0",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"2",
",",
"0",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"0",
",",
"1",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"0",
",",
"2",
")",
")",
"self",
".",
"assert_nao_colisao",
"(",
"Ator",
"(",
"2",
",",
"2",
")",
",",
"Ator",
"(",
"0",
",",
"4",
")",
")"
] | [
68,
4
] | [
77,
55
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
adicionar_ambiente | (whatsapp) | return db.collection(u'ambiente_usuario').document().set(data) | caso a função conferir_ambiente retorno com o valor de None, essa função é
chamada para adicionar usuário em determinado ambiente | caso a função conferir_ambiente retorno com o valor de None, essa função é
chamada para adicionar usuário em determinado ambiente | def adicionar_ambiente(whatsapp):
"""caso a função conferir_ambiente retorno com o valor de None, essa função é
chamada para adicionar usuário em determinado ambiente"""
data = {
u'usuario': whatsapp,
u'atendimento_humanizado': False,
u'chatbot': True,
u'fila_espera': False
}
return db.collection(u'ambiente_usuario').document().set(data) | [
"def",
"adicionar_ambiente",
"(",
"whatsapp",
")",
":",
"data",
"=",
"{",
"u'usuario'",
":",
"whatsapp",
",",
"u'atendimento_humanizado'",
":",
"False",
",",
"u'chatbot'",
":",
"True",
",",
"u'fila_espera'",
":",
"False",
"}",
"return",
"db",
".",
"collection",
"(",
"u'ambiente_usuario'",
")",
".",
"document",
"(",
")",
".",
"set",
"(",
"data",
")"
] | [
79,
0
] | [
91,
66
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
create | () | return render_template('autor/create.html', error=error, success=success) | Cria um novo autor. | Cria um novo autor. | def create():
"""Cria um novo autor."""
error = None
success = False
if request.method == 'POST':
nome = request.form['nome']
if not nome:
error = 'Nome é obrigatório.'
else:
try:
if verifica_autor_bd(nome):
error = 'Autor já cadastrado!'
else:
db.insert_bd('INSERT INTO autor values (default, "%s")' % nome)
success = True
except Exception as e:
print(e)
return redirect(url_for('error'))
return render_template('autor/create.html', error=error, success=success) | [
"def",
"create",
"(",
")",
":",
"error",
"=",
"None",
"success",
"=",
"False",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"nome",
"=",
"request",
".",
"form",
"[",
"'nome'",
"]",
"if",
"not",
"nome",
":",
"error",
"=",
"'Nome é obrigatório.'",
"else",
":",
"try",
":",
"if",
"verifica_autor_bd",
"(",
"nome",
")",
":",
"error",
"=",
"'Autor já cadastrado!'",
"else",
":",
"db",
".",
"insert_bd",
"(",
"'INSERT INTO autor values (default, \"%s\")'",
"%",
"nome",
")",
"success",
"=",
"True",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'error'",
")",
")",
"return",
"render_template",
"(",
"'autor/create.html'",
",",
"error",
"=",
"error",
",",
"success",
"=",
"success",
")"
] | [
49,
0
] | [
68,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Deque.pop_first | (self) | Remove um elemento no inicio da fila | Remove um elemento no inicio da fila | def pop_first(self):
""" Remove um elemento no inicio da fila """
if self._size > 0:
self._size -= 1
return self.deque.pop(0)
raise IndexError('empty list') | [
"def",
"pop_first",
"(",
"self",
")",
":",
"if",
"self",
".",
"_size",
">",
"0",
":",
"self",
".",
"_size",
"-=",
"1",
"return",
"self",
".",
"deque",
".",
"pop",
"(",
"0",
")",
"raise",
"IndexError",
"(",
"'empty list'",
")"
] | [
24,
4
] | [
31,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
UndirectedWeightedGraph.edges | (self) | return self.__edges | Retorna a estrutura de dados utilizada para representar as arestas, neste caso: defaultdict(dict) | Retorna a estrutura de dados utilizada para representar as arestas, neste caso: defaultdict(dict) | def edges(self):
''' Retorna a estrutura de dados utilizada para representar as arestas, neste caso: defaultdict(dict)'''
return self.__edges | [
"def",
"edges",
"(",
"self",
")",
":",
"return",
"self",
".",
"__edges"
] | [
150,
4
] | [
152,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
logout | (request) | return redirect('index') | Faz o logout do usuário no sistema | Faz o logout do usuário no sistema | def logout(request):
"""Faz o logout do usuário no sistema"""
auth.logout(request)
return redirect('index') | [
"def",
"logout",
"(",
"request",
")",
":",
"auth",
".",
"logout",
"(",
"request",
")",
"return",
"redirect",
"(",
"'index'",
")"
] | [
57,
0
] | [
60,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
KB.ask | (self, query) | return first(self.ask_generator(query), default=False) | Retorna uma substituição que torna a consulta verdadeira ou, caso contrário, retorna False. | Retorna uma substituição que torna a consulta verdadeira ou, caso contrário, retorna False. | def ask(self, query):
"""Retorna uma substituição que torna a consulta verdadeira ou, caso contrário, retorna False."""
return first(self.ask_generator(query), default=False) | [
"def",
"ask",
"(",
"self",
",",
"query",
")",
":",
"return",
"first",
"(",
"self",
".",
"ask_generator",
"(",
"query",
")",
",",
"default",
"=",
"False",
")"
] | [
57,
4
] | [
59,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Misc.tempo | (self, ctx, *, cidade: str) | Verifica o tempo atual na sua cidade
| Verifica o tempo atual na sua cidade
| async def tempo(self, ctx, *, cidade: str):
"""Verifica o tempo atual na sua cidade
"""
if apitempo is None:
return
cidade = cidade.title()
if cidade.startswith('Cidade do'):
cidade = 'rolândia'
locator = geolocator.geocode(cidade)
urlcompleta = tempourl + "lat=" + str(locator.latitude) + "&lon=" + str(locator.longitude) + '&appid=' + apitempo + "&lang=pt_br"
async with aiohttp.ClientSession() as session:
#não é possível usar um gerenciador de contexto aqui porque
#o Tempo (classe) chama funções que só estão disponíveis quando
#a conexão ainda está aberta.
request = await session.get(urlcompleta)
w = Tempo(ctx, request, cidade)
await w.start(ctx)
del request | [
"async",
"def",
"tempo",
"(",
"self",
",",
"ctx",
",",
"*",
",",
"cidade",
":",
"str",
")",
":",
"if",
"apitempo",
"is",
"None",
":",
"return",
"cidade",
"=",
"cidade",
".",
"title",
"(",
")",
"if",
"cidade",
".",
"startswith",
"(",
"'Cidade do'",
")",
":",
"cidade",
"=",
"'rolândia'\r",
"locator",
"=",
"geolocator",
".",
"geocode",
"(",
"cidade",
")",
"urlcompleta",
"=",
"tempourl",
"+",
"\"lat=\"",
"+",
"str",
"(",
"locator",
".",
"latitude",
")",
"+",
"\"&lon=\"",
"+",
"str",
"(",
"locator",
".",
"longitude",
")",
"+",
"'&appid='",
"+",
"apitempo",
"+",
"\"&lang=pt_br\"",
"async",
"with",
"aiohttp",
".",
"ClientSession",
"(",
")",
"as",
"session",
":",
"#não é possível usar um gerenciador de contexto aqui porque\r",
"#o Tempo (classe) chama funções que só estão disponíveis quando\r",
"#a conexão ainda está aberta.\r",
"request",
"=",
"await",
"session",
".",
"get",
"(",
"urlcompleta",
")",
"w",
"=",
"Tempo",
"(",
"ctx",
",",
"request",
",",
"cidade",
")",
"await",
"w",
".",
"start",
"(",
"ctx",
")",
"del",
"request"
] | [
364,
4
] | [
386,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
InsertionSort.__recursiveInsertionSort | (self,array,leftIndex,rightIndex,pivot) | Implementação do método InsertionSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| Implementação do método InsertionSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| def __recursiveInsertionSort(self,array,leftIndex,rightIndex,pivot):
"""Implementação do método InsertionSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
"""
if(pivot <= rightIndex):
self.__recursiveSwitchBack(array,leftIndex,pivot)
self.__recursiveInsertionSort(array,leftIndex,rightIndex,pivot+1) | [
"def",
"__recursiveInsertionSort",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"pivot",
")",
":",
"if",
"(",
"pivot",
"<=",
"rightIndex",
")",
":",
"self",
".",
"__recursiveSwitchBack",
"(",
"array",
",",
"leftIndex",
",",
"pivot",
")",
"self",
".",
"__recursiveInsertionSort",
"(",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"pivot",
"+",
"1",
")"
] | [
48,
1
] | [
58,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Car.read_odometer | (self) | return odometer | Exibe uma frase que mostra a milhagem do carro. | Exibe uma frase que mostra a milhagem do carro. | def read_odometer(self):
""" Exibe uma frase que mostra a milhagem do carro."""
odometer = 'This car has a ' + str(self.odometer_reading) + ' miles on it.'
return odometer | [
"def",
"read_odometer",
"(",
"self",
")",
":",
"odometer",
"=",
"'This car has a '",
"+",
"str",
"(",
"self",
".",
"odometer_reading",
")",
"+",
"' miles on it.'",
"return",
"odometer"
] | [
23,
4
] | [
26,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
SASM.TSS | (self, Rrs_nm) | return TSS_var | Retorna o valor de TSS g/m3 para um dado pixel
| Retorna o valor de TSS g/m3 para um dado pixel
| def TSS(self, Rrs_nm):
""" Retorna o valor de TSS g/m3 para um dado pixel
"""
rrs_nm = self.Rrs_to_rrs_converter(Rrs_nm)
g1, g2 = (0.084, 0.17)
x = (-g1 + math.sqrt(g1 + 4*g2*rrs_nm))/2*g2
if self.Sensor == 'MODIS-Aqua':
TSS_var = 23.47*(x/1-x)/(1-0.69*(x/1-x))
elif self.Sensor == 'Landsat-8 OLI':
TSS_var = 25.34*(x/1-x)/(1-0.69*(x/1-x))
elif self.Sensor == 'World-View2':
TSS_var = 26.37*(x/1-x)/(1-0.69*(x/1-x))
return TSS_var | [
"def",
"TSS",
"(",
"self",
",",
"Rrs_nm",
")",
":",
"rrs_nm",
"=",
"self",
".",
"Rrs_to_rrs_converter",
"(",
"Rrs_nm",
")",
"g1",
",",
"g2",
"=",
"(",
"0.084",
",",
"0.17",
")",
"x",
"=",
"(",
"-",
"g1",
"+",
"math",
".",
"sqrt",
"(",
"g1",
"+",
"4",
"*",
"g2",
"*",
"rrs_nm",
")",
")",
"/",
"2",
"*",
"g2",
"if",
"self",
".",
"Sensor",
"==",
"'MODIS-Aqua'",
":",
"TSS_var",
"=",
"23.47",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
"/",
"(",
"1",
"-",
"0.69",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
")",
"elif",
"self",
".",
"Sensor",
"==",
"'Landsat-8 OLI'",
":",
"TSS_var",
"=",
"25.34",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
"/",
"(",
"1",
"-",
"0.69",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
")",
"elif",
"self",
".",
"Sensor",
"==",
"'World-View2'",
":",
"TSS_var",
"=",
"26.37",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
"/",
"(",
"1",
"-",
"0.69",
"*",
"(",
"x",
"/",
"1",
"-",
"x",
")",
")",
"return",
"TSS_var"
] | [
65,
4
] | [
85,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
SASM.Rrs_to_rrs_converter | (self, Rrs_nm) | return rrs_nm | converte Rrs em rrs com base no modelo de Mobley 1999
| converte Rrs em rrs com base no modelo de Mobley 1999
| def Rrs_to_rrs_converter(self, Rrs_nm):
""" converte Rrs em rrs com base no modelo de Mobley 1999
"""
rrs_nm = Rrs_nm/(0.52 + 1.7*Rrs_nm)
return rrs_nm | [
"def",
"Rrs_to_rrs_converter",
"(",
"self",
",",
"Rrs_nm",
")",
":",
"rrs_nm",
"=",
"Rrs_nm",
"/",
"(",
"0.52",
"+",
"1.7",
"*",
"Rrs_nm",
")",
"return",
"rrs_nm"
] | [
56,
4
] | [
63,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Carro.__init__ | (self, fabricante, modelo, ano) | Inicializa os atributos que descrevem um carro. | Inicializa os atributos que descrevem um carro. | def __init__(self, fabricante, modelo, ano):
"""Inicializa os atributos que descrevem um carro."""
self.fabricante = fabricante
self.modelo = modelo
self.ano = ano
self.leitura_hodometro = 0 | [
"def",
"__init__",
"(",
"self",
",",
"fabricante",
",",
"modelo",
",",
"ano",
")",
":",
"self",
".",
"fabricante",
"=",
"fabricante",
"self",
".",
"modelo",
"=",
"modelo",
"self",
".",
"ano",
"=",
"ano",
"self",
".",
"leitura_hodometro",
"=",
"0"
] | [
2,
4
] | [
7,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Messenger.__get_elements__ | (self, text) | Método interno da Classe. Não deve ser utilizado com ojetos instanciados dentro do programa.
Serve apenas para dar à classe acessibilidade aos campos adequados dentro da página web. | Método interno da Classe. Não deve ser utilizado com ojetos instanciados dentro do programa.
Serve apenas para dar à classe acessibilidade aos campos adequados dentro da página web. | def __get_elements__(self, text):
"""Método interno da Classe. Não deve ser utilizado com ojetos instanciados dentro do programa.
Serve apenas para dar à classe acessibilidade aos campos adequados dentro da página web."""
__text_box = self._browser.find_element_by_class_name('_2FVVk._2UL8j')
for c in text:
__text_box.send_keys(c)
__send_button = self._browser.find_element_by_class_name('_1U1xa')
__send_button.send_keys(Keys.ENTER)
sleep(1.5) | [
"def",
"__get_elements__",
"(",
"self",
",",
"text",
")",
":",
"__text_box",
"=",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_2FVVk._2UL8j'",
")",
"for",
"c",
"in",
"text",
":",
"__text_box",
".",
"send_keys",
"(",
"c",
")",
"__send_button",
"=",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_1U1xa'",
")",
"__send_button",
".",
"send_keys",
"(",
"Keys",
".",
"ENTER",
")",
"sleep",
"(",
"1.5",
")"
] | [
32,
4
] | [
43,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Scoreboard.prep_level | (self) | Transforma o nivel em uma imagem renderizada | Transforma o nivel em uma imagem renderizada | def prep_level(self):
"""Transforma o nivel em uma imagem renderizada"""
text = f'{self.stats.level}'
self.level_image = self.font.render(text, True, self.text_color, (20, 24, 33))
# Posiciona o nível abaixo da pontuação
self.level_rect = self.level_image.get_rect()
self.level_rect.right = self.screen_rect.right - 20
self.level_rect.top = self.score_rect.bottom + 10 | [
"def",
"prep_level",
"(",
"self",
")",
":",
"text",
"=",
"f'{self.stats.level}'",
"self",
".",
"level_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"text",
",",
"True",
",",
"self",
".",
"text_color",
",",
"(",
"20",
",",
"24",
",",
"33",
")",
")",
"# Posiciona o nível abaixo da pontuação",
"self",
".",
"level_rect",
"=",
"self",
".",
"level_image",
".",
"get_rect",
"(",
")",
"self",
".",
"level_rect",
".",
"right",
"=",
"self",
".",
"screen_rect",
".",
"right",
"-",
"20",
"self",
".",
"level_rect",
".",
"top",
"=",
"self",
".",
"score_rect",
".",
"bottom",
"+",
"10"
] | [
48,
4
] | [
56,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
check_play_button | (ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, mouse_x, mouse_y) | Inicia um novo jogo quando o jogador clicar em Play. | Inicia um novo jogo quando o jogador clicar em Play. | def check_play_button(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, mouse_x, mouse_y):
"""Inicia um novo jogo quando o jogador clicar em Play."""
buttom_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if buttom_clicked:
start_game(ai_settings, screen, stats, sb, ship, aliens, bullets) | [
"def",
"check_play_button",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"play_button",
",",
"ship",
",",
"aliens",
",",
"bullets",
",",
"mouse_x",
",",
"mouse_y",
")",
":",
"buttom_clicked",
"=",
"play_button",
".",
"rect",
".",
"collidepoint",
"(",
"mouse_x",
",",
"mouse_y",
")",
"if",
"buttom_clicked",
":",
"start_game",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")"
] | [
48,
0
] | [
53,
74
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Environment.exogenous_change | (self) | Verifica se há mudança espontânea no mundo | Verifica se há mudança espontânea no mundo | def exogenous_change(self):
"Verifica se há mudança espontânea no mundo"
pass | [
"def",
"exogenous_change",
"(",
"self",
")",
":",
"pass"
] | [
160,
4
] | [
162,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
n_palavras_diferentes | (lista_palavras) | return len(freq) | Essa funcao recebe uma lista de palavras e devolve o numero de palavras diferentes utilizadas | Essa funcao recebe uma lista de palavras e devolve o numero de palavras diferentes utilizadas | def n_palavras_diferentes(lista_palavras):
'''Essa funcao recebe uma lista de palavras e devolve o numero de palavras diferentes utilizadas'''
freq = dict()
for palavra in lista_palavras:
p = palavra.lower()
if p in freq:
freq[p] += 1
else:
freq[p] = 1
return len(freq) | [
"def",
"n_palavras_diferentes",
"(",
"lista_palavras",
")",
":",
"freq",
"=",
"dict",
"(",
")",
"for",
"palavra",
"in",
"lista_palavras",
":",
"p",
"=",
"palavra",
".",
"lower",
"(",
")",
"if",
"p",
"in",
"freq",
":",
"freq",
"[",
"p",
"]",
"+=",
"1",
"else",
":",
"freq",
"[",
"p",
"]",
"=",
"1",
"return",
"len",
"(",
"freq",
")"
] | [
59,
0
] | [
69,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Bateria.__init__ | (self, capacidade_bateria=70) | Inicializa os atributos da bateria. | Inicializa os atributos da bateria. | def __init__(self, capacidade_bateria=70):
"""Inicializa os atributos da bateria."""
self.capacidade_bateria = capacidade_bateria | [
"def",
"__init__",
"(",
"self",
",",
"capacidade_bateria",
"=",
"70",
")",
":",
"self",
".",
"capacidade_bateria",
"=",
"capacidade_bateria"
] | [
50,
4
] | [
52,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ModeloTransformer.embTexts | (self, dataSeries:pd.Series, **kwagars) | Função para gerar embedding da BASE DE TWEETS com média dos tensores dos tokens
Parâmetros:
dataSeries: dataframe['tweet']
return: dataframe com média dos tensores de cada token que perfaz o tweet
| Função para gerar embedding da BASE DE TWEETS com média dos tensores dos tokens
Parâmetros:
dataSeries: dataframe['tweet'] | def embTexts(self, dataSeries:pd.Series, **kwagars) -> pd.DataFrame:
'''Função para gerar embedding da BASE DE TWEETS com média dos tensores dos tokens
Parâmetros:
dataSeries: dataframe['tweet']
return: dataframe com média dos tensores de cada token que perfaz o tweet
'''
retorno = []
if (self.embedMethod != ModeloTransformer.METHOD.STATIC_AVG):
# TODO: Verificar se realmente é necessário definir este tamanho explicitamente
# se ficar assim e algum modelo gerar os embeddings de outro tamanho vai dar problema
if (self.embedMethod == ModeloTransformer.METHOD.CONTEXT_CONCAT):
#montando array para receber embedding dos tweets do dataframe
embeddings = np.ndarray((len(dataSeries),3072))
else:
#montando array para receber embedding dos tweets do dataframe
embeddings = np.ndarray((len(dataSeries),768))
for i, text in enumerate(dataSeries):
#gerando embeding do text
tweet = self.get_tweet_embed(text, self.embedMethod)
#convertando em um array e inserindo no array criado
embeddings[i] = convert_tensor2array(tweet.to(device="cpu"))
return pd.DataFrame(embeddings)
else:
for i, text in enumerate(dataSeries):
retorno.append(self.transform_sentence_to_avgembword(text))
return pd.DataFrame(retorno) | [
"def",
"embTexts",
"(",
"self",
",",
"dataSeries",
":",
"pd",
".",
"Series",
",",
"*",
"*",
"kwagars",
")",
"->",
"pd",
".",
"DataFrame",
":",
"retorno",
"=",
"[",
"]",
"if",
"(",
"self",
".",
"embedMethod",
"!=",
"ModeloTransformer",
".",
"METHOD",
".",
"STATIC_AVG",
")",
":",
"# TODO: Verificar se realmente é necessário definir este tamanho explicitamente",
"# se ficar assim e algum modelo gerar os embeddings de outro tamanho vai dar problema",
"if",
"(",
"self",
".",
"embedMethod",
"==",
"ModeloTransformer",
".",
"METHOD",
".",
"CONTEXT_CONCAT",
")",
":",
"#montando array para receber embedding dos tweets do dataframe",
"embeddings",
"=",
"np",
".",
"ndarray",
"(",
"(",
"len",
"(",
"dataSeries",
")",
",",
"3072",
")",
")",
"else",
":",
"#montando array para receber embedding dos tweets do dataframe",
"embeddings",
"=",
"np",
".",
"ndarray",
"(",
"(",
"len",
"(",
"dataSeries",
")",
",",
"768",
")",
")",
"for",
"i",
",",
"text",
"in",
"enumerate",
"(",
"dataSeries",
")",
":",
"#gerando embeding do text",
"tweet",
"=",
"self",
".",
"get_tweet_embed",
"(",
"text",
",",
"self",
".",
"embedMethod",
")",
"#convertando em um array e inserindo no array criado",
"embeddings",
"[",
"i",
"]",
"=",
"convert_tensor2array",
"(",
"tweet",
".",
"to",
"(",
"device",
"=",
"\"cpu\"",
")",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"embeddings",
")",
"else",
":",
"for",
"i",
",",
"text",
"in",
"enumerate",
"(",
"dataSeries",
")",
":",
"retorno",
".",
"append",
"(",
"self",
".",
"transform_sentence_to_avgembword",
"(",
"text",
")",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"retorno",
")"
] | [
33,
4
] | [
61,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Statistics.cont_tokens_sentence | (self, list_sentences) | return data | [Calcula o número de tokens por sentença.]
Returns:
[list] -- [retorna uma lista contendo o número de palavras por sentenças.]
| [Calcula o número de tokens por sentença.] | def cont_tokens_sentence(self, list_sentences):
"""[Calcula o número de tokens por sentença.]
Returns:
[list] -- [retorna uma lista contendo o número de palavras por sentenças.]
"""
data = []
for sentence in list_sentences:
data.append(len(word_tokenize(sentence)))
return data | [
"def",
"cont_tokens_sentence",
"(",
"self",
",",
"list_sentences",
")",
":",
"data",
"=",
"[",
"]",
"for",
"sentence",
"in",
"list_sentences",
":",
"data",
".",
"append",
"(",
"len",
"(",
"word_tokenize",
"(",
"sentence",
")",
")",
")",
"return",
"data"
] | [
173,
4
] | [
184,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Observador.atualizar | (self, mensagem) | Fazer o que quiser com a msg. | Fazer o que quiser com a msg. | def atualizar(self, mensagem):
"""Fazer o que quiser com a msg."""
print(f'|{self.nome} recebeu| {mensagem}') | [
"def",
"atualizar",
"(",
"self",
",",
"mensagem",
")",
":",
"print",
"(",
"f'|{self.nome} recebeu| {mensagem}'",
")"
] | [
4,
4
] | [
6,
50
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestValidateDocs.test_correct_argument | (self) | Testa a função quando os argumentos estão corretos | Testa a função quando os argumentos estão corretos | def test_correct_argument(self):
"""Testa a função quando os argumentos estão corretos"""
DocClasses = [
docbr.CPF,
docbr.CNH,
docbr.CNPJ,
docbr.CNS,
docbr.PIS,
docbr.TituloEleitoral,
]
documents = []
right_answers = []
for DocClass in DocClasses:
# Documentos válidos
tuples = [(DocClass, doc) for doc in DocClass().generate_list(200)]
documents += tuples
right_answers += [True] * len(tuples)
# Documentos aleatórios
len_doc = len(DocClass().generate())
for i in range(200):
random_doc = get_random_number_str(len_doc)
documents += [(DocClass, random_doc)]
right_answers += [DocClass().validate(random_doc)]
self.assertEqual(docbr.validate_docs(documents), right_answers) | [
"def",
"test_correct_argument",
"(",
"self",
")",
":",
"DocClasses",
"=",
"[",
"docbr",
".",
"CPF",
",",
"docbr",
".",
"CNH",
",",
"docbr",
".",
"CNPJ",
",",
"docbr",
".",
"CNS",
",",
"docbr",
".",
"PIS",
",",
"docbr",
".",
"TituloEleitoral",
",",
"]",
"documents",
"=",
"[",
"]",
"right_answers",
"=",
"[",
"]",
"for",
"DocClass",
"in",
"DocClasses",
":",
"# Documentos válidos",
"tuples",
"=",
"[",
"(",
"DocClass",
",",
"doc",
")",
"for",
"doc",
"in",
"DocClass",
"(",
")",
".",
"generate_list",
"(",
"200",
")",
"]",
"documents",
"+=",
"tuples",
"right_answers",
"+=",
"[",
"True",
"]",
"*",
"len",
"(",
"tuples",
")",
"# Documentos aleatórios",
"len_doc",
"=",
"len",
"(",
"DocClass",
"(",
")",
".",
"generate",
"(",
")",
")",
"for",
"i",
"in",
"range",
"(",
"200",
")",
":",
"random_doc",
"=",
"get_random_number_str",
"(",
"len_doc",
")",
"documents",
"+=",
"[",
"(",
"DocClass",
",",
"random_doc",
")",
"]",
"right_answers",
"+=",
"[",
"DocClass",
"(",
")",
".",
"validate",
"(",
"random_doc",
")",
"]",
"self",
".",
"assertEqual",
"(",
"docbr",
".",
"validate_docs",
"(",
"documents",
")",
",",
"right_answers",
")"
] | [
14,
4
] | [
41,
71
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RequisicaoVipsResource.handle_put | (self, request, user, *args, **kwargs) | Trata as requisições de PUT para atualizar/criar uma requisição de VIP.
URLs: vip/<id_vip>/
| Trata as requisições de PUT para atualizar/criar uma requisição de VIP. | def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para atualizar/criar uma requisição de VIP.
URLs: vip/<id_vip>/
"""
try:
vip_id = kwargs.get('id_vip')
if not is_valid_int_greater_zero_param(vip_id):
self.log.error(
u'The vip_id parameter is not a valid value: %s.', vip_id)
raise InvalidValueError(None, 'vip_id', vip_id)
if not has_perm(user,
AdminPermission.VIPS_REQUEST,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
return self.__update_vip(vip_id, request, user)
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except (RequisicaoVipsNotFoundError):
return self.response_error(152)
except (RequisicaoVipsError, GrupoError, HealthcheckExpectError, EquipamentoError, IpError):
return self.response_error(1) | [
"def",
"handle_put",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"vip_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_vip'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"vip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The vip_id parameter is not a valid value: %s.'",
",",
"vip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'vip_id'",
",",
"vip_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"VIPS_REQUEST",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"return",
"self",
".",
"__update_vip",
"(",
"vip_id",
",",
"request",
",",
"user",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"(",
"RequisicaoVipsNotFoundError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"152",
")",
"except",
"(",
"RequisicaoVipsError",
",",
"GrupoError",
",",
"HealthcheckExpectError",
",",
"EquipamentoError",
",",
"IpError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
513,
4
] | [
538,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
test_put_interventions | (client) | Teste put /intervention - Compara dados enviados com dados salvos no banco e valida status_code 200 | Teste put /intervention - Compara dados enviados com dados salvos no banco e valida status_code 200 | def test_put_interventions(client):
"""Teste put /intervention - Compara dados enviados com dados salvos no banco e valida status_code 200"""
access_token = get_access(client, 'noadmin', 'noadmin')
idPrescriptionDrug = '99'
data = {
"status": "s",
"admissionNumber": 5,
"idInterventionReason": [5],
"error": False,
"cost": False,
"observation": "teste observations",
"interactions": [5]
}
url = 'intervention/' + idPrescriptionDrug
response = client.put(url, data=json.dumps(data), headers=make_headers(access_token))
responseData = json.loads(response.data)['data']
interventions = session.query(Intervention).get((responseData, '0'))
assert response.status_code == 200
assert interventions.status == data['status']
assert interventions.admissionNumber == data['admissionNumber']
assert interventions.idInterventionReason == data['idInterventionReason']
assert interventions.error == data['error']
assert interventions.cost == data['cost']
assert interventions.notes == data['observation']
assert interventions.interactions == data['interactions'] | [
"def",
"test_put_interventions",
"(",
"client",
")",
":",
"access_token",
"=",
"get_access",
"(",
"client",
",",
"'noadmin'",
",",
"'noadmin'",
")",
"idPrescriptionDrug",
"=",
"'99'",
"data",
"=",
"{",
"\"status\"",
":",
"\"s\"",
",",
"\"admissionNumber\"",
":",
"5",
",",
"\"idInterventionReason\"",
":",
"[",
"5",
"]",
",",
"\"error\"",
":",
"False",
",",
"\"cost\"",
":",
"False",
",",
"\"observation\"",
":",
"\"teste observations\"",
",",
"\"interactions\"",
":",
"[",
"5",
"]",
"}",
"url",
"=",
"'intervention/'",
"+",
"idPrescriptionDrug",
"response",
"=",
"client",
".",
"put",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
",",
"headers",
"=",
"make_headers",
"(",
"access_token",
")",
")",
"responseData",
"=",
"json",
".",
"loads",
"(",
"response",
".",
"data",
")",
"[",
"'data'",
"]",
"interventions",
"=",
"session",
".",
"query",
"(",
"Intervention",
")",
".",
"get",
"(",
"(",
"responseData",
",",
"'0'",
")",
")",
"assert",
"response",
".",
"status_code",
"==",
"200",
"assert",
"interventions",
".",
"status",
"==",
"data",
"[",
"'status'",
"]",
"assert",
"interventions",
".",
"admissionNumber",
"==",
"data",
"[",
"'admissionNumber'",
"]",
"assert",
"interventions",
".",
"idInterventionReason",
"==",
"data",
"[",
"'idInterventionReason'",
"]",
"assert",
"interventions",
".",
"error",
"==",
"data",
"[",
"'error'",
"]",
"assert",
"interventions",
".",
"cost",
"==",
"data",
"[",
"'cost'",
"]",
"assert",
"interventions",
".",
"notes",
"==",
"data",
"[",
"'observation'",
"]",
"assert",
"interventions",
".",
"interactions",
"==",
"data",
"[",
"'interactions'",
"]"
] | [
29,
0
] | [
57,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestPlayer.test_create_player_obj_with_non_list_type_pokemons | (self) | Testa instancia de classe, usando um tipo diferente do esperado. | Testa instancia de classe, usando um tipo diferente do esperado. | def test_create_player_obj_with_non_list_type_pokemons(self):
"""Testa instancia de classe, usando um tipo diferente do esperado."""
self.assertRaises(TypeError, lambda: Player({"pokemon1": "charmander", "pokemon2": "pikachu", "pokemon3": "pichu"})) | [
"def",
"test_create_player_obj_with_non_list_type_pokemons",
"(",
"self",
")",
":",
"self",
".",
"assertRaises",
"(",
"TypeError",
",",
"lambda",
":",
"Player",
"(",
"{",
"\"pokemon1\"",
":",
"\"charmander\"",
",",
"\"pokemon2\"",
":",
"\"pikachu\"",
",",
"\"pokemon3\"",
":",
"\"pichu\"",
"}",
")",
")"
] | [
11,
4
] | [
13,
124
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
deleta_receita | (request, receita_id) | return redirect('dashboard') | Usuário deleta uma receita | Usuário deleta uma receita | def deleta_receita(request, receita_id):
"""Usuário deleta uma receita"""
# recebendo o id do objeto receita
receita = get_object_or_404(Receita, pk=receita_id)
receita.delete()
return redirect('dashboard') | [
"def",
"deleta_receita",
"(",
"request",
",",
"receita_id",
")",
":",
"# recebendo o id do objeto receita",
"receita",
"=",
"get_object_or_404",
"(",
"Receita",
",",
"pk",
"=",
"receita_id",
")",
"receita",
".",
"delete",
"(",
")",
"return",
"redirect",
"(",
"'dashboard'",
")"
] | [
53,
0
] | [
58,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DoublyLinkedList._getnode | (self, index) | return pointer | Retorna o i-esimo ponteiro indicado pelo index | Retorna o i-esimo ponteiro indicado pelo index | def _getnode(self, index):
""" Retorna o i-esimo ponteiro indicado pelo index """
if index == self._size - 1:
return self.tail
pointer = self.head
for i in range(index):
if pointer is not None:
pointer = pointer.next
else:
raise IndexError('list index out of range')
return pointer | [
"def",
"_getnode",
"(",
"self",
",",
"index",
")",
":",
"if",
"index",
"==",
"self",
".",
"_size",
"-",
"1",
":",
"return",
"self",
".",
"tail",
"pointer",
"=",
"self",
".",
"head",
"for",
"i",
"in",
"range",
"(",
"index",
")",
":",
"if",
"pointer",
"is",
"not",
"None",
":",
"pointer",
"=",
"pointer",
".",
"next",
"else",
":",
"raise",
"IndexError",
"(",
"'list index out of range'",
")",
"return",
"pointer"
] | [
114,
4
] | [
128,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Alien.update | (self) | Move o alienigena para a direita. | Move o alienigena para a direita. | def update(self):
"""Move o alienigena para a direita."""
self.x += (self.ai_settings.alien_speed_factor *
self.ai_settings.fleet_direction)
self.rect.x = self.x | [
"def",
"update",
"(",
"self",
")",
":",
"self",
".",
"x",
"+=",
"(",
"self",
".",
"ai_settings",
".",
"alien_speed_factor",
"*",
"self",
".",
"ai_settings",
".",
"fleet_direction",
")",
"self",
".",
"rect",
".",
"x",
"=",
"self",
".",
"x"
] | [
32,
4
] | [
36,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Car.update_odometer | (self, mileage) | Define o valor de leitura do odometro do veículo. | Define o valor de leitura do odometro do veículo. | def update_odometer(self, mileage):
""" Define o valor de leitura do odometro do veículo."""
if mileage >= self.odometer_reading:
self.odometer_reading = mileage
else:
print("You don't roll back an odometer.") | [
"def",
"update_odometer",
"(",
"self",
",",
"mileage",
")",
":",
"if",
"mileage",
">=",
"self",
".",
"odometer_reading",
":",
"self",
".",
"odometer_reading",
"=",
"mileage",
"else",
":",
"print",
"(",
"\"You don't roll back an odometer.\"",
")"
] | [
28,
4
] | [
33,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
cint | (n) | return n | A função cint, recebe um valor (n) que pode ser uma número inteiro, real, string ou uma lista e converte o valor para número inteiro
No caso de (n) ser uma lista irá converter cada um dos valores contidos na lista para inteiros e continuará sendo uma lista
No caso de ser uma string vazia ou letra, receberá o valor padrão de 0
| A função cint, recebe um valor (n) que pode ser uma número inteiro, real, string ou uma lista e converte o valor para número inteiro
No caso de (n) ser uma lista irá converter cada um dos valores contidos na lista para inteiros e continuará sendo uma lista
No caso de ser uma string vazia ou letra, receberá o valor padrão de 0
| def cint(n):
""" A função cint, recebe um valor (n) que pode ser uma número inteiro, real, string ou uma lista e converte o valor para número inteiro
No caso de (n) ser uma lista irá converter cada um dos valores contidos na lista para inteiros e continuará sendo uma lista
No caso de ser uma string vazia ou letra, receberá o valor padrão de 0
"""
try:
n = int(n)
except ValueError:
n = 0
except TypeError:
c = 0
for i in range(0, len(n)):
try:
n[i] = int(n[i])
except ValueError:
n[i] = 0
except TypeError:
n[i] = 0
return n | [
"def",
"cint",
"(",
"n",
")",
":",
"try",
":",
"n",
"=",
"int",
"(",
"n",
")",
"except",
"ValueError",
":",
"n",
"=",
"0",
"except",
"TypeError",
":",
"c",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"n",
")",
")",
":",
"try",
":",
"n",
"[",
"i",
"]",
"=",
"int",
"(",
"n",
"[",
"i",
"]",
")",
"except",
"ValueError",
":",
"n",
"[",
"i",
"]",
"=",
"0",
"except",
"TypeError",
":",
"n",
"[",
"i",
"]",
"=",
"0",
"return",
"n"
] | [
0,
0
] | [
18,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
CallbackARQ.tratamentoEventoData | (self, quadro) | Realiza o tratamento de um evento do tipo DATA | Realiza o tratamento de um evento do tipo DATA | def tratamentoEventoData(self, quadro):
''' Realiza o tratamento de um evento do tipo DATA '''
if quadro.sequencia == self.rx:
# print('enviando confirmação correta', self.atual)
self.upper.recebe(quadro) # Enviando quadro para Aplicacao
self.quadroACK.sequencia = self.rx # Bit sequencia campo controle quadro ACK
self.quadroACK.tipo = 1 # Bit tipo campo controle quadro ACK
self.lower.envia(self.quadroACK) # Enviando confirmacação para Enquadramento
self.rx = self.rx ^ 1
elif quadro.sequencia != self.rx:
# print('enviando confirmação errada', self.atual)
self.quadroACK.sequencia = quadro.sequencia
self.quadroACK.tipo = 1
self.lower.envia(self.quadroACK) | [
"def",
"tratamentoEventoData",
"(",
"self",
",",
"quadro",
")",
":",
"if",
"quadro",
".",
"sequencia",
"==",
"self",
".",
"rx",
":",
"# print('enviando confirmação correta', self.atual)",
"self",
".",
"upper",
".",
"recebe",
"(",
"quadro",
")",
"# Enviando quadro para Aplicacao",
"self",
".",
"quadroACK",
".",
"sequencia",
"=",
"self",
".",
"rx",
"# Bit sequencia campo controle quadro ACK",
"self",
".",
"quadroACK",
".",
"tipo",
"=",
"1",
"# Bit tipo campo controle quadro ACK",
"self",
".",
"lower",
".",
"envia",
"(",
"self",
".",
"quadroACK",
")",
"# Enviando confirmacação para Enquadramento",
"self",
".",
"rx",
"=",
"self",
".",
"rx",
"^",
"1",
"elif",
"quadro",
".",
"sequencia",
"!=",
"self",
".",
"rx",
":",
"# print('enviando confirmação errada', self.atual)",
"self",
".",
"quadroACK",
".",
"sequencia",
"=",
"quadro",
".",
"sequencia",
"self",
".",
"quadroACK",
".",
"tipo",
"=",
"1",
"self",
".",
"lower",
".",
"envia",
"(",
"self",
".",
"quadroACK",
")"
] | [
121,
4
] | [
134,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurante.restaurante_aberto | (self) | Exibe uma mensagem dizendo que o restaurante está aberto. | Exibe uma mensagem dizendo que o restaurante está aberto. | def restaurante_aberto(self):
"""Exibe uma mensagem dizendo que o restaurante está aberto."""
print("O restaurante " + self.nome_restaurante.title() +
" está aberto.") | [
"def",
"restaurante_aberto",
"(",
"self",
")",
":",
"print",
"(",
"\"O restaurante \"",
"+",
"self",
".",
"nome_restaurante",
".",
"title",
"(",
")",
"+",
"\" está aberto.\")",
""
] | [
19,
4
] | [
22,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Alien.__init__ | (self, ai_settings, screen) | Inicializa o alienígena e define sua posição inicial | Inicializa o alienígena e define sua posição inicial | def __init__(self, ai_settings, screen):
"""Inicializa o alienígena e define sua posição inicial"""
super().__init__()
self.screen = screen
self.ai_settings = ai_settings
# Carrega a imagem do alienigena e define seu atributo rect
self.image = pygame.image.load('Assets/aliens/alien3.bmp')
self.rect = self.image.get_rect()
# Inicia cada novo alienígena próximo à parte superior esquerda da tela
self.rect.x = self.rect.width
self.rect.y = self.rect.height
# Armazena a posição exata do alien
self.x = float(self.rect.x) | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
")",
"self",
".",
"screen",
"=",
"screen",
"self",
".",
"ai_settings",
"=",
"ai_settings",
"# Carrega a imagem do alienigena e define seu atributo rect",
"self",
".",
"image",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/aliens/alien3.bmp'",
")",
"self",
".",
"rect",
"=",
"self",
".",
"image",
".",
"get_rect",
"(",
")",
"# Inicia cada novo alienígena próximo à parte superior esquerda da tela",
"self",
".",
"rect",
".",
"x",
"=",
"self",
".",
"rect",
".",
"width",
"self",
".",
"rect",
".",
"y",
"=",
"self",
".",
"rect",
".",
"height",
"# Armazena a posição exata do alien",
"self",
".",
"x",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"x",
")"
] | [
6,
4
] | [
21,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
cadastrar_funcionario | (request) | return render(request, "cadastrar_funcionario.html", {"form": form}) | Cria formulário funcionário. | Cria formulário funcionário. | def cadastrar_funcionario(request):
""" Cria formulário funcionário."""
if request.method == "POST":
form = FuncionarioForm(request.POST)
if form.is_valid():
novo = Funcionario(**form.cleaned_data)
novo.save()
return redirect('funcionario')
else:
form = FuncionarioForm()
return render(request, "cadastrar_funcionario.html", {"form": form}) | [
"def",
"cadastrar_funcionario",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"form",
"=",
"FuncionarioForm",
"(",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"novo",
"=",
"Funcionario",
"(",
"*",
"*",
"form",
".",
"cleaned_data",
")",
"novo",
".",
"save",
"(",
")",
"return",
"redirect",
"(",
"'funcionario'",
")",
"else",
":",
"form",
"=",
"FuncionarioForm",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"cadastrar_funcionario.html\"",
",",
"{",
"\"form\"",
":",
"form",
"}",
")"
] | [
68,
0
] | [
78,
72
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
KB_AgentProgram | (KB) | return program | Um programa genérico de agente baseado em conhecimento lógico. | Um programa genérico de agente baseado em conhecimento lógico. | def KB_AgentProgram(KB):
"""Um programa genérico de agente baseado em conhecimento lógico."""
steps = itertools.count()
def program(percept):
t = next(steps)
KB.tell(make_percept_sentence(percept, t))
action = KB.ask(make_action_query(t))
KB.tell(make_action_sentence(action, t))
return action
def make_percept_sentence(self, percept, t):
return Expr("Percept")(percept, t)
def make_action_query(self, t):
return expr("ShouldDo(action, {})".format(t))
def make_action_sentence(self, action, t):
return Expr("Did")(action[expr('action')], t)
return program | [
"def",
"KB_AgentProgram",
"(",
"KB",
")",
":",
"steps",
"=",
"itertools",
".",
"count",
"(",
")",
"def",
"program",
"(",
"percept",
")",
":",
"t",
"=",
"next",
"(",
"steps",
")",
"KB",
".",
"tell",
"(",
"make_percept_sentence",
"(",
"percept",
",",
"t",
")",
")",
"action",
"=",
"KB",
".",
"ask",
"(",
"make_action_query",
"(",
"t",
")",
")",
"KB",
".",
"tell",
"(",
"make_action_sentence",
"(",
"action",
",",
"t",
")",
")",
"return",
"action",
"def",
"make_percept_sentence",
"(",
"self",
",",
"percept",
",",
"t",
")",
":",
"return",
"Expr",
"(",
"\"Percept\"",
")",
"(",
"percept",
",",
"t",
")",
"def",
"make_action_query",
"(",
"self",
",",
"t",
")",
":",
"return",
"expr",
"(",
"\"ShouldDo(action, {})\"",
".",
"format",
"(",
"t",
")",
")",
"def",
"make_action_sentence",
"(",
"self",
",",
"action",
",",
"t",
")",
":",
"return",
"Expr",
"(",
"\"Did\"",
")",
"(",
"action",
"[",
"expr",
"(",
"'action'",
")",
"]",
",",
"t",
")",
"return",
"program"
] | [
103,
0
] | [
123,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_all_agents_by_user | (username) | return Agent.objects.filter(user__name=username) | Traga todos os agentes de associados a um usuário pelo nome do usuário | Traga todos os agentes de associados a um usuário pelo nome do usuário | def get_all_agents_by_user(username) -> Agent:
"""Traga todos os agentes de associados a um usuário pelo nome do usuário"""
return Agent.objects.filter(user__name=username) | [
"def",
"get_all_agents_by_user",
"(",
"username",
")",
"->",
"Agent",
":",
"return",
"Agent",
".",
"objects",
".",
"filter",
"(",
"user__name",
"=",
"username",
")"
] | [
31,
0
] | [
33,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
MinhaUFOP.cardapio_do_ru | (self, **kwargs) | Retorna o cardapio do RU para a semana
Kwargs:
dia_da_semana (int): Retorna o cardápio para o dia da semana
informado. 0 a 4, onde 0 é segunda e 4 é sexta.
url (str): URL para fazer a requisição ao servidor
headers (dict): Headers da requisição ao servidor
Raises:
MinhaUFOPHTTPError: O servidor retornou o código {código HTTP}
| Retorna o cardapio do RU para a semana | def cardapio_do_ru(self, **kwargs) -> dict:
"""Retorna o cardapio do RU para a semana
Kwargs:
dia_da_semana (int): Retorna o cardápio para o dia da semana
informado. 0 a 4, onde 0 é segunda e 4 é sexta.
url (str): URL para fazer a requisição ao servidor
headers (dict): Headers da requisição ao servidor
Raises:
MinhaUFOPHTTPError: O servidor retornou o código {código HTTP}
"""
dia = kwargs.get('dia_da_semana')
url = kwargs.get('url', "https://zeppelin10.ufop.br/api/v1/ru/cardapio")
headers = kwargs.get('headers', {'Authorization': f'Bearer {self.token}'})
response = requests.request("GET", url, headers=headers)
if response.ok:
if dia:
return response.json()[dia]
else:
return response.json()
else:
raise MinhaUFOPHTTPError(response) | [
"def",
"cardapio_do_ru",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
"->",
"dict",
":",
"dia",
"=",
"kwargs",
".",
"get",
"(",
"'dia_da_semana'",
")",
"url",
"=",
"kwargs",
".",
"get",
"(",
"'url'",
",",
"\"https://zeppelin10.ufop.br/api/v1/ru/cardapio\"",
")",
"headers",
"=",
"kwargs",
".",
"get",
"(",
"'headers'",
",",
"{",
"'Authorization'",
":",
"f'Bearer {self.token}'",
"}",
")",
"response",
"=",
"requests",
".",
"request",
"(",
"\"GET\"",
",",
"url",
",",
"headers",
"=",
"headers",
")",
"if",
"response",
".",
"ok",
":",
"if",
"dia",
":",
"return",
"response",
".",
"json",
"(",
")",
"[",
"dia",
"]",
"else",
":",
"return",
"response",
".",
"json",
"(",
")",
"else",
":",
"raise",
"MinhaUFOPHTTPError",
"(",
"response",
")"
] | [
113,
4
] | [
139,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Ordem_Servico.get_ordem_servico_atrasada | (self) | Mostra datas agendadas atrasadas em cor vermelha
no devsys-ordemservicos.html | Mostra datas agendadas atrasadas em cor vermelha
no devsys-ordemservicos.html | def get_ordem_servico_atrasada(self):
""" Mostra datas agendadas atrasadas em cor vermelha
no devsys-ordemservicos.html"""
if self.dt_agenda < datetime.now():
return True
else:
return False | [
"def",
"get_ordem_servico_atrasada",
"(",
"self",
")",
":",
"if",
"self",
".",
"dt_agenda",
"<",
"datetime",
".",
"now",
"(",
")",
":",
"return",
"True",
"else",
":",
"return",
"False"
] | [
298,
4
] | [
304,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
city_country | (city, country) | return information_city | Informa sobre o país em que uma dada cidade se encontra. | Informa sobre o país em que uma dada cidade se encontra. | def city_country(city, country):
"""Informa sobre o país em que uma dada cidade se encontra."""
information_city = city + ', ' + country
return information_city | [
"def",
"city_country",
"(",
"city",
",",
"country",
")",
":",
"information_city",
"=",
"city",
"+",
"', '",
"+",
"country",
"return",
"information_city"
] | [
2,
0
] | [
5,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Pesquisador.doSumarioUFCG | (self) | return result | Chamada no jupyter notebook para gerar relatório geral do pesquisador.
Returns:
type: Dicionário com elementos do Sistema, Sumários e dados listados de produção.
| Chamada no jupyter notebook para gerar relatório geral do pesquisador. | def doSumarioUFCG(self):
"""Chamada no jupyter notebook para gerar relatório geral do pesquisador.
Returns:
type: Dicionário com elementos do Sistema, Sumários e dados listados de produção.
"""
dadosGlobais = self.carregaDadosGlobais()
flag = self.getDadosBasicos()
if flag:
#----Arquivos externos utilizados
tmp = self.validaPath();
dfExternos = pd.DataFrame([tmp])
# try:
# tmp = self.ID
# except AttributeError as error:
# print('BAD XML:')
# return
#else:
#----Lendo dados de XML
dadosGlobais = self.carregaDadosGlobais()
Pessoais = self.getDadosPessoais()
Titulacao = self.getDadosTitulacao()
Bibliografico = self.getProducaoBibliografica()
Apresentacoes = self.getApresentacoes()
Tecnico = self.getProducaoTecnica()
Outra = self.getProducaoOutra()
Complementares = self.getDadosComplementares()
#----Colunas
cols_final_Pessoais = ['DATA-ATUALIZACAO', 'ID', 'CPF', 'Matrícula', 'IES', 'Lotação', 'NOME-COMPLETO']
cols_final_Demograficos = ['NOME-COMPLETO', 'DATA-NASCIMENTO','NACIONALIDADE', 'RACA-OU-COR', 'SEXO', 'UF-NASCIMENTO']
colsP = cols_final_Pessoais + cols_final_Demograficos
cols_final_Titulos = ['ANO-DE-CONCLUSAO','ANO-DE-INICIO','TITULACAO', 'NOME-INSTITUICAO', 'NOME-AGENCIA', 'TIPO',
'SEQUENCIA-FORMACAO','NOME-CURSO', 'STATUS-DO-CURSO']
lista_final_Bib = ['ANO', 'SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA', 'CLASSIFICACAO-DO-EVENTO', 'NOME-DO-EVENTO', 'TITULO', 'PAIS','REVISTA']
lista_final_Tec = ['ANO', 'SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA','TIPO-PRODUCAO','TITULO']
lista_final_Apresentacoes = ['ANO', 'SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA','TITULO', 'IDIOMA', 'PAIS']
lista_final_Outra = ['ANO', 'SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA', 'TIPO-DE-ORIENTACAO-CONCLUIDA','TITULO', 'IDIOMA', 'PAIS']
lista_final_Complementares = ['ANO', 'SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA', 'TITULO', 'IDIOMA', 'PAIS']
Pessoais = self.fixDF(Pessoais,colsP)
Pessoal = Pessoais[cols_final_Pessoais]
Demografico = Pessoais[cols_final_Demograficos]
Titulacao = Titulacao[cols_final_Titulos]
Bibliografico = self.fixDF(Bibliografico, lista_final_Bib)
Tecnico = self.fixDF(Tecnico, lista_final_Tec)
Apresentacoes = self.fixDF(Apresentacoes, lista_final_Apresentacoes)
Outra = self.fixDF(Outra, lista_final_Outra)
Complementares = self.fixDF(Complementares, lista_final_Complementares)
colunasResumo = ['PRODUCAO', 'NATUREZA', 'TIPO','SEQUENCIA-PRODUCAO', 'PAIS']
Bibliografico = Bibliografico.rename(columns={'CLASSIFICACAO-DO-EVENTO':'TIPO'})
Tecnico = Tecnico.rename(columns={'TIPO_PRODUCAO':'TIPO'})
Outra = Outra.rename(columns={'TIPO-DE-ORIENTACAO-CONCLUIDA':'TIPO'})
produtos = [Bibliografico, Apresentacoes, Tecnico, Outra, Complementares]
resumos= [self.fixDF(df,colunasResumo) for df in produtos]
df = pd.concat(resumos)
df = df.replace({'':'VAZIO'})
df.loc[:,'flag_Nacional'] = df['PAIS'].apply(lambda val: 'Nacional' if str(val)=='Brasil' else ('Internacional' if len(val)!=0 else "VAZIO"))
dfPontos = df.merge(self.Pontos, on = ['PRODUCAO','NATUREZA','flag_Nacional'], how = 'left')
dfPontos = dfPontos.dropna(axis = 0)
dfPontos = dfPontos[['LATTES', 'PRODUCAO','NATUREZA','flag_Nacional','SEQUENCIA-PRODUCAO','PONTOS','MAX']]
dfSum = dfPontos.groupby(['LATTES', 'PRODUCAO','NATUREZA','flag_Nacional']).agg({'SEQUENCIA-PRODUCAO':'nunique', 'PONTOS':'max', 'MAX':'max'}).reset_index()
dfSum['Pontuacao'] = np.where(((dfSum['SEQUENCIA-PRODUCAO']*dfSum['PONTOS']<= dfSum['MAX']) & (dfSum['MAX']!=0)),
dfSum['SEQUENCIA-PRODUCAO']*dfSum['PONTOS'], dfSum['MAX'])
nota_Producao = dfSum['Pontuacao'].sum()
try:
CPF = self.root.find('DADOS-GERAIS').attrib['CPF']
except:
CPF = self.file.split('/')[-1].split('-')[0]
try:
ano_doutor = int(Titulacao[Titulacao['TITULACAO']=='DOUTORADO']['ANO-DE-CONCLUSAO'].max())
except (UnboundLocalError, ValueError, TypeError) as error:
ano_doutor = 0.0
if isinstance(CPF,str):
try:
DATA_saap = self.SAAP
DATA_saap = self.SAAP[['CPF_NUMERO','AVALIACOES']]
DATA_saap.columns = ['CPF',"AVALIACOES"]
except AttributeError as error:
n_saap = 0
else:
DATA_saap = DATA_saap.copy()
DATA_saap.loc[:,'CPF'] = DATA_saap['CPF'].astype(str)
DATA_saap.loc[:,'PONTOS'] = DATA_saap['AVALIACOES']*0.25
n_saap = max(DATA_saap[DATA_saap['CPF']== CPF]['PONTOS'].values,2) if CPF in DATA_saap['CPF'].tolist() else 0
finally:
NOTA_Doutorado = 12 if (2020-ano_doutor)<=5 else ( 8 if ano_doutor!=0 else 0)
NOTA_CVP = n_saap + NOTA_Doutorado + nota_Producao
AREA = self.getArea()
if AREA is not None:
Area = ' '.join(self.getArea())
infoCVP = {'ID':self.ID,
'NOME':unidecode(self.NOME.strip().upper()),
'CPF': CPF,
'CPF_SAAP':self.file.split('/')[-1].split('.')[0].split('-')[0],
'ID_proj':self.file.split('/')[-1].split('.')[0].split('-')[1],
'EDITAL': self.file.split('/')[-2].split('-')[0],
'AREA':Area,
'PRODUCAO':nota_Producao, 'DOUTOR':ano_doutor, 'SAAP':n_saap,
'NOTA':NOTA_CVP}
df = pd.DataFrame([infoCVP])
result = [df, dfPontos, dfSum, Pessoal, Demografico, Titulacao]
else:
print('BAD XML:')
return
return result | [
"def",
"doSumarioUFCG",
"(",
"self",
")",
":",
"dadosGlobais",
"=",
"self",
".",
"carregaDadosGlobais",
"(",
")",
"flag",
"=",
"self",
".",
"getDadosBasicos",
"(",
")",
"if",
"flag",
":",
"#----Arquivos externos utilizados",
"tmp",
"=",
"self",
".",
"validaPath",
"(",
")",
"dfExternos",
"=",
"pd",
".",
"DataFrame",
"(",
"[",
"tmp",
"]",
")",
"# try:",
"# tmp = self.ID",
"# except AttributeError as error:",
"# print('BAD XML:')",
"# return",
"#else:",
"#----Lendo dados de XML",
"dadosGlobais",
"=",
"self",
".",
"carregaDadosGlobais",
"(",
")",
"Pessoais",
"=",
"self",
".",
"getDadosPessoais",
"(",
")",
"Titulacao",
"=",
"self",
".",
"getDadosTitulacao",
"(",
")",
"Bibliografico",
"=",
"self",
".",
"getProducaoBibliografica",
"(",
")",
"Apresentacoes",
"=",
"self",
".",
"getApresentacoes",
"(",
")",
"Tecnico",
"=",
"self",
".",
"getProducaoTecnica",
"(",
")",
"Outra",
"=",
"self",
".",
"getProducaoOutra",
"(",
")",
"Complementares",
"=",
"self",
".",
"getDadosComplementares",
"(",
")",
"#----Colunas",
"cols_final_Pessoais",
"=",
"[",
"'DATA-ATUALIZACAO'",
",",
"'ID'",
",",
"'CPF'",
",",
"'Matrícula',",
" ",
"IES',",
" ",
"Lotação', '",
"N",
"ME-COMPLETO']",
"",
"cols_final_Demograficos",
"=",
"[",
"'NOME-COMPLETO'",
",",
"'DATA-NASCIMENTO'",
",",
"'NACIONALIDADE'",
",",
"'RACA-OU-COR'",
",",
"'SEXO'",
",",
"'UF-NASCIMENTO'",
"]",
"colsP",
"=",
"cols_final_Pessoais",
"+",
"cols_final_Demograficos",
"cols_final_Titulos",
"=",
"[",
"'ANO-DE-CONCLUSAO'",
",",
"'ANO-DE-INICIO'",
",",
"'TITULACAO'",
",",
"'NOME-INSTITUICAO'",
",",
"'NOME-AGENCIA'",
",",
"'TIPO'",
",",
"'SEQUENCIA-FORMACAO'",
",",
"'NOME-CURSO'",
",",
"'STATUS-DO-CURSO'",
"]",
"lista_final_Bib",
"=",
"[",
"'ANO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'CLASSIFICACAO-DO-EVENTO'",
",",
"'NOME-DO-EVENTO'",
",",
"'TITULO'",
",",
"'PAIS'",
",",
"'REVISTA'",
"]",
"lista_final_Tec",
"=",
"[",
"'ANO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TIPO-PRODUCAO'",
",",
"'TITULO'",
"]",
"lista_final_Apresentacoes",
"=",
"[",
"'ANO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'IDIOMA'",
",",
"'PAIS'",
"]",
"lista_final_Outra",
"=",
"[",
"'ANO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TIPO-DE-ORIENTACAO-CONCLUIDA'",
",",
"'TITULO'",
",",
"'IDIOMA'",
",",
"'PAIS'",
"]",
"lista_final_Complementares",
"=",
"[",
"'ANO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'IDIOMA'",
",",
"'PAIS'",
"]",
"Pessoais",
"=",
"self",
".",
"fixDF",
"(",
"Pessoais",
",",
"colsP",
")",
"Pessoal",
"=",
"Pessoais",
"[",
"cols_final_Pessoais",
"]",
"Demografico",
"=",
"Pessoais",
"[",
"cols_final_Demograficos",
"]",
"Titulacao",
"=",
"Titulacao",
"[",
"cols_final_Titulos",
"]",
"Bibliografico",
"=",
"self",
".",
"fixDF",
"(",
"Bibliografico",
",",
"lista_final_Bib",
")",
"Tecnico",
"=",
"self",
".",
"fixDF",
"(",
"Tecnico",
",",
"lista_final_Tec",
")",
"Apresentacoes",
"=",
"self",
".",
"fixDF",
"(",
"Apresentacoes",
",",
"lista_final_Apresentacoes",
")",
"Outra",
"=",
"self",
".",
"fixDF",
"(",
"Outra",
",",
"lista_final_Outra",
")",
"Complementares",
"=",
"self",
".",
"fixDF",
"(",
"Complementares",
",",
"lista_final_Complementares",
")",
"colunasResumo",
"=",
"[",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TIPO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PAIS'",
"]",
"Bibliografico",
"=",
"Bibliografico",
".",
"rename",
"(",
"columns",
"=",
"{",
"'CLASSIFICACAO-DO-EVENTO'",
":",
"'TIPO'",
"}",
")",
"Tecnico",
"=",
"Tecnico",
".",
"rename",
"(",
"columns",
"=",
"{",
"'TIPO_PRODUCAO'",
":",
"'TIPO'",
"}",
")",
"Outra",
"=",
"Outra",
".",
"rename",
"(",
"columns",
"=",
"{",
"'TIPO-DE-ORIENTACAO-CONCLUIDA'",
":",
"'TIPO'",
"}",
")",
"produtos",
"=",
"[",
"Bibliografico",
",",
"Apresentacoes",
",",
"Tecnico",
",",
"Outra",
",",
"Complementares",
"]",
"resumos",
"=",
"[",
"self",
".",
"fixDF",
"(",
"df",
",",
"colunasResumo",
")",
"for",
"df",
"in",
"produtos",
"]",
"df",
"=",
"pd",
".",
"concat",
"(",
"resumos",
")",
"df",
"=",
"df",
".",
"replace",
"(",
"{",
"''",
":",
"'VAZIO'",
"}",
")",
"df",
".",
"loc",
"[",
":",
",",
"'flag_Nacional'",
"]",
"=",
"df",
"[",
"'PAIS'",
"]",
".",
"apply",
"(",
"lambda",
"val",
":",
"'Nacional'",
"if",
"str",
"(",
"val",
")",
"==",
"'Brasil'",
"else",
"(",
"'Internacional'",
"if",
"len",
"(",
"val",
")",
"!=",
"0",
"else",
"\"VAZIO\"",
")",
")",
"dfPontos",
"=",
"df",
".",
"merge",
"(",
"self",
".",
"Pontos",
",",
"on",
"=",
"[",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'flag_Nacional'",
"]",
",",
"how",
"=",
"'left'",
")",
"dfPontos",
"=",
"dfPontos",
".",
"dropna",
"(",
"axis",
"=",
"0",
")",
"dfPontos",
"=",
"dfPontos",
"[",
"[",
"'LATTES'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'flag_Nacional'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'PONTOS'",
",",
"'MAX'",
"]",
"]",
"dfSum",
"=",
"dfPontos",
".",
"groupby",
"(",
"[",
"'LATTES'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'flag_Nacional'",
"]",
")",
".",
"agg",
"(",
"{",
"'SEQUENCIA-PRODUCAO'",
":",
"'nunique'",
",",
"'PONTOS'",
":",
"'max'",
",",
"'MAX'",
":",
"'max'",
"}",
")",
".",
"reset_index",
"(",
")",
"dfSum",
"[",
"'Pontuacao'",
"]",
"=",
"np",
".",
"where",
"(",
"(",
"(",
"dfSum",
"[",
"'SEQUENCIA-PRODUCAO'",
"]",
"*",
"dfSum",
"[",
"'PONTOS'",
"]",
"<=",
"dfSum",
"[",
"'MAX'",
"]",
")",
"&",
"(",
"dfSum",
"[",
"'MAX'",
"]",
"!=",
"0",
")",
")",
",",
"dfSum",
"[",
"'SEQUENCIA-PRODUCAO'",
"]",
"*",
"dfSum",
"[",
"'PONTOS'",
"]",
",",
"dfSum",
"[",
"'MAX'",
"]",
")",
"nota_Producao",
"=",
"dfSum",
"[",
"'Pontuacao'",
"]",
".",
"sum",
"(",
")",
"try",
":",
"CPF",
"=",
"self",
".",
"root",
".",
"find",
"(",
"'DADOS-GERAIS'",
")",
".",
"attrib",
"[",
"'CPF'",
"]",
"except",
":",
"CPF",
"=",
"self",
".",
"file",
".",
"split",
"(",
"'/'",
")",
"[",
"-",
"1",
"]",
".",
"split",
"(",
"'-'",
")",
"[",
"0",
"]",
"try",
":",
"ano_doutor",
"=",
"int",
"(",
"Titulacao",
"[",
"Titulacao",
"[",
"'TITULACAO'",
"]",
"==",
"'DOUTORADO'",
"]",
"[",
"'ANO-DE-CONCLUSAO'",
"]",
".",
"max",
"(",
")",
")",
"except",
"(",
"UnboundLocalError",
",",
"ValueError",
",",
"TypeError",
")",
"as",
"error",
":",
"ano_doutor",
"=",
"0.0",
"if",
"isinstance",
"(",
"CPF",
",",
"str",
")",
":",
"try",
":",
"DATA_saap",
"=",
"self",
".",
"SAAP",
"DATA_saap",
"=",
"self",
".",
"SAAP",
"[",
"[",
"'CPF_NUMERO'",
",",
"'AVALIACOES'",
"]",
"]",
"DATA_saap",
".",
"columns",
"=",
"[",
"'CPF'",
",",
"\"AVALIACOES\"",
"]",
"except",
"AttributeError",
"as",
"error",
":",
"n_saap",
"=",
"0",
"else",
":",
"DATA_saap",
"=",
"DATA_saap",
".",
"copy",
"(",
")",
"DATA_saap",
".",
"loc",
"[",
":",
",",
"'CPF'",
"]",
"=",
"DATA_saap",
"[",
"'CPF'",
"]",
".",
"astype",
"(",
"str",
")",
"DATA_saap",
".",
"loc",
"[",
":",
",",
"'PONTOS'",
"]",
"=",
"DATA_saap",
"[",
"'AVALIACOES'",
"]",
"*",
"0.25",
"n_saap",
"=",
"max",
"(",
"DATA_saap",
"[",
"DATA_saap",
"[",
"'CPF'",
"]",
"==",
"CPF",
"]",
"[",
"'PONTOS'",
"]",
".",
"values",
",",
"2",
")",
"if",
"CPF",
"in",
"DATA_saap",
"[",
"'CPF'",
"]",
".",
"tolist",
"(",
")",
"else",
"0",
"finally",
":",
"NOTA_Doutorado",
"=",
"12",
"if",
"(",
"2020",
"-",
"ano_doutor",
")",
"<=",
"5",
"else",
"(",
"8",
"if",
"ano_doutor",
"!=",
"0",
"else",
"0",
")",
"NOTA_CVP",
"=",
"n_saap",
"+",
"NOTA_Doutorado",
"+",
"nota_Producao",
"AREA",
"=",
"self",
".",
"getArea",
"(",
")",
"if",
"AREA",
"is",
"not",
"None",
":",
"Area",
"=",
"' '",
".",
"join",
"(",
"self",
".",
"getArea",
"(",
")",
")",
"infoCVP",
"=",
"{",
"'ID'",
":",
"self",
".",
"ID",
",",
"'NOME'",
":",
"unidecode",
"(",
"self",
".",
"NOME",
".",
"strip",
"(",
")",
".",
"upper",
"(",
")",
")",
",",
"'CPF'",
":",
"CPF",
",",
"'CPF_SAAP'",
":",
"self",
".",
"file",
".",
"split",
"(",
"'/'",
")",
"[",
"-",
"1",
"]",
".",
"split",
"(",
"'.'",
")",
"[",
"0",
"]",
".",
"split",
"(",
"'-'",
")",
"[",
"0",
"]",
",",
"'ID_proj'",
":",
"self",
".",
"file",
".",
"split",
"(",
"'/'",
")",
"[",
"-",
"1",
"]",
".",
"split",
"(",
"'.'",
")",
"[",
"0",
"]",
".",
"split",
"(",
"'-'",
")",
"[",
"1",
"]",
",",
"'EDITAL'",
":",
"self",
".",
"file",
".",
"split",
"(",
"'/'",
")",
"[",
"-",
"2",
"]",
".",
"split",
"(",
"'-'",
")",
"[",
"0",
"]",
",",
"'AREA'",
":",
"Area",
",",
"'PRODUCAO'",
":",
"nota_Producao",
",",
"'DOUTOR'",
":",
"ano_doutor",
",",
"'SAAP'",
":",
"n_saap",
",",
"'NOTA'",
":",
"NOTA_CVP",
"}",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
"[",
"infoCVP",
"]",
")",
"result",
"=",
"[",
"df",
",",
"dfPontos",
",",
"dfSum",
",",
"Pessoal",
",",
"Demografico",
",",
"Titulacao",
"]",
"else",
":",
"print",
"(",
"'BAD XML:'",
")",
"return",
"return",
"result"
] | [
1005,
4
] | [
1116,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Cadastral.mostra_detalhes_fundo | (self, cnpj) | Mostra detalhes cadastral do fundo. | Mostra detalhes cadastral do fundo. | def mostra_detalhes_fundo(self, cnpj):
"""Mostra detalhes cadastral do fundo."""
try:
fundo_df = self.busca_fundo_cnpj(cnpj).copy()
except KeyError:
msg("red", "Erro: Fundo com cnpj {} nao encontrado".format(cnpj), 1)
fundo_df.rename(index=self.csv_columns, inplace=True)
for col in fundo_df.index:
msg("cyan", col, end=": ")
msg("nocolor", fundo_df.loc[col]) | [
"def",
"mostra_detalhes_fundo",
"(",
"self",
",",
"cnpj",
")",
":",
"try",
":",
"fundo_df",
"=",
"self",
".",
"busca_fundo_cnpj",
"(",
"cnpj",
")",
".",
"copy",
"(",
")",
"except",
"KeyError",
":",
"msg",
"(",
"\"red\"",
",",
"\"Erro: Fundo com cnpj {} nao encontrado\"",
".",
"format",
"(",
"cnpj",
")",
",",
"1",
")",
"fundo_df",
".",
"rename",
"(",
"index",
"=",
"self",
".",
"csv_columns",
",",
"inplace",
"=",
"True",
")",
"for",
"col",
"in",
"fundo_df",
".",
"index",
":",
"msg",
"(",
"\"cyan\"",
",",
"col",
",",
"end",
"=",
"\": \"",
")",
"msg",
"(",
"\"nocolor\"",
",",
"fundo_df",
".",
"loc",
"[",
"col",
"]",
")"
] | [
289,
4
] | [
299,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GnomeSort.__iteractiveGnomeSort | (self,array,leftIndex,rightIndex) | Implementação do método GnomeSort de forma iterativa
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| Implementação do método GnomeSort de forma iterativa
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| def __iteractiveGnomeSort(self,array,leftIndex,rightIndex):
"""Implementação do método GnomeSort de forma iterativa
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
"""
pivot = leftIndex +1
while(pivot <= rightIndex):
if(array[pivot] >= array[pivot -1]):
pivot = pivot +1
else:
array[pivot] , array[pivot -1] = array[pivot -1] , array[pivot]
if(pivot > leftIndex + 1):
pivot = pivot -1
else:
pivot = pivot + 1 | [
"def",
"__iteractiveGnomeSort",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
")",
":",
"pivot",
"=",
"leftIndex",
"+",
"1",
"while",
"(",
"pivot",
"<=",
"rightIndex",
")",
":",
"if",
"(",
"array",
"[",
"pivot",
"]",
">=",
"array",
"[",
"pivot",
"-",
"1",
"]",
")",
":",
"pivot",
"=",
"pivot",
"+",
"1",
"else",
":",
"array",
"[",
"pivot",
"]",
",",
"array",
"[",
"pivot",
"-",
"1",
"]",
"=",
"array",
"[",
"pivot",
"-",
"1",
"]",
",",
"array",
"[",
"pivot",
"]",
"if",
"(",
"pivot",
">",
"leftIndex",
"+",
"1",
")",
":",
"pivot",
"=",
"pivot",
"-",
"1",
"else",
":",
"pivot",
"=",
"pivot",
"+",
"1"
] | [
36,
1
] | [
53,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
senhas_nao_iguais | (senha, senha2) | return senha != senha2 | Verifica se as senhas digitadas não são iguais | Verifica se as senhas digitadas não são iguais | def senhas_nao_iguais(senha, senha2):
"""Verifica se as senhas digitadas não são iguais"""
return senha != senha2 | [
"def",
"senhas_nao_iguais",
"(",
"senha",
",",
"senha2",
")",
":",
"return",
"senha",
"!=",
"senha2"
] | [
81,
0
] | [
83,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DType63.npad | (self) | return bin2int(self.data[BYTES_63[20]]) | F20 - Valor que varia de 0 a 3 indicando o preenchimento nulo para manter o tamanho do bloco (em bytes) fixo | F20 - Valor que varia de 0 a 3 indicando o preenchimento nulo para manter o tamanho do bloco (em bytes) fixo | def npad(self) -> int:
"""F20 - Valor que varia de 0 a 3 indicando o preenchimento nulo para manter o tamanho do bloco (em bytes) fixo"""
return bin2int(self.data[BYTES_63[20]]) | [
"def",
"npad",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_63",
"[",
"20",
"]",
"]",
")"
] | [
1117,
4
] | [
1119,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
cria_receita | (request) | Cria uma nova receita | Cria uma nova receita | def cria_receita(request):
"""Cria uma nova receita"""
if request.user.is_authenticated:
if request.method == 'POST':
nome_receita = request.POST['nome_receita']
ingredientes = request.POST['ingredientes']
modo_preparo = request.POST['modo_preparo']
tempo_preparo = request.POST['tempo_preparo']
rendimento = request.POST['rendimento']
categoria = request.POST['categoria']
foto_receita = request.FILES['foto_receita']#por se tratar de um dado do tipo file
user = get_object_or_404(User, pk=request.user.id)
if campo_vazio(nome_receita):
messages.error(request, 'Nome da receita é obrigatório')
return redirect('cria_receita')
if campo_vazio(ingredientes):
messages.error(request, 'ingredientes são obrigatórios')
return redirect('cria_receita')
if campo_vazio(modo_preparo):
messages.error(request, 'Modo de preparo é obrigatório')
return redirect('cria_receita')
if campo_vazio(tempo_preparo):
messages.error(request, 'tempo de preparo é obrigatório')
return redirect('cria_receita')
if campo_vazio(rendimento):
messages.error(request, 'rendimento é obrigatórios')
return redirect('cria_receita')
if campo_vazio(categoria):
messages.error(request, 'categoria é obrigatório')
return redirect('cria_receita')
receita = Receita.objects.create(
pessoa=user,
nome_receita=nome_receita,
ingredientes=ingredientes,
modo_preparo=modo_preparo,
tempo_preparo=tempo_preparo,
rendimento=rendimento,
categoria=categoria,
publicado=False,
foto_receita=foto_receita
)
receita.save()
return redirect('dashboard')
else:
return render(request, 'cria_receita.html')
else:
return redirect('index') | [
"def",
"cria_receita",
"(",
"request",
")",
":",
"if",
"request",
".",
"user",
".",
"is_authenticated",
":",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"nome_receita",
"=",
"request",
".",
"POST",
"[",
"'nome_receita'",
"]",
"ingredientes",
"=",
"request",
".",
"POST",
"[",
"'ingredientes'",
"]",
"modo_preparo",
"=",
"request",
".",
"POST",
"[",
"'modo_preparo'",
"]",
"tempo_preparo",
"=",
"request",
".",
"POST",
"[",
"'tempo_preparo'",
"]",
"rendimento",
"=",
"request",
".",
"POST",
"[",
"'rendimento'",
"]",
"categoria",
"=",
"request",
".",
"POST",
"[",
"'categoria'",
"]",
"foto_receita",
"=",
"request",
".",
"FILES",
"[",
"'foto_receita'",
"]",
"#por se tratar de um dado do tipo file",
"user",
"=",
"get_object_or_404",
"(",
"User",
",",
"pk",
"=",
"request",
".",
"user",
".",
"id",
")",
"if",
"campo_vazio",
"(",
"nome_receita",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'Nome da receita é obrigatório')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"if",
"campo_vazio",
"(",
"ingredientes",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'ingredientes são obrigatórios')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"if",
"campo_vazio",
"(",
"modo_preparo",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'Modo de preparo é obrigatório')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"if",
"campo_vazio",
"(",
"tempo_preparo",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'tempo de preparo é obrigatório')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"if",
"campo_vazio",
"(",
"rendimento",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'rendimento é obrigatórios')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"if",
"campo_vazio",
"(",
"categoria",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'categoria é obrigatório')",
"",
"return",
"redirect",
"(",
"'cria_receita'",
")",
"receita",
"=",
"Receita",
".",
"objects",
".",
"create",
"(",
"pessoa",
"=",
"user",
",",
"nome_receita",
"=",
"nome_receita",
",",
"ingredientes",
"=",
"ingredientes",
",",
"modo_preparo",
"=",
"modo_preparo",
",",
"tempo_preparo",
"=",
"tempo_preparo",
",",
"rendimento",
"=",
"rendimento",
",",
"categoria",
"=",
"categoria",
",",
"publicado",
"=",
"False",
",",
"foto_receita",
"=",
"foto_receita",
")",
"receita",
".",
"save",
"(",
")",
"return",
"redirect",
"(",
"'dashboard'",
")",
"else",
":",
"return",
"render",
"(",
"request",
",",
"'cria_receita.html'",
")",
"else",
":",
"return",
"redirect",
"(",
"'index'",
")"
] | [
28,
0
] | [
81,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestCnh.test_special_case | (self) | Verifica os casos especiais de CNH | Verifica os casos especiais de CNH | def test_special_case(self):
""" Verifica os casos especiais de CNH """
cases = [
('00000000000', False),
('AAAAAAAAAAA', False),
('78623161668', False),
('0123 456 789 10', False),
('65821310502', True),
('658 213 105 02', True),
('10764125809', True),
('77625261946', True)
]
for cnh, is_valid in cases:
self.assertEqual(self.cnh.validate(cnh), is_valid) | [
"def",
"test_special_case",
"(",
"self",
")",
":",
"cases",
"=",
"[",
"(",
"'00000000000'",
",",
"False",
")",
",",
"(",
"'AAAAAAAAAAA'",
",",
"False",
")",
",",
"(",
"'78623161668'",
",",
"False",
")",
",",
"(",
"'0123 456 789 10'",
",",
"False",
")",
",",
"(",
"'65821310502'",
",",
"True",
")",
",",
"(",
"'658 213 105 02'",
",",
"True",
")",
",",
"(",
"'10764125809'",
",",
"True",
")",
",",
"(",
"'77625261946'",
",",
"True",
")",
"]",
"for",
"cnh",
",",
"is_valid",
"in",
"cases",
":",
"self",
".",
"assertEqual",
"(",
"self",
".",
"cnh",
".",
"validate",
"(",
"cnh",
")",
",",
"is_valid",
")"
] | [
31,
4
] | [
44,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
start_new_level | (ai_settings, screen, stats, sb, ship, aliens) | Inicia um novo nivel do jogo. | Inicia um novo nivel do jogo. | def start_new_level(ai_settings, screen, stats, sb, ship, aliens):
"""Inicia um novo nivel do jogo."""
stats.level += 1
sb.prep_level()
create_fleet(ai_settings, screen, ship, aliens) | [
"def",
"start_new_level",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
")",
":",
"stats",
".",
"level",
"+=",
"1",
"sb",
".",
"prep_level",
"(",
")",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")"
] | [
137,
0
] | [
141,
51
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
conversion_journals_to_kernel | (journals: list) | return [conversion_journal_to_bundle(journal) for journal in journals] | Transforma uma lista de periódicos não normalizados em
uma lista de periódicos em formato Kernel | Transforma uma lista de periódicos não normalizados em
uma lista de periódicos em formato Kernel | def conversion_journals_to_kernel(journals: list) -> list:
"""Transforma uma lista de periódicos não normalizados em
uma lista de periódicos em formato Kernel"""
logger.info("Convertendo %d periódicos para formato Kernel" % (len(journals)))
return [conversion_journal_to_bundle(journal) for journal in journals] | [
"def",
"conversion_journals_to_kernel",
"(",
"journals",
":",
"list",
")",
"->",
"list",
":",
"logger",
".",
"info",
"(",
"\"Convertendo %d periódicos para formato Kernel\" ",
" ",
"l",
"en(",
"j",
"ournals)",
")",
")",
"",
"return",
"[",
"conversion_journal_to_bundle",
"(",
"journal",
")",
"for",
"journal",
"in",
"journals",
"]"
] | [
153,
0
] | [
158,
74
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
BaseDoc.mask | (self, doc: str = '') | Mascara o documento enviado | Mascara o documento enviado | def mask(self, doc: str = '') -> str:
"""Mascara o documento enviado"""
pass | [
"def",
"mask",
"(",
"self",
",",
"doc",
":",
"str",
"=",
"''",
")",
"->",
"str",
":",
"pass"
] | [
40,
4
] | [
42,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
init_app | (app) | Inicilizando objeto DebugToolbar na Aplicação | Inicilizando objeto DebugToolbar na Aplicação | def init_app(app):
""" Inicilizando objeto DebugToolbar na Aplicação """
if app.debug:
DebugToolbarExtension(app) | [
"def",
"init_app",
"(",
"app",
")",
":",
"if",
"app",
".",
"debug",
":",
"DebugToolbarExtension",
"(",
"app",
")"
] | [
4,
0
] | [
7,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
plot_serie_erro | (erroD, erroC) | Plota a evolucao do erro com o refinamento da malha | Plota a evolucao do erro com o refinamento da malha | def plot_serie_erro(erroD, erroC):
''''Plota a evolucao do erro com o refinamento da malha'''
xspace = np.array([128, 256, 512, 1024, 2048])
plt.clf()
plt.plot(xspace, erroD)
plt.plot(xspace, erroC)
plt.ylim(0, 0.12)
plt.legend(['Erro Teste D', 'Erro Teste C'])
plt.ylabel('Erro quadrático')
plt.xlabel('N')
plt.suptitle('Evolução do erro em função de N')
plt.savefig('{}.png'.format('plots/erroXn'))
plt.show() | [
"def",
"plot_serie_erro",
"(",
"erroD",
",",
"erroC",
")",
":",
"xspace",
"=",
"np",
".",
"array",
"(",
"[",
"128",
",",
"256",
",",
"512",
",",
"1024",
",",
"2048",
"]",
")",
"plt",
".",
"clf",
"(",
")",
"plt",
".",
"plot",
"(",
"xspace",
",",
"erroD",
")",
"plt",
".",
"plot",
"(",
"xspace",
",",
"erroC",
")",
"plt",
".",
"ylim",
"(",
"0",
",",
"0.12",
")",
"plt",
".",
"legend",
"(",
"[",
"'Erro Teste D'",
",",
"'Erro Teste C'",
"]",
")",
"plt",
".",
"ylabel",
"(",
"'Erro quadrático')",
"\r",
"plt",
".",
"xlabel",
"(",
"'N'",
")",
"plt",
".",
"suptitle",
"(",
"'Evolução do erro em função de N')\r",
"",
"plt",
".",
"savefig",
"(",
"'{}.png'",
".",
"format",
"(",
"'plots/erroXn'",
")",
")",
"plt",
".",
"show",
"(",
")"
] | [
254,
0
] | [
266,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Environment.is_done | (self) | return not any(agent.is_alive() for agent in self.agents) | Por padrão, o programa encerra quando não podemos encontrar um agente vivo. | Por padrão, o programa encerra quando não podemos encontrar um agente vivo. | def is_done(self):
"Por padrão, o programa encerra quando não podemos encontrar um agente vivo."
return not any(agent.is_alive() for agent in self.agents) | [
"def",
"is_done",
"(",
"self",
")",
":",
"return",
"not",
"any",
"(",
"agent",
".",
"is_alive",
"(",
")",
"for",
"agent",
"in",
"self",
".",
"agents",
")"
] | [
164,
4
] | [
166,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RoteiroResource.handle_get | (self, request, user, *args, **kwargs) | Trata as requisições de GET para listar Roteiros.
URLs: roteiro/$
roteiro/tiporoteiro/<id_tipo_roteiro>/
roteiro/equipamento/<id_equip>/
| Trata as requisições de GET para listar Roteiros. | def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições de GET para listar Roteiros.
URLs: roteiro/$
roteiro/tiporoteiro/<id_tipo_roteiro>/
roteiro/equipamento/<id_equip>/
"""
try:
map_list = []
equipment_id = kwargs.get('id_equip')
if equipment_id is None:
if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
scripts = Roteiro.search(kwargs.get('id_tipo_roteiro'))
for script in scripts:
script_map = dict()
script_map['id'] = script.id
script_map['nome'] = script.roteiro
script_map['descricao'] = script.descricao
script_map['id_tipo_roteiro'] = script.tipo_roteiro_id
map_list.append(script_map)
else:
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.READ_OPERATION,
None,
equipment_id,
AdminPermission.EQUIP_READ_OPERATION):
return self.not_authorized()
equipment_scripts = EquipamentoRoteiro.search(
None, equipment_id)
for equipment_script in equipment_scripts:
script_map = dict()
script_map['id'] = equipment_script.roteiro.id
script_map['nome'] = equipment_script.roteiro.roteiro
script_map[
'descricao'] = equipment_script.roteiro.descricao
script_map[
'id_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.id
script_map[
'nome_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.tipo
script_map[
'descricao_tipo_roteiro'] = equipment_script.roteiro.tipo_roteiro.descricao
map_list.append(script_map)
return self.response(dumps_networkapi({'roteiro': map_list}))
except EquipamentoNotFoundError:
return self.response_error(117, equipment_id)
except (RoteiroError, GrupoError, EquipamentoError):
return self.response_error(1) | [
"def",
"handle_get",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"map_list",
"=",
"[",
"]",
"equipment_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_equip'",
")",
"if",
"equipment_id",
"is",
"None",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"SCRIPT_MANAGEMENT",
",",
"AdminPermission",
".",
"READ_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"scripts",
"=",
"Roteiro",
".",
"search",
"(",
"kwargs",
".",
"get",
"(",
"'id_tipo_roteiro'",
")",
")",
"for",
"script",
"in",
"scripts",
":",
"script_map",
"=",
"dict",
"(",
")",
"script_map",
"[",
"'id'",
"]",
"=",
"script",
".",
"id",
"script_map",
"[",
"'nome'",
"]",
"=",
"script",
".",
"roteiro",
"script_map",
"[",
"'descricao'",
"]",
"=",
"script",
".",
"descricao",
"script_map",
"[",
"'id_tipo_roteiro'",
"]",
"=",
"script",
".",
"tipo_roteiro_id",
"map_list",
".",
"append",
"(",
"script_map",
")",
"else",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"READ_OPERATION",
",",
"None",
",",
"equipment_id",
",",
"AdminPermission",
".",
"EQUIP_READ_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"equipment_scripts",
"=",
"EquipamentoRoteiro",
".",
"search",
"(",
"None",
",",
"equipment_id",
")",
"for",
"equipment_script",
"in",
"equipment_scripts",
":",
"script_map",
"=",
"dict",
"(",
")",
"script_map",
"[",
"'id'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"id",
"script_map",
"[",
"'nome'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"roteiro",
"script_map",
"[",
"'descricao'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"descricao",
"script_map",
"[",
"'id_tipo_roteiro'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"tipo_roteiro",
".",
"id",
"script_map",
"[",
"'nome_tipo_roteiro'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"tipo_roteiro",
".",
"tipo",
"script_map",
"[",
"'descricao_tipo_roteiro'",
"]",
"=",
"equipment_script",
".",
"roteiro",
".",
"tipo_roteiro",
".",
"descricao",
"map_list",
".",
"append",
"(",
"script_map",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'roteiro'",
":",
"map_list",
"}",
")",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equipment_id",
")",
"except",
"(",
"RoteiroError",
",",
"GrupoError",
",",
"EquipamentoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
37,
4
] | [
94,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.anterior | (self, previous = None, update = True) | Setter e getter do link para a linha prévia, por padrão também tenta atualizar o link dela para a seguinte (esta).
Atenção: não há atualização do link para a seguinte aqui se isso for solicitado explicitamente, assim podendo causar distorções e discordâncias se esse método for utilizado sozinho. | Setter e getter do link para a linha prévia, por padrão também tenta atualizar o link dela para a seguinte (esta).
Atenção: não há atualização do link para a seguinte aqui se isso for solicitado explicitamente, assim podendo causar distorções e discordâncias se esse método for utilizado sozinho. | def anterior (self, previous = None, update = True):
'''Setter e getter do link para a linha prévia, por padrão também tenta atualizar o link dela para a seguinte (esta).
Atenção: não há atualização do link para a seguinte aqui se isso for solicitado explicitamente, assim podendo causar distorções e discordâncias se esse método for utilizado sozinho.'''
try:
if previous == None:
return self.prev
if update:
previous.seguinte(self)
except AttributeError:
pass
self.prev = previous | [
"def",
"anterior",
"(",
"self",
",",
"previous",
"=",
"None",
",",
"update",
"=",
"True",
")",
":",
"try",
":",
"if",
"previous",
"==",
"None",
":",
"return",
"self",
".",
"prev",
"if",
"update",
":",
"previous",
".",
"seguinte",
"(",
"self",
")",
"except",
"AttributeError",
":",
"pass",
"self",
".",
"prev",
"=",
"previous"
] | [
171,
1
] | [
181,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Agent.can_grab | (self, thing) | return False | Retorna True se este agente pode pegar essa coisa.
Substituir para subclasses apropriadas de Agente e Coisa. | Retorna True se este agente pode pegar essa coisa.
Substituir para subclasses apropriadas de Agente e Coisa. | def can_grab(self, thing):
"""Retorna True se este agente pode pegar essa coisa.
Substituir para subclasses apropriadas de Agente e Coisa."""
return False | [
"def",
"can_grab",
"(",
"self",
",",
"thing",
")",
":",
"return",
"False"
] | [
57,
4
] | [
60,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Pesquisador.getDadosPessoais | (self) | return result | Extrai informações pessoais do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos.
Returns:
type: Dataframe.
| Extrai informações pessoais do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos. | def getDadosPessoais(self):
"""Extrai informações pessoais do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos.
Returns:
type: Dataframe.
"""
#----Se existe um Lattes
if self.__FLAG:
dictPessoais = {}
#----Parse Data, xml2dict returns double list, only first is relevant here
lista = self.xml2dict(tag = 'DADOS-GERAIS')
df = pd.DataFrame(lista[0])
#---- Organizando DF
cols = ["NOME-COMPLETO", "CPF", "PAIS-DE-NASCIMENTO", "UF-NASCIMENTO", "DATA-NASCIMENTO","SEXO", "RACA-OU-COR"]
coldf = df.columns.tolist()
new_cols = list(set(coldf).intersection(set(cols)))
df = df[new_cols]
#----
#----Incluindo dados do banco de servidores
if self.__UFCG:
try:
CPF = df['CPF'].values[0]
except KeyError as error:
#LOG.warning("Não esta na lista de servidores %s", self.ID)
tmp = None
else:
data_UFCG = self.getDadosUFCG(CPF)
df = df.merge(data_UFCG, on='CPF', how='left')
#---- Inclui Identificador Lattes
df["ID"] = self.ID
df["DATA-ATUALIZACAO"] = self.Atualiza
try:
IES = list(self.root.findall("DADOS-GERAIS/ENDERECO/ENDERECO-PROFISSIONAL"))[0].attrib['NOME-INSTITUICAO-EMPRESA']
except IndexError as error:
IES = 'NAO ENCONTRADO'
df["IES"] = IES
result = df
else:
result = None
return result | [
"def",
"getDadosPessoais",
"(",
"self",
")",
":",
"#----Se existe um Lattes",
"if",
"self",
".",
"__FLAG",
":",
"dictPessoais",
"=",
"{",
"}",
"#----Parse Data, xml2dict returns double list, only first is relevant here",
"lista",
"=",
"self",
".",
"xml2dict",
"(",
"tag",
"=",
"'DADOS-GERAIS'",
")",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"0",
"]",
")",
"#---- Organizando DF",
"cols",
"=",
"[",
"\"NOME-COMPLETO\"",
",",
"\"CPF\"",
",",
"\"PAIS-DE-NASCIMENTO\"",
",",
"\"UF-NASCIMENTO\"",
",",
"\"DATA-NASCIMENTO\"",
",",
"\"SEXO\"",
",",
"\"RACA-OU-COR\"",
"]",
"coldf",
"=",
"df",
".",
"columns",
".",
"tolist",
"(",
")",
"new_cols",
"=",
"list",
"(",
"set",
"(",
"coldf",
")",
".",
"intersection",
"(",
"set",
"(",
"cols",
")",
")",
")",
"df",
"=",
"df",
"[",
"new_cols",
"]",
"#----",
"#----Incluindo dados do banco de servidores",
"if",
"self",
".",
"__UFCG",
":",
"try",
":",
"CPF",
"=",
"df",
"[",
"'CPF'",
"]",
".",
"values",
"[",
"0",
"]",
"except",
"KeyError",
"as",
"error",
":",
"#LOG.warning(\"Não esta na lista de servidores %s\", self.ID)",
"tmp",
"=",
"None",
"else",
":",
"data_UFCG",
"=",
"self",
".",
"getDadosUFCG",
"(",
"CPF",
")",
"df",
"=",
"df",
".",
"merge",
"(",
"data_UFCG",
",",
"on",
"=",
"'CPF'",
",",
"how",
"=",
"'left'",
")",
"#---- Inclui Identificador Lattes",
"df",
"[",
"\"ID\"",
"]",
"=",
"self",
".",
"ID",
"df",
"[",
"\"DATA-ATUALIZACAO\"",
"]",
"=",
"self",
".",
"Atualiza",
"try",
":",
"IES",
"=",
"list",
"(",
"self",
".",
"root",
".",
"findall",
"(",
"\"DADOS-GERAIS/ENDERECO/ENDERECO-PROFISSIONAL\"",
")",
")",
"[",
"0",
"]",
".",
"attrib",
"[",
"'NOME-INSTITUICAO-EMPRESA'",
"]",
"except",
"IndexError",
"as",
"error",
":",
"IES",
"=",
"'NAO ENCONTRADO'",
"df",
"[",
"\"IES\"",
"]",
"=",
"IES",
"result",
"=",
"df",
"else",
":",
"result",
"=",
"None",
"return",
"result"
] | [
705,
4
] | [
745,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
test_put_prescriptions_by_id | (client) | Teste put /prescriptions/id - Compara dados enviados com dados salvos no banco e valida status_code 200 | Teste put /prescriptions/id - Compara dados enviados com dados salvos no banco e valida status_code 200 | def test_put_prescriptions_by_id(client):
"""Teste put /prescriptions/id - Compara dados enviados com dados salvos no banco e valida status_code 200"""
access_token = get_access(client, 'noadmin', 'noadmin')
idPrescription = '20'
mimetype = 'application/json'
authorization = 'Bearer {}'.format(access_token)
headers = {
'Content-Type': mimetype,
'Accept': mimetype,
'Authorization': authorization
}
data = {
"status": "s",
"notes": "note test",
"concilia": "s"
}
url = 'prescriptions/' + idPrescription
response = client.put(url, data=json.dumps(data), headers=headers)
responseData = json.loads(response.data)['data']
prescription = session.query(Prescription).get(idPrescription)
assert response.status_code == 200
assert responseData == str(prescription.id)
assert data['status'] == prescription.status
assert data['notes'] == prescription.notes
assert data['concilia'] == prescription.concilia | [
"def",
"test_put_prescriptions_by_id",
"(",
"client",
")",
":",
"access_token",
"=",
"get_access",
"(",
"client",
",",
"'noadmin'",
",",
"'noadmin'",
")",
"idPrescription",
"=",
"'20'",
"mimetype",
"=",
"'application/json'",
"authorization",
"=",
"'Bearer {}'",
".",
"format",
"(",
"access_token",
")",
"headers",
"=",
"{",
"'Content-Type'",
":",
"mimetype",
",",
"'Accept'",
":",
"mimetype",
",",
"'Authorization'",
":",
"authorization",
"}",
"data",
"=",
"{",
"\"status\"",
":",
"\"s\"",
",",
"\"notes\"",
":",
"\"note test\"",
",",
"\"concilia\"",
":",
"\"s\"",
"}",
"url",
"=",
"'prescriptions/'",
"+",
"idPrescription",
"response",
"=",
"client",
".",
"put",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
",",
"headers",
"=",
"headers",
")",
"responseData",
"=",
"json",
".",
"loads",
"(",
"response",
".",
"data",
")",
"[",
"'data'",
"]",
"prescription",
"=",
"session",
".",
"query",
"(",
"Prescription",
")",
".",
"get",
"(",
"idPrescription",
")",
"assert",
"response",
".",
"status_code",
"==",
"200",
"assert",
"responseData",
"==",
"str",
"(",
"prescription",
".",
"id",
")",
"assert",
"data",
"[",
"'status'",
"]",
"==",
"prescription",
".",
"status",
"assert",
"data",
"[",
"'notes'",
"]",
"==",
"prescription",
".",
"notes",
"assert",
"data",
"[",
"'concilia'",
"]",
"==",
"prescription",
".",
"concilia"
] | [
43,
0
] | [
72,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OptimalControl.plotting | (self,t,x,u,lambda_) | return ax | Função simples desenvolvida para plot. É um procedimento padrão. | Função simples desenvolvida para plot. É um procedimento padrão. | def plotting(self,t,x,u,lambda_):
'''Função simples desenvolvida para plot. É um procedimento padrão.'''
variables = {'x': x, 'u': u, 'lambda': lambda_}
names = {'x': 'Estado', 'u': 'Controle Ótimo', 'lambda': 'Função Adjunta'}
_, ax = plt.subplots(3,1,figsize = (10,12))
for i, key in enumerate(variables):
for k in range(np.shape(variables[key])[1]):
ax[i].plot(t,variables[key][:,k], label = key + str(k))
ax[i].set_title(names[key], fontsize = 15)
ax[i].grid(linestyle = '-', linewidth = 1, alpha = 0.5)
return ax | [
"def",
"plotting",
"(",
"self",
",",
"t",
",",
"x",
",",
"u",
",",
"lambda_",
")",
":",
"variables",
"=",
"{",
"'x'",
":",
"x",
",",
"'u'",
":",
"u",
",",
"'lambda'",
":",
"lambda_",
"}",
"names",
"=",
"{",
"'x'",
":",
"'Estado'",
",",
"'u'",
":",
"'Controle Ótimo',",
" ",
"lambda':",
" ",
"Função Adjunta'}",
"",
"_",
",",
"ax",
"=",
"plt",
".",
"subplots",
"(",
"3",
",",
"1",
",",
"figsize",
"=",
"(",
"10",
",",
"12",
")",
")",
"for",
"i",
",",
"key",
"in",
"enumerate",
"(",
"variables",
")",
":",
"for",
"k",
"in",
"range",
"(",
"np",
".",
"shape",
"(",
"variables",
"[",
"key",
"]",
")",
"[",
"1",
"]",
")",
":",
"ax",
"[",
"i",
"]",
".",
"plot",
"(",
"t",
",",
"variables",
"[",
"key",
"]",
"[",
":",
",",
"k",
"]",
",",
"label",
"=",
"key",
"+",
"str",
"(",
"k",
")",
")",
"ax",
"[",
"i",
"]",
".",
"set_title",
"(",
"names",
"[",
"key",
"]",
",",
"fontsize",
"=",
"15",
")",
"ax",
"[",
"i",
"]",
".",
"grid",
"(",
"linestyle",
"=",
"'-'",
",",
"linewidth",
"=",
"1",
",",
"alpha",
"=",
"0.5",
")",
"return",
"ax"
] | [
141,
4
] | [
154,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
extrair_api_infos | (response_dict) | return api_json | extrari a api e devolver um dicionario apenas com os dados da API | extrari a api e devolver um dicionario apenas com os dados da API | def extrair_api_infos(response_dict):
"""extrari a api e devolver um dicionario apenas com os dados da API"""
api_json = response_dict['context']['skills']['main skill']['user_defined'].get('API')
return api_json | [
"def",
"extrair_api_infos",
"(",
"response_dict",
")",
":",
"api_json",
"=",
"response_dict",
"[",
"'context'",
"]",
"[",
"'skills'",
"]",
"[",
"'main skill'",
"]",
"[",
"'user_defined'",
"]",
".",
"get",
"(",
"'API'",
")",
"return",
"api_json"
] | [
73,
0
] | [
76,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
make_car | (car, model, **car_info) | return car_information | Exibe informações sobre um carro. | Exibe informações sobre um carro. | def make_car(car, model, **car_info):
"""Exibe informações sobre um carro."""
car_information = {}
car_information['car'] = name_car
car_information['model'] = modelo
for key, value in car_info.items():
car_information[key] = value
return car_information | [
"def",
"make_car",
"(",
"car",
",",
"model",
",",
"*",
"*",
"car_info",
")",
":",
"car_information",
"=",
"{",
"}",
"car_information",
"[",
"'car'",
"]",
"=",
"name_car",
"car_information",
"[",
"'model'",
"]",
"=",
"modelo",
"for",
"key",
",",
"value",
"in",
"car_info",
".",
"items",
"(",
")",
":",
"car_information",
"[",
"key",
"]",
"=",
"value",
"return",
"car_information"
] | [
9,
0
] | [
16,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestPlayer.test_create_player_obj_with_empty_pokemon_list | (self) | Testa instancia de classe usando uma lista vazia. | Testa instancia de classe usando uma lista vazia. | def test_create_player_obj_with_empty_pokemon_list(self):
"""Testa instancia de classe usando uma lista vazia."""
self.assertRaises(ValueError, lambda: Player([])) | [
"def",
"test_create_player_obj_with_empty_pokemon_list",
"(",
"self",
")",
":",
"self",
".",
"assertRaises",
"(",
"ValueError",
",",
"lambda",
":",
"Player",
"(",
"[",
"]",
")",
")"
] | [
6,
4
] | [
8,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
search | (tabela, *, parms='*', clause=None) | return rows | Função que recebe como parâmetro obrigatório o nome da tabela a ser consultada,
como parâmetro padrão recebe os filtros da pesquisa e retorna todas as linhas encontradas | Função que recebe como parâmetro obrigatório o nome da tabela a ser consultada,
como parâmetro padrão recebe os filtros da pesquisa e retorna todas as linhas encontradas | def search(tabela, *, parms='*', clause=None):
""" Função que recebe como parâmetro obrigatório o nome da tabela a ser consultada,
como parâmetro padrão recebe os filtros da pesquisa e retorna todas as linhas encontradas """
banco = Banco()
banco.connect()
banco.execute(f"SELECT {parms} FROM {tabela} {clause}")
rows = banco.fetchall()
banco.disconnect()
return rows | [
"def",
"search",
"(",
"tabela",
",",
"*",
",",
"parms",
"=",
"'*'",
",",
"clause",
"=",
"None",
")",
":",
"banco",
"=",
"Banco",
"(",
")",
"banco",
".",
"connect",
"(",
")",
"banco",
".",
"execute",
"(",
"f\"SELECT {parms} FROM {tabela} {clause}\"",
")",
"rows",
"=",
"banco",
".",
"fetchall",
"(",
")",
"banco",
".",
"disconnect",
"(",
")",
"return",
"rows"
] | [
138,
0
] | [
146,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Conta.__sub__ | (self, outro) | Habilita obj - obj. Redunção do saldo | Habilita obj - obj. Redunção do saldo | def __sub__(self, outro):
""" Habilita obj - obj. Redunção do saldo"""
self.saldo -= outro.saldo | [
"def",
"__sub__",
"(",
"self",
",",
"outro",
")",
":",
"self",
".",
"saldo",
"-=",
"outro",
".",
"saldo"
] | [
15,
4
] | [
17,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
fetch_stage_file_path | (content: List[str], func_name: str) | return os.path.join(config.get("CACHE_PATH"), func_name, name) | Retorna o path para um arquivo temporário contendo
uma lista de `stage_id` | Retorna o path para um arquivo temporário contendo
uma lista de `stage_id` | def fetch_stage_file_path(content: List[str], func_name: str) -> str:
"""Retorna o path para um arquivo temporário contendo
uma lista de `stage_id`"""
name = hashlib.md5("".join(content).encode()).hexdigest()
return os.path.join(config.get("CACHE_PATH"), func_name, name) | [
"def",
"fetch_stage_file_path",
"(",
"content",
":",
"List",
"[",
"str",
"]",
",",
"func_name",
":",
"str",
")",
"->",
"str",
":",
"name",
"=",
"hashlib",
".",
"md5",
"(",
"\"\"",
".",
"join",
"(",
"content",
")",
".",
"encode",
"(",
")",
")",
".",
"hexdigest",
"(",
")",
"return",
"os",
".",
"path",
".",
"join",
"(",
"config",
".",
"get",
"(",
"\"CACHE_PATH\"",
")",
",",
"func_name",
",",
"name",
")"
] | [
125,
0
] | [
130,
66
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_env_value | (env_variable) | Função para recuperar variável de ambiente.
Args:
env_variable (str): Nome da variável.
Raises:
ImproperlyConfigured: Levanta a exceção caso a variável não exista.
Returns:
str: Valor da variável de ambiente.
| Função para recuperar variável de ambiente. | def get_env_value(env_variable):
"""Função para recuperar variável de ambiente.
Args:
env_variable (str): Nome da variável.
Raises:
ImproperlyConfigured: Levanta a exceção caso a variável não exista.
Returns:
str: Valor da variável de ambiente.
"""
try:
return str(os.environ[env_variable]).strip()
except KeyError:
error_msg = f"Set the {env_variable} environment variable"
raise ImproperlyConfigured(error_msg) | [
"def",
"get_env_value",
"(",
"env_variable",
")",
":",
"try",
":",
"return",
"str",
"(",
"os",
".",
"environ",
"[",
"env_variable",
"]",
")",
".",
"strip",
"(",
")",
"except",
"KeyError",
":",
"error_msg",
"=",
"f\"Set the {env_variable} environment variable\"",
"raise",
"ImproperlyConfigured",
"(",
"error_msg",
")"
] | [
5,
0
] | [
22,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
create_app | (app) | return app | Factory principal da aplicação | Factory principal da aplicação | def create_app(app):
"""Factory principal da aplicação"""
app = Flask(__name__)
config.init_app(app)
return app | [
"def",
"create_app",
"(",
"app",
")",
":",
"app",
"=",
"Flask",
"(",
"__name__",
")",
"config",
".",
"init_app",
"(",
"app",
")",
"return",
"app"
] | [
5,
0
] | [
10,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoAcessoResource.handle_delete | (self, request, user, *args, **kwargs) | Trata uma requisição DELETE para excluir uma informação de acesso a equipamento
URL: /equipamentoacesso/id_equipamento/id_tipo_acesso/
| Trata uma requisição DELETE para excluir uma informação de acesso a equipamento | def handle_delete(self, request, user, *args, **kwargs):
"""Trata uma requisição DELETE para excluir uma informação de acesso a equipamento
URL: /equipamentoacesso/id_equipamento/id_tipo_acesso/
"""
# Verifica acesso e obtém dados do request
try:
# Obtém argumentos passados na URL
id_equipamento = kwargs.get('id_equipamento')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_equipamento):
self.log.error(
u'The id_equipamento parameter is not a valid value: %s.', id_equipamento)
raise InvalidValueError(None, 'id_equipamento', id_equipamento)
id_tipo_acesso = kwargs.get('id_tipo_acesso')
# Valid ID Equipment
if not is_valid_int_greater_zero_param(id_tipo_acesso):
self.log.error(
u'The id_tipo_acesso parameter is not a valid value: %s.', id_tipo_acesso)
raise InvalidValueError(None, 'id_tipo_acesso', id_tipo_acesso)
Equipamento.get_by_pk(id_equipamento)
TipoAcesso.get_by_pk(id_tipo_acesso)
# Após obtenção do id_equipamento podemos verificar a permissão
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
id_equipamento,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_EQUIPMENT_ACCESS % id_tipo_acesso):
# Remove a informação de acesso a equipamento
EquipamentoAcesso.remove(user, id_equipamento, id_tipo_acesso)
# Retorna response vazio em caso de sucesso
return self.response(dumps_networkapi({}))
except InvalidValueError as e:
return self.response_error(269, e.param, e.value)
except EquipamentoNotFoundError:
return self.response_error(117, id_equipamento)
except AccessTypeNotFoundError:
return self.response_error(171, id_tipo_acesso)
except EquipamentoAcesso.DoesNotExist:
return self.response_error(209, id_equipamento, id_tipo_acesso)
except (EquipamentoError, GrupoError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Verifica acesso e obtém dados do request",
"try",
":",
"# Obtém argumentos passados na URL",
"id_equipamento",
"=",
"kwargs",
".",
"get",
"(",
"'id_equipamento'",
")",
"# Valid ID Equipment",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"id_equipamento",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The id_equipamento parameter is not a valid value: %s.'",
",",
"id_equipamento",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'id_equipamento'",
",",
"id_equipamento",
")",
"id_tipo_acesso",
"=",
"kwargs",
".",
"get",
"(",
"'id_tipo_acesso'",
")",
"# Valid ID Equipment",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"id_tipo_acesso",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The id_tipo_acesso parameter is not a valid value: %s.'",
",",
"id_tipo_acesso",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'id_tipo_acesso'",
",",
"id_tipo_acesso",
")",
"Equipamento",
".",
"get_by_pk",
"(",
"id_equipamento",
")",
"TipoAcesso",
".",
"get_by_pk",
"(",
"id_tipo_acesso",
")",
"# Após obtenção do id_equipamento podemos verificar a permissão",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"id_equipamento",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"with",
"distributedlock",
"(",
"LOCK_EQUIPMENT_ACCESS",
"%",
"id_tipo_acesso",
")",
":",
"# Remove a informação de acesso a equipamento",
"EquipamentoAcesso",
".",
"remove",
"(",
"user",
",",
"id_equipamento",
",",
"id_tipo_acesso",
")",
"# Retorna response vazio em caso de sucesso",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
"as",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"id_equipamento",
")",
"except",
"AccessTypeNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"171",
",",
"id_tipo_acesso",
")",
"except",
"EquipamentoAcesso",
".",
"DoesNotExist",
":",
"return",
"self",
".",
"response_error",
"(",
"209",
",",
"id_equipamento",
",",
"id_tipo_acesso",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
307,
4
] | [
362,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MinioStorage._client | (self) | return self._client_instance | Posterga a instanciação de `pymongo.MongoClient` até o seu primeiro
uso.
| Posterga a instanciação de `pymongo.MongoClient` até o seu primeiro
uso.
| def _client(self):
"""Posterga a instanciação de `pymongo.MongoClient` até o seu primeiro
uso.
"""
if not self._client_instance:
# Initialize minioClient with an endpoint and access/secret keys.
self._client_instance = Minio(
self.minio_host,
access_key=self.minio_access_key,
secret_key=self.minio_secret_key,
secure=self.minio_secure,
http_client=self.http_client
)
logger.debug(
"new Minio client created: <%s at %s>",
repr(self._client_instance),
id(self._client_instance),
)
logger.debug(
"using Minio client: <%s at %s>",
repr(self._client_instance),
id(self._client_instance),
)
return self._client_instance | [
"def",
"_client",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"_client_instance",
":",
"# Initialize minioClient with an endpoint and access/secret keys.",
"self",
".",
"_client_instance",
"=",
"Minio",
"(",
"self",
".",
"minio_host",
",",
"access_key",
"=",
"self",
".",
"minio_access_key",
",",
"secret_key",
"=",
"self",
".",
"minio_secret_key",
",",
"secure",
"=",
"self",
".",
"minio_secure",
",",
"http_client",
"=",
"self",
".",
"http_client",
")",
"logger",
".",
"debug",
"(",
"\"new Minio client created: <%s at %s>\"",
",",
"repr",
"(",
"self",
".",
"_client_instance",
")",
",",
"id",
"(",
"self",
".",
"_client_instance",
")",
",",
")",
"logger",
".",
"debug",
"(",
"\"using Minio client: <%s at %s>\"",
",",
"repr",
"(",
"self",
".",
"_client_instance",
")",
",",
"id",
"(",
"self",
".",
"_client_instance",
")",
",",
")",
"return",
"self",
".",
"_client_instance"
] | [
72,
4
] | [
96,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
UndirectedWeightedGraph.weight | (self, v, w) | Retorna o peso de uma aresta. Se a aresta não existe é retornado o valor 0 | Retorna o peso de uma aresta. Se a aresta não existe é retornado o valor 0 | def weight(self, v, w):
''' Retorna o peso de uma aresta. Se a aresta não existe é retornado o valor 0 '''
if self.has_edge(v,w):
return self.__edges[v][w]
elif (v == w) and self.has_node(v):
return 0
else:
return float("inf") | [
"def",
"weight",
"(",
"self",
",",
"v",
",",
"w",
")",
":",
"if",
"self",
".",
"has_edge",
"(",
"v",
",",
"w",
")",
":",
"return",
"self",
".",
"__edges",
"[",
"v",
"]",
"[",
"w",
"]",
"elif",
"(",
"v",
"==",
"w",
")",
"and",
"self",
".",
"has_node",
"(",
"v",
")",
":",
"return",
"0",
"else",
":",
"return",
"float",
"(",
"\"inf\"",
")"
] | [
218,
4
] | [
225,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OptimalControl._forward | (self,t,x,u,params,h) | return x | A função realiza o processo forward que integra a equação de x' = g
g: função (t,x,u)
u: controle do último passo. vetor de tamanho N + 1
h: passo a ser dado pelo método de Runge-Kutta
| A função realiza o processo forward que integra a equação de x' = g
g: função (t,x,u)
u: controle do último passo. vetor de tamanho N + 1
h: passo a ser dado pelo método de Runge-Kutta
| def _forward(self,t,x,u,params,h):
'''A função realiza o processo forward que integra a equação de x' = g
g: função (t,x,u)
u: controle do último passo. vetor de tamanho N + 1
h: passo a ser dado pelo método de Runge-Kutta
'''
for i in range(len(t)-1):
k1 = self.dx(t[i],x[i],u[i], params)
k2 = self.dx(t[i]+h/2,x[i] + 0.5*h*k1, 0.5*(u[i] + u[i+1]), params)
k3 = self.dx(t[i]+h/2,x[i] + 0.5*h*k2, 0.5*(u[i] + u[i+1]), params)
k4 = self.dx(t[i]+h,x[i] + h*k3, u[i+1], params)
x[i+1] = x[i] + (h/6)*(k1 + 2*k2 + 2*k3 + k4)
return x | [
"def",
"_forward",
"(",
"self",
",",
"t",
",",
"x",
",",
"u",
",",
"params",
",",
"h",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"t",
")",
"-",
"1",
")",
":",
"k1",
"=",
"self",
".",
"dx",
"(",
"t",
"[",
"i",
"]",
",",
"x",
"[",
"i",
"]",
",",
"u",
"[",
"i",
"]",
",",
"params",
")",
"k2",
"=",
"self",
".",
"dx",
"(",
"t",
"[",
"i",
"]",
"+",
"h",
"/",
"2",
",",
"x",
"[",
"i",
"]",
"+",
"0.5",
"*",
"h",
"*",
"k1",
",",
"0.5",
"*",
"(",
"u",
"[",
"i",
"]",
"+",
"u",
"[",
"i",
"+",
"1",
"]",
")",
",",
"params",
")",
"k3",
"=",
"self",
".",
"dx",
"(",
"t",
"[",
"i",
"]",
"+",
"h",
"/",
"2",
",",
"x",
"[",
"i",
"]",
"+",
"0.5",
"*",
"h",
"*",
"k2",
",",
"0.5",
"*",
"(",
"u",
"[",
"i",
"]",
"+",
"u",
"[",
"i",
"+",
"1",
"]",
")",
",",
"params",
")",
"k4",
"=",
"self",
".",
"dx",
"(",
"t",
"[",
"i",
"]",
"+",
"h",
",",
"x",
"[",
"i",
"]",
"+",
"h",
"*",
"k3",
",",
"u",
"[",
"i",
"+",
"1",
"]",
",",
"params",
")",
"x",
"[",
"i",
"+",
"1",
"]",
"=",
"x",
"[",
"i",
"]",
"+",
"(",
"h",
"/",
"6",
")",
"*",
"(",
"k1",
"+",
"2",
"*",
"k2",
"+",
"2",
"*",
"k3",
"+",
"k4",
")",
"return",
"x"
] | [
46,
4
] | [
58,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
loads | (xml, force_list=None) | return map, attrs_map | Cria um dict com os dados do element root.
O dict terá como chave o nome do element root e como valor o conteúdo do element root.
Quando o conteúdo de um element é uma lista de Nós então o valor do element será
um dict com uma chave para cada nó.
Entretanto, se existir nós, de um mesmo pai, com o mesmo nome, então eles serão
armazenados uma mesma chave do dict que terá como valor uma lista.
Se o element root tem atributo, então também retorna um dict com os atributos.
Throws: XMLError
| Cria um dict com os dados do element root. | def loads(xml, force_list=None):
"""Cria um dict com os dados do element root.
O dict terá como chave o nome do element root e como valor o conteúdo do element root.
Quando o conteúdo de um element é uma lista de Nós então o valor do element será
um dict com uma chave para cada nó.
Entretanto, se existir nós, de um mesmo pai, com o mesmo nome, então eles serão
armazenados uma mesma chave do dict que terá como valor uma lista.
Se o element root tem atributo, então também retorna um dict com os atributos.
Throws: XMLError
"""
if force_list is None:
force_list = []
try:
doc = parseString(xml)
except Exception, e:
raise XMLError(e, u'Falha ao realizar o parse do xml.')
root = doc.documentElement
map = dict()
attrs_map = dict()
if root.hasAttributes():
attributes = root.attributes
for i in range(attributes.length):
attr = attributes.item(i)
attrs_map[attr.nodeName] = attr.nodeValue
map[root.nodeName] = _create_childs_map(root, force_list)
return map, attrs_map | [
"def",
"loads",
"(",
"xml",
",",
"force_list",
"=",
"None",
")",
":",
"if",
"force_list",
"is",
"None",
":",
"force_list",
"=",
"[",
"]",
"try",
":",
"doc",
"=",
"parseString",
"(",
"xml",
")",
"except",
"Exception",
",",
"e",
":",
"raise",
"XMLError",
"(",
"e",
",",
"u'Falha ao realizar o parse do xml.'",
")",
"root",
"=",
"doc",
".",
"documentElement",
"map",
"=",
"dict",
"(",
")",
"attrs_map",
"=",
"dict",
"(",
")",
"if",
"root",
".",
"hasAttributes",
"(",
")",
":",
"attributes",
"=",
"root",
".",
"attributes",
"for",
"i",
"in",
"range",
"(",
"attributes",
".",
"length",
")",
":",
"attr",
"=",
"attributes",
".",
"item",
"(",
"i",
")",
"attrs_map",
"[",
"attr",
".",
"nodeName",
"]",
"=",
"attr",
".",
"nodeValue",
"map",
"[",
"root",
".",
"nodeName",
"]",
"=",
"_create_childs_map",
"(",
"root",
",",
"force_list",
")",
"return",
"map",
",",
"attrs_map"
] | [
196,
0
] | [
230,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Anuncio.get_absolute_url | (self) | return reverse('anuncios:anuncio_detail', kwargs={'pk': self.id}) | Retorna a url para a página que detalha o anúncio | Retorna a url para a página que detalha o anúncio | def get_absolute_url(self) -> str:
"""Retorna a url para a página que detalha o anúncio"""
return reverse('anuncios:anuncio_detail', kwargs={'pk': self.id}) | [
"def",
"get_absolute_url",
"(",
"self",
")",
"->",
"str",
":",
"return",
"reverse",
"(",
"'anuncios:anuncio_detail'",
",",
"kwargs",
"=",
"{",
"'pk'",
":",
"self",
".",
"id",
"}",
")"
] | [
67,
4
] | [
69,
73
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PIS._is_repeated_digits | (self, doc: str) | return len(set(doc)) == 1 | Verifica se o PIS/NIS/PASEP/NIT contém com números repetidos.
Exemplo: 11111111111 | Verifica se o PIS/NIS/PASEP/NIT contém com números repetidos.
Exemplo: 11111111111 | def _is_repeated_digits(self, doc: str) -> bool:
"""Verifica se o PIS/NIS/PASEP/NIT contém com números repetidos.
Exemplo: 11111111111"""
return len(set(doc)) == 1 | [
"def",
"_is_repeated_digits",
"(",
"self",
",",
"doc",
":",
"str",
")",
"->",
"bool",
":",
"return",
"len",
"(",
"set",
"(",
"doc",
")",
")",
"==",
"1"
] | [
53,
4
] | [
56,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.