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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Log.error | (self, msg, *args) | Imprime uma mensagem de erro no log | Imprime uma mensagem de erro no log | def error(self, msg, *args):
"""Imprime uma mensagem de erro no log"""
try:
get_lock()
msg = str(msg) % args
show_traceback = getattr(settings, 'LOG_SHOW_TRACEBACK', True)
self.logger.error(
msg, extra={'module_name': self.module_name}, exc_info=show_traceback)
finally:
release_lock() | [
"def",
"error",
"(",
"self",
",",
"msg",
",",
"*",
"args",
")",
":",
"try",
":",
"get_lock",
"(",
")",
"msg",
"=",
"str",
"(",
"msg",
")",
"%",
"args",
"show_traceback",
"=",
"getattr",
"(",
"settings",
",",
"'LOG_SHOW_TRACEBACK'",
",",
"True",
")",
"self",
".",
"logger",
".",
"error",
"(",
"msg",
",",
"extra",
"=",
"{",
"'module_name'",
":",
"self",
".",
"module_name",
"}",
",",
"exc_info",
"=",
"show_traceback",
")",
"finally",
":",
"release_lock",
"(",
")"
] | [
244,
4
] | [
255,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.__lt__ | (self,outro) | return not self.__ge__(outro) | Inversão de .__ge__ | Inversão de .__ge__ | def __lt__ (self,outro):
'''Inversão de .__ge__'''
return not self.__ge__(outro) | [
"def",
"__lt__",
"(",
"self",
",",
"outro",
")",
":",
"return",
"not",
"self",
".",
"__ge__",
"(",
"outro",
")"
] | [
379,
1
] | [
381,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Carro.incrementar_hodometro | (self, quilometros) | Soma a quantidade especificada ao valor de leitura do hodômetro. | Soma a quantidade especificada ao valor de leitura do hodômetro. | def incrementar_hodometro(self, quilometros):
"""Soma a quantidade especificada ao valor de leitura do hodômetro."""
self.leitura_hodometro += quilometros | [
"def",
"incrementar_hodometro",
"(",
"self",
",",
"quilometros",
")",
":",
"self",
".",
"leitura_hodometro",
"+=",
"quilometros"
] | [
35,
4
] | [
37,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurant.describe_restaurant | (self) | Exibe a descrição do restaurante. | Exibe a descrição do restaurante. | def describe_restaurant(self):
""" Exibe a descrição do restaurante."""
print("O restaurante " + self.name.title() + " é especialista na culinária " + self.cuisine.title() + ".") | [
"def",
"describe_restaurant",
"(",
"self",
")",
":",
"print",
"(",
"\"O restaurante \"",
"+",
"self",
".",
"name",
".",
"title",
"(",
")",
"+",
"\" é especialista na culinária \" +",
"s",
"lf.c",
"u",
"isine.t",
"i",
"tle()",
" ",
"+",
"\"",
"\")",
""
] | [
11,
4
] | [
13,
116
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
EquipamentoAcesso.create | (self, authenticated_user) | Efetua a inclusão de informações de acesso a equipamentos
@return: Instância da informação de acesso a equipamento incluída
@raise Equipamento.DoesNotExist: Equipamento informado é inexistente
@raise TipoAcesso.DoesNotExist: Tipo de acesso informado é inexistente
@raise EquipamentoAccessDuplicatedError: Já existe cadastrada a associação de equipamento e tipo de acesso informada
@raise EquipamentoError: Falha ao incluir informações de acesso a equipamentos.
| Efetua a inclusão de informações de acesso a equipamentos
| def create(self, authenticated_user):
"""Efetua a inclusão de informações de acesso a equipamentos
@return: Instância da informação de acesso a equipamento incluída
@raise Equipamento.DoesNotExist: Equipamento informado é inexistente
@raise TipoAcesso.DoesNotExist: Tipo de acesso informado é inexistente
@raise EquipamentoAccessDuplicatedError: Já existe cadastrada a associação de equipamento e tipo de acesso informada
@raise EquipamentoError: Falha ao incluir informações de acesso a equipamentos.
"""
# Valida a existência do equipamento
self.equipamento = Equipamento.get_by_pk(self.equipamento.id)
try:
#Validades tipo_acesso existence
self.tipo_acesso = TipoAcesso.get_by_pk(self.tipo_acesso.id)
#Validates vrf existence
if self.vrf:
self.vrf = Vrf.get_by_pk(self.vrf.id)
# Verifica a existência de uma associação de equipamento e tipo de acesso igual à que está
# sendo incluída
if EquipamentoAcesso.objects.filter(equipamento=self.equipamento, tipo_acesso=self.tipo_acesso).count() > 0:
raise EquipamentoAccessDuplicatedError(
None, u'Já existe esta associação de equipamento e tipo de acesso cadastrada.')
# Persiste a informação
return self.save()
except TipoAcesso.DoesNotExist as e:
raise e
except VrfNotFoundError as e:
raise e
except EquipamentoAccessDuplicatedError as e:
raise e
except Exception as e:
self.log.error(
u'Falha ao inserir informação de acesso a equipamento.')
raise EquipamentoError(
e, u'Falha ao inserir informação de acesso a equipamento.') | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
")",
":",
"# Valida a existência do equipamento",
"self",
".",
"equipamento",
"=",
"Equipamento",
".",
"get_by_pk",
"(",
"self",
".",
"equipamento",
".",
"id",
")",
"try",
":",
"#Validades tipo_acesso existence",
"self",
".",
"tipo_acesso",
"=",
"TipoAcesso",
".",
"get_by_pk",
"(",
"self",
".",
"tipo_acesso",
".",
"id",
")",
"#Validates vrf existence",
"if",
"self",
".",
"vrf",
":",
"self",
".",
"vrf",
"=",
"Vrf",
".",
"get_by_pk",
"(",
"self",
".",
"vrf",
".",
"id",
")",
"# Verifica a existência de uma associação de equipamento e tipo de acesso igual à que está",
"# sendo incluída",
"if",
"EquipamentoAcesso",
".",
"objects",
".",
"filter",
"(",
"equipamento",
"=",
"self",
".",
"equipamento",
",",
"tipo_acesso",
"=",
"self",
".",
"tipo_acesso",
")",
".",
"count",
"(",
")",
">",
"0",
":",
"raise",
"EquipamentoAccessDuplicatedError",
"(",
"None",
",",
"u'Já existe esta associação de equipamento e tipo de acesso cadastrada.')",
"",
"# Persiste a informação",
"return",
"self",
".",
"save",
"(",
")",
"except",
"TipoAcesso",
".",
"DoesNotExist",
"as",
"e",
":",
"raise",
"e",
"except",
"VrfNotFoundError",
"as",
"e",
":",
"raise",
"e",
"except",
"EquipamentoAccessDuplicatedError",
"as",
"e",
":",
"raise",
"e",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir informação de acesso a equipamento.')",
"",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao inserir informação de acesso a equipamento.')",
""
] | [
1720,
4
] | [
1757,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BuildPSPackage.collect_renditions | (
self, target_path, acron, issue_folder, pack_name, langs, pid,
) | return manifest | Coleta as manifestações em formato PDF por meio de um caminho
produzido a partir de `pasta-dos-pdfs/acronimo/issue-volume-numbero/nome-do-pacote`.
Este método funciona da seguinte forma:
1) Dado que um documento possua um idioma padrão e uma tradução (pt, en);
2) Que o nome do pacote seja `pacote-2020-abc`;
3) Que o idioma principal seja `pt` e a tradução `en`;
4) As seguintes tentativas de cópia serão feitas:
4.1) Arquivo `pacote-2020-abc.pdf` -> `destino/pacote-2020-abc.pdf`
4.2) Arquivo `en_pacote-2020-abc.pdf` -> `destino/en_pacote-2020-abc.pdf`
4.3) Se o ponto 4.2 falhar uma próxima tentativa para o idioma `en` será feita;
4.4) Arquivo `pacote-2020-abc-en.pdf` -> `destino/pacote-2020-abc-en.pdf`;
Caso o documento possua apenas um idioma (pt), apenas o passo 4.1
será realizado. | Coleta as manifestações em formato PDF por meio de um caminho
produzido a partir de `pasta-dos-pdfs/acronimo/issue-volume-numbero/nome-do-pacote`. | def collect_renditions(
self, target_path, acron, issue_folder, pack_name, langs, pid,
):
"""Coleta as manifestações em formato PDF por meio de um caminho
produzido a partir de `pasta-dos-pdfs/acronimo/issue-volume-numbero/nome-do-pacote`.
Este método funciona da seguinte forma:
1) Dado que um documento possua um idioma padrão e uma tradução (pt, en);
2) Que o nome do pacote seja `pacote-2020-abc`;
3) Que o idioma principal seja `pt` e a tradução `en`;
4) As seguintes tentativas de cópia serão feitas:
4.1) Arquivo `pacote-2020-abc.pdf` -> `destino/pacote-2020-abc.pdf`
4.2) Arquivo `en_pacote-2020-abc.pdf` -> `destino/en_pacote-2020-abc.pdf`
4.3) Se o ponto 4.2 falhar uma próxima tentativa para o idioma `en` será feita;
4.4) Arquivo `pacote-2020-abc-en.pdf` -> `destino/pacote-2020-abc-en.pdf`;
Caso o documento possua apenas um idioma (pt), apenas o passo 4.1
será realizado."""
source_path = os.path.join(self.pdf_folder, acron, issue_folder)
filename_formats = ["{lang}_{name}.pdf", "{name}-{lang}.pdf"]
manifest = {}
renditions_to_search = {langs[0]: [pack_name + ".pdf"]}
for lang in langs[1:]:
renditions_to_search.setdefault(lang, [])
for filename in filename_formats:
renditions_to_search[lang].append(
filename.format(name=pack_name, lang=lang)
)
for lang, renditions in renditions_to_search.items():
for rendition in renditions:
source_file_path = os.path.join(source_path, rendition)
try:
shutil.copy(source_file_path, target_path)
except FileNotFoundError:
logger.error(
"[%s] - Could not find rendition '%s' during packing XML '%s.xml'.",
pid,
source_file_path,
pack_name,
)
else:
manifest[lang] = rendition
break
return manifest | [
"def",
"collect_renditions",
"(",
"self",
",",
"target_path",
",",
"acron",
",",
"issue_folder",
",",
"pack_name",
",",
"langs",
",",
"pid",
",",
")",
":",
"source_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"pdf_folder",
",",
"acron",
",",
"issue_folder",
")",
"filename_formats",
"=",
"[",
"\"{lang}_{name}.pdf\"",
",",
"\"{name}-{lang}.pdf\"",
"]",
"manifest",
"=",
"{",
"}",
"renditions_to_search",
"=",
"{",
"langs",
"[",
"0",
"]",
":",
"[",
"pack_name",
"+",
"\".pdf\"",
"]",
"}",
"for",
"lang",
"in",
"langs",
"[",
"1",
":",
"]",
":",
"renditions_to_search",
".",
"setdefault",
"(",
"lang",
",",
"[",
"]",
")",
"for",
"filename",
"in",
"filename_formats",
":",
"renditions_to_search",
"[",
"lang",
"]",
".",
"append",
"(",
"filename",
".",
"format",
"(",
"name",
"=",
"pack_name",
",",
"lang",
"=",
"lang",
")",
")",
"for",
"lang",
",",
"renditions",
"in",
"renditions_to_search",
".",
"items",
"(",
")",
":",
"for",
"rendition",
"in",
"renditions",
":",
"source_file_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"source_path",
",",
"rendition",
")",
"try",
":",
"shutil",
".",
"copy",
"(",
"source_file_path",
",",
"target_path",
")",
"except",
"FileNotFoundError",
":",
"logger",
".",
"error",
"(",
"\"[%s] - Could not find rendition '%s' during packing XML '%s.xml'.\"",
",",
"pid",
",",
"source_file_path",
",",
"pack_name",
",",
")",
"else",
":",
"manifest",
"[",
"lang",
"]",
"=",
"rendition",
"break",
"return",
"manifest"
] | [
243,
4
] | [
293,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
main | (args) | Argumentos: <nome do mcu> <arquivo formato elf> | Argumentos: <nome do mcu> <arquivo formato elf> | def main(args):
""" Argumentos: <nome do mcu> <arquivo formato elf> """
try:
mcu = args[1]
familia = familias[mcu]
comando = [disassembler, '-m', familia, '-d'] + args[2:]
sfr_dic = registradores[familia]
except IndexError:
report('''{0}: Sem argumentos suficiente
Sintaxe: {0} <MCU> <arquivo.elf>
ou
{0} <MCU> <seção> <arquivo.hex>
Exemplos:
{0} atmega328p main.elf
{0} atmega328p -j .sec1 main.hex
'''.format(args[0]))
return 1
# Para famílias desconhecidas ou lista de dicionário desconhecido
# usa um dicionário vazio
except KeyError:
sfr_dic = []
try:
report("Dicionário de registradores para '{}' \
ainda não está diponível...".format(familia))
except UnboundLocalError:
comando = [disassembler] + args[1:]
report("MCU desconhecido: '{}'".format(mcu))
objdump = subprocess.Popen(comando, stdout=subprocess.PIPE,
universal_newlines=True)
try:
# Passando saída de avr-objdum para o console
for linha in iter(objdump.stdout.readline, ''):
combina = decode[0].search(linha) or decode[1].search(linha)
try:
# Se aconteceu alguma igualdade entre o endereço acessado
# e o dicionário de registradores.
if combina:
# De acordo com o datasheet, os registradores de 0-0x3F,
# quando acessados com instruções (LDS & STS),
# recebem um offset +0x20 nos endereços
sfr = int(combina['sfr'], 0)
if combina['opcode'] in ['sts', 'lds'] and sfr < 0x60:
sfr -= 0x20
linha = ''.join([
linha[:combina.start(0)],
re.sub(combina['sfr'], sfr_dic[sfr], combina[0]),
linha[combina.end(0):]
])
# Se a instrução bater mas não os operandos,
# significa que não tem lista de registradores suportado
# ou que está sendo acessado um endereço da memória ram
except IndexError:
pass
# Caso a lista de instrução não for encontrada
# não precisa fazer nenhuma mudança.
except KeyError:
pass
sys.stdout.write(linha)
objdump.stdout.close()
return objdump.wait()
except BrokenPipeError:
report(
'''Deu ruim e nem sei o que aconteceu...
Se vira!''')
return 0 | [
"def",
"main",
"(",
"args",
")",
":",
"try",
":",
"mcu",
"=",
"args",
"[",
"1",
"]",
"familia",
"=",
"familias",
"[",
"mcu",
"]",
"comando",
"=",
"[",
"disassembler",
",",
"'-m'",
",",
"familia",
",",
"'-d'",
"]",
"+",
"args",
"[",
"2",
":",
"]",
"sfr_dic",
"=",
"registradores",
"[",
"familia",
"]",
"except",
"IndexError",
":",
"report",
"(",
"'''{0}: Sem argumentos suficiente\n\nSintaxe: {0} <MCU> <arquivo.elf>\nou\n {0} <MCU> <seção> <arquivo.hex>\n\nExemplos:\n {0} atmega328p main.elf\n {0} atmega328p -j .sec1 main.hex\n'''",
".",
"format",
"(",
"args",
"[",
"0",
"]",
")",
")",
"return",
"1",
"# Para famílias desconhecidas ou lista de dicionário desconhecido",
"# usa um dicionário vazio",
"except",
"KeyError",
":",
"sfr_dic",
"=",
"[",
"]",
"try",
":",
"report",
"(",
"\"Dicionário de registradores para '{}' \\\n ainda não está diponível...\".fo",
"r",
"mat(fa",
"m",
"ilia))",
"",
"",
"except",
"UnboundLocalError",
":",
"comando",
"=",
"[",
"disassembler",
"]",
"+",
"args",
"[",
"1",
":",
"]",
"report",
"(",
"\"MCU desconhecido: '{}'\"",
".",
"format",
"(",
"mcu",
")",
")",
"objdump",
"=",
"subprocess",
".",
"Popen",
"(",
"comando",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"universal_newlines",
"=",
"True",
")",
"try",
":",
"# Passando saída de avr-objdum para o console",
"for",
"linha",
"in",
"iter",
"(",
"objdump",
".",
"stdout",
".",
"readline",
",",
"''",
")",
":",
"combina",
"=",
"decode",
"[",
"0",
"]",
".",
"search",
"(",
"linha",
")",
"or",
"decode",
"[",
"1",
"]",
".",
"search",
"(",
"linha",
")",
"try",
":",
"# Se aconteceu alguma igualdade entre o endereço acessado",
"# e o dicionário de registradores.",
"if",
"combina",
":",
"# De acordo com o datasheet, os registradores de 0-0x3F,",
"# quando acessados com instruções (LDS & STS),",
"# recebem um offset +0x20 nos endereços",
"sfr",
"=",
"int",
"(",
"combina",
"[",
"'sfr'",
"]",
",",
"0",
")",
"if",
"combina",
"[",
"'opcode'",
"]",
"in",
"[",
"'sts'",
",",
"'lds'",
"]",
"and",
"sfr",
"<",
"0x60",
":",
"sfr",
"-=",
"0x20",
"linha",
"=",
"''",
".",
"join",
"(",
"[",
"linha",
"[",
":",
"combina",
".",
"start",
"(",
"0",
")",
"]",
",",
"re",
".",
"sub",
"(",
"combina",
"[",
"'sfr'",
"]",
",",
"sfr_dic",
"[",
"sfr",
"]",
",",
"combina",
"[",
"0",
"]",
")",
",",
"linha",
"[",
"combina",
".",
"end",
"(",
"0",
")",
":",
"]",
"]",
")",
"# Se a instrução bater mas não os operandos,",
"# significa que não tem lista de registradores suportado",
"# ou que está sendo acessado um endereço da memória ram",
"except",
"IndexError",
":",
"pass",
"# Caso a lista de instrução não for encontrada",
"# não precisa fazer nenhuma mudança.",
"except",
"KeyError",
":",
"pass",
"sys",
".",
"stdout",
".",
"write",
"(",
"linha",
")",
"objdump",
".",
"stdout",
".",
"close",
"(",
")",
"return",
"objdump",
".",
"wait",
"(",
")",
"except",
"BrokenPipeError",
":",
"report",
"(",
"'''Deu ruim e nem sei o que aconteceu...\n Se vira!'''",
")",
"return",
"0"
] | [
818,
0
] | [
895,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurante.ver_pessoas_atendidas | (self) | Exibe uma frase que mostra o número de pessoas atendidas. | Exibe uma frase que mostra o número de pessoas atendidas. | def ver_pessoas_atendidas(self):
"""Exibe uma frase que mostra o número de pessoas atendidas."""
if self.pessoas_atendidas <2:
print("Hoje foi atendido apenas 1 pessoa.")
else:
print("Hoje foram atendidos um total de " +
str(self.pessoas_atendidas) + " pessoas.") | [
"def",
"ver_pessoas_atendidas",
"(",
"self",
")",
":",
"if",
"self",
".",
"pessoas_atendidas",
"<",
"2",
":",
"print",
"(",
"\"Hoje foi atendido apenas 1 pessoa.\"",
")",
"else",
":",
"print",
"(",
"\"Hoje foram atendidos um total de \"",
"+",
"str",
"(",
"self",
".",
"pessoas_atendidas",
")",
"+",
"\" pessoas.\"",
")"
] | [
38,
4
] | [
44,
58
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SistemaLivros.excluir_todos | (self) | Exclui todos os livros cadastrados | Exclui todos os livros cadastrados | def excluir_todos(self):
""" Exclui todos os livros cadastrados """
self.dados = [] | [
"def",
"excluir_todos",
"(",
"self",
")",
":",
"self",
".",
"dados",
"=",
"[",
"]"
] | [
138,
4
] | [
140,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SimpleReflexAgentProgram | (rules, interpret_input) | return program | Este agente toma medidas baseadas apenas na percepção. | Este agente toma medidas baseadas apenas na percepção. | def SimpleReflexAgentProgram(rules, interpret_input):
"Este agente toma medidas baseadas apenas na percepção."
def program(percept):
state = interpret_input(percept)
rule = rule_match(state, rules)
action = rule.action
return action
return program | [
"def",
"SimpleReflexAgentProgram",
"(",
"rules",
",",
"interpret_input",
")",
":",
"def",
"program",
"(",
"percept",
")",
":",
"state",
"=",
"interpret_input",
"(",
"percept",
")",
"rule",
"=",
"rule_match",
"(",
"state",
",",
"rules",
")",
"action",
"=",
"rule",
".",
"action",
"return",
"action",
"return",
"program"
] | [
95,
0
] | [
102,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
test_post_patient_permission | (client) | Teste post /patient/admission - Deve retornar erro [401 UNAUTHORIZED] devido ao usuário utilizado | Teste post /patient/admission - Deve retornar erro [401 UNAUTHORIZED] devido ao usuário utilizado | def test_post_patient_permission(client):
"""Teste post /patient/admission - Deve retornar erro [401 UNAUTHORIZED] devido ao usuário utilizado"""
access_token = get_access(client)
admission = '5'
data = {
"height": "15.0"
}
url = 'patient/' + admission
response = client.post(url, data=json.dumps(data), headers=make_headers(access_token))
assert response.status_code == 401 | [
"def",
"test_post_patient_permission",
"(",
"client",
")",
":",
"access_token",
"=",
"get_access",
"(",
"client",
")",
"admission",
"=",
"'5'",
"data",
"=",
"{",
"\"height\"",
":",
"\"15.0\"",
"}",
"url",
"=",
"'patient/'",
"+",
"admission",
"response",
"=",
"client",
".",
"post",
"(",
"url",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"data",
")",
",",
"headers",
"=",
"make_headers",
"(",
"access_token",
")",
")",
"assert",
"response",
".",
"status_code",
"==",
"401"
] | [
3,
0
] | [
15,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Knowledge.kill_wumpus | (self) | Altera o status de qualquer sala de tal forma que não pode ser o Wumpus. | Altera o status de qualquer sala de tal forma que não pode ser o Wumpus. | def kill_wumpus(self):
"""Altera o status de qualquer sala de tal forma que não pode ser o Wumpus."""
for path in self._rooms:
for room in path:
room.wumpus = Status.Absent | [
"def",
"kill_wumpus",
"(",
"self",
")",
":",
"for",
"path",
"in",
"self",
".",
"_rooms",
":",
"for",
"room",
"in",
"path",
":",
"room",
".",
"wumpus",
"=",
"Status",
".",
"Absent"
] | [
297,
2
] | [
303,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Callback.disable | (self) | Desativa o monitoramento do descritor neste callback | Desativa o monitoramento do descritor neste callback | def disable(self):
'Desativa o monitoramento do descritor neste callback'
self._enabled = False | [
"def",
"disable",
"(",
"self",
")",
":",
"self",
".",
"_enabled",
"=",
"False"
] | [
66,
4
] | [
68,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
UndirectedWeightedGraph.size | (self) | return len(self.__edges) | Retorna o número de vértices no grafo | Retorna o número de vértices no grafo | def size(self):
''' Retorna o número de vértices no grafo '''
return len(self.__edges) | [
"def",
"size",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"__edges",
")"
] | [
163,
4
] | [
165,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ModeloRoteiro.create | (self, authenticated_user) | Insere uma nova associação entre um Modelo e um Roteiro.
@return: Nothing
@raise RoteiroNotFoundError: Roteiro não cadastrado.
@raise RoteiroError: Falha ao pesquisar o roteiro.
@raise ModeloRoteiroDuplicatedError: Equipamento já está associado ao roteiro.
@raise ModeloError: Falha ao inserir o modelo no roteiro.
| Insere uma nova associação entre um Modelo e um Roteiro.
| def create(self, authenticated_user):
""" Insere uma nova associação entre um Modelo e um Roteiro.
@return: Nothing
@raise RoteiroNotFoundError: Roteiro não cadastrado.
@raise RoteiroError: Falha ao pesquisar o roteiro.
@raise ModeloRoteiroDuplicatedError: Equipamento já está associado ao roteiro.
@raise ModeloError: Falha ao inserir o modelo no roteiro.
"""
self.modelo = Modelo().get_by_pk(self.modelo.id)
self.roteiro = Roteiro.get_by_pk(self.roteiro.id)
try:
try:
roteiros = ModeloRoteiro.objects.filter(
modelo__id=self.modelo.id)
for rot in roteiros:
if rot.roteiro.id == self.roteiro.id:
raise ModeloRoteiroDuplicatedError(
None, u'Modelo id %s já está associado a um roteiro.' % str(self.modelo.id))
except ObjectDoesNotExist:
pass
self.save()
except ModeloRoteiroDuplicatedError as e:
raise e
except Exception as e:
self.log.error(u'Falha ao inserir a associação modelo/roteiro: %s/%s. %s' %
(self.modelo.id, self.roteiro.id, e))
raise EquipamentoError(
e, u'Falha ao inserir a associação modelo/roteiro: %s/%s.' % (self.modelo.id, self.roteiro.id)) | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
")",
":",
"self",
".",
"modelo",
"=",
"Modelo",
"(",
")",
".",
"get_by_pk",
"(",
"self",
".",
"modelo",
".",
"id",
")",
"self",
".",
"roteiro",
"=",
"Roteiro",
".",
"get_by_pk",
"(",
"self",
".",
"roteiro",
".",
"id",
")",
"try",
":",
"try",
":",
"roteiros",
"=",
"ModeloRoteiro",
".",
"objects",
".",
"filter",
"(",
"modelo__id",
"=",
"self",
".",
"modelo",
".",
"id",
")",
"for",
"rot",
"in",
"roteiros",
":",
"if",
"rot",
".",
"roteiro",
".",
"id",
"==",
"self",
".",
"roteiro",
".",
"id",
":",
"raise",
"ModeloRoteiroDuplicatedError",
"(",
"None",
",",
"u'Modelo id %s já está associado a um roteiro.' %",
"s",
"r(s",
"e",
"lf.m",
"o",
"delo.i",
"d",
"))",
"",
"",
"except",
"ObjectDoesNotExist",
":",
"pass",
"self",
".",
"save",
"(",
")",
"except",
"ModeloRoteiroDuplicatedError",
"as",
"e",
":",
"raise",
"e",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir a associação modelo/roteiro: %s/%s. %s' %",
"",
"(",
"self",
".",
"modelo",
".",
"id",
",",
"self",
".",
"roteiro",
".",
"id",
",",
"e",
")",
")",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao inserir a associação modelo/roteiro: %s/%s.' %",
"(",
"e",
"lf.m",
"o",
"delo.i",
"d",
", ",
"s",
"lf.r",
"o",
"teiro.i",
"d",
"))",
"",
""
] | [
1921,
4
] | [
1948,
113
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
NetworkAPITestClient.postXML | (self, url, data=None, **extra) | return self.post(url, data=data, content_type=CONTENT_APPLICATION_XML) | Converte o dicionario data para XML e faz um requisição POST | Converte o dicionario data para XML e faz um requisição POST | def postXML(self, url, data=None, **extra):
""" Converte o dicionario data para XML e faz um requisição POST """
if type(data) == dict:
data = dict2xml(data)
return self.post(url, data=data, content_type=CONTENT_APPLICATION_XML) | [
"def",
"postXML",
"(",
"self",
",",
"url",
",",
"data",
"=",
"None",
",",
"*",
"*",
"extra",
")",
":",
"if",
"type",
"(",
"data",
")",
"==",
"dict",
":",
"data",
"=",
"dict2xml",
"(",
"data",
")",
"return",
"self",
".",
"post",
"(",
"url",
",",
"data",
"=",
"data",
",",
"content_type",
"=",
"CONTENT_APPLICATION_XML",
")"
] | [
254,
4
] | [
259,
78
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
LinkedList.insert | (self, index, element) | Insere um elemento em qualquer posição da lista | Insere um elemento em qualquer posição da lista | def insert(self, index, element):
""" Insere um elemento em qualquer posição da lista """
node = Node(element)
if index == 0:
node.next = self.head
self.head = node
else:
pointer = self._getnode(index - 1)
# Antes de inserir o elemento, é necessário fazer a ligação
# com o elemento inserido e com o restante da lista
node.next = pointer.next
pointer.next = node
self._size += 1 | [
"def",
"insert",
"(",
"self",
",",
"index",
",",
"element",
")",
":",
"node",
"=",
"Node",
"(",
"element",
")",
"if",
"index",
"==",
"0",
":",
"node",
".",
"next",
"=",
"self",
".",
"head",
"self",
".",
"head",
"=",
"node",
"else",
":",
"pointer",
"=",
"self",
".",
"_getnode",
"(",
"index",
"-",
"1",
")",
"# Antes de inserir o elemento, é necessário fazer a ligação\r",
"# com o elemento inserido e com o restante da lista\r",
"node",
".",
"next",
"=",
"pointer",
".",
"next",
"pointer",
".",
"next",
"=",
"node",
"self",
".",
"_size",
"+=",
"1"
] | [
35,
4
] | [
50,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType24.text | (self) | return bin2str(self.data[start:stop]) | F2 - Texto armazenado no bloco sem os bytes nulos ao final | F2 - Texto armazenado no bloco sem os bytes nulos ao final | def text(self) -> str:
"""F2 - Texto armazenado no bloco sem os bytes nulos ao final"""
start = BYTES_24[1].stop
stop = start + self.text_len
return bin2str(self.data[start:stop]) | [
"def",
"text",
"(",
"self",
")",
"->",
"str",
":",
"start",
"=",
"BYTES_24",
"[",
"1",
"]",
".",
"stop",
"stop",
"=",
"start",
"+",
"self",
".",
"text_len",
"return",
"bin2str",
"(",
"self",
".",
"data",
"[",
"start",
":",
"stop",
"]",
")"
] | [
536,
4
] | [
540,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
binary_search | (x,l) | return up | Esse algorítmo é o algorítmo de busca binária, mas ele retorna
qual o índice o qual devo colocar o elemento para que a lista
permaneça ordenada.
Input: elemento x e lista l
Output: Índice em que o elemento deve ser inserido para manter a ordenação da lista
| Esse algorítmo é o algorítmo de busca binária, mas ele retorna
qual o índice o qual devo colocar o elemento para que a lista
permaneça ordenada. | def binary_search(x,l):
""" Esse algorítmo é o algorítmo de busca binária, mas ele retorna
qual o índice o qual devo colocar o elemento para que a lista
permaneça ordenada.
Input: elemento x e lista l
Output: Índice em que o elemento deve ser inserido para manter a ordenação da lista
"""
lo = 0 # Cota inferior inicial (Lower bound)
up = len(l) # Cota superior inicial (Upper bound)
while lo < up:
mid = int((lo+up)/2) #Ponto Médio
if l[mid] < x:
lo = mid + 1
else:
up = mid
return up | [
"def",
"binary_search",
"(",
"x",
",",
"l",
")",
":",
"lo",
"=",
"0",
"# Cota inferior inicial (Lower bound)",
"up",
"=",
"len",
"(",
"l",
")",
"# Cota superior inicial (Upper bound)",
"while",
"lo",
"<",
"up",
":",
"mid",
"=",
"int",
"(",
"(",
"lo",
"+",
"up",
")",
"/",
"2",
")",
"#Ponto Médio ",
"if",
"l",
"[",
"mid",
"]",
"<",
"x",
":",
"lo",
"=",
"mid",
"+",
"1",
"else",
":",
"up",
"=",
"mid",
"return",
"up"
] | [
8,
0
] | [
24,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Bau.add_brinquedo | (self, brinquedo) | Insere um Brinquedo na lista de brinquedos de seu tipo ou adiciona um tipo de Brinquedo novo. | Insere um Brinquedo na lista de brinquedos de seu tipo ou adiciona um tipo de Brinquedo novo. | def add_brinquedo(self, brinquedo):
"""Insere um Brinquedo na lista de brinquedos de seu tipo ou adiciona um tipo de Brinquedo novo."""
try:
self.brinquedos[brinquedo.nome].append(brinquedo)
except KeyError:
self.brinquedos[brinquedo.nome] = [brinquedo] | [
"def",
"add_brinquedo",
"(",
"self",
",",
"brinquedo",
")",
":",
"try",
":",
"self",
".",
"brinquedos",
"[",
"brinquedo",
".",
"nome",
"]",
".",
"append",
"(",
"brinquedo",
")",
"except",
"KeyError",
":",
"self",
".",
"brinquedos",
"[",
"brinquedo",
".",
"nome",
"]",
"=",
"[",
"brinquedo",
"]"
] | [
27,
4
] | [
33,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
HealthcheckExpectDistinctResource.handle_get | (self, request, user, *args, **kwargs) | Trata as requisições GET para buscar expect_strings do Healthchecks_expects com distinct.
URL: /healthcheckexpect/distinct/
| Trata as requisições GET para buscar expect_strings do Healthchecks_expects com distinct. | def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições GET para buscar expect_strings do Healthchecks_expects com distinct.
URL: /healthcheckexpect/distinct/
"""
try:
if not has_perm(user,
AdminPermission.HEALTH_CHECK_EXPECT,
AdminPermission.READ_OPERATION):
return self.not_authorized()
expect_strings = HealthcheckExpect.get_expect_strings()
return self.response(
dumps_networkapi({'healthcheck_expect': expect_strings})
)
except (HealthcheckExpectError, GrupoError):
return self.response_error(1) | [
"def",
"handle_get",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"HEALTH_CHECK_EXPECT",
",",
"AdminPermission",
".",
"READ_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"expect_strings",
"=",
"HealthcheckExpect",
".",
"get_expect_strings",
"(",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'healthcheck_expect'",
":",
"expect_strings",
"}",
")",
")",
"except",
"(",
"HealthcheckExpectError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
33,
4
] | [
51,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.startswith | (self, prefixo, partida=0,limite=None, passo=1) | return self.find(prefixo)==partida | Retorna verdadeiro se o prefixo tiver índice igual à partida (0 por padrão) em .ln (caso seja string).
Caso .ln.__class__ != str, verifica se algum elemento entre a partida e o limite (__len__, por padrão), com incremento passo (por padrão 1), possui o prefixo em índice 0 ou igual à partida. A soma do índice com o passo não é protegida de exceções.
Caso nada seja encontrado, retorna self.find(prefixo) == partida. | Retorna verdadeiro se o prefixo tiver índice igual à partida (0 por padrão) em .ln (caso seja string).
Caso .ln.__class__ != str, verifica se algum elemento entre a partida e o limite (__len__, por padrão), com incremento passo (por padrão 1), possui o prefixo em índice 0 ou igual à partida. A soma do índice com o passo não é protegida de exceções.
Caso nada seja encontrado, retorna self.find(prefixo) == partida. | def startswith (self, prefixo, partida=0,limite=None, passo=1):
'''Retorna verdadeiro se o prefixo tiver índice igual à partida (0 por padrão) em .ln (caso seja string).
Caso .ln.__class__ != str, verifica se algum elemento entre a partida e o limite (__len__, por padrão), com incremento passo (por padrão 1), possui o prefixo em índice 0 ou igual à partida. A soma do índice com o passo não é protegida de exceções.
Caso nada seja encontrado, retorna self.find(prefixo) == partida.'''
try:
# if len(prefixo)>limite-partida:
# return
#except TypeError:
return self.ln.startswith(prefixo,partida,limite)
except AttributeError:
if limite == None:
limite = self.__len__()
p = partida
while p < limite:
try:
i = self[p].index(prefixo)#startswith(prefixo)
if i == 0 or i == partida:
return True
except AttributeError:
pass
except ValueError:
pass
p += passo
return self.find(prefixo)==partida; | [
"def",
"startswith",
"(",
"self",
",",
"prefixo",
",",
"partida",
"=",
"0",
",",
"limite",
"=",
"None",
",",
"passo",
"=",
"1",
")",
":",
"try",
":",
"#\tif len(prefixo)>limite-partida:",
"#\t\treturn",
"#except TypeError:",
"return",
"self",
".",
"ln",
".",
"startswith",
"(",
"prefixo",
",",
"partida",
",",
"limite",
")",
"except",
"AttributeError",
":",
"if",
"limite",
"==",
"None",
":",
"limite",
"=",
"self",
".",
"__len__",
"(",
")",
"p",
"=",
"partida",
"while",
"p",
"<",
"limite",
":",
"try",
":",
"i",
"=",
"self",
"[",
"p",
"]",
".",
"index",
"(",
"prefixo",
")",
"#startswith(prefixo)",
"if",
"i",
"==",
"0",
"or",
"i",
"==",
"partida",
":",
"return",
"True",
"except",
"AttributeError",
":",
"pass",
"except",
"ValueError",
":",
"pass",
"p",
"+=",
"passo",
"return",
"self",
".",
"find",
"(",
"prefixo",
")",
"==",
"partida"
] | [
289,
1
] | [
312,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Pesquisador.getDadosBasicos | (self) | return self.__FLAG | Le arquivo XML, inicia parsing e define alguns atributos importantes.
Returns:
type: Retorna FLAG de sucesso para ser utilizado nos métodos seguintes.
| Le arquivo XML, inicia parsing e define alguns atributos importantes. | def getDadosBasicos(self):
"""Le arquivo XML, inicia parsing e define alguns atributos importantes.
Returns:
type: Retorna FLAG de sucesso para ser utilizado nos métodos seguintes.
"""
file = self.__file
try:
#----XML funciona?
tree = etree.parse(file)
self.__FLAG = True
except:
self.ID = None
else:
#----Se estes paramêtros não puderem ser definidos o XML não é CV Lattes ou
#----foi extraído sem informações pessoais.
self.root = tree.getroot()
self.ID = self.root.get('NUMERO-IDENTIFICADOR')
self.Atualiza = self.root.get('DATA-ATUALIZACAO')
self.NOME = self.root.getchildren()[0].get('NOME-COMPLETO')
if not hasattr(self,'root'):
#----Sem root nã tem como fazer parsing. Os métodps seguintes retornam None.
self.__FLAG = False
if not hasattr(self,'ID'):
#----Sem ID no xml não podemos prosseguir
self.__FLAG = False
finally:
if ((self.ID is None) or (self.NOME is None)):
self.__FLAG = False
return self.__FLAG | [
"def",
"getDadosBasicos",
"(",
"self",
")",
":",
"file",
"=",
"self",
".",
"__file",
"try",
":",
"#----XML funciona?",
"tree",
"=",
"etree",
".",
"parse",
"(",
"file",
")",
"self",
".",
"__FLAG",
"=",
"True",
"except",
":",
"self",
".",
"ID",
"=",
"None",
"else",
":",
"#----Se estes paramêtros não puderem ser definidos o XML não é CV Lattes ou",
"#----foi extraído sem informações pessoais.",
"self",
".",
"root",
"=",
"tree",
".",
"getroot",
"(",
")",
"self",
".",
"ID",
"=",
"self",
".",
"root",
".",
"get",
"(",
"'NUMERO-IDENTIFICADOR'",
")",
"self",
".",
"Atualiza",
"=",
"self",
".",
"root",
".",
"get",
"(",
"'DATA-ATUALIZACAO'",
")",
"self",
".",
"NOME",
"=",
"self",
".",
"root",
".",
"getchildren",
"(",
")",
"[",
"0",
"]",
".",
"get",
"(",
"'NOME-COMPLETO'",
")",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'root'",
")",
":",
"#----Sem root nã tem como fazer parsing. Os métodps seguintes retornam None.",
"self",
".",
"__FLAG",
"=",
"False",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'ID'",
")",
":",
"#----Sem ID no xml não podemos prosseguir",
"self",
".",
"__FLAG",
"=",
"False",
"finally",
":",
"if",
"(",
"(",
"self",
".",
"ID",
"is",
"None",
")",
"or",
"(",
"self",
".",
"NOME",
"is",
"None",
")",
")",
":",
"self",
".",
"__FLAG",
"=",
"False",
"return",
"self",
".",
"__FLAG"
] | [
443,
4
] | [
473,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestTituloEleitoral.test_special_case | (self) | Verifica os casos especiais de Titulo de Eleitor | Verifica os casos especiais de Titulo de Eleitor | def test_special_case(self):
""" Verifica os casos especiais de Titulo de Eleitor """
cases = [
('3467875434578764345789654', False),
('AAAAAAAAAAA', False),
('', False),
]
for titulo_eleitoral, is_valid in cases:
self.assertEqual(self.titulo_eleitoral.validate(titulo_eleitoral), is_valid) | [
"def",
"test_special_case",
"(",
"self",
")",
":",
"cases",
"=",
"[",
"(",
"'3467875434578764345789654'",
",",
"False",
")",
",",
"(",
"'AAAAAAAAAAA'",
",",
"False",
")",
",",
"(",
"''",
",",
"False",
")",
",",
"]",
"for",
"titulo_eleitoral",
",",
"is_valid",
"in",
"cases",
":",
"self",
".",
"assertEqual",
"(",
"self",
".",
"titulo_eleitoral",
".",
"validate",
"(",
"titulo_eleitoral",
")",
",",
"is_valid",
")"
] | [
37,
4
] | [
45,
88
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Grafo.dijkstra | (self, start: int) | return distancia | Retorna a lista de distância do vértice start até todos os vértices
Args:
start (int): vértice inicial
Returns:
list: lista de distâncias
| Retorna a lista de distância do vértice start até todos os vértices
Args:
start (int): vértice inicial
Returns:
list: lista de distâncias
| def dijkstra(self, start: int) -> list:
"""Retorna a lista de distância do vértice start até todos os vértices
Args:
start (int): vértice inicial
Returns:
list: lista de distâncias
"""
distancia = self.dist.copy()
S = set() # Conjunto de vértices explorados
distancia[start] = 0
while True:
V = set([(i, distancia[i]) for i in range(len(self.adj))])
diferenca_de_conjuntos = list(V.difference(S))
if not diferenca_de_conjuntos:
break
heapq.heapify(diferenca_de_conjuntos)
u, distancia_u = heapq.heappop(diferenca_de_conjuntos)
S.add((u, distancia[u]))
for v in self.adj[u]:
if distancia[v[1]] > distancia_u + self._peso_entre_u_e_v(u, v):
distancia[v[1]] = distancia_u + \
self._peso_entre_u_e_v(u, v)
return distancia | [
"def",
"dijkstra",
"(",
"self",
",",
"start",
":",
"int",
")",
"->",
"list",
":",
"distancia",
"=",
"self",
".",
"dist",
".",
"copy",
"(",
")",
"S",
"=",
"set",
"(",
")",
"# Conjunto de vértices explorados\r",
"distancia",
"[",
"start",
"]",
"=",
"0",
"while",
"True",
":",
"V",
"=",
"set",
"(",
"[",
"(",
"i",
",",
"distancia",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"adj",
")",
")",
"]",
")",
"diferenca_de_conjuntos",
"=",
"list",
"(",
"V",
".",
"difference",
"(",
"S",
")",
")",
"if",
"not",
"diferenca_de_conjuntos",
":",
"break",
"heapq",
".",
"heapify",
"(",
"diferenca_de_conjuntos",
")",
"u",
",",
"distancia_u",
"=",
"heapq",
".",
"heappop",
"(",
"diferenca_de_conjuntos",
")",
"S",
".",
"add",
"(",
"(",
"u",
",",
"distancia",
"[",
"u",
"]",
")",
")",
"for",
"v",
"in",
"self",
".",
"adj",
"[",
"u",
"]",
":",
"if",
"distancia",
"[",
"v",
"[",
"1",
"]",
"]",
">",
"distancia_u",
"+",
"self",
".",
"_peso_entre_u_e_v",
"(",
"u",
",",
"v",
")",
":",
"distancia",
"[",
"v",
"[",
"1",
"]",
"]",
"=",
"distancia_u",
"+",
"self",
".",
"_peso_entre_u_e_v",
"(",
"u",
",",
"v",
")",
"return",
"distancia"
] | [
54,
4
] | [
82,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoAcesso.update | (cls, authenticated_user, id_equipamento, id_tipo_acesso, **kwargs) | Efetua a alteração de informações de acesso a equipamentos conforme argumentos recebidos
@param id_equipamento: Identificador do equipamento da informação de acesso a equipamento a ser alterada
@param id_tipo_acesso: Identificador do tipo de acesso da informação de acesso a equipamento a ser alterada
@return: Instância da informação de acesso a equipamento alterada
@raise EquipamentoAcesso.DoesNotExist: Informação de acesso a equipamento informada é inexistente
@raise EquipamentoError: Falha ao alterar informação de acesso a equipamento.
| Efetua a alteração de informações de acesso a equipamentos conforme argumentos recebidos
| def update(cls, authenticated_user, id_equipamento, id_tipo_acesso, **kwargs):
"""Efetua a alteração de informações de acesso a equipamentos conforme argumentos recebidos
@param id_equipamento: Identificador do equipamento da informação de acesso a equipamento a ser alterada
@param id_tipo_acesso: Identificador do tipo de acesso da informação de acesso a equipamento a ser alterada
@return: Instância da informação de acesso a equipamento alterada
@raise EquipamentoAcesso.DoesNotExist: Informação de acesso a equipamento informada é inexistente
@raise EquipamentoError: Falha ao alterar informação de acesso a equipamento.
"""
try:
# Obtém a informação de acesso a equipamento a ser alterada
equipamento_acesso = EquipamentoAcesso.objects.get(
equipamento__id=id_equipamento, tipo_acesso__id=id_tipo_acesso)
# Bind dos valores recebidos para o objeto a ser alterado
equipamento_acesso.__dict__.update(kwargs)
# Persiste a informação
return equipamento_acesso.save(authenticated_user)
except EquipamentoAcesso.DoesNotExist as e:
raise e
except Exception as e:
cls.log.error(
u'Falha ao alterar informação de acesso a equipamento.')
raise EquipamentoError(
e, u'Falha ao alterar informação de acesso a equipamento.') | [
"def",
"update",
"(",
"cls",
",",
"authenticated_user",
",",
"id_equipamento",
",",
"id_tipo_acesso",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"# Obtém a informação de acesso a equipamento a ser alterada",
"equipamento_acesso",
"=",
"EquipamentoAcesso",
".",
"objects",
".",
"get",
"(",
"equipamento__id",
"=",
"id_equipamento",
",",
"tipo_acesso__id",
"=",
"id_tipo_acesso",
")",
"# Bind dos valores recebidos para o objeto a ser alterado",
"equipamento_acesso",
".",
"__dict__",
".",
"update",
"(",
"kwargs",
")",
"# Persiste a informação",
"return",
"equipamento_acesso",
".",
"save",
"(",
"authenticated_user",
")",
"except",
"EquipamentoAcesso",
".",
"DoesNotExist",
"as",
"e",
":",
"raise",
"e",
"except",
"Exception",
"as",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao alterar informação de acesso a equipamento.')",
"",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao alterar informação de acesso a equipamento.')",
""
] | [
1760,
4
] | [
1786,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Extractor.filtro_sobel | (self, img) | return Wxy.astype(int) | Obter o resultado a imagem após aplicar o filtro Sobel
| Obter o resultado a imagem após aplicar o filtro Sobel
| def filtro_sobel(self, img):
"""Obter o resultado a imagem após aplicar o filtro Sobel
"""
qtdeLinhas, qtdeColunas = img.shape
kernel_x = np.array([[-1, 0, 1],[-2, 0, 2],[-1, 0, 1]]) #kernel da derivada em relação a x
kernel_y = np.array([[1, 2, 1],[0, 0, 0], [-1, -2, -1]]) #kernel da derivada em relação a y
Wx = self.conv(img, kernel_x)
Wy =self. conv(img, kernel_y)
Wxy = np.hypot(Wx,Wy)
Wxy *= 255.0 / np.max(Wxy) #Normalizar
return Wxy.astype(int) | [
"def",
"filtro_sobel",
"(",
"self",
",",
"img",
")",
":",
"qtdeLinhas",
",",
"qtdeColunas",
"=",
"img",
".",
"shape",
"kernel_x",
"=",
"np",
".",
"array",
"(",
"[",
"[",
"-",
"1",
",",
"0",
",",
"1",
"]",
",",
"[",
"-",
"2",
",",
"0",
",",
"2",
"]",
",",
"[",
"-",
"1",
",",
"0",
",",
"1",
"]",
"]",
")",
"#kernel da derivada em relação a x",
"kernel_y",
"=",
"np",
".",
"array",
"(",
"[",
"[",
"1",
",",
"2",
",",
"1",
"]",
",",
"[",
"0",
",",
"0",
",",
"0",
"]",
",",
"[",
"-",
"1",
",",
"-",
"2",
",",
"-",
"1",
"]",
"]",
")",
"#kernel da derivada em relação a y",
"Wx",
"=",
"self",
".",
"conv",
"(",
"img",
",",
"kernel_x",
")",
"Wy",
"=",
"self",
".",
"conv",
"(",
"img",
",",
"kernel_y",
")",
"Wxy",
"=",
"np",
".",
"hypot",
"(",
"Wx",
",",
"Wy",
")",
"Wxy",
"*=",
"255.0",
"/",
"np",
".",
"max",
"(",
"Wxy",
")",
"#Normalizar",
"return",
"Wxy",
".",
"astype",
"(",
"int",
")"
] | [
32,
4
] | [
45,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PackPOOII.cor | (palavra, cor) | Retorna a palavra com a cor escolhida
Parametros
----------
palavra : str
Texto para ter sua cor alterada
cor : str
Cor escolhida para o texto
| Retorna a palavra com a cor escolhida | def cor(palavra, cor):
""" Retorna a palavra com a cor escolhida
Parametros
----------
palavra : str
Texto para ter sua cor alterada
cor : str
Cor escolhida para o texto
"""
cor = cor.upper()
if cor == "YELLOW":
pYellow = f"\033[33m{palavra} \033[m"
return pYellow
elif cor == "BLACK":
pBlack = f"\033[30m{palavra} \033[m"
return pBlack
elif cor == "RED":
pRed = f"\033[1;31m{palavra} \033[m"
return pRed
elif cor == "BLUE":
pBlue = f"\033[1;34m{palavra} \033[m"
return pBlue
elif cor == "CIAN":
pCian = f"\033[1;36m{palavra} \033[m"
return pCian
elif cor == "GREEN":
pGreen = f"\033[1;32m{palavra} \033[m"
return pGreen
elif cor == "WHITE":
pWhite = f"\033[37m{palavra} \033[m"
return pWhite
else:
return "Cor não existe" | [
"def",
"cor",
"(",
"palavra",
",",
"cor",
")",
":",
"cor",
"=",
"cor",
".",
"upper",
"(",
")",
"if",
"cor",
"==",
"\"YELLOW\"",
":",
"pYellow",
"=",
"f\"\\033[33m{palavra} \\033[m\"",
"return",
"pYellow",
"elif",
"cor",
"==",
"\"BLACK\"",
":",
"pBlack",
"=",
"f\"\\033[30m{palavra} \\033[m\"",
"return",
"pBlack",
"elif",
"cor",
"==",
"\"RED\"",
":",
"pRed",
"=",
"f\"\\033[1;31m{palavra} \\033[m\"",
"return",
"pRed",
"elif",
"cor",
"==",
"\"BLUE\"",
":",
"pBlue",
"=",
"f\"\\033[1;34m{palavra} \\033[m\"",
"return",
"pBlue",
"elif",
"cor",
"==",
"\"CIAN\"",
":",
"pCian",
"=",
"f\"\\033[1;36m{palavra} \\033[m\"",
"return",
"pCian",
"elif",
"cor",
"==",
"\"GREEN\"",
":",
"pGreen",
"=",
"f\"\\033[1;32m{palavra} \\033[m\"",
"return",
"pGreen",
"elif",
"cor",
"==",
"\"WHITE\"",
":",
"pWhite",
"=",
"f\"\\033[37m{palavra} \\033[m\"",
"return",
"pWhite",
"else",
":",
"return",
"\"Cor não existe\""
] | [
71,
4
] | [
106,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
p_lista_argumentos | (p) | lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
| lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
| def p_lista_argumentos(p):
"""lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
"""
pai = MyNode(name='lista_argumentos', type='LISTA_ARGUMENTOS')
p[0] = pai
if len(p) > 2:
p[1].parent = pai
filho2 = MyNode(name='VIRGULA', type='VIRGULA', parent=pai)
filho_sym = MyNode(name=p[2], type='SIMBOLO', parent=filho2)
p[2] = filho2
p[3].parent = pai
else:
p[1].parent = pai | [
"def",
"p_lista_argumentos",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'lista_argumentos'",
",",
"type",
"=",
"'LISTA_ARGUMENTOS'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"if",
"len",
"(",
"p",
")",
">",
"2",
":",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai",
"filho2",
"=",
"MyNode",
"(",
"name",
"=",
"'VIRGULA'",
",",
"type",
"=",
"'VIRGULA'",
",",
"parent",
"=",
"pai",
")",
"filho_sym",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"2",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho2",
")",
"p",
"[",
"2",
"]",
"=",
"filho2",
"p",
"[",
"3",
"]",
".",
"parent",
"=",
"pai",
"else",
":",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
782,
0
] | [
799,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
move_not_inwards | (s) | Reescreva sentenças s movendo sinal de negação.
>>> move_not_inwards(~(A | B))
(~A & ~B) | Reescreva sentenças s movendo sinal de negação.
>>> move_not_inwards(~(A | B))
(~A & ~B) | def move_not_inwards(s):
"""Reescreva sentenças s movendo sinal de negação.
>>> move_not_inwards(~(A | B))
(~A & ~B)"""
s = expr(s)
if s.op == '~':
def NOT(b):
return move_not_inwards(~b)
a = s.args[0]
if a.op == '~':
return move_not_inwards(a.args[0]) # ~~A ==> A
if a.op == '&':
return associate('|', list(map(NOT, a.args)))
if a.op == '|':
return associate('&', list(map(NOT, a.args)))
return s
elif is_symbol(s.op) or not s.args:
return s
else:
return Expr(s.op, *list(map(move_not_inwards, s.args))) | [
"def",
"move_not_inwards",
"(",
"s",
")",
":",
"s",
"=",
"expr",
"(",
"s",
")",
"if",
"s",
".",
"op",
"==",
"'~'",
":",
"def",
"NOT",
"(",
"b",
")",
":",
"return",
"move_not_inwards",
"(",
"~",
"b",
")",
"a",
"=",
"s",
".",
"args",
"[",
"0",
"]",
"if",
"a",
".",
"op",
"==",
"'~'",
":",
"return",
"move_not_inwards",
"(",
"a",
".",
"args",
"[",
"0",
"]",
")",
"# ~~A ==> A",
"if",
"a",
".",
"op",
"==",
"'&'",
":",
"return",
"associate",
"(",
"'|'",
",",
"list",
"(",
"map",
"(",
"NOT",
",",
"a",
".",
"args",
")",
")",
")",
"if",
"a",
".",
"op",
"==",
"'|'",
":",
"return",
"associate",
"(",
"'&'",
",",
"list",
"(",
"map",
"(",
"NOT",
",",
"a",
".",
"args",
")",
")",
")",
"return",
"s",
"elif",
"is_symbol",
"(",
"s",
".",
"op",
")",
"or",
"not",
"s",
".",
"args",
":",
"return",
"s",
"else",
":",
"return",
"Expr",
"(",
"s",
".",
"op",
",",
"*",
"list",
"(",
"map",
"(",
"move_not_inwards",
",",
"s",
".",
"args",
")",
")",
")"
] | [
308,
0
] | [
327,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
base_parser | (args) | return parser | Parser com parametros basico da execução do app | Parser com parametros basico da execução do app | def base_parser(args):
""" Parser com parametros basico da execução do app """
parser = argparse.ArgumentParser(add_help=False)
parser.add_argument("--loglevel", default="INFO")
packtools_version = pkg_resources.get_distribution("documentstore-migracao").version
parser.add_argument("--version", action="version", version=packtools_version)
return parser | [
"def",
"base_parser",
"(",
"args",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"add_help",
"=",
"False",
")",
"parser",
".",
"add_argument",
"(",
"\"--loglevel\"",
",",
"default",
"=",
"\"INFO\"",
")",
"packtools_version",
"=",
"pkg_resources",
".",
"get_distribution",
"(",
"\"documentstore-migracao\"",
")",
".",
"version",
"parser",
".",
"add_argument",
"(",
"\"--version\"",
",",
"action",
"=",
"\"version\"",
",",
"version",
"=",
"packtools_version",
")",
"return",
"parser"
] | [
4,
0
] | [
12,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
LDLt | (matrix) | return L, D | Encontra as matrizes L e D, vale notar que D foi armazena em um vetor. Isso foi feito para eficiencia
computacional, uma vez que a matriz D é esparsa | Encontra as matrizes L e D, vale notar que D foi armazena em um vetor. Isso foi feito para eficiencia
computacional, uma vez que a matriz D é esparsa | def LDLt(matrix):
''''Encontra as matrizes L e D, vale notar que D foi armazena em um vetor. Isso foi feito para eficiencia
computacional, uma vez que a matriz D é esparsa '''
size = matrix.shape[0]
L = np.zeros((size, size))
D = np.zeros(size)
for i in range(size):
D[i] = achaDz(matrix, L, D, i)
L[i, i] = 1
for k in range(i + 1, size):
L[k, i] = achaLxy(matrix, L, D, k, i)
return L, D | [
"def",
"LDLt",
"(",
"matrix",
")",
":",
"size",
"=",
"matrix",
".",
"shape",
"[",
"0",
"]",
"L",
"=",
"np",
".",
"zeros",
"(",
"(",
"size",
",",
"size",
")",
")",
"D",
"=",
"np",
".",
"zeros",
"(",
"size",
")",
"for",
"i",
"in",
"range",
"(",
"size",
")",
":",
"D",
"[",
"i",
"]",
"=",
"achaDz",
"(",
"matrix",
",",
"L",
",",
"D",
",",
"i",
")",
"L",
"[",
"i",
",",
"i",
"]",
"=",
"1",
"for",
"k",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"size",
")",
":",
"L",
"[",
"k",
",",
"i",
"]",
"=",
"achaLxy",
"(",
"matrix",
",",
"L",
",",
"D",
",",
"k",
",",
"i",
")",
"return",
"L",
",",
"D"
] | [
87,
0
] | [
98,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Environment.some_things_at | (self, location, tclass=Thing) | return self.list_things_at(location, tclass) != [] | Retorna true se pelo menos uma das coisas no local
for uma instância de classe tclass (ou uma subclasse). | Retorna true se pelo menos uma das coisas no local
for uma instância de classe tclass (ou uma subclasse). | def some_things_at(self, location, tclass=Thing):
"""Retorna true se pelo menos uma das coisas no local
for uma instância de classe tclass (ou uma subclasse)."""
return self.list_things_at(location, tclass) != [] | [
"def",
"some_things_at",
"(",
"self",
",",
"location",
",",
"tclass",
"=",
"Thing",
")",
":",
"return",
"self",
".",
"list_things_at",
"(",
"location",
",",
"tclass",
")",
"!=",
"[",
"]"
] | [
193,
4
] | [
196,
58
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Remocao_do_continuo | (Rrs_dict, nm_min, nm_max, Exemplo=False) | return Rrs_dict | Função que retorna um dicionário com o contínuo removido.
Atributos de Entrada:
Rrs_dict: dicionário contendo nm e Rrs (ou nm, Lw)...
nm_min: comprimento de onda mínimo para extração do contínuo
nm_max: comprimento de onda máximo para extração do contínuo
Exemplo: retorna um exemplo com a chamada da função.
Retorna: dicionário com keys='nm' e values com contínuo removido.
| Função que retorna um dicionário com o contínuo removido.
Atributos de Entrada:
Rrs_dict: dicionário contendo nm e Rrs (ou nm, Lw)...
nm_min: comprimento de onda mínimo para extração do contínuo
nm_max: comprimento de onda máximo para extração do contínuo
Exemplo: retorna um exemplo com a chamada da função.
Retorna: dicionário com keys='nm' e values com contínuo removido.
| def Remocao_do_continuo(Rrs_dict, nm_min, nm_max, Exemplo=False):
""" Função que retorna um dicionário com o contínuo removido.
Atributos de Entrada:
Rrs_dict: dicionário contendo nm e Rrs (ou nm, Lw)...
nm_min: comprimento de onda mínimo para extração do contínuo
nm_max: comprimento de onda máximo para extração do contínuo
Exemplo: retorna um exemplo com a chamada da função.
Retorna: dicionário com keys='nm' e values com contínuo removido.
"""
if Exemplo ==True:
Exemplo()
nm_interp = np.array([nm_min, nm_max+1])
f = interpolate.interp1d(nm_interp, (Rrs_dict[nm_min], Rrs_dict[nm_max]))
nm_desejado = np.arange(nm_min, nm_max)
Reflectancia_nm_desejada = f(nm_desejado)
Reflectancia_nm_desejada_dict = {}
i = 0
for N in nm_desejado:
Reflectancia_nm_desejada_dict[N] = Reflectancia_nm_desejada[i]
i+=1
plt.figure(1)
plt.clf()
plt.plot(sorted(Rrs_dict.keys()), sorted(Rrs_dict.values()), 'bo')
plt.plot(sorted(Rrs_dict.keys()), sorted(Rrs_dict.values()), 'b--')
plt.plot(sorted(Reflectancia_nm_desejada_dict.keys()),
sorted(Reflectancia_nm_desejada_dict.values()), 'ro')
for key in sorted(Reflectancia_nm_desejada_dict.keys()):
Rrs_dict[key] -= Reflectancia_nm_desejada_dict[key]
plt.plot(sorted(Rrs_dict.keys()),
sorted(Rrs_dict.values()), 'k-')
plt.legend(['original', 'original', 'interpolada', 'Contínuo Remov'], loc='best')
plt.show()
plt.figure(2)
plt.plot(sorted(Rrs_dict.keys()),
sorted(Rrs_dict.values()), 'r-')
plt.legend(["Contínuo Removido"])
plt.show()
return Rrs_dict | [
"def",
"Remocao_do_continuo",
"(",
"Rrs_dict",
",",
"nm_min",
",",
"nm_max",
",",
"Exemplo",
"=",
"False",
")",
":",
"if",
"Exemplo",
"==",
"True",
":",
"Exemplo",
"(",
")",
"nm_interp",
"=",
"np",
".",
"array",
"(",
"[",
"nm_min",
",",
"nm_max",
"+",
"1",
"]",
")",
"f",
"=",
"interpolate",
".",
"interp1d",
"(",
"nm_interp",
",",
"(",
"Rrs_dict",
"[",
"nm_min",
"]",
",",
"Rrs_dict",
"[",
"nm_max",
"]",
")",
")",
"nm_desejado",
"=",
"np",
".",
"arange",
"(",
"nm_min",
",",
"nm_max",
")",
"Reflectancia_nm_desejada",
"=",
"f",
"(",
"nm_desejado",
")",
"Reflectancia_nm_desejada_dict",
"=",
"{",
"}",
"i",
"=",
"0",
"for",
"N",
"in",
"nm_desejado",
":",
"Reflectancia_nm_desejada_dict",
"[",
"N",
"]",
"=",
"Reflectancia_nm_desejada",
"[",
"i",
"]",
"i",
"+=",
"1",
"plt",
".",
"figure",
"(",
"1",
")",
"plt",
".",
"clf",
"(",
")",
"plt",
".",
"plot",
"(",
"sorted",
"(",
"Rrs_dict",
".",
"keys",
"(",
")",
")",
",",
"sorted",
"(",
"Rrs_dict",
".",
"values",
"(",
")",
")",
",",
"'bo'",
")",
"plt",
".",
"plot",
"(",
"sorted",
"(",
"Rrs_dict",
".",
"keys",
"(",
")",
")",
",",
"sorted",
"(",
"Rrs_dict",
".",
"values",
"(",
")",
")",
",",
"'b--'",
")",
"plt",
".",
"plot",
"(",
"sorted",
"(",
"Reflectancia_nm_desejada_dict",
".",
"keys",
"(",
")",
")",
",",
"sorted",
"(",
"Reflectancia_nm_desejada_dict",
".",
"values",
"(",
")",
")",
",",
"'ro'",
")",
"for",
"key",
"in",
"sorted",
"(",
"Reflectancia_nm_desejada_dict",
".",
"keys",
"(",
")",
")",
":",
"Rrs_dict",
"[",
"key",
"]",
"-=",
"Reflectancia_nm_desejada_dict",
"[",
"key",
"]",
"plt",
".",
"plot",
"(",
"sorted",
"(",
"Rrs_dict",
".",
"keys",
"(",
")",
")",
",",
"sorted",
"(",
"Rrs_dict",
".",
"values",
"(",
")",
")",
",",
"'k-'",
")",
"plt",
".",
"legend",
"(",
"[",
"'original'",
",",
"'original'",
",",
"'interpolada'",
",",
"'Contínuo Remov']",
",",
" ",
"oc=",
"'",
"best')",
"",
"plt",
".",
"show",
"(",
")",
"plt",
".",
"figure",
"(",
"2",
")",
"plt",
".",
"plot",
"(",
"sorted",
"(",
"Rrs_dict",
".",
"keys",
"(",
")",
")",
",",
"sorted",
"(",
"Rrs_dict",
".",
"values",
"(",
")",
")",
",",
"'r-'",
")",
"plt",
".",
"legend",
"(",
"[",
"\"Contínuo Removido\"]",
")",
"",
"plt",
".",
"show",
"(",
")",
"return",
"Rrs_dict"
] | [
24,
0
] | [
86,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoResource.handle_delete | (self, request, user, *args, **kwargs) | Trata requisições de DELETE para remover um equipamento.
URL: /equipamento/id/
| Trata requisições de DELETE para remover um equipamento. | def handle_delete(self, request, user, *args, **kwargs):
"""Trata requisições de DELETE para remover um equipamento.
URL: /equipamento/id/
"""
try:
equipment_id = kwargs.get('id_equip')
if not is_valid_int_greater_zero_param(equipment_id):
self.log.error(
u'The equipment_id parameter is not a valid value: %s.', equipment_id)
raise InvalidValueError(None, 'equipment_id', equipment_id)
equip = Equipamento.get_by_pk(equipment_id)
with distributedlock(LOCK_EQUIPMENT % equipment_id):
ip_equipamento_list = IpEquipamento.objects.filter(
equipamento=equipment_id)
ip6_equipamento_list = Ipv6Equipament.objects.filter(
equipamento=equipment_id)
# Delete vlan's cache
key_list = []
for eq in ip_equipamento_list:
vlan = eq.ip.networkipv4.vlan
vlan_id = vlan.id
key_list.append(vlan_id)
for eq in ip6_equipamento_list:
vlan = eq.ip.networkipv6.vlan
vlan_id = vlan.id
key_list.append(vlan_id)
destroy_cache_function(key_list)
remove_equipment(equipment_id, user)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EquipamentoNotFoundError:
return self.response_error(117, equipment_id)
except UserNotAuthorizedError:
return self.not_authorized()
except IpCantBeRemovedFromVip, e:
return self.response_error(345, equip.nome, e.cause, e.message)
except (EquipamentoError, GrupoError), e:
return self.response_error(e)
except Exception, e:
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"equipment_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_equip'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equipment_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The equipment_id parameter is not a valid value: %s.'",
",",
"equipment_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equipment_id'",
",",
"equipment_id",
")",
"equip",
"=",
"Equipamento",
".",
"get_by_pk",
"(",
"equipment_id",
")",
"with",
"distributedlock",
"(",
"LOCK_EQUIPMENT",
"%",
"equipment_id",
")",
":",
"ip_equipamento_list",
"=",
"IpEquipamento",
".",
"objects",
".",
"filter",
"(",
"equipamento",
"=",
"equipment_id",
")",
"ip6_equipamento_list",
"=",
"Ipv6Equipament",
".",
"objects",
".",
"filter",
"(",
"equipamento",
"=",
"equipment_id",
")",
"# Delete vlan's cache",
"key_list",
"=",
"[",
"]",
"for",
"eq",
"in",
"ip_equipamento_list",
":",
"vlan",
"=",
"eq",
".",
"ip",
".",
"networkipv4",
".",
"vlan",
"vlan_id",
"=",
"vlan",
".",
"id",
"key_list",
".",
"append",
"(",
"vlan_id",
")",
"for",
"eq",
"in",
"ip6_equipamento_list",
":",
"vlan",
"=",
"eq",
".",
"ip",
".",
"networkipv6",
".",
"vlan",
"vlan_id",
"=",
"vlan",
".",
"id",
"key_list",
".",
"append",
"(",
"vlan_id",
")",
"destroy_cache_function",
"(",
"key_list",
")",
"remove_equipment",
"(",
"equipment_id",
",",
"user",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equipment_id",
")",
"except",
"UserNotAuthorizedError",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"IpCantBeRemovedFromVip",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"345",
",",
"equip",
".",
"nome",
",",
"e",
".",
"cause",
",",
"e",
".",
"message",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"e",
")",
"except",
"Exception",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
350,
4
] | [
401,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
InterfaceResource.handle_delete | (self, request, user, *args, **kwargs) | Trata uma requisição DELETE para excluir uma interface
URL: /interface/<id_interface>/
| Trata uma requisição DELETE para excluir uma interface | def handle_delete(self, request, user, *args, **kwargs):
"""Trata uma requisição DELETE para excluir uma interface
URL: /interface/<id_interface>/
"""
# Get request data and check permission
try:
# Valid Interface ID
id_interface = kwargs.get('id_interface')
if not is_valid_int_greater_zero_param(id_interface):
self.log.error(
u'The id_interface parameter is not a valid value: %s.', id_interface)
raise InvalidValueError(None, 'id_interface', id_interface)
# Get interface and equipment to check permission
interface = Interface.get_by_pk(id_interface)
id_equipamento = interface.equipamento_id
# Check permission
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_INTERFACE % id_interface):
# Remove interface
Interface.remove(user, id_interface)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
except InterfaceNotFoundError:
return self.response_error(141)
except InterfaceUsedByOtherInterfaceError:
return self.response_error(214, id_interface)
except (InterfaceError, GrupoError, EquipamentoError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Get request data and check permission",
"try",
":",
"# Valid Interface ID",
"id_interface",
"=",
"kwargs",
".",
"get",
"(",
"'id_interface'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"id_interface",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The id_interface parameter is not a valid value: %s.'",
",",
"id_interface",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'id_interface'",
",",
"id_interface",
")",
"# Get interface and equipment to check permission",
"interface",
"=",
"Interface",
".",
"get_by_pk",
"(",
"id_interface",
")",
"id_equipamento",
"=",
"interface",
".",
"equipamento_id",
"# Check permission",
"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_INTERFACE",
"%",
"id_interface",
")",
":",
"# Remove interface",
"Interface",
".",
"remove",
"(",
"user",
",",
"id_interface",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisição.')",
"",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"except",
"InterfaceNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"141",
")",
"except",
"InterfaceUsedByOtherInterfaceError",
":",
"return",
"self",
".",
"response_error",
"(",
"214",
",",
"id_interface",
")",
"except",
"(",
"InterfaceError",
",",
"GrupoError",
",",
"EquipamentoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
362,
4
] | [
407,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
KB.ask_generator | (self, query) | Produza todas as substituições que tornam a consulta verdadeira. | Produza todas as substituições que tornam a consulta verdadeira. | def ask_generator(self, query):
"Produza todas as substituições que tornam a consulta verdadeira."
raise NotImplementedError | [
"def",
"ask_generator",
"(",
"self",
",",
"query",
")",
":",
"raise",
"NotImplementedError"
] | [
61,
4
] | [
63,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Ship.update | (self) | Atualiza a posicao da espaconave de acordo com a flag
de movimento. | Atualiza a posicao da espaconave de acordo com a flag
de movimento. | def update(self):
"""Atualiza a posicao da espaconave de acordo com a flag
de movimento."""
# Atualiza o valor do centro da espaconave, e nao o rectangulo
if self.moving_right and self.rect.right <=\
self.screen_rect.right:
self.center += self.ai_settings.ship_speed_factor
if self.moving_left and self.rect.left >= 0:
self.center -= self.ai_settings.ship_speed_factor
# Atualiza o objecto reac de acordo com self.center
self.rect.centerx = self.center | [
"def",
"update",
"(",
"self",
")",
":",
"# Atualiza o valor do centro da espaconave, e nao o rectangulo",
"if",
"self",
".",
"moving_right",
"and",
"self",
".",
"rect",
".",
"right",
"<=",
"self",
".",
"screen_rect",
".",
"right",
":",
"self",
".",
"center",
"+=",
"self",
".",
"ai_settings",
".",
"ship_speed_factor",
"if",
"self",
".",
"moving_left",
"and",
"self",
".",
"rect",
".",
"left",
">=",
"0",
":",
"self",
".",
"center",
"-=",
"self",
".",
"ai_settings",
".",
"ship_speed_factor",
"# Atualiza o objecto reac de acordo com self.center",
"self",
".",
"rect",
".",
"centerx",
"=",
"self",
".",
"center"
] | [
26,
4
] | [
39,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ScoreBoard.prep_images | (self) | Prepara as imagens iniciais | Prepara as imagens iniciais | def prep_images(self):
"""Prepara as imagens iniciais"""
self.prep_score()
self.prep_high_score()
self.prep_level()
self.prep_ships() | [
"def",
"prep_images",
"(",
"self",
")",
":",
"self",
".",
"prep_score",
"(",
")",
"self",
".",
"prep_high_score",
"(",
")",
"self",
".",
"prep_level",
"(",
")",
"self",
".",
"prep_ships",
"(",
")"
] | [
22,
4
] | [
27,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
make_sanduiche | (*intens) | return sanduiche | Exibe um sanduiche personalizado | Exibe um sanduiche personalizado | def make_sanduiche(*intens):
"""Exibe um sanduiche personalizado"""
sanduiche = [seu_sanduiche]
return sanduiche | [
"def",
"make_sanduiche",
"(",
"*",
"intens",
")",
":",
"sanduiche",
"=",
"[",
"seu_sanduiche",
"]",
"return",
"sanduiche"
] | [
7,
0
] | [
10,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoAmbiente.create | (self, authenticated_user=None) | Insere uma nova associação entre um Equipamento e um Ambiente.
@return: Nothing
@raise AmbienteNotFoundError: Ambiente não cadastrado.
@raise EquipamentoAmbienteDuplicatedError: Equipamento já está cadastrado no Ambiente.
@raise EquipamentoError: Falha ao inserir a associação Equipamento e Ambiente.
| Insere uma nova associação entre um Equipamento e um Ambiente. | def create(self, authenticated_user=None):
"""Insere uma nova associação entre um Equipamento e um Ambiente.
@return: Nothing
@raise AmbienteNotFoundError: Ambiente não cadastrado.
@raise EquipamentoAmbienteDuplicatedError: Equipamento já está cadastrado no Ambiente.
@raise EquipamentoError: Falha ao inserir a associação Equipamento e Ambiente.
"""
self.ambiente = Ambiente().get_by_pk(self.ambiente.id)
self.equipamento = Equipamento().get_by_pk(self.equipamento.id)
try:
EquipamentoAmbiente().get_by_equipment_environment(
self.equipamento.id, self.ambiente.id)
raise EquipamentoAmbienteDuplicatedError(
None, u'Equipamento já está cadastrado no ambiente.')
except EquipamentoAmbienteNotFoundError:
pass
try:
self.save()
except Exception as e:
self.log.error(u'Falha ao inserir a associação equipamento/ambiente: %s/%s.' %
(self.equipamento.id, self.ambiente.id))
raise EquipamentoError(
e, u'Falha ao inserir a associação equipamento/ambiente: %s/%s.' % (self.equipamento.id, self.ambiente.id)) | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
"=",
"None",
")",
":",
"self",
".",
"ambiente",
"=",
"Ambiente",
"(",
")",
".",
"get_by_pk",
"(",
"self",
".",
"ambiente",
".",
"id",
")",
"self",
".",
"equipamento",
"=",
"Equipamento",
"(",
")",
".",
"get_by_pk",
"(",
"self",
".",
"equipamento",
".",
"id",
")",
"try",
":",
"EquipamentoAmbiente",
"(",
")",
".",
"get_by_equipment_environment",
"(",
"self",
".",
"equipamento",
".",
"id",
",",
"self",
".",
"ambiente",
".",
"id",
")",
"raise",
"EquipamentoAmbienteDuplicatedError",
"(",
"None",
",",
"u'Equipamento já está cadastrado no ambiente.')",
"",
"except",
"EquipamentoAmbienteNotFoundError",
":",
"pass",
"try",
":",
"self",
".",
"save",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir a associação equipamento/ambiente: %s/%s.' %",
"",
"(",
"self",
".",
"equipamento",
".",
"id",
",",
"self",
".",
"ambiente",
".",
"id",
")",
")",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao inserir a associação equipamento/ambiente: %s/%s.' %",
"(",
"e",
"lf.e",
"q",
"uipamento.i",
"d",
", ",
"s",
"lf.a",
"m",
"biente.i",
"d",
"))",
"",
""
] | [
1324,
4
] | [
1353,
125
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Coordinate3D.distance | (self, other) | return (x_diff_sq + y_diff_sq + z_diff_sq)**0.5 | Retorna a distância euclidiana entre duas Coordinate3D's | Retorna a distância euclidiana entre duas Coordinate3D's | def distance(self, other):
"""Retorna a distância euclidiana entre duas Coordinate3D's"""
x_diff_sq = (self.x-other.x)**2
y_diff_sq = (self.y-other.y)**2
z_diff_sq = (self.z-other.z)**2
return (x_diff_sq + y_diff_sq + z_diff_sq)**0.5 | [
"def",
"distance",
"(",
"self",
",",
"other",
")",
":",
"x_diff_sq",
"=",
"(",
"self",
".",
"x",
"-",
"other",
".",
"x",
")",
"**",
"2",
"y_diff_sq",
"=",
"(",
"self",
".",
"y",
"-",
"other",
".",
"y",
")",
"**",
"2",
"z_diff_sq",
"=",
"(",
"self",
".",
"z",
"-",
"other",
".",
"z",
")",
"**",
"2",
"return",
"(",
"x_diff_sq",
"+",
"y_diff_sq",
"+",
"z_diff_sq",
")",
"**",
"0.5"
] | [
23,
4
] | [
28,
55
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
create_matrix_MMQ | (uarray) | return matrix | Funcao que cria a matriz do MMQ
Ela basicamente executa os produtos internos corretos, na metade inferior da matrix
soma a matrix com sua transposta, tirando vantagem da natureza simetrica do problema,
para executar menos calculos. | Funcao que cria a matriz do MMQ
Ela basicamente executa os produtos internos corretos, na metade inferior da matrix
soma a matrix com sua transposta, tirando vantagem da natureza simetrica do problema,
para executar menos calculos. | def create_matrix_MMQ(uarray):
''''Funcao que cria a matriz do MMQ
Ela basicamente executa os produtos internos corretos, na metade inferior da matrix
soma a matrix com sua transposta, tirando vantagem da natureza simetrica do problema,
para executar menos calculos.'''
shape = uarray.shape[0]
matrix = np.zeros((shape, shape))
for i in range(shape):
for j in range(shape):
if j > i:
matrix[i][j] = prod_interno(uarray[i], uarray[j])
matrixt = matrix.transpose()
matrix += matrixt
for i in range(shape):
matrix[i][i] = prod_interno(uarray[i], uarray[i])
return matrix | [
"def",
"create_matrix_MMQ",
"(",
"uarray",
")",
":",
"shape",
"=",
"uarray",
".",
"shape",
"[",
"0",
"]",
"matrix",
"=",
"np",
".",
"zeros",
"(",
"(",
"shape",
",",
"shape",
")",
")",
"for",
"i",
"in",
"range",
"(",
"shape",
")",
":",
"for",
"j",
"in",
"range",
"(",
"shape",
")",
":",
"if",
"j",
">",
"i",
":",
"matrix",
"[",
"i",
"]",
"[",
"j",
"]",
"=",
"prod_interno",
"(",
"uarray",
"[",
"i",
"]",
",",
"uarray",
"[",
"j",
"]",
")",
"matrixt",
"=",
"matrix",
".",
"transpose",
"(",
")",
"matrix",
"+=",
"matrixt",
"for",
"i",
"in",
"range",
"(",
"shape",
")",
":",
"matrix",
"[",
"i",
"]",
"[",
"i",
"]",
"=",
"prod_interno",
"(",
"uarray",
"[",
"i",
"]",
",",
"uarray",
"[",
"i",
"]",
")",
"return",
"matrix"
] | [
38,
0
] | [
53,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Soma.__init__ | (self, numero1, numero2) | Inicializa os atributos do programa soma! | Inicializa os atributos do programa soma! | def __init__(self, numero1, numero2):
"""Inicializa os atributos do programa soma!"""
self.numero1 = numero1
self.numero2 = numero2 | [
"def",
"__init__",
"(",
"self",
",",
"numero1",
",",
"numero2",
")",
":",
"self",
".",
"numero1",
"=",
"numero1",
"self",
".",
"numero2",
"=",
"numero2"
] | [
10,
4
] | [
13,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
parse_date | (date: str) | Traduz datas em formato simples ano-mes-dia, ano-mes para
o formato iso utilizado durantr a persistência do Kernel | Traduz datas em formato simples ano-mes-dia, ano-mes para
o formato iso utilizado durantr a persistência do Kernel | def parse_date(date: str) -> str:
"""Traduz datas em formato simples ano-mes-dia, ano-mes para
o formato iso utilizado durantr a persistência do Kernel"""
_date = None
def limit_month_range(date):
"""Remove o segundo mês da data limitando o intervalo de criaçã
>>> limit_month_range("2018-Oct-Dec")
>>> "2018-Dec"
"""
parts = [part for part in date.split("-") if len(part.strip()) > 0]
return "-".join([parts[0], parts[-1]])
def remove_invalid_date_parts(date):
"""Remove partes inválidas de datas e retorna uma data válida
>>> remove_invalid_date_parts("2019-12-100")
>>> "2019-12"
>>> remove_invalid_date_parts("2019-20-01")
>>> "2019" # Não faz sentido utilizar o dia válido após um mês inválido
"""
date = date.split("-")
_date = []
for index, part in enumerate(date):
if len(part) == 0 or part == "00" or part == "0":
break
elif index == 1 and part.isnumeric() and int(part) > 12:
break
elif index == 2 and part.isnumeric() and int(part) > 31:
break
elif part.isdigit():
part = str(int(part))
_date.append(part)
return "-".join(_date)
formats = [
("%Y-%m-%d", lambda x: x),
("%Y-%m", lambda x: x),
("%Y", lambda x: x),
("%Y-%b-%d", lambda x: x),
("%Y-%b", lambda x: x),
("%Y-%B", lambda x: x),
("%Y-%B-%d", lambda x: x),
("%Y-%B", remove_invalid_date_parts),
("%Y-%b", limit_month_range),
("%Y-%m-%d", remove_invalid_date_parts),
("%Y-%m", remove_invalid_date_parts),
("%Y", remove_invalid_date_parts),
]
for template, func in formats:
try:
_date = (
datetime.strptime(func(date.strip()), template).isoformat(
timespec="microseconds"
)
+ "Z"
)
except ValueError:
continue
else:
return _date
raise ValueError("Could not transform date '%s' to ISO format" % date) from None | [
"def",
"parse_date",
"(",
"date",
":",
"str",
")",
"->",
"str",
":",
"_date",
"=",
"None",
"def",
"limit_month_range",
"(",
"date",
")",
":",
"\"\"\"Remove o segundo mês da data limitando o intervalo de criaçã\n >>> limit_month_range(\"2018-Oct-Dec\")\n >>> \"2018-Dec\"\n \"\"\"",
"parts",
"=",
"[",
"part",
"for",
"part",
"in",
"date",
".",
"split",
"(",
"\"-\"",
")",
"if",
"len",
"(",
"part",
".",
"strip",
"(",
")",
")",
">",
"0",
"]",
"return",
"\"-\"",
".",
"join",
"(",
"[",
"parts",
"[",
"0",
"]",
",",
"parts",
"[",
"-",
"1",
"]",
"]",
")",
"def",
"remove_invalid_date_parts",
"(",
"date",
")",
":",
"\"\"\"Remove partes inválidas de datas e retorna uma data válida\n\n >>> remove_invalid_date_parts(\"2019-12-100\")\n >>> \"2019-12\"\n >>> remove_invalid_date_parts(\"2019-20-01\")\n >>> \"2019\" # Não faz sentido utilizar o dia válido após um mês inválido\n \"\"\"",
"date",
"=",
"date",
".",
"split",
"(",
"\"-\"",
")",
"_date",
"=",
"[",
"]",
"for",
"index",
",",
"part",
"in",
"enumerate",
"(",
"date",
")",
":",
"if",
"len",
"(",
"part",
")",
"==",
"0",
"or",
"part",
"==",
"\"00\"",
"or",
"part",
"==",
"\"0\"",
":",
"break",
"elif",
"index",
"==",
"1",
"and",
"part",
".",
"isnumeric",
"(",
")",
"and",
"int",
"(",
"part",
")",
">",
"12",
":",
"break",
"elif",
"index",
"==",
"2",
"and",
"part",
".",
"isnumeric",
"(",
")",
"and",
"int",
"(",
"part",
")",
">",
"31",
":",
"break",
"elif",
"part",
".",
"isdigit",
"(",
")",
":",
"part",
"=",
"str",
"(",
"int",
"(",
"part",
")",
")",
"_date",
".",
"append",
"(",
"part",
")",
"return",
"\"-\"",
".",
"join",
"(",
"_date",
")",
"formats",
"=",
"[",
"(",
"\"%Y-%m-%d\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%m\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%b-%d\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%b\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%B\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%B-%d\"",
",",
"lambda",
"x",
":",
"x",
")",
",",
"(",
"\"%Y-%B\"",
",",
"remove_invalid_date_parts",
")",
",",
"(",
"\"%Y-%b\"",
",",
"limit_month_range",
")",
",",
"(",
"\"%Y-%m-%d\"",
",",
"remove_invalid_date_parts",
")",
",",
"(",
"\"%Y-%m\"",
",",
"remove_invalid_date_parts",
")",
",",
"(",
"\"%Y\"",
",",
"remove_invalid_date_parts",
")",
",",
"]",
"for",
"template",
",",
"func",
"in",
"formats",
":",
"try",
":",
"_date",
"=",
"(",
"datetime",
".",
"strptime",
"(",
"func",
"(",
"date",
".",
"strip",
"(",
")",
")",
",",
"template",
")",
".",
"isoformat",
"(",
"timespec",
"=",
"\"microseconds\"",
")",
"+",
"\"Z\"",
")",
"except",
"ValueError",
":",
"continue",
"else",
":",
"return",
"_date",
"raise",
"ValueError",
"(",
"\"Could not transform date '%s' to ISO format\"",
"%",
"date",
")",
"from",
"None"
] | [
15,
0
] | [
81,
84
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Orcamento.total_itens | (self) | return len(self.__itens) | Conta total de itens do orçamento.
Returns:
int: Quantidade total de itens do orçamento
| Conta total de itens do orçamento. | def total_itens(self) -> int:
"""Conta total de itens do orçamento.
Returns:
int: Quantidade total de itens do orçamento
"""
return len(self.__itens) | [
"def",
"total_itens",
"(",
"self",
")",
"->",
"int",
":",
"return",
"len",
"(",
"self",
".",
"__itens",
")"
] | [
67,
4
] | [
73,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_portals | (portals, disjoint) | return True | Verifica se os vértices portais de um segmento
se conectam à mesma partição de vértices comuns.
Faz essa verificação em tempo O(n)
| Verifica se os vértices portais de um segmento
se conectam à mesma partição de vértices comuns.
Faz essa verificação em tempo O(n)
| def check_portals(portals, disjoint):
'''Verifica se os vértices portais de um segmento
se conectam à mesma partição de vértices comuns.
Faz essa verificação em tempo O(n)
'''
f_check = set()
for p in portals:
if p not in disjoint:
return False
k = disjoint.find(p)
if k in f_check:
return False
f_check.add(k)
return True | [
"def",
"check_portals",
"(",
"portals",
",",
"disjoint",
")",
":",
"f_check",
"=",
"set",
"(",
")",
"for",
"p",
"in",
"portals",
":",
"if",
"p",
"not",
"in",
"disjoint",
":",
"return",
"False",
"k",
"=",
"disjoint",
".",
"find",
"(",
"p",
")",
"if",
"k",
"in",
"f_check",
":",
"return",
"False",
"f_check",
".",
"add",
"(",
"k",
")",
"return",
"True"
] | [
4,
0
] | [
20,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Quadro.tipo | (self) | return seq >> 7 | Getter para o tipo do quadro | Getter para o tipo do quadro | def tipo(self):
''' Getter para o tipo do quadro '''
seq = self._ctrl & 0x80 # 0b10000000
return seq >> 7 | [
"def",
"tipo",
"(",
"self",
")",
":",
"seq",
"=",
"self",
".",
"_ctrl",
"&",
"0x80",
"# 0b10000000",
"return",
"seq",
">>",
"7"
] | [
33,
4
] | [
36,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
index | (page) | Exibe todas as editoras cadastradas. | Exibe todas as editoras cadastradas. | def index(page):
"""Exibe todas as editoras cadastradas."""
try:
perpage = 9
startat = ( page - 1 ) * perpage
perpage *= page
totaleditoras = db.query_bd('select * from editora')
totalpages = int(len(totaleditoras) / 9) + 1
if request.method == 'POST':
busca = request.form['busca']
tipo = request.form['tipo']
sql = "SELECT * FROM editora WHERE {} LIKE '%{}%' limit {}, {};".format(tipo, busca, startat, perpage)
editoras = db.query_bd(sql)
totalpages = int(len(editoras) / 9) + 1
else:
editoras = db.query_bd('select * from editora limit %s, %s;' % (startat, perpage))
editoras = editoras[:9]
return render_template('editora/index.html', editoras=editoras, page=page, totalpages=totalpages)
except:
return render_template('404.html') | [
"def",
"index",
"(",
"page",
")",
":",
"try",
":",
"perpage",
"=",
"9",
"startat",
"=",
"(",
"page",
"-",
"1",
")",
"*",
"perpage",
"perpage",
"*=",
"page",
"totaleditoras",
"=",
"db",
".",
"query_bd",
"(",
"'select * from editora'",
")",
"totalpages",
"=",
"int",
"(",
"len",
"(",
"totaleditoras",
")",
"/",
"9",
")",
"+",
"1",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"busca",
"=",
"request",
".",
"form",
"[",
"'busca'",
"]",
"tipo",
"=",
"request",
".",
"form",
"[",
"'tipo'",
"]",
"sql",
"=",
"\"SELECT * FROM editora WHERE {} LIKE '%{}%' limit {}, {};\"",
".",
"format",
"(",
"tipo",
",",
"busca",
",",
"startat",
",",
"perpage",
")",
"editoras",
"=",
"db",
".",
"query_bd",
"(",
"sql",
")",
"totalpages",
"=",
"int",
"(",
"len",
"(",
"editoras",
")",
"/",
"9",
")",
"+",
"1",
"else",
":",
"editoras",
"=",
"db",
".",
"query_bd",
"(",
"'select * from editora limit %s, %s;'",
"%",
"(",
"startat",
",",
"perpage",
")",
")",
"editoras",
"=",
"editoras",
"[",
":",
"9",
"]",
"return",
"render_template",
"(",
"'editora/index.html'",
",",
"editoras",
"=",
"editoras",
",",
"page",
"=",
"page",
",",
"totalpages",
"=",
"totalpages",
")",
"except",
":",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
25,
0
] | [
44,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
jogo_bolinhas | (feli) | return True | Faz a mecânica geral do jogo. | Faz a mecânica geral do jogo. | def jogo_bolinhas(feli):
"""Faz a mecânica geral do jogo."""
# define quantas "rodadas" o jogo vai ter, baseado na felicidade do brinquedo
dif = feli//4
for i in range(dif):
n = randint(0, 9) # gera o algarismo na bolinha
print_tela(n)
t0 = time()
esc = input('>>> ')
t = time() - t0
if t > 1.5 or esc != str(n):
input('Você perdeu, lesminha kkkkk (Aperte ENTER para sair...)')
return False
input('Vencedor! Você tem bons reflexos! (Aperte ENTER para sair...)')
return True | [
"def",
"jogo_bolinhas",
"(",
"feli",
")",
":",
"# define quantas \"rodadas\" o jogo vai ter, baseado na felicidade do brinquedo",
"dif",
"=",
"feli",
"//",
"4",
"for",
"i",
"in",
"range",
"(",
"dif",
")",
":",
"n",
"=",
"randint",
"(",
"0",
",",
"9",
")",
"# gera o algarismo na bolinha",
"print_tela",
"(",
"n",
")",
"t0",
"=",
"time",
"(",
")",
"esc",
"=",
"input",
"(",
"'>>> '",
")",
"t",
"=",
"time",
"(",
")",
"-",
"t0",
"if",
"t",
">",
"1.5",
"or",
"esc",
"!=",
"str",
"(",
"n",
")",
":",
"input",
"(",
"'Você perdeu, lesminha kkkkk (Aperte ENTER para sair...)')",
"",
"return",
"False",
"input",
"(",
"'Vencedor! Você tem bons reflexos! (Aperte ENTER para sair...)')",
"",
"return",
"True"
] | [
48,
0
] | [
67,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Restaurant.describe_restaurant | (self) | return description | Retorna a descrição do restaurante - nome e culinária. | Retorna a descrição do restaurante - nome e culinária. | def describe_restaurant(self):
"""Retorna a descrição do restaurante - nome e culinária."""
description = 'O restaurante ' + self.restaurant_name.title() + ' é espeicalista na culinária ' + self.cuisine_type.title() + ';'
return description | [
"def",
"describe_restaurant",
"(",
"self",
")",
":",
"description",
"=",
"'O restaurante '",
"+",
"self",
".",
"restaurant_name",
".",
"title",
"(",
")",
"+",
"' é espeicalista na culinária ' +",
"s",
"lf.c",
"u",
"isine_type.t",
"i",
"tle()",
" ",
"+",
"'",
"'",
"return",
"description"
] | [
33,
4
] | [
36,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_saturado | (material, propriedade, propriedade_value, p=None, T=None) | Dadu um estado saturado verifica se a propriedade analisada pode pertencer a ele | Dadu um estado saturado verifica se a propriedade analisada pode pertencer a ele | def check_saturado(material, propriedade, propriedade_value, p=None, T=None):
''' Dadu um estado saturado verifica se a propriedade analisada pode pertencer a ele'''
propriedade_liq, propriedade_gas = satura_propriedade(propriedade, material)
try:
if p != None:
possivel_estado = estado(material, 'saturado', p=p)
if T != None:
possivel_estado = estado(material, 'saturado', T=p)
propriedade_liq = possivel_estado.get_propriedade(propriedade_liq)
propriedade_gas = possivel_estado.get_propriedade(propriedade_gas)
possivel_estado.titulo_dada_propriedade(propriedade, propriedade_value)
if propriedade_gas < propriedade_value < propriedade_liq:
return True, possivel_estado
elif propriedade_gas > propriedade_value > propriedade_liq:
return True, possivel_estado
else:
return False, False
except:
print('error')
return False, False | [
"def",
"check_saturado",
"(",
"material",
",",
"propriedade",
",",
"propriedade_value",
",",
"p",
"=",
"None",
",",
"T",
"=",
"None",
")",
":",
"propriedade_liq",
",",
"propriedade_gas",
"=",
"satura_propriedade",
"(",
"propriedade",
",",
"material",
")",
"try",
":",
"if",
"p",
"!=",
"None",
":",
"possivel_estado",
"=",
"estado",
"(",
"material",
",",
"'saturado'",
",",
"p",
"=",
"p",
")",
"if",
"T",
"!=",
"None",
":",
"possivel_estado",
"=",
"estado",
"(",
"material",
",",
"'saturado'",
",",
"T",
"=",
"p",
")",
"propriedade_liq",
"=",
"possivel_estado",
".",
"get_propriedade",
"(",
"propriedade_liq",
")",
"propriedade_gas",
"=",
"possivel_estado",
".",
"get_propriedade",
"(",
"propriedade_gas",
")",
"possivel_estado",
".",
"titulo_dada_propriedade",
"(",
"propriedade",
",",
"propriedade_value",
")",
"if",
"propriedade_gas",
"<",
"propriedade_value",
"<",
"propriedade_liq",
":",
"return",
"True",
",",
"possivel_estado",
"elif",
"propriedade_gas",
">",
"propriedade_value",
">",
"propriedade_liq",
":",
"return",
"True",
",",
"possivel_estado",
"else",
":",
"return",
"False",
",",
"False",
"except",
":",
"print",
"(",
"'error'",
")",
"return",
"False",
",",
"False"
] | [
391,
0
] | [
410,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Settings.__init__ | (self) | Inicializa as configurações do jogo. | Inicializa as configurações do jogo. | def __init__(self):
'''Inicializa as configurações do jogo.'''
# Configurações da tela
self.screen_width = 1000
self.screen_height = 600
self.bg_color = (230, 230, 230)
# Configurações da espaçonave
self.ship_speed_factor = 1.5 | [
"def",
"__init__",
"(",
"self",
")",
":",
"# Configurações da tela",
"self",
".",
"screen_width",
"=",
"1000",
"self",
".",
"screen_height",
"=",
"600",
"self",
".",
"bg_color",
"=",
"(",
"230",
",",
"230",
",",
"230",
")",
"# Configurações da espaçonave",
"self",
".",
"ship_speed_factor",
"=",
"1.5"
] | [
3,
1
] | [
11,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
iterative_factorial | (number) | return factorial | Calcula o fatorial de um número.
Realiza o cálculo do fatorial do número passado por parâmetro e o re-
torna. O fatorial de um número é dado pelo produto de todos os núme-
ros positivos menores ou iguais a esse número, excetuando-se 0, cujo
fatorial tem valor 1. Essa função utiliza uma abordagem iterativa
para a realização do cálculo.
Parameters
----------
number : int
O número cujo fatorial será calculado.
Return
------
factorial : int
O valor do fatorial calulado.
| Calcula o fatorial de um número. | def iterative_factorial(number):
""" Calcula o fatorial de um número.
Realiza o cálculo do fatorial do número passado por parâmetro e o re-
torna. O fatorial de um número é dado pelo produto de todos os núme-
ros positivos menores ou iguais a esse número, excetuando-se 0, cujo
fatorial tem valor 1. Essa função utiliza uma abordagem iterativa
para a realização do cálculo.
Parameters
----------
number : int
O número cujo fatorial será calculado.
Return
------
factorial : int
O valor do fatorial calulado.
"""
assert (number >= 0) # Fatorial só pode ser calculado para não-negativos
factorial = 1
if (number != 0):
for n in range(1, number + 1):
factorial *= n
return factorial | [
"def",
"iterative_factorial",
"(",
"number",
")",
":",
"assert",
"(",
"number",
">=",
"0",
")",
"# Fatorial só pode ser calculado para não-negativos",
"factorial",
"=",
"1",
"if",
"(",
"number",
"!=",
"0",
")",
":",
"for",
"n",
"in",
"range",
"(",
"1",
",",
"number",
"+",
"1",
")",
":",
"factorial",
"*=",
"n",
"return",
"factorial"
] | [
2,
0
] | [
27,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
NetworkData.get_network_interfaces | (cls, router_obj) | return router['network'] | Retorna somente as configurações de interfaces do router passado por parâmetro. | Retorna somente as configurações de interfaces do router passado por parâmetro. | def get_network_interfaces(cls, router_obj):
"""Retorna somente as configurações de interfaces do router passado por parâmetro."""
router = cls.get_router_config(router_obj)
return router['network'] | [
"def",
"get_network_interfaces",
"(",
"cls",
",",
"router_obj",
")",
":",
"router",
"=",
"cls",
".",
"get_router_config",
"(",
"router_obj",
")",
"return",
"router",
"[",
"'network'",
"]"
] | [
106,
4
] | [
111,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
dumps | (map, root_name, root_attributes=None) | return xml | Cria um string no formato XML a partir dos elementos do map.
Os elementos do mapa serão nós filhos do root_name.
Cada chave do map será um Nó no XML. E o valor da chave será o conteúdo do Nó.
Throws: XMLError, InvalidNodeNameXMLError, InvalidNodeTypeXMLError
| Cria um string no formato XML a partir dos elementos do map. | def dumps(map, root_name, root_attributes=None):
"""Cria um string no formato XML a partir dos elementos do map.
Os elementos do mapa serão nós filhos do root_name.
Cada chave do map será um Nó no XML. E o valor da chave será o conteúdo do Nó.
Throws: XMLError, InvalidNodeNameXMLError, InvalidNodeTypeXMLError
"""
xml = ''
try:
implementation = getDOMImplementation()
except ImportError, i:
raise XMLError(i, u'Erro ao obter o DOMImplementation')
doc = implementation.createDocument(None, root_name, None)
try:
root = doc.documentElement
if (root_attributes is not None):
for key, value in root_attributes.iteritems():
attribute = doc.createAttribute(key)
attribute.nodeValue = value
root.setAttributeNode(attribute)
_add_nodes_to_parent(map, root, doc)
xml = doc.toxml('UTF-8')
except InvalidCharacterErr, i:
raise InvalidNodeNameXMLError(
i, u'Valor inválido para nome de uma TAG de XML: %s' % root_name)
finally:
doc.unlink()
return xml | [
"def",
"dumps",
"(",
"map",
",",
"root_name",
",",
"root_attributes",
"=",
"None",
")",
":",
"xml",
"=",
"''",
"try",
":",
"implementation",
"=",
"getDOMImplementation",
"(",
")",
"except",
"ImportError",
",",
"i",
":",
"raise",
"XMLError",
"(",
"i",
",",
"u'Erro ao obter o DOMImplementation'",
")",
"doc",
"=",
"implementation",
".",
"createDocument",
"(",
"None",
",",
"root_name",
",",
"None",
")",
"try",
":",
"root",
"=",
"doc",
".",
"documentElement",
"if",
"(",
"root_attributes",
"is",
"not",
"None",
")",
":",
"for",
"key",
",",
"value",
"in",
"root_attributes",
".",
"iteritems",
"(",
")",
":",
"attribute",
"=",
"doc",
".",
"createAttribute",
"(",
"key",
")",
"attribute",
".",
"nodeValue",
"=",
"value",
"root",
".",
"setAttributeNode",
"(",
"attribute",
")",
"_add_nodes_to_parent",
"(",
"map",
",",
"root",
",",
"doc",
")",
"xml",
"=",
"doc",
".",
"toxml",
"(",
"'UTF-8'",
")",
"except",
"InvalidCharacterErr",
",",
"i",
":",
"raise",
"InvalidNodeNameXMLError",
"(",
"i",
",",
"u'Valor inválido para nome de uma TAG de XML: %s' ",
" ",
"oot_name)",
"",
"finally",
":",
"doc",
".",
"unlink",
"(",
")",
"return",
"xml"
] | [
104,
0
] | [
139,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Problem.result | (self, state, action) | Retorna o estado que resulta da execução do dado
Ação em um determinado estado. A acção deve ser uma das
Auto-ações (estado). | Retorna o estado que resulta da execução do dado
Ação em um determinado estado. A acção deve ser uma das
Auto-ações (estado). | def result(self, state, action):
"""Retorna o estado que resulta da execução do dado
Ação em um determinado estado. A acção deve ser uma das
Auto-ações (estado)."""
raise NotImplementedError | [
"def",
"result",
"(",
"self",
",",
"state",
",",
"action",
")",
":",
"raise",
"NotImplementedError"
] | [
39,
4
] | [
43,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SelectionSort.__bidirectionalSelectionSort | (self,array,leftIndex,rightIndex) | Implementação do método SelectionSort de forma iterativa e bidirecional
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 SelectionSort de forma iterativa e bidirecional
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 __bidirectionalSelectionSort(self,array,leftIndex,rightIndex):
"""Implementação do método SelectionSort de forma iterativa e bidirecional
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
"""
while(leftIndex < rightIndex):
minIndex = leftIndex
for i in range(leftIndex + 1 ,rightIndex +1):
if(array[minIndex] > array[i]):
minIndex = i
array[minIndex], array[leftIndex] = array[leftIndex], array[minIndex]
leftIndex = leftIndex +1
maxIndex = rightIndex
for i in range(rightIndex - 1 , leftIndex - 1, -1):
if(array[maxIndex] < array[i]):
maxIndex = i
array[maxIndex], array[rightIndex] = array[rightIndex], array[maxIndex]
rightIndex = rightIndex - 1 | [
"def",
"__bidirectionalSelectionSort",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
")",
":",
"while",
"(",
"leftIndex",
"<",
"rightIndex",
")",
":",
"minIndex",
"=",
"leftIndex",
"for",
"i",
"in",
"range",
"(",
"leftIndex",
"+",
"1",
",",
"rightIndex",
"+",
"1",
")",
":",
"if",
"(",
"array",
"[",
"minIndex",
"]",
">",
"array",
"[",
"i",
"]",
")",
":",
"minIndex",
"=",
"i",
"array",
"[",
"minIndex",
"]",
",",
"array",
"[",
"leftIndex",
"]",
"=",
"array",
"[",
"leftIndex",
"]",
",",
"array",
"[",
"minIndex",
"]",
"leftIndex",
"=",
"leftIndex",
"+",
"1",
"maxIndex",
"=",
"rightIndex",
"for",
"i",
"in",
"range",
"(",
"rightIndex",
"-",
"1",
",",
"leftIndex",
"-",
"1",
",",
"-",
"1",
")",
":",
"if",
"(",
"array",
"[",
"maxIndex",
"]",
"<",
"array",
"[",
"i",
"]",
")",
":",
"maxIndex",
"=",
"i",
"array",
"[",
"maxIndex",
"]",
",",
"array",
"[",
"rightIndex",
"]",
"=",
"array",
"[",
"rightIndex",
"]",
",",
"array",
"[",
"maxIndex",
"]",
"rightIndex",
"=",
"rightIndex",
"-",
"1"
] | [
52,
1
] | [
73,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
topic | (request, topic_id) | return render(request, 'learning_logs/topic.html', context) | Mostra um único assunto e todas as suas entradas. | Mostra um único assunto e todas as suas entradas. | def topic(request, topic_id):
"""Mostra um único assunto e todas as suas entradas."""
topic = Topic.objects.get(id=topic_id)
# Garante que o assunto pertence ao usuário atual
check_topic_owner(request, topic)
entries = topic.entry_set.order_by('-date_added')
context = {'topic': topic, 'entries': entries}
return render(request, 'learning_logs/topic.html', context) | [
"def",
"topic",
"(",
"request",
",",
"topic_id",
")",
":",
"topic",
"=",
"Topic",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"topic_id",
")",
"# Garante que o assunto pertence ao usuário atual",
"check_topic_owner",
"(",
"request",
",",
"topic",
")",
"entries",
"=",
"topic",
".",
"entry_set",
".",
"order_by",
"(",
"'-date_added'",
")",
"context",
"=",
"{",
"'topic'",
":",
"topic",
",",
"'entries'",
":",
"entries",
"}",
"return",
"render",
"(",
"request",
",",
"'learning_logs/topic.html'",
",",
"context",
")"
] | [
24,
0
] | [
31,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
BidsSpider.follow_this_date | (self, url) | return month_year >= self.start_date | Extrai data da URL e verifica se deve entrar na página ou não.
Essa é uma maneira de evitar que todas as páginas sejam varridas.
Esse método coleta apenas da data inicial a página mais recente.
Formato da URL:
http://www.feiradesantana.ba.gov.br/seadm/licitacoes_pm.asp?cat=PMFS&dt=08-2020#links
| Extrai data da URL e verifica se deve entrar na página ou não. | def follow_this_date(self, url):
"""Extrai data da URL e verifica se deve entrar na página ou não.
Essa é uma maneira de evitar que todas as páginas sejam varridas.
Esse método coleta apenas da data inicial a página mais recente.
Formato da URL:
http://www.feiradesantana.ba.gov.br/seadm/licitacoes_pm.asp?cat=PMFS&dt=08-2020#links
"""
month_year = extract_param(url, "dt")
month_year = month_year.split("-") # 08-2020
month_year = date(int(month_year[1]), int(month_year[0]), 1)
return month_year >= self.start_date | [
"def",
"follow_this_date",
"(",
"self",
",",
"url",
")",
":",
"month_year",
"=",
"extract_param",
"(",
"url",
",",
"\"dt\"",
")",
"month_year",
"=",
"month_year",
".",
"split",
"(",
"\"-\"",
")",
"# 08-2020",
"month_year",
"=",
"date",
"(",
"int",
"(",
"month_year",
"[",
"1",
"]",
")",
",",
"int",
"(",
"month_year",
"[",
"0",
"]",
")",
",",
"1",
")",
"return",
"month_year",
">=",
"self",
".",
"start_date"
] | [
51,
4
] | [
64,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_operador_negacao | (p) | operador_negacao : NAO | operador_negacao : NAO | def p_operador_negacao(p):
"operador_negacao : NAO"
if p[1] == "!":
filho = MyNode(name='nao', type='NAO')
negacao_lexema = MyNode(name=p[1], type='SIMBOLO', parent=filho)
p[0] = MyNode(name='operador_negacao', type='OPERADOR_NEGACAO', children=[filho]) | [
"def",
"p_operador_negacao",
"(",
"p",
")",
":",
"if",
"p",
"[",
"1",
"]",
"==",
"\"!\"",
":",
"filho",
"=",
"MyNode",
"(",
"name",
"=",
"'nao'",
",",
"type",
"=",
"'NAO'",
")",
"negacao_lexema",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"1",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho",
")",
"p",
"[",
"0",
"]",
"=",
"MyNode",
"(",
"name",
"=",
"'operador_negacao'",
",",
"type",
"=",
"'OPERADOR_NEGACAO'",
",",
"children",
"=",
"[",
"filho",
"]",
")"
] | [
887,
0
] | [
893,
89
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cadastral.fundo_social_nome | (self, cnpj) | return self.busca_fundo_cnpj(cnpj)["DENOM_SOCIAL"] | Retorna o nome social do fundo. | Retorna o nome social do fundo. | def fundo_social_nome(self, cnpj):
"""Retorna o nome social do fundo."""
return self.busca_fundo_cnpj(cnpj)["DENOM_SOCIAL"] | [
"def",
"fundo_social_nome",
"(",
"self",
",",
"cnpj",
")",
":",
"return",
"self",
".",
"busca_fundo_cnpj",
"(",
"cnpj",
")",
"[",
"\"DENOM_SOCIAL\"",
"]"
] | [
281,
4
] | [
283,
58
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ModeloTFIDF.embTexts | (self, dataSeries:pd.Series, **kwagars) | return pd.DataFrame(X.todense()) | Montar dataframe com vetores dos tweets pelo Bow com TFDF
Parametros:
corpus: pd.Series com os tweets
return: dataframe com os vetores dos textos
| Montar dataframe com vetores dos tweets pelo Bow com TFDF
Parametros:
corpus: pd.Series com os tweets
return: dataframe com os vetores dos textos
| def embTexts(self, dataSeries:pd.Series, **kwagars) -> pd.DataFrame:
'''Montar dataframe com vetores dos tweets pelo Bow com TFDF
Parametros:
corpus: pd.Series com os tweets
return: dataframe com os vetores dos textos
'''
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(dataSeries)
return pd.DataFrame(X.todense()) | [
"def",
"embTexts",
"(",
"self",
",",
"dataSeries",
":",
"pd",
".",
"Series",
",",
"*",
"*",
"kwagars",
")",
"->",
"pd",
".",
"DataFrame",
":",
"vectorizer",
"=",
"TfidfVectorizer",
"(",
")",
"X",
"=",
"vectorizer",
".",
"fit_transform",
"(",
"dataSeries",
")",
"return",
"pd",
".",
"DataFrame",
"(",
"X",
".",
"todense",
"(",
")",
")"
] | [
8,
4
] | [
16,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Statistics.min_max_tokens_sentences | (self) | return min(data_temp), max(data_temp) | [Gera uma lista de sentenças tokenizadas.]
Returns:
[type] -- [description]
| [Gera uma lista de sentenças tokenizadas.] | def min_max_tokens_sentences(self):
"""[Gera uma lista de sentenças tokenizadas.]
Returns:
[type] -- [description]
"""
data_temp = []
for sentence in self.list_sentences:
data_temp.append(len(nltk.word_tokenize(sentence)))
return min(data_temp), max(data_temp) | [
"def",
"min_max_tokens_sentences",
"(",
"self",
")",
":",
"data_temp",
"=",
"[",
"]",
"for",
"sentence",
"in",
"self",
".",
"list_sentences",
":",
"data_temp",
".",
"append",
"(",
"len",
"(",
"nltk",
".",
"word_tokenize",
"(",
"sentence",
")",
")",
")",
"return",
"min",
"(",
"data_temp",
")",
",",
"max",
"(",
"data_temp",
")"
] | [
64,
4
] | [
75,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
MainProgram.GetScreenInfo | () | return ScreenResolution, ZoomRatio | Define a resolução e taxa de zoom do display.
Quando o programa rodar em um monitor com resolução < fullhd
ou zoom > 100% as imagens serão criadas em um tamanho < original.
| Define a resolução e taxa de zoom do display. | def GetScreenInfo():
""" Define a resolução e taxa de zoom do display.
Quando o programa rodar em um monitor com resolução < fullhd
ou zoom > 100% as imagens serão criadas em um tamanho < original.
"""
# Pega A Quantidade De Pixels Da Tela (Windows)
user32 = ctypes.windll.user32
ScreenRelativeResolution = user32.GetSystemMetrics(78), user32.GetSystemMetrics(79)
print(ScreenRelativeResolution)
print()
# Pega A Resolução Real Da Tela (Monitor)
ScreenResolution = screeninfo.get_monitors()[0].width, screeninfo.get_monitors()[0].height
if ScreenResolution == (1920, 1080):
if ScreenRelativeResolution == ScreenResolution:
ZoomRatio = 100
elif ScreenRelativeResolution == (1536, 864):
ZoomRatio = 125
elif ScreenRelativeResolution == (1280, 720):
ZoomRatio = 150
else:
ZoomRatio = 0
elif ScreenResolution == (1280, 720):
if ScreenRelativeResolution == ScreenRelativeResolution:
ZoomRatio = 150
else:
ZoomRatio = 100
else:
ZoomRatio = 100
return ScreenResolution, ZoomRatio | [
"def",
"GetScreenInfo",
"(",
")",
":",
"# Pega A Quantidade De Pixels Da Tela (Windows)",
"user32",
"=",
"ctypes",
".",
"windll",
".",
"user32",
"ScreenRelativeResolution",
"=",
"user32",
".",
"GetSystemMetrics",
"(",
"78",
")",
",",
"user32",
".",
"GetSystemMetrics",
"(",
"79",
")",
"print",
"(",
"ScreenRelativeResolution",
")",
"print",
"(",
")",
"# Pega A Resolução Real Da Tela (Monitor)",
"ScreenResolution",
"=",
"screeninfo",
".",
"get_monitors",
"(",
")",
"[",
"0",
"]",
".",
"width",
",",
"screeninfo",
".",
"get_monitors",
"(",
")",
"[",
"0",
"]",
".",
"height",
"if",
"ScreenResolution",
"==",
"(",
"1920",
",",
"1080",
")",
":",
"if",
"ScreenRelativeResolution",
"==",
"ScreenResolution",
":",
"ZoomRatio",
"=",
"100",
"elif",
"ScreenRelativeResolution",
"==",
"(",
"1536",
",",
"864",
")",
":",
"ZoomRatio",
"=",
"125",
"elif",
"ScreenRelativeResolution",
"==",
"(",
"1280",
",",
"720",
")",
":",
"ZoomRatio",
"=",
"150",
"else",
":",
"ZoomRatio",
"=",
"0",
"elif",
"ScreenResolution",
"==",
"(",
"1280",
",",
"720",
")",
":",
"if",
"ScreenRelativeResolution",
"==",
"ScreenRelativeResolution",
":",
"ZoomRatio",
"=",
"150",
"else",
":",
"ZoomRatio",
"=",
"100",
"else",
":",
"ZoomRatio",
"=",
"100",
"return",
"ScreenResolution",
",",
"ZoomRatio"
] | [
62,
4
] | [
102,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestPokeAPIHandler.test_get_pokemon_base_experience_returns_int | (self) | Testa se a base_experience esta retornando um inteiro | Testa se a base_experience esta retornando um inteiro | def test_get_pokemon_base_experience_returns_int(self):
"""Testa se a base_experience esta retornando um inteiro"""
pokemon_url = "https://pokeapi.co/api/v2/pokemon/butterfree"
r = requests.get(pokemon_url)
pokemon = r.json()
base_experience = pokemon["base_experience"]
self.assertEqual(type(base_experience), int, "Tipo retornado diferente do esperado.") | [
"def",
"test_get_pokemon_base_experience_returns_int",
"(",
"self",
")",
":",
"pokemon_url",
"=",
"\"https://pokeapi.co/api/v2/pokemon/butterfree\"",
"r",
"=",
"requests",
".",
"get",
"(",
"pokemon_url",
")",
"pokemon",
"=",
"r",
".",
"json",
"(",
")",
"base_experience",
"=",
"pokemon",
"[",
"\"base_experience\"",
"]",
"self",
".",
"assertEqual",
"(",
"type",
"(",
"base_experience",
")",
",",
"int",
",",
"\"Tipo retornado diferente do esperado.\"",
")"
] | [
14,
4
] | [
22,
93
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BoletoData._sacado_get | (self) | return self._sacado | Tenta usar o sacado que foi setado ou constroi um
Se você não especificar um sacado o boleto tentará construir um sacado
a partir de outras proriedades setadas.
Para facilitar você deve sempre setar essa propriedade.
| Tenta usar o sacado que foi setado ou constroi um | def _sacado_get(self):
"""Tenta usar o sacado que foi setado ou constroi um
Se você não especificar um sacado o boleto tentará construir um sacado
a partir de outras proriedades setadas.
Para facilitar você deve sempre setar essa propriedade.
"""
if self._sacado is None:
self.sacado = [
'%s - CPF/CNPJ: %s' % (self.sacado_nome,
self.sacado_documento),
self.sacado_endereco,
'%s - %s - %s - %s' % (
self.sacado_bairro,
self.sacado_cidade,
self.sacado_uf,
self.sacado_cep
)
]
return self._sacado | [
"def",
"_sacado_get",
"(",
"self",
")",
":",
"if",
"self",
".",
"_sacado",
"is",
"None",
":",
"self",
".",
"sacado",
"=",
"[",
"'%s - CPF/CNPJ: %s'",
"%",
"(",
"self",
".",
"sacado_nome",
",",
"self",
".",
"sacado_documento",
")",
",",
"self",
".",
"sacado_endereco",
",",
"'%s - %s - %s - %s'",
"%",
"(",
"self",
".",
"sacado_bairro",
",",
"self",
".",
"sacado_cidade",
",",
"self",
".",
"sacado_uf",
",",
"self",
".",
"sacado_cep",
")",
"]",
"return",
"self",
".",
"_sacado"
] | [
386,
4
] | [
407,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
linha.__eq__ | (self,outro) | return not self.__ne__(outro) | Inversão de .__ne__ | Inversão de .__ne__ | def __eq__ (self,outro):
'''Inversão de .__ne__'''
return not self.__ne__(outro) | [
"def",
"__eq__",
"(",
"self",
",",
"outro",
")",
":",
"return",
"not",
"self",
".",
"__ne__",
"(",
"outro",
")"
] | [
382,
1
] | [
384,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Banco.connect | (self) | Realiza a conexão com o banco de dados | Realiza a conexão com o banco de dados | def connect(self):
""" Realiza a conexão com o banco de dados"""
self.conn = connect('banco.db')
self.cursor = self.conn.cursor()
self.connected = True | [
"def",
"connect",
"(",
"self",
")",
":",
"self",
".",
"conn",
"=",
"connect",
"(",
"'banco.db'",
")",
"self",
".",
"cursor",
"=",
"self",
".",
"conn",
".",
"cursor",
"(",
")",
"self",
".",
"connected",
"=",
"True"
] | [
11,
4
] | [
15,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
salva_nf_no_banco | (nota_fiscal: Any) | Salva NF no banco de dados assim que uma NF é criada. Padrão
observadores aplicado.
Args:
nota_fiscal.py (class Nota_fiscal): Cria Nota fiscal
| Salva NF no banco de dados assim que uma NF é criada. Padrão
observadores aplicado. | def salva_nf_no_banco(nota_fiscal: Any):
"""Salva NF no banco de dados assim que uma NF é criada. Padrão
observadores aplicado.
Args:
nota_fiscal.py (class Nota_fiscal): Cria Nota fiscal
"""
print(f'\nSalvando nota fiscal {nota_fiscal.cnpj} no banco de dados.') | [
"def",
"salva_nf_no_banco",
"(",
"nota_fiscal",
":",
"Any",
")",
":",
"print",
"(",
"f'\\nSalvando nota fiscal {nota_fiscal.cnpj} no banco de dados.'",
")"
] | [
13,
0
] | [
20,
74
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
prices_wide_holc_ta | (segmentos,prices_long_holc) | return prices_wide_holc | retorna o prices holc com os indicadores tecnicos no formato wide
Parameters
----------
:param segmentos: segmentos dos ativos
:prices_long_loc DataFrame: dataframe dos prices holc no formato long
| retorna o prices holc com os indicadores tecnicos no formato wide
Parameters
----------
:param segmentos: segmentos dos ativos
:prices_long_loc DataFrame: dataframe dos prices holc no formato long
| def prices_wide_holc_ta(segmentos,prices_long_holc):
"""retorna o prices holc com os indicadores tecnicos no formato wide
Parameters
----------
:param segmentos: segmentos dos ativos
:prices_long_loc DataFrame: dataframe dos prices holc no formato long
"""
prices_wide_holc = prices_long_holc.pivot_table(index=["data","ativo"],columns='tipo',values='valor').reset_index()
prices_wide_holc = prices_wide_holc.sort_values('data')
prices_wide_holc = pd.merge(prices_wide_holc,segmentos,how='left',left_on='ativo',right_on='ativo')
return prices_wide_holc | [
"def",
"prices_wide_holc_ta",
"(",
"segmentos",
",",
"prices_long_holc",
")",
":",
"prices_wide_holc",
"=",
"prices_long_holc",
".",
"pivot_table",
"(",
"index",
"=",
"[",
"\"data\"",
",",
"\"ativo\"",
"]",
",",
"columns",
"=",
"'tipo'",
",",
"values",
"=",
"'valor'",
")",
".",
"reset_index",
"(",
")",
"prices_wide_holc",
"=",
"prices_wide_holc",
".",
"sort_values",
"(",
"'data'",
")",
"prices_wide_holc",
"=",
"pd",
".",
"merge",
"(",
"prices_wide_holc",
",",
"segmentos",
",",
"how",
"=",
"'left'",
",",
"left_on",
"=",
"'ativo'",
",",
"right_on",
"=",
"'ativo'",
")",
"return",
"prices_wide_holc"
] | [
56,
0
] | [
69,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_events_urls | () | Raspa URLs de todos os eventos da ANPUH. | Raspa URLs de todos os eventos da ANPUH. | def get_events_urls():
"""Raspa URLs de todos os eventos da ANPUH."""
pass | [
"def",
"get_events_urls",
"(",
")",
":",
"pass"
] | [
15,
0
] | [
17,
8
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
delete | (id) | Deleta um autor.
Certifica que o autor existe.
| Deleta um autor. | def delete(id):
"""Deleta um autor.
Certifica que o autor existe.
"""
get_editora(id)
try:
db.insert_bd('DELETE FROM editora WHERE id = %d' % id)
return redirect(url_for('editora.index'))
except:
return render_template('404.html') | [
"def",
"delete",
"(",
"id",
")",
":",
"get_editora",
"(",
"id",
")",
"try",
":",
"db",
".",
"insert_bd",
"(",
"'DELETE FROM editora WHERE id = %d'",
"%",
"id",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'editora.index'",
")",
")",
"except",
":",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
107,
0
] | [
117,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestTextDrawerMultiQGates.test_2Qgate | (self) | 2Q no params. | 2Q no params. | def test_2Qgate(self):
""" 2Q no params. """
expected = '\n'.join([" ┌───────┐",
"q_1: |0>┤1 ├",
" │ twoQ │",
"q_0: |0>┤0 ├",
" └───────┘"])
qr = QuantumRegister(2, 'q')
circuit = QuantumCircuit(qr)
my_gate2 = Gate(name='twoQ', num_qubits=2, params=[], label='twoQ')
circuit.append(my_gate2, [qr[0], qr[1]])
self.assertEqual(str(_text_circuit_drawer(circuit, reverse_bits=True)), expected) | [
"def",
"test_2Qgate",
"(",
"self",
")",
":",
"expected",
"=",
"'\\n'",
".",
"join",
"(",
"[",
"\" ┌───────┐\",",
"",
"\"q_1: |0>┤1 ├\",",
"",
"\" │ twoQ │\",",
"",
"\"q_0: |0>┤0 ├\",",
"",
"\" └───────┘\"])",
"",
"",
"qr",
"=",
"QuantumRegister",
"(",
"2",
",",
"'q'",
")",
"circuit",
"=",
"QuantumCircuit",
"(",
"qr",
")",
"my_gate2",
"=",
"Gate",
"(",
"name",
"=",
"'twoQ'",
",",
"num_qubits",
"=",
"2",
",",
"params",
"=",
"[",
"]",
",",
"label",
"=",
"'twoQ'",
")",
"circuit",
".",
"append",
"(",
"my_gate2",
",",
"[",
"qr",
"[",
"0",
"]",
",",
"qr",
"[",
"1",
"]",
"]",
")",
"self",
".",
"assertEqual",
"(",
"str",
"(",
"_text_circuit_drawer",
"(",
"circuit",
",",
"reverse_bits",
"=",
"True",
")",
")",
",",
"expected",
")"
] | [
938,
4
] | [
952,
89
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MyList.__getitem__ | (self, pos) | return self._d[pos] | Outra é usando __iter__ e __next__. | Outra é usando __iter__ e __next__. | def __getitem__(self, pos):
"""Outra é usando __iter__ e __next__."""
return self._d[pos] | [
"def",
"__getitem__",
"(",
"self",
",",
"pos",
")",
":",
"return",
"self",
".",
"_d",
"[",
"pos",
"]"
] | [
7,
4
] | [
9,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
historico | (
historia="",sintomas="",medicamentos=""
) | return historia, sintomas, medicamentos | Histótia: Adicionar os relatos de doenças anteriores do paciente,\n incluindo sintomas antigos e histórico de doenças familiares
\n Sintomas: Descrever os atuais sintomas do paciente
\n Medicamentos: Remédios e tratamentos usados durante o tratamento geral do paciente. | Histótia: Adicionar os relatos de doenças anteriores do paciente,\n incluindo sintomas antigos e histórico de doenças familiares
\n Sintomas: Descrever os atuais sintomas do paciente
\n Medicamentos: Remédios e tratamentos usados durante o tratamento geral do paciente. | def historico(
historia="",sintomas="",medicamentos=""
):
"""Histótia: Adicionar os relatos de doenças anteriores do paciente,\n incluindo sintomas antigos e histórico de doenças familiares
\n Sintomas: Descrever os atuais sintomas do paciente
\n Medicamentos: Remédios e tratamentos usados durante o tratamento geral do paciente."""
historia = str(
input(
"Digite o histórico de vida do paciente: "
)
)
sintomas = str(
input( "Digite os sintomas do paciente: " )
)
medicamentos = str(
input("Digite o medicamento a ser usado e a dosagem: " )
)
return historia, sintomas, medicamentos | [
"def",
"historico",
"(",
"historia",
"=",
"\"\"",
",",
"sintomas",
"=",
"\"\"",
",",
"medicamentos",
"=",
"\"\"",
")",
":",
"historia",
"=",
"str",
"(",
"input",
"(",
"\"Digite o histórico de vida do paciente: \"",
")",
")",
"sintomas",
"=",
"str",
"(",
"input",
"(",
"\"Digite os sintomas do paciente: \"",
")",
")",
"medicamentos",
"=",
"str",
"(",
"input",
"(",
"\"Digite o medicamento a ser usado e a dosagem: \"",
")",
")",
"return",
"historia",
",",
"sintomas",
",",
"medicamentos"
] | [
37,
0
] | [
54,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
User.describe_user | (self) | Exibe os atributos do usuário. | Exibe os atributos do usuário. | def describe_user(self):
"""Exibe os atributos do usuário."""
description = {'First name': self.first_name.title(), 'Last name': self.last_name.title(),'Login_Attempts': str(self.login_attempts)}
for value, key in description.items():
print(value + ': ' + key) | [
"def",
"describe_user",
"(",
"self",
")",
":",
"description",
"=",
"{",
"'First name'",
":",
"self",
".",
"first_name",
".",
"title",
"(",
")",
",",
"'Last name'",
":",
"self",
".",
"last_name",
".",
"title",
"(",
")",
",",
"'Login_Attempts'",
":",
"str",
"(",
"self",
".",
"login_attempts",
")",
"}",
"for",
"value",
",",
"key",
"in",
"description",
".",
"items",
"(",
")",
":",
"print",
"(",
"value",
"+",
"': '",
"+",
"key",
")"
] | [
31,
4
] | [
35,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
set_mixed_citations_cache | (mst_source: str, override: bool = False) | Extrai os parágrafos de bases `mst` salvando-os em arquivos JSON.
É possível extrair parágrafos de uma ou mais bases durante a mesma execução,
bastantando o path `mst_source` apontar para um diretório com uma ou mais bases.
| Extrai os parágrafos de bases `mst` salvando-os em arquivos JSON. | def set_mixed_citations_cache(mst_source: str, override: bool = False) -> None:
"""Extrai os parágrafos de bases `mst` salvando-os em arquivos JSON.
É possível extrair parágrafos de uma ou mais bases durante a mesma execução,
bastantando o path `mst_source` apontar para um diretório com uma ou mais bases.
"""
if not os.path.exists(mst_source):
raise FileNotFoundError("MST path '%s' does not exists" % mst_source)
CACHE_DIR = config.get("PARAGRAPH_CACHE_PATH")
def create_paragraphs_cache(mst_source: str, cache_dir: str) -> None:
"""Extrai referências de arquivos MST e salva o resultado em um arquivo
JSON.
O path para o arquivo de cache é formado por dirietório-de-cache/pid.json"""
if not os.path.isfile(mst_source):
raise FileNotFoundError("File '%s' does not exist." % mst_source)
for paragraph in run_isis2json(mst_source, mongo=True):
pid = get_nested(paragraph, "v880", 0, "_", default=None)
if pid is None:
continue
output_file_path = f"{os.path.join(cache_dir, pid)}.json"
if not os.path.exists(cache_dir):
os.makedirs(cache_dir)
with open(output_file_path, "a") as f:
f.write(json.dumps(paragraph) + "\n")
def format_path_to_pid(file_path: str) -> Union[None, str]:
"""Tenta recuperar um `pid v2` a partir de um caminho para um arquivo
MST.
O pid inferido a partir do caminho deve seguir a estrutura adotada
pela coleção SciELO BR para segmentar a base artigo e seus parágrafos
(issn/year/order/order_in_issue).
Exemplo:
>>> format_path_to_pid("~/artigo/p/1808-8694/2011/0002/00018.mst")
>>> "S1808-86942011000200018"
>>> format_path_to_pid("~/artigo/p/1808-8694/2011/0002")
>>> None
"""
match = re.match(r".*([\w-]{9})\/(.{4})\/(.{4})\/(.{5})\.mst", file_path)
if not match:
return None
return "S" + "".join(match.groups())
bases = get_files_in_path(mst_source, extension=".mst")
with jvm(domains=["bruma", "jyson"], classpath=os.environ["CLASSPATH"]):
with tqdm(total=len(bases)) as pbar:
for base in bases:
try:
pid = format_path_to_pid(base)
if pid is None or (
not os.path.exists(os.path.join(CACHE_DIR, pid + ".json"))
or override
):
create_paragraphs_cache(base, cache_dir=CACHE_DIR)
except Exception as exc:
logger.error(exc)
pbar.update(1) | [
"def",
"set_mixed_citations_cache",
"(",
"mst_source",
":",
"str",
",",
"override",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"mst_source",
")",
":",
"raise",
"FileNotFoundError",
"(",
"\"MST path '%s' does not exists\"",
"%",
"mst_source",
")",
"CACHE_DIR",
"=",
"config",
".",
"get",
"(",
"\"PARAGRAPH_CACHE_PATH\"",
")",
"def",
"create_paragraphs_cache",
"(",
"mst_source",
":",
"str",
",",
"cache_dir",
":",
"str",
")",
"->",
"None",
":",
"\"\"\"Extrai referências de arquivos MST e salva o resultado em um arquivo\n JSON.\n\n O path para o arquivo de cache é formado por dirietório-de-cache/pid.json\"\"\"",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"mst_source",
")",
":",
"raise",
"FileNotFoundError",
"(",
"\"File '%s' does not exist.\"",
"%",
"mst_source",
")",
"for",
"paragraph",
"in",
"run_isis2json",
"(",
"mst_source",
",",
"mongo",
"=",
"True",
")",
":",
"pid",
"=",
"get_nested",
"(",
"paragraph",
",",
"\"v880\"",
",",
"0",
",",
"\"_\"",
",",
"default",
"=",
"None",
")",
"if",
"pid",
"is",
"None",
":",
"continue",
"output_file_path",
"=",
"f\"{os.path.join(cache_dir, pid)}.json\"",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"cache_dir",
")",
":",
"os",
".",
"makedirs",
"(",
"cache_dir",
")",
"with",
"open",
"(",
"output_file_path",
",",
"\"a\"",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"json",
".",
"dumps",
"(",
"paragraph",
")",
"+",
"\"\\n\"",
")",
"def",
"format_path_to_pid",
"(",
"file_path",
":",
"str",
")",
"->",
"Union",
"[",
"None",
",",
"str",
"]",
":",
"\"\"\"Tenta recuperar um `pid v2` a partir de um caminho para um arquivo\n MST.\n\n O pid inferido a partir do caminho deve seguir a estrutura adotada\n pela coleção SciELO BR para segmentar a base artigo e seus parágrafos\n (issn/year/order/order_in_issue).\n\n Exemplo:\n >>> format_path_to_pid(\"~/artigo/p/1808-8694/2011/0002/00018.mst\")\n >>> \"S1808-86942011000200018\"\n >>> format_path_to_pid(\"~/artigo/p/1808-8694/2011/0002\")\n >>> None\n \"\"\"",
"match",
"=",
"re",
".",
"match",
"(",
"r\".*([\\w-]{9})\\/(.{4})\\/(.{4})\\/(.{5})\\.mst\"",
",",
"file_path",
")",
"if",
"not",
"match",
":",
"return",
"None",
"return",
"\"S\"",
"+",
"\"\"",
".",
"join",
"(",
"match",
".",
"groups",
"(",
")",
")",
"bases",
"=",
"get_files_in_path",
"(",
"mst_source",
",",
"extension",
"=",
"\".mst\"",
")",
"with",
"jvm",
"(",
"domains",
"=",
"[",
"\"bruma\"",
",",
"\"jyson\"",
"]",
",",
"classpath",
"=",
"os",
".",
"environ",
"[",
"\"CLASSPATH\"",
"]",
")",
":",
"with",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"bases",
")",
")",
"as",
"pbar",
":",
"for",
"base",
"in",
"bases",
":",
"try",
":",
"pid",
"=",
"format_path_to_pid",
"(",
"base",
")",
"if",
"pid",
"is",
"None",
"or",
"(",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
".",
"join",
"(",
"CACHE_DIR",
",",
"pid",
"+",
"\".json\"",
")",
")",
"or",
"override",
")",
":",
"create_paragraphs_cache",
"(",
"base",
",",
"cache_dir",
"=",
"CACHE_DIR",
")",
"except",
"Exception",
"as",
"exc",
":",
"logger",
".",
"error",
"(",
"exc",
")",
"pbar",
".",
"update",
"(",
"1",
")"
] | [
304,
0
] | [
376,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
como_jogar | (titulo, conteudo) | Cria a tela de "como jogar" para um jogo, recebendo o título e as instruções daquele jogo. | Cria a tela de "como jogar" para um jogo, recebendo o título e as instruções daquele jogo. | def como_jogar(titulo, conteudo):
"""Cria a tela de "como jogar" para um jogo, recebendo o título e as instruções daquele jogo."""
janela = cjane.Janela()
janela.muda_linha(1, titulo.upper())
janela.muda_linha(3, ' - INSTRUÇÕES:', alin='ljust')
for i in range(5, 22):
try:
linha = conteudo[i - 5]
janela.muda_linha(i, linha, alin='ljust')
except IndexError:
pass
print(janela)
input('(Aperte ENTER para jogar!)') | [
"def",
"como_jogar",
"(",
"titulo",
",",
"conteudo",
")",
":",
"janela",
"=",
"cjane",
".",
"Janela",
"(",
")",
"janela",
".",
"muda_linha",
"(",
"1",
",",
"titulo",
".",
"upper",
"(",
")",
")",
"janela",
".",
"muda_linha",
"(",
"3",
",",
"' - INSTRUÇÕES:', ",
"a",
"in='",
"l",
"just')",
"",
"for",
"i",
"in",
"range",
"(",
"5",
",",
"22",
")",
":",
"try",
":",
"linha",
"=",
"conteudo",
"[",
"i",
"-",
"5",
"]",
"janela",
".",
"muda_linha",
"(",
"i",
",",
"linha",
",",
"alin",
"=",
"'ljust'",
")",
"except",
"IndexError",
":",
"pass",
"print",
"(",
"janela",
")",
"input",
"(",
"'(Aperte ENTER para jogar!)'",
")"
] | [
3,
0
] | [
18,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Environment.default_location | (self, thing) | return None | Localização padrão para colocar uma nova Coisa. | Localização padrão para colocar uma nova Coisa. | def default_location(self, thing):
"Localização padrão para colocar uma nova Coisa."
return None | [
"def",
"default_location",
"(",
"self",
",",
"thing",
")",
":",
"return",
"None"
] | [
156,
4
] | [
158,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
remove_equipment | (equipment_id, user) | return | Remove um equipamento e todos os seus relacionamentos.
@return: Nothing.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise EquipamentoError, GrupoError: Falha no banco de dados.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
| Remove um equipamento e todos os seus relacionamentos. | def remove_equipment(equipment_id, user):
"""Remove um equipamento e todos os seus relacionamentos.
@return: Nothing.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise EquipamentoError, GrupoError: Falha no banco de dados.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
"""
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
equipment_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None, u'Usuário não tem permissão para executar a operação.')
Equipamento().remove(user, equipment_id)
return | [
"def",
"remove_equipment",
"(",
"equipment_id",
",",
"user",
")",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"equipment_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"raise",
"UserNotAuthorizedError",
"(",
"None",
",",
"u'Usuário não tem permissão para executar a operação.')",
"",
"Equipamento",
"(",
")",
".",
"remove",
"(",
"user",
",",
"equipment_id",
")",
"return"
] | [
62,
0
] | [
83,
10
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
atualiza_receita | (request) | Salva uma receita atualizda pelo usuário | Salva uma receita atualizda pelo usuário | def atualiza_receita(request):
"""Salva uma receita atualizda pelo usuário"""
if request.method == 'POST':
receita_id = request.POST['receita_id']
# buscando o id da receita
r = Receita.objects.get(pk=receita_id)
r.nome_receita = request.POST['nome_receita']
r.ingredientes = request.POST['ingredientes']
r.modo_de_preparo = request.POST['modo_de_preparo']
r.tempo_de_preparo = request.POST['tempo_de_preparo']
r.rendimento = request.POST['rendimento']
r.categoria = request.POST['categoria']
if 'foto_receita' in request.FILES:
r.foto_receita = request.FILES['foto_receita']
r.save()
return redirect('dashboard') | [
"def",
"atualiza_receita",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"receita_id",
"=",
"request",
".",
"POST",
"[",
"'receita_id'",
"]",
"# buscando o id da receita",
"r",
"=",
"Receita",
".",
"objects",
".",
"get",
"(",
"pk",
"=",
"receita_id",
")",
"r",
".",
"nome_receita",
"=",
"request",
".",
"POST",
"[",
"'nome_receita'",
"]",
"r",
".",
"ingredientes",
"=",
"request",
".",
"POST",
"[",
"'ingredientes'",
"]",
"r",
".",
"modo_de_preparo",
"=",
"request",
".",
"POST",
"[",
"'modo_de_preparo'",
"]",
"r",
".",
"tempo_de_preparo",
"=",
"request",
".",
"POST",
"[",
"'tempo_de_preparo'",
"]",
"r",
".",
"rendimento",
"=",
"request",
".",
"POST",
"[",
"'rendimento'",
"]",
"r",
".",
"categoria",
"=",
"request",
".",
"POST",
"[",
"'categoria'",
"]",
"if",
"'foto_receita'",
"in",
"request",
".",
"FILES",
":",
"r",
".",
"foto_receita",
"=",
"request",
".",
"FILES",
"[",
"'foto_receita'",
"]",
"r",
".",
"save",
"(",
")",
"return",
"redirect",
"(",
"'dashboard'",
")"
] | [
69,
0
] | [
84,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
compare_graph_searchers | () | Imprime uma tabela de resultados de pesquisa. | Imprime uma tabela de resultados de pesquisa. | def compare_graph_searchers():
"""Imprime uma tabela de resultados de pesquisa."""
compare_searchers(problems=[GraphProblem('Arad', 'Bucharest', romania_map),
GraphProblem('Oradea', 'Neamt', romania_map),
GraphProblem('Q', 'WA', australia_map)],
header=['Searcher', 'romania_map(Arad, Bucharest)',
'romania_map(Oradea, Neamt)', 'australia_map']) | [
"def",
"compare_graph_searchers",
"(",
")",
":",
"compare_searchers",
"(",
"problems",
"=",
"[",
"GraphProblem",
"(",
"'Arad'",
",",
"'Bucharest'",
",",
"romania_map",
")",
",",
"GraphProblem",
"(",
"'Oradea'",
",",
"'Neamt'",
",",
"romania_map",
")",
",",
"GraphProblem",
"(",
"'Q'",
",",
"'WA'",
",",
"australia_map",
")",
"]",
",",
"header",
"=",
"[",
"'Searcher'",
",",
"'romania_map(Arad, Bucharest)'",
",",
"'romania_map(Oradea, Neamt)'",
",",
"'australia_map'",
"]",
")"
] | [
982,
0
] | [
988,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
_get_changes_on_children_properties | (values) | return changes | Funcao que obtem as mudancas das propriedades complexas | Funcao que obtem as mudancas das propriedades complexas | def _get_changes_on_children_properties(values):
"""Funcao que obtem as mudancas das propriedades complexas"""
changes = []
for property_obj in values:
_changes = property_obj._get_all_changes()
changes += [{**_changes, "id": property_obj.id}] if _changes else []
# O 'id' da propriedade é importante para sabermos em qual modelo aplicar a mudança
return changes | [
"def",
"_get_changes_on_children_properties",
"(",
"values",
")",
":",
"changes",
"=",
"[",
"]",
"for",
"property_obj",
"in",
"values",
":",
"_changes",
"=",
"property_obj",
".",
"_get_all_changes",
"(",
")",
"changes",
"+=",
"[",
"{",
"*",
"*",
"_changes",
",",
"\"id\"",
":",
"property_obj",
".",
"id",
"}",
"]",
"if",
"_changes",
"else",
"[",
"]",
"# O 'id' da propriedade é importante para sabermos em qual modelo aplicar a mudança",
"return",
"changes"
] | [
428,
0
] | [
435,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
node_to_path | (node) | return path | Retorna o caminho encontrado pelo algoritmo. | Retorna o caminho encontrado pelo algoritmo. | def node_to_path(node):
"""Retorna o caminho encontrado pelo algoritmo."""
path = [node.state]
while node.parent:
node = node.parent
path.append(node.state)
path.reverse()
return path | [
"def",
"node_to_path",
"(",
"node",
")",
":",
"path",
"=",
"[",
"node",
".",
"state",
"]",
"while",
"node",
".",
"parent",
":",
"node",
"=",
"node",
".",
"parent",
"path",
".",
"append",
"(",
"node",
".",
"state",
")",
"path",
".",
"reverse",
"(",
")",
"return",
"path"
] | [
185,
0
] | [
192,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
change_fleet_direction | (ai_settings, aliens) | Faz toda a frota descer e muda a sua direcao. | Faz toda a frota descer e muda a sua direcao. | def change_fleet_direction(ai_settings, aliens):
"""Faz toda a frota descer e muda a sua direcao."""
for alien in aliens.sprites():
alien.rect.y += ai_settings.fleet_drop_speed
ai_settings.fleet_direction *= -1 | [
"def",
"change_fleet_direction",
"(",
"ai_settings",
",",
"aliens",
")",
":",
"for",
"alien",
"in",
"aliens",
".",
"sprites",
"(",
")",
":",
"alien",
".",
"rect",
".",
"y",
"+=",
"ai_settings",
".",
"fleet_drop_speed",
"ai_settings",
".",
"fleet_direction",
"*=",
"-",
"1"
] | [
194,
0
] | [
198,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
resolve_LDLt | (L, D, b) | return b3 | Aplica as resolucoes sucessivamente, para resolver um sistema LDLt | Aplica as resolucoes sucessivamente, para resolver um sistema LDLt | def resolve_LDLt(L, D, b):
''''Aplica as resolucoes sucessivamente, para resolver um sistema LDLt'''
b1 = resolve_L(L, b)
b2 = resolve_D(D, b1)
b3 = resolve_U(L.transpose(), b2)
return b3 | [
"def",
"resolve_LDLt",
"(",
"L",
",",
"D",
",",
"b",
")",
":",
"b1",
"=",
"resolve_L",
"(",
"L",
",",
"b",
")",
"b2",
"=",
"resolve_D",
"(",
"D",
",",
"b1",
")",
"b3",
"=",
"resolve_U",
"(",
"L",
".",
"transpose",
"(",
")",
",",
"b2",
")",
"return",
"b3"
] | [
134,
0
] | [
139,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Genetic.do_full_step | (self, func, **kwargs) | Execute uma etapa completa de GA.
Este método passa por todos os outros métodos para realizar uma completa
Etapa GA, para que possa ser chamada a partir de um loop no método run ()..
| Execute uma etapa completa de GA. | def do_full_step(self, func, **kwargs):
"""Execute uma etapa completa de GA.
Este método passa por todos os outros métodos para realizar uma completa
Etapa GA, para que possa ser chamada a partir de um loop no método run ()..
"""
if self.fitness is not None and self.step_number < self.maxiter:
self.cross_over(self.population)
self.mutation(self.population)
for individual in self.population:
np.clip(individual.chromosome, self.bounds[0], self.bounds[1], out=individual.chromosome)
if self.submit_to_cluster:
raise NotImplementedError('Multistep jobs are under revision.')
else:
self.evaluate_single_fitness_test(func, **kwargs)
self.step_number += 1 | [
"def",
"do_full_step",
"(",
"self",
",",
"func",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"fitness",
"is",
"not",
"None",
"and",
"self",
".",
"step_number",
"<",
"self",
".",
"maxiter",
":",
"self",
".",
"cross_over",
"(",
"self",
".",
"population",
")",
"self",
".",
"mutation",
"(",
"self",
".",
"population",
")",
"for",
"individual",
"in",
"self",
".",
"population",
":",
"np",
".",
"clip",
"(",
"individual",
".",
"chromosome",
",",
"self",
".",
"bounds",
"[",
"0",
"]",
",",
"self",
".",
"bounds",
"[",
"1",
"]",
",",
"out",
"=",
"individual",
".",
"chromosome",
")",
"if",
"self",
".",
"submit_to_cluster",
":",
"raise",
"NotImplementedError",
"(",
"'Multistep jobs are under revision.'",
")",
"else",
":",
"self",
".",
"evaluate_single_fitness_test",
"(",
"func",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"step_number",
"+=",
"1"
] | [
550,
4
] | [
565,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Contrato.avan | self): | Avança o tipo do contrato na sequencia: Novo, Em Andamento,
Acertado e Concluido | Avança o tipo do contrato na sequencia: Novo, Em Andamento,
Acertado e Concluido | def avança(self):
"""Avança o tipo do contrato na sequencia: Novo, Em Andamento,
Acertado e Concluido"""
if self.__tipo == 'NOVO':
self.__tipo = 'EM ANDAMENTO'
elif self.__tipo == 'EM ANDAMENTO':
self.__tipo = 'ACERTADO'
elif self.__tipo == 'ACERTADO':
self.__tipo = 'CONCLUIDO' | [
"def",
"avan",
"ça",
"(",
"s",
"elf)",
":",
"",
"if",
"self",
".",
"__tipo",
"==",
"'NOVO'",
":",
"self",
".",
"__tipo",
"=",
"'EM ANDAMENTO'",
"elif",
"self",
".",
"__tipo",
"==",
"'EM ANDAMENTO'",
":",
"self",
".",
"__tipo",
"=",
"'ACERTADO'",
"elif",
"self",
".",
"__tipo",
"==",
"'ACERTADO'",
":",
"self",
".",
"__tipo",
"=",
"'CONCLUIDO'"
] | [
43,
4
] | [
52,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
p_argumentos_cfr | (t) | argumentos : argumentos COMA argumento | argumentos : argumentos COMA argumento | def p_argumentos_cfr(t):
'''argumentos : argumentos COMA argumento'''
text = t[1]['text']
text += t[3]['text'] + '\n'
t[0] = {'text': text, 'c3d' : '' } | [
"def",
"p_argumentos_cfr",
"(",
"t",
")",
":",
"text",
"=",
"t",
"[",
"1",
"]",
"[",
"'text'",
"]",
"text",
"+=",
"t",
"[",
"3",
"]",
"[",
"'text'",
"]",
"+",
"'\\n'",
"t",
"[",
"0",
"]",
"=",
"{",
"'text'",
":",
"text",
",",
"'c3d'",
":",
"''",
"}"
] | [
2521,
0
] | [
2525,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GeraArquivoCsv.__init__ | (self, dicionarios) | Gera um arquivo csv a partir de uma lista de dicionários, opcionalmente você pode
informar uma tupla de chaves que pode ser usada para gerar o arquivo csv de acordo
a essa tupla.
Args:
dicionarios (list(dict)): Dados que vão ser utilizados
campos (tuple)(OPCIONAL): Tupla contendo lista de chaves que serão as colunas do
arquivo csv.
| Gera um arquivo csv a partir de uma lista de dicionários, opcionalmente você pode
informar uma tupla de chaves que pode ser usada para gerar o arquivo csv de acordo
a essa tupla. | def __init__(self, dicionarios):
"""Gera um arquivo csv a partir de uma lista de dicionários, opcionalmente você pode
informar uma tupla de chaves que pode ser usada para gerar o arquivo csv de acordo
a essa tupla.
Args:
dicionarios (list(dict)): Dados que vão ser utilizados
campos (tuple)(OPCIONAL): Tupla contendo lista de chaves que serão as colunas do
arquivo csv.
"""
self.dicionarios = dicionarios | [
"def",
"__init__",
"(",
"self",
",",
"dicionarios",
")",
":",
"self",
".",
"dicionarios",
"=",
"dicionarios"
] | [
102,
4
] | [
112,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
change_fleet_direction | (ai_settings, aliens) | Faz toda a frota descer e muda a sua direção | Faz toda a frota descer e muda a sua direção | def change_fleet_direction(ai_settings, aliens):
"""Faz toda a frota descer e muda a sua direção"""
for alien in aliens.sprites():
alien.rect.y += ai_settings.fleet_drop_speed
ai_settings.fleet_direction *= -1 | [
"def",
"change_fleet_direction",
"(",
"ai_settings",
",",
"aliens",
")",
":",
"for",
"alien",
"in",
"aliens",
".",
"sprites",
"(",
")",
":",
"alien",
".",
"rect",
".",
"y",
"+=",
"ai_settings",
".",
"fleet_drop_speed",
"ai_settings",
".",
"fleet_direction",
"*=",
"-",
"1"
] | [
241,
0
] | [
245,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Maze.clear | (self, path) | Limpa o caminho marcado no labirinto. | Limpa o caminho marcado no labirinto. | def clear(self, path):
"""Limpa o caminho marcado no labirinto."""
for maze_location in path:
self._grid[maze_location.row][maze_location.col] = Cell.EMPTY
self._grid[self.start.row][self.start.col] = Cell.START
self._grid[self.goal.row][self.goal.col] = Cell.GOAL | [
"def",
"clear",
"(",
"self",
",",
"path",
")",
":",
"for",
"maze_location",
"in",
"path",
":",
"self",
".",
"_grid",
"[",
"maze_location",
".",
"row",
"]",
"[",
"maze_location",
".",
"col",
"]",
"=",
"Cell",
".",
"EMPTY",
"self",
".",
"_grid",
"[",
"self",
".",
"start",
".",
"row",
"]",
"[",
"self",
".",
"start",
".",
"col",
"]",
"=",
"Cell",
".",
"START",
"self",
".",
"_grid",
"[",
"self",
".",
"goal",
".",
"row",
"]",
"[",
"self",
".",
"goal",
".",
"col",
"]",
"=",
"Cell",
".",
"GOAL"
] | [
79,
4
] | [
84,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
forward_backward | (HMM, ev, prior) | return sv | Algoritmo forward-backward para suavização. Calcula probabilidades posteriores
De uma seqüência de estados dada uma seqüência de observações. | Algoritmo forward-backward para suavização. Calcula probabilidades posteriores
De uma seqüência de estados dada uma seqüência de observações. | def forward_backward(HMM, ev, prior):
"""Algoritmo forward-backward para suavização. Calcula probabilidades posteriores
De uma seqüência de estados dada uma seqüência de observações."""
t = len(ev)
ev.insert(0, None)
fv = [[0.0, 0.0] for i in range(len(ev))]
b = [1.0, 1.0]
bv = [b]
sv = [[0, 0] for i in range(len(ev))]
fv[0] = prior
for i in range(1, t + 1):
fv[i] = forward(HMM, fv[i - 1], ev[i])
for i in range(t, -1, -1):
sv[i - 1] = normalize(element_wise_product(fv[i], b))
b = backward(HMM, b, ev[i])
bv.append(b)
sv = sv[::-1]
return sv | [
"def",
"forward_backward",
"(",
"HMM",
",",
"ev",
",",
"prior",
")",
":",
"t",
"=",
"len",
"(",
"ev",
")",
"ev",
".",
"insert",
"(",
"0",
",",
"None",
")",
"fv",
"=",
"[",
"[",
"0.0",
",",
"0.0",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"ev",
")",
")",
"]",
"b",
"=",
"[",
"1.0",
",",
"1.0",
"]",
"bv",
"=",
"[",
"b",
"]",
"sv",
"=",
"[",
"[",
"0",
",",
"0",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"ev",
")",
")",
"]",
"fv",
"[",
"0",
"]",
"=",
"prior",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"t",
"+",
"1",
")",
":",
"fv",
"[",
"i",
"]",
"=",
"forward",
"(",
"HMM",
",",
"fv",
"[",
"i",
"-",
"1",
"]",
",",
"ev",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"t",
",",
"-",
"1",
",",
"-",
"1",
")",
":",
"sv",
"[",
"i",
"-",
"1",
"]",
"=",
"normalize",
"(",
"element_wise_product",
"(",
"fv",
"[",
"i",
"]",
",",
"b",
")",
")",
"b",
"=",
"backward",
"(",
"HMM",
",",
"b",
",",
"ev",
"[",
"i",
"]",
")",
"bv",
".",
"append",
"(",
"b",
")",
"sv",
"=",
"sv",
"[",
":",
":",
"-",
"1",
"]",
"return",
"sv"
] | [
551,
0
] | [
573,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
SelectionSort.__validateParams | (self,array,leftIndex,rightIndex) | Verificação da validade dos parametros de limite passados
Este método busca evitar entradas inválidas para o algoritmo de ordenação, tais como: índices negativos,
índice direito menor que o esquerdo, índice direito superior ao tamanho do array.
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
Retorna:
Boolean: Indicando se os parâmetros são ou não válidos
| Verificação da validade dos parametros de limite passados
Este método busca evitar entradas inválidas para o algoritmo de ordenação, tais como: índices negativos,
índice direito menor que o esquerdo, índice direito superior ao tamanho do array. | def __validateParams(self,array,leftIndex,rightIndex):
"""Verificação da validade dos parametros de limite passados
Este método busca evitar entradas inválidas para o algoritmo de ordenação, tais como: índices negativos,
índice direito menor que o esquerdo, índice direito superior ao tamanho do array.
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
Retorna:
Boolean: Indicando se os parâmetros são ou não válidos
"""
if(array == None or leftIndex < 0 or rightIndex > len(array) - 1 or leftIndex >= rightIndex):
return False
else:
return True | [
"def",
"__validateParams",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
")",
":",
"if",
"(",
"array",
"==",
"None",
"or",
"leftIndex",
"<",
"0",
"or",
"rightIndex",
">",
"len",
"(",
"array",
")",
"-",
"1",
"or",
"leftIndex",
">=",
"rightIndex",
")",
":",
"return",
"False",
"else",
":",
"return",
"True"
] | [
141,
1
] | [
158,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
buscaBinariaRecursiva | (alvo, array) | return buscaBinariaRecursivaAux(alvo, array, 0, len(array) - 1) | Retorna o índice do array em que o elemento alvo está contido.
Considerando a coleção recebida como parâmetro, identifica e retor-
na o índice em que o elemento especificado está contido. Caso esse
elemento não esteja presente na coleção, retorna -1. Utiliza uma
abordagem recursiva.
Parameters
----------
alvo : ?
Elemento cujo índice está sendo buscado
array : list
A lista cujo índice do elemento deve ser identificado
Return
------
index : int
O índice em que o elemento alvo está armazenado
| Retorna o índice do array em que o elemento alvo está contido. | def buscaBinariaRecursiva(alvo, array):
""" Retorna o índice do array em que o elemento alvo está contido.
Considerando a coleção recebida como parâmetro, identifica e retor-
na o índice em que o elemento especificado está contido. Caso esse
elemento não esteja presente na coleção, retorna -1. Utiliza uma
abordagem recursiva.
Parameters
----------
alvo : ?
Elemento cujo índice está sendo buscado
array : list
A lista cujo índice do elemento deve ser identificado
Return
------
index : int
O índice em que o elemento alvo está armazenado
"""
return buscaBinariaRecursivaAux(alvo, array, 0, len(array) - 1) | [
"def",
"buscaBinariaRecursiva",
"(",
"alvo",
",",
"array",
")",
":",
"return",
"buscaBinariaRecursivaAux",
"(",
"alvo",
",",
"array",
",",
"0",
",",
"len",
"(",
"array",
")",
"-",
"1",
")"
] | [
50,
0
] | [
70,
67
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Knowledge.__init__ | (self, size=(4, 4)) | Inicializa uma nova instância da classe Knowledge. | Inicializa uma nova instância da classe Knowledge. | def __init__(self, size=(4, 4)):
"""Inicializa uma nova instância da classe Knowledge."""
self.size = size
# Inicialmente o agente não sabe nada
w, h = self.size
status = Status.Unknown, Status.Unknown, Status.Unknown
self._rooms = [[Room(*status) for x in range(w)] for y in range(h)]
# A entrada da caverna é segura e sem ouro
self._rooms[0][0] = Room() | [
"def",
"__init__",
"(",
"self",
",",
"size",
"=",
"(",
"4",
",",
"4",
")",
")",
":",
"self",
".",
"size",
"=",
"size",
"# Inicialmente o agente não sabe nada",
"w",
",",
"h",
"=",
"self",
".",
"size",
"status",
"=",
"Status",
".",
"Unknown",
",",
"Status",
".",
"Unknown",
",",
"Status",
".",
"Unknown",
"self",
".",
"_rooms",
"=",
"[",
"[",
"Room",
"(",
"*",
"status",
")",
"for",
"x",
"in",
"range",
"(",
"w",
")",
"]",
"for",
"y",
"in",
"range",
"(",
"h",
")",
"]",
"# A entrada da caverna é segura e sem ouro",
"self",
".",
"_rooms",
"[",
"0",
"]",
"[",
"0",
"]",
"=",
"Room",
"(",
")"
] | [
219,
2
] | [
231,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
find_by_href | (browser, link) | Encontrar o elemento `a` com o link `link`.
Argumentos:
- browser = Instancia do browser [firefox, chrome, ...]
- link = link que será procurado em todos as tags `a`
| Encontrar o elemento `a` com o link `link`. | def find_by_href(browser, link):
"""Encontrar o elemento `a` com o link `link`.
Argumentos:
- browser = Instancia do browser [firefox, chrome, ...]
- link = link que será procurado em todos as tags `a`
"""
elementos = browser.find_elements_by_tag_name('a')
for elemento in elementos:
if link in elemento.get_attribute('href'):
return elemento | [
"def",
"find_by_href",
"(",
"browser",
",",
"link",
")",
":",
"elementos",
"=",
"browser",
".",
"find_elements_by_tag_name",
"(",
"'a'",
")",
"for",
"elemento",
"in",
"elementos",
":",
"if",
"link",
"in",
"elemento",
".",
"get_attribute",
"(",
"'href'",
")",
":",
"return",
"elemento"
] | [
18,
0
] | [
29,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Main.mostra_gela | (self) | Mostra todos os alimentos da geladeira, em ordem decrescente de magnitude do saciamento. | Mostra todos os alimentos da geladeira, em ordem decrescente de magnitude do saciamento. | def mostra_gela(self):
"""Mostra todos os alimentos da geladeira, em ordem decrescente de magnitude do saciamento."""
cfunc.mudar_titulo('Geladeira')
janela = cjane.JanelaTable({'QTE.': 6, 'Nome': 36, 'Tipo': 15, 'Fome': 8, 'Saúde': 9})
for comida in self.gela.comidasort():
linha = [self.gela[comida.nome][1], comida.nome, comida.__class__.__name__,
comida.saciar, comida.saude]
janela.add_linha(linha)
janela.mostrar_janela() | [
"def",
"mostra_gela",
"(",
"self",
")",
":",
"cfunc",
".",
"mudar_titulo",
"(",
"'Geladeira'",
")",
"janela",
"=",
"cjane",
".",
"JanelaTable",
"(",
"{",
"'QTE.'",
":",
"6",
",",
"'Nome'",
":",
"36",
",",
"'Tipo'",
":",
"15",
",",
"'Fome'",
":",
"8",
",",
"'Saúde':",
" ",
"}",
")",
"",
"for",
"comida",
"in",
"self",
".",
"gela",
".",
"comidasort",
"(",
")",
":",
"linha",
"=",
"[",
"self",
".",
"gela",
"[",
"comida",
".",
"nome",
"]",
"[",
"1",
"]",
",",
"comida",
".",
"nome",
",",
"comida",
".",
"__class__",
".",
"__name__",
",",
"comida",
".",
"saciar",
",",
"comida",
".",
"saude",
"]",
"janela",
".",
"add_linha",
"(",
"linha",
")",
"janela",
".",
"mostrar_janela",
"(",
")"
] | [
324,
4
] | [
336,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestPis.test_special_case | (self) | Verifica os casos especiais de PIS | Verifica os casos especiais de PIS | def test_special_case(self):
""" Verifica os casos especiais de PIS """
cases = [
('3467875434578764345789654', False),
('AAAAAAAAAAA', False),
('', False),
]
for pis, is_valid in cases:
self.assertEqual(self.pis.validate(pis), is_valid) | [
"def",
"test_special_case",
"(",
"self",
")",
":",
"cases",
"=",
"[",
"(",
"'3467875434578764345789654'",
",",
"False",
")",
",",
"(",
"'AAAAAAAAAAA'",
",",
"False",
")",
",",
"(",
"''",
",",
"False",
")",
",",
"]",
"for",
"pis",
",",
"is_valid",
"in",
"cases",
":",
"self",
".",
"assertEqual",
"(",
"self",
".",
"pis",
".",
"validate",
"(",
"pis",
")",
",",
"is_valid",
")"
] | [
35,
4
] | [
43,
62
] | 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.