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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
dados_funcionario | (request) | return render(request, "devsys-funcionario.html", dados) | Lista dados do funcionário. | Lista dados do funcionário. | def dados_funcionario(request):
""" Lista dados do funcionário."""
usuario_fun = request.user
try:
funcionario = Funcionario.objects.filter(usuario_fun=usuario_fun)
except Exception:
raise Http404()
#if funcionario:
if funcionario:
# variáveis usadas no html:
#Mudando variáveis e rotas...
dados = {"funcionario": funcionario}
else:
raise Http404()
return render(request, "devsys-funcionario.html", dados) | [
"def",
"dados_funcionario",
"(",
"request",
")",
":",
"usuario_fun",
"=",
"request",
".",
"user",
"try",
":",
"funcionario",
"=",
"Funcionario",
".",
"objects",
".",
"filter",
"(",
"usuario_fun",
"=",
"usuario_fun",
")",
"except",
"Exception",
":",
"raise",
"Http404",
"(",
")",
"#if funcionario:",
"if",
"funcionario",
":",
"# variáveis usadas no html:",
"#Mudando variáveis e rotas...",
"dados",
"=",
"{",
"\"funcionario\"",
":",
"funcionario",
"}",
"else",
":",
"raise",
"Http404",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"devsys-funcionario.html\"",
",",
"dados",
")"
] | [
91,
0
] | [
109,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
NetworkData.get_all_global_adress | (cls) | return _global_address | Retorna somente os itens de endereço de todos os router. | Retorna somente os itens de endereço de todos os router. | def get_all_global_adress(cls):
""" Retorna somente os itens de endereço de todos os router. """
_global_address = []
_globals = NetworkData.get_global_network()
for line in _globals:
_global_address.append(f"{line['address']}/{line['mask']}")
return _global_address | [
"def",
"get_all_global_adress",
"(",
"cls",
")",
":",
"_global_address",
"=",
"[",
"]",
"_globals",
"=",
"NetworkData",
".",
"get_global_network",
"(",
")",
"for",
"line",
"in",
"_globals",
":",
"_global_address",
".",
"append",
"(",
"f\"{line['address']}/{line['mask']}\"",
")",
"return",
"_global_address"
] | [
55,
4
] | [
64,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PesquisaAnonima.conjunto_respostas | (self, nova_resposta) | Armazena uma única resposta da pesquisa. | Armazena uma única resposta da pesquisa. | def conjunto_respostas(self, nova_resposta):
"""Armazena uma única resposta da pesquisa."""
self.respostas.append(nova_resposta) | [
"def",
"conjunto_respostas",
"(",
"self",
",",
"nova_resposta",
")",
":",
"self",
".",
"respostas",
".",
"append",
"(",
"nova_resposta",
")"
] | [
14,
4
] | [
16,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
swap | (a_list, pos1, pos2) | Troca a posição de dois itens em uma lista | Troca a posição de dois itens em uma lista | def swap(a_list, pos1, pos2):
""" Troca a posição de dois itens em uma lista """
temp = a_list[pos1]
a_list[pos1] = a_list[pos2]
a_list[pos2] = temp | [
"def",
"swap",
"(",
"a_list",
",",
"pos1",
",",
"pos2",
")",
":",
"temp",
"=",
"a_list",
"[",
"pos1",
"]",
"a_list",
"[",
"pos1",
"]",
"=",
"a_list",
"[",
"pos2",
"]",
"a_list",
"[",
"pos2",
"]",
"=",
"temp"
] | [
3,
0
] | [
7,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestTradeCalculator.test_is_base_experience_approximated_passing_negative_value | (self) | Teste passando um argumento negativo
>>> _is_base_experience_approximated(42, 42)
bool
>>> _is_base_experience_approximated(-10, 4)
Error
| Teste passando um argumento negativo
>>> _is_base_experience_approximated(42, 42)
bool | def test_is_base_experience_approximated_passing_negative_value(self):
"""Teste passando um argumento negativo
>>> _is_base_experience_approximated(42, 42)
bool
>>> _is_base_experience_approximated(-10, 4)
Error
"""
p1 = Player([Pokemon("Pichu", 42), Pokemon("Pikachu", 145)])
p2 = Player([Pokemon("Dito", 30), Pokemon("Charizard", 260)])
tc = TradeCalculator(p1, p2)
self.assertRaises(ValueError, lambda: tc._is_base_experience_approximated(-42, 10)) | [
"def",
"test_is_base_experience_approximated_passing_negative_value",
"(",
"self",
")",
":",
"p1",
"=",
"Player",
"(",
"[",
"Pokemon",
"(",
"\"Pichu\"",
",",
"42",
")",
",",
"Pokemon",
"(",
"\"Pikachu\"",
",",
"145",
")",
"]",
")",
"p2",
"=",
"Player",
"(",
"[",
"Pokemon",
"(",
"\"Dito\"",
",",
"30",
")",
",",
"Pokemon",
"(",
"\"Charizard\"",
",",
"260",
")",
"]",
")",
"tc",
"=",
"TradeCalculator",
"(",
"p1",
",",
"p2",
")",
"self",
".",
"assertRaises",
"(",
"ValueError",
",",
"lambda",
":",
"tc",
".",
"_is_base_experience_approximated",
"(",
"-",
"42",
",",
"10",
")",
")"
] | [
68,
4
] | [
81,
91
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
interpolador_h_s_gas | (h, s, estado_inicial, iters=100, precision=0.99999, delta=100) | return interpolador_h_s_gas(h, s, estado_new, iters=iters - 1, precision=0.99999, delta=0.8 * delta) | Dada uma entropia e uma entalpia de um gas super aquecido, econtra esse estado
Só usar como last resource, n se deve saber nem temperatura nem pressao
Util em ciclos rankine com eficiencia isoentropica diferente de 100 onde de um lado se tem ume turbina e do outro uma valvula
| Dada uma entropia e uma entalpia de um gas super aquecido, econtra esse estado
Só usar como last resource, n se deve saber nem temperatura nem pressao
Util em ciclos rankine com eficiencia isoentropica diferente de 100 onde de um lado se tem ume turbina e do outro uma valvula
| def interpolador_h_s_gas(h, s, estado_inicial, iters=100, precision=0.99999, delta=100):
'''Dada uma entropia e uma entalpia de um gas super aquecido, econtra esse estado
Só usar como last resource, n se deve saber nem temperatura nem pressao
Util em ciclos rankine com eficiencia isoentropica diferente de 100 onde de um lado se tem ume turbina e do outro uma valvula
'''
material = estado_inicial._material
table = estado_inicial._table_name
p_atual = float(estado_inicial._p)
T_atual = float(estado_inicial._T)
estado00 = estado_inicial
estado10 = estado(material, table, p_atual, T_atual + delta)
estado11 = estado(material, table, p_atual + delta, T_atual + delta)
estado01 = estado(material, table, p_atual + delta, T_atual)
arr = array([[T_atual, '', T_atual + delta],
[estado00.specific_enthalpy, h, estado10.specific_enthalpy]])
T_new = interpolacao(arr)
arr = array([[estado00.specific_entropy, '', estado10.specific_entropy],
[T_atual, T_new, T_atual + delta]])
S0 = interpolacao(arr)
arr = array([[estado01.specific_entropy, '', estado11.specific_entropy],
[T_atual, T_new, T_atual + delta]])
S1 = interpolacao(arr)
arr = array([[p_atual, '', p_atual + delta],
[S0, s, S1]])
p_new = interpolacao(arr)
estado_new = estado(material, table, p_new, T_new)
print(estado_new.specific_entropy)
if abs(estado_new.specific_entropy - s) <= 1 - precision and abs(estado_new.specific_enthalpy - h) <= 1 - precision:
return estado_new
return interpolador_h_s_gas(h, s, estado_new, iters=iters - 1, precision=0.99999, delta=0.8 * delta) | [
"def",
"interpolador_h_s_gas",
"(",
"h",
",",
"s",
",",
"estado_inicial",
",",
"iters",
"=",
"100",
",",
"precision",
"=",
"0.99999",
",",
"delta",
"=",
"100",
")",
":",
"material",
"=",
"estado_inicial",
".",
"_material",
"table",
"=",
"estado_inicial",
".",
"_table_name",
"p_atual",
"=",
"float",
"(",
"estado_inicial",
".",
"_p",
")",
"T_atual",
"=",
"float",
"(",
"estado_inicial",
".",
"_T",
")",
"estado00",
"=",
"estado_inicial",
"estado10",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
",",
"T_atual",
"+",
"delta",
")",
"estado11",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
"+",
"delta",
",",
"T_atual",
"+",
"delta",
")",
"estado01",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
"+",
"delta",
",",
"T_atual",
")",
"arr",
"=",
"array",
"(",
"[",
"[",
"T_atual",
",",
"''",
",",
"T_atual",
"+",
"delta",
"]",
",",
"[",
"estado00",
".",
"specific_enthalpy",
",",
"h",
",",
"estado10",
".",
"specific_enthalpy",
"]",
"]",
")",
"T_new",
"=",
"interpolacao",
"(",
"arr",
")",
"arr",
"=",
"array",
"(",
"[",
"[",
"estado00",
".",
"specific_entropy",
",",
"''",
",",
"estado10",
".",
"specific_entropy",
"]",
",",
"[",
"T_atual",
",",
"T_new",
",",
"T_atual",
"+",
"delta",
"]",
"]",
")",
"S0",
"=",
"interpolacao",
"(",
"arr",
")",
"arr",
"=",
"array",
"(",
"[",
"[",
"estado01",
".",
"specific_entropy",
",",
"''",
",",
"estado11",
".",
"specific_entropy",
"]",
",",
"[",
"T_atual",
",",
"T_new",
",",
"T_atual",
"+",
"delta",
"]",
"]",
")",
"S1",
"=",
"interpolacao",
"(",
"arr",
")",
"arr",
"=",
"array",
"(",
"[",
"[",
"p_atual",
",",
"''",
",",
"p_atual",
"+",
"delta",
"]",
",",
"[",
"S0",
",",
"s",
",",
"S1",
"]",
"]",
")",
"p_new",
"=",
"interpolacao",
"(",
"arr",
")",
"estado_new",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_new",
",",
"T_new",
")",
"print",
"(",
"estado_new",
".",
"specific_entropy",
")",
"if",
"abs",
"(",
"estado_new",
".",
"specific_entropy",
"-",
"s",
")",
"<=",
"1",
"-",
"precision",
"and",
"abs",
"(",
"estado_new",
".",
"specific_enthalpy",
"-",
"h",
")",
"<=",
"1",
"-",
"precision",
":",
"return",
"estado_new",
"return",
"interpolador_h_s_gas",
"(",
"h",
",",
"s",
",",
"estado_new",
",",
"iters",
"=",
"iters",
"-",
"1",
",",
"precision",
"=",
"0.99999",
",",
"delta",
"=",
"0.8",
"*",
"delta",
")"
] | [
282,
0
] | [
316,
104
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestCns.test_generate_validate | (self) | Verifica os métodos de geração e validação de documento. | Verifica os métodos de geração e validação de documento. | def test_generate_validate(self):
"""Verifica os métodos de geração e validação de documento."""
# generate_list
cnss = self.cns.generate_list(5000) \
+ self.cns.generate_list(5000, mask=True) \
+ self.cns.generate_list(5000, mask=True, repeat=True)
self.assertIsInstance(cnss, list)
self.assertTrue(len(cnss) == 15000)
# validate_list
cnss_validates = self.cns.validate_list(cnss)
self.assertTrue(sum(cnss_validates) == 15000) | [
"def",
"test_generate_validate",
"(",
"self",
")",
":",
"# generate_list",
"cnss",
"=",
"self",
".",
"cns",
".",
"generate_list",
"(",
"5000",
")",
"+",
"self",
".",
"cns",
".",
"generate_list",
"(",
"5000",
",",
"mask",
"=",
"True",
")",
"+",
"self",
".",
"cns",
".",
"generate_list",
"(",
"5000",
",",
"mask",
"=",
"True",
",",
"repeat",
"=",
"True",
")",
"self",
".",
"assertIsInstance",
"(",
"cnss",
",",
"list",
")",
"self",
".",
"assertTrue",
"(",
"len",
"(",
"cnss",
")",
"==",
"15000",
")",
"# validate_list",
"cnss_validates",
"=",
"self",
".",
"cns",
".",
"validate_list",
"(",
"cnss",
")",
"self",
".",
"assertTrue",
"(",
"sum",
"(",
"cnss_validates",
")",
"==",
"15000",
")"
] | [
11,
4
] | [
22,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CallbackAplicacao.handle | (self) | Leitura do teclado e chama enquadra() da classe CallbackEnquadramento | Leitura do teclado e chama enquadra() da classe CallbackEnquadramento | def handle(self):
''' Leitura do teclado e chama enquadra() da classe CallbackEnquadramento '''
if self.file:
l = self.fd.read(self.msg_length)
if l != b'':
self.quadro.payload = l # payload do quadro
self.lower.envia(self.quadro) # passando o quadro para a subcamada
else:
self.disable()
else:
l = bytes(sys.stdin.readline().encode('UTF-8'))[:-1]
self.quadro.payload = l # payload do quadro
self.lower.envia(self.quadro) | [
"def",
"handle",
"(",
"self",
")",
":",
"if",
"self",
".",
"file",
":",
"l",
"=",
"self",
".",
"fd",
".",
"read",
"(",
"self",
".",
"msg_length",
")",
"if",
"l",
"!=",
"b''",
":",
"self",
".",
"quadro",
".",
"payload",
"=",
"l",
"# payload do quadro",
"self",
".",
"lower",
".",
"envia",
"(",
"self",
".",
"quadro",
")",
"# passando o quadro para a subcamada",
"else",
":",
"self",
".",
"disable",
"(",
")",
"else",
":",
"l",
"=",
"bytes",
"(",
"sys",
".",
"stdin",
".",
"readline",
"(",
")",
".",
"encode",
"(",
"'UTF-8'",
")",
")",
"[",
":",
"-",
"1",
"]",
"self",
".",
"quadro",
".",
"payload",
"=",
"l",
"# payload do quadro",
"self",
".",
"lower",
".",
"envia",
"(",
"self",
".",
"quadro",
")"
] | [
18,
4
] | [
30,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
EletricCar.describe_details | (self) | Retorna detalhes do carro elétrico. | Retorna detalhes do carro elétrico. | def describe_details(self):
"""Retorna detalhes do carro elétrico."""
while True:
disponible_color = {1: 'White', 2: 'Black', 3: 'Silver', 4: 'Red'}
print('Escolha a cor do seu Tesla Eletric Car. \nDisponible Color:')
for number, color in disponible_color.items():
print('\t' + str(number) + ': ' + color + '.')
color = int(input('Digite aqui sua cor favorita:\n'))
if color in disponible_color:
if color == 1:
your_car = {'Color': 'White', 'Horse Power': '126 hp', 'Torque': '14 kNm', 'Style': 'Sedan'}
print('Congratulations!!!!\nDetails of the your Tesla Electric Car:')
for value, key in your_car.items():
print('\t' + value + ': ' + key)
break
elif color == 2:
your_car = {'Color': 'Black', 'Horse Power': '136 hp', 'Torque': '14 kNm', 'Style': 'Hatch'}
print('Congratulations!!!!\nDetails of the your Tesla Electric Car:')
for value, key in your_car.items():
print('\t' + value + ': ' + key)
break
elif color == 3:
your_car = {'Color': 'Silver', 'Horse Power': '126 hp', 'Torque': '16 kNm', 'Style': 'SUV'}
print('Congratulations!!!!\nDetails of the your Tesla Electric Car:')
for value, key in your_car.items():
print('\t' + value + ': ' + key)
break
else:
your_car = {'Color': 'Red', 'Power': '150 hp', 'Torque': '18 kNm', 'Style': 'Cupê'}
print('Congratulations!!!!\nDetails of the your Tesla Electric Car:')
for value, key in your_car.items():
print('\t' + value + ': ' + key)
break
else:
print('Não estamos personalizando o carro elétrico no momento!') | [
"def",
"describe_details",
"(",
"self",
")",
":",
"while",
"True",
":",
"disponible_color",
"=",
"{",
"1",
":",
"'White'",
",",
"2",
":",
"'Black'",
",",
"3",
":",
"'Silver'",
",",
"4",
":",
"'Red'",
"}",
"print",
"(",
"'Escolha a cor do seu Tesla Eletric Car. \\nDisponible Color:'",
")",
"for",
"number",
",",
"color",
"in",
"disponible_color",
".",
"items",
"(",
")",
":",
"print",
"(",
"'\\t'",
"+",
"str",
"(",
"number",
")",
"+",
"': '",
"+",
"color",
"+",
"'.'",
")",
"color",
"=",
"int",
"(",
"input",
"(",
"'Digite aqui sua cor favorita:\\n'",
")",
")",
"if",
"color",
"in",
"disponible_color",
":",
"if",
"color",
"==",
"1",
":",
"your_car",
"=",
"{",
"'Color'",
":",
"'White'",
",",
"'Horse Power'",
":",
"'126 hp'",
",",
"'Torque'",
":",
"'14 kNm'",
",",
"'Style'",
":",
"'Sedan'",
"}",
"print",
"(",
"'Congratulations!!!!\\nDetails of the your Tesla Electric Car:'",
")",
"for",
"value",
",",
"key",
"in",
"your_car",
".",
"items",
"(",
")",
":",
"print",
"(",
"'\\t'",
"+",
"value",
"+",
"': '",
"+",
"key",
")",
"break",
"elif",
"color",
"==",
"2",
":",
"your_car",
"=",
"{",
"'Color'",
":",
"'Black'",
",",
"'Horse Power'",
":",
"'136 hp'",
",",
"'Torque'",
":",
"'14 kNm'",
",",
"'Style'",
":",
"'Hatch'",
"}",
"print",
"(",
"'Congratulations!!!!\\nDetails of the your Tesla Electric Car:'",
")",
"for",
"value",
",",
"key",
"in",
"your_car",
".",
"items",
"(",
")",
":",
"print",
"(",
"'\\t'",
"+",
"value",
"+",
"': '",
"+",
"key",
")",
"break",
"elif",
"color",
"==",
"3",
":",
"your_car",
"=",
"{",
"'Color'",
":",
"'Silver'",
",",
"'Horse Power'",
":",
"'126 hp'",
",",
"'Torque'",
":",
"'16 kNm'",
",",
"'Style'",
":",
"'SUV'",
"}",
"print",
"(",
"'Congratulations!!!!\\nDetails of the your Tesla Electric Car:'",
")",
"for",
"value",
",",
"key",
"in",
"your_car",
".",
"items",
"(",
")",
":",
"print",
"(",
"'\\t'",
"+",
"value",
"+",
"': '",
"+",
"key",
")",
"break",
"else",
":",
"your_car",
"=",
"{",
"'Color'",
":",
"'Red'",
",",
"'Power'",
":",
"'150 hp'",
",",
"'Torque'",
":",
"'18 kNm'",
",",
"'Style'",
":",
"'Cupê'}",
"",
"print",
"(",
"'Congratulations!!!!\\nDetails of the your Tesla Electric Car:'",
")",
"for",
"value",
",",
"key",
"in",
"your_car",
".",
"items",
"(",
")",
":",
"print",
"(",
"'\\t'",
"+",
"value",
"+",
"': '",
"+",
"key",
")",
"break",
"else",
":",
"print",
"(",
"'Não estamos personalizando o carro elétrico no momento!')",
""
] | [
81,
4
] | [
118,
82
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
cabecalho | (titulo) | -> Cabeçalho
Exibe na tela o título do programa e modela de acordo com o número de caracteres
// Output
======================
Titulo do Programa
======================
:param titulo: dada como parâmetro ao chamar a função
:return:
| -> Cabeçalho
Exibe na tela o título do programa e modela de acordo com o número de caracteres | def cabecalho(titulo):
""" -> Cabeçalho
Exibe na tela o título do programa e modela de acordo com o número de caracteres
// Output
======================
Titulo do Programa
======================
:param titulo: dada como parâmetro ao chamar a função
:return:
"""
div = '=' * int(len(titulo) + 4)
titulo = ' ' + titulo
print(f'{div}\n{titulo}\n{div}') | [
"def",
"cabecalho",
"(",
"titulo",
")",
":",
"div",
"=",
"'='",
"*",
"int",
"(",
"len",
"(",
"titulo",
")",
"+",
"4",
")",
"titulo",
"=",
"' '",
"+",
"titulo",
"print",
"(",
"f'{div}\\n{titulo}\\n{div}'",
")"
] | [
2,
0
] | [
16,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | False | true | null |
|
DireitoGrupoEquipamentoResource.handle_delete | (self, request, user, *args, **kwargs) | Trata as requisições de DELETE para remover direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/<id_direito>/
| Trata as requisições de DELETE para remover direitos de um grupo de usuário em um grupo de equipamento. | def handle_delete(self, request, user, *args, **kwargs):
"""Trata as requisições de DELETE para remover direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/<id_direito>/
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
right_id = kwargs.get('id_direito')
if not is_valid_int_greater_zero_param(right_id, False):
self.log.error(
u'The right_id parameter is not a valid value: %s.', right_id)
raise InvalidValueError(None, 'right_id', right_id)
DireitosGrupoEquipamento.get_by_pk(right_id)
with distributedlock(LOCK_GROUP_RIGHTS % right_id):
DireitosGrupoEquipamento.remove(user, right_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except DireitosGrupoEquipamento.DoesNotExist:
return self.response_error(258, right_id)
except (GrupoError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"USER_ADMINISTRATION",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"right_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_direito'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"right_id",
",",
"False",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The right_id parameter is not a valid value: %s.'",
",",
"right_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'right_id'",
",",
"right_id",
")",
"DireitosGrupoEquipamento",
".",
"get_by_pk",
"(",
"right_id",
")",
"with",
"distributedlock",
"(",
"LOCK_GROUP_RIGHTS",
"%",
"right_id",
")",
":",
"DireitosGrupoEquipamento",
".",
"remove",
"(",
"user",
",",
"right_id",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"DireitosGrupoEquipamento",
".",
"DoesNotExist",
":",
"return",
"self",
".",
"response_error",
"(",
"258",
",",
"right_id",
")",
"except",
"(",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
456,
4
] | [
483,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
cmd_compara_fundo | (args) | Compara performance dos fundos. | Compara performance dos fundos. | def cmd_compara_fundo(args):
"""Compara performance dos fundos."""
range_datas = retorna_datas(args.datainicio, args.datafim)
inf_cadastral = Cadastral()
informe = Informe()
compara = Compara(inf_cadastral, informe)
for data in range_datas:
compara.informe.download_informe_mensal(data)
if not compara.informe.cria_df_informe(cnpj=args.cnpj):
msg("red", "Erro: algum dos cnpjs '{}' nao encontrado".format(args.cnpj), 1)
compara.compara_fundos() | [
"def",
"cmd_compara_fundo",
"(",
"args",
")",
":",
"range_datas",
"=",
"retorna_datas",
"(",
"args",
".",
"datainicio",
",",
"args",
".",
"datafim",
")",
"inf_cadastral",
"=",
"Cadastral",
"(",
")",
"informe",
"=",
"Informe",
"(",
")",
"compara",
"=",
"Compara",
"(",
"inf_cadastral",
",",
"informe",
")",
"for",
"data",
"in",
"range_datas",
":",
"compara",
".",
"informe",
".",
"download_informe_mensal",
"(",
"data",
")",
"if",
"not",
"compara",
".",
"informe",
".",
"cria_df_informe",
"(",
"cnpj",
"=",
"args",
".",
"cnpj",
")",
":",
"msg",
"(",
"\"red\"",
",",
"\"Erro: algum dos cnpjs '{}' nao encontrado\"",
".",
"format",
"(",
"args",
".",
"cnpj",
")",
",",
"1",
")",
"compara",
".",
"compara_fundos",
"(",
")"
] | [
756,
0
] | [
770,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_soup | (url, headers=HEADERS) | return soup | Obtém objeto BeautifulSoup (soup) para o url dado. | Obtém objeto BeautifulSoup (soup) para o url dado. | def get_soup(url, headers=HEADERS):
"""Obtém objeto BeautifulSoup (soup) para o url dado."""
reqopen = Request(url, headers=headers)
req = urlopen(reqopen)
soup = BeautifulSoup(req.read(), "html.parser")
return soup | [
"def",
"get_soup",
"(",
"url",
",",
"headers",
"=",
"HEADERS",
")",
":",
"reqopen",
"=",
"Request",
"(",
"url",
",",
"headers",
"=",
"headers",
")",
"req",
"=",
"urlopen",
"(",
"reqopen",
")",
"soup",
"=",
"BeautifulSoup",
"(",
"req",
".",
"read",
"(",
")",
",",
"\"html.parser\"",
")",
"return",
"soup"
] | [
7,
0
] | [
12,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ajuste | (w, x, d, y) | return w + taxa_aprendiz * (d - y) * x | Define a taxa de aprendizagem e ajusta o valor do w. | Define a taxa de aprendizagem e ajusta o valor do w. | def ajuste(w, x, d, y):
""" Define a taxa de aprendizagem e ajusta o valor do w. """
taxa_aprendiz = 0.01
return w + taxa_aprendiz * (d - y) * x | [
"def",
"ajuste",
"(",
"w",
",",
"x",
",",
"d",
",",
"y",
")",
":",
"taxa_aprendiz",
"=",
"0.01",
"return",
"w",
"+",
"taxa_aprendiz",
"*",
"(",
"d",
"-",
"y",
")",
"*",
"x"
] | [
37,
0
] | [
40,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_expressao | (p) | expressao : expressao_logica
| atribuicao
| expressao : expressao_logica
| atribuicao
| def p_expressao(p):
"""expressao : expressao_logica
| atribuicao
"""
pai = MyNode(name='expressao', type='EXPRESSAO')
p[0] = pai
p[1].parent = pai | [
"def",
"p_expressao",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'expressao'",
",",
"type",
"=",
"'EXPRESSAO'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
517,
0
] | [
523,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Deque.peek_first | (self) | Retorna o elemento que esta no inicio da fila | Retorna o elemento que esta no inicio da fila | def peek_first(self):
""" Retorna o elemento que esta no inicio da fila """
if self._size > 0:
return self.deque[0]
raise IndexError('empty list') | [
"def",
"peek_first",
"(",
"self",
")",
":",
"if",
"self",
".",
"_size",
">",
"0",
":",
"return",
"self",
".",
"deque",
"[",
"0",
"]",
"raise",
"IndexError",
"(",
"'empty list'",
")"
] | [
44,
4
] | [
50,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
dissociate | (op, args) | return result | Dada uma op associativa, retornar um resultado da lista tal
que Expr (op, * resultado) significa o mesmo que Expr (op, * args). | Dada uma op associativa, retornar um resultado da lista tal
que Expr (op, * resultado) significa o mesmo que Expr (op, * args). | def dissociate(op, args):
"""Dada uma op associativa, retornar um resultado da lista tal
que Expr (op, * resultado) significa o mesmo que Expr (op, * args)."""
result = []
def collect(subargs):
for arg in subargs:
if arg.op == op:
collect(arg.args)
else:
result.append(arg)
collect(args)
return result | [
"def",
"dissociate",
"(",
"op",
",",
"args",
")",
":",
"result",
"=",
"[",
"]",
"def",
"collect",
"(",
"subargs",
")",
":",
"for",
"arg",
"in",
"subargs",
":",
"if",
"arg",
".",
"op",
"==",
"op",
":",
"collect",
"(",
"arg",
".",
"args",
")",
"else",
":",
"result",
".",
"append",
"(",
"arg",
")",
"collect",
"(",
"args",
")",
"return",
"result"
] | [
378,
0
] | [
390,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
init_db | () | Função que cria as tabelas do banco de dados caso não existam | Função que cria as tabelas do banco de dados caso não existam | def init_db():
""" Função que cria as tabelas do banco de dados caso não existam """
banco = Banco()
banco.connect()
banco.execute("""CREATE TABLE IF NOT EXISTS processos (
id INTEGER,
caso INTEGER UNIQUE,
autor TEXT NOT NULL,
reu TEXT NOT NULL,
adv_externo TEXT NOT NULL,
adv_adverso TEXT NOT NULL,
processo TEXT NOT NULL,
inicio TEXT NOT NULL,
vr_causa REAL NOT NULL,
tipo_acao TEXT NOT NULL,
vara_tribunal TEXT NOT NULL,
uf_municipio TEXT NOT NULL,
situacao TEXT,
pos_feito TEXT,
observacao TEXT,
valor_atual REAL,
pedido TEXT,
fim TEXT,
perda TEXT,
end_parte_adv TEXT,
PRIMARY KEY("id" AUTOINCREMENT))
""")
banco.execute("""CREATE TABLE IF NOT EXISTS advogados(
id INTEGER,
nome TEXT NOT NULL,
endereco TEXT NOT NULL,
cidade_uf TEXT NOT NULL,
cep NUMERIC,
fax NUMERIC,
fone_com NUMERIC,
email TEXT NOT NULL,
oab TEXT NOT NULL UNIQUE,
cpf INTEGER NOT NULL UNIQUE,
PRIMARY KEY("id" AUTOINCREMENT))
""")
banco.execute("""CREATE TABLE IF NOT EXISTS consultas(
id INTEGER,
consulta INTEGER NOT NULL UNIQUE,
ref TEXT NOT NULL,
prioridade TEXT NOT NULL,
esperado TEXT,
entrada TEXT NOT NULL,
origem TEXT NOT NULL,
assunto TEXT NOT NULL,
interessado TEXT NOT NULL,
adv_cojur TEXT NOT NULL,
emenda TEXT NOT NULL,
saida TEXT,
destino TEXT NOT NULL,
PRIMARY KEY("id" AUTOINCREMENT)
)
""")
banco.execute("""CREATE TABLE IF NOT EXISTS ocorrencias (
id INTEGER,
caso INTEGER NOT NULL,
data TEXT NOT NULL,
descricao TEXT,
valor TEXT NOT NULL,
vr_atual TEXT NOT NULL,
FOREIGN KEY(caso) REFERENCES processos (caso) ON DELETE CASCADE,
PRIMARY KEY("id" AUTOINCREMENT)
)
""")
banco.execute("""CREATE TABLE IF NOT EXISTS cadastro (
id INTEGER,
usuario TEXT NOT NULL UNIQUE,
senha TEXT NOT NULL,
PRIMARY KEY("id" AUTOINCREMENT)
)
""")
banco.persist()
banco.disconnect() | [
"def",
"init_db",
"(",
")",
":",
"banco",
"=",
"Banco",
"(",
")",
"banco",
".",
"connect",
"(",
")",
"banco",
".",
"execute",
"(",
"\"\"\"CREATE TABLE IF NOT EXISTS processos (\r\n id INTEGER,\r\n caso INTEGER UNIQUE,\r\n autor TEXT NOT NULL,\r\n reu\tTEXT NOT NULL,\r\n adv_externo\tTEXT NOT NULL,\r\n adv_adverso\tTEXT NOT NULL,\r\n processo\tTEXT NOT NULL,\r\n inicio\tTEXT NOT NULL,\r\n vr_causa\tREAL NOT NULL,\r\n tipo_acao\tTEXT NOT NULL,\r\n vara_tribunal\tTEXT NOT NULL,\r\n uf_municipio\tTEXT NOT NULL,\r\n situacao\tTEXT,\r\n pos_feito\tTEXT,\r\n observacao\tTEXT,\r\n valor_atual\tREAL,\r\n pedido\tTEXT,\r\n fim\tTEXT,\r\n perda\tTEXT,\r\n end_parte_adv TEXT,\r\n PRIMARY KEY(\"id\" AUTOINCREMENT))\r\n \"\"\"",
")",
"banco",
".",
"execute",
"(",
"\"\"\"CREATE TABLE IF NOT EXISTS advogados(\r\n id INTEGER,\r\n nome\tTEXT NOT NULL,\r\n endereco\tTEXT NOT NULL,\r\n cidade_uf\tTEXT NOT NULL,\r\n cep\tNUMERIC,\r\n fax\tNUMERIC,\r\n fone_com\tNUMERIC,\r\n email\tTEXT NOT NULL,\r\n oab\tTEXT NOT NULL UNIQUE,\r\n cpf\tINTEGER NOT NULL UNIQUE,\r\n PRIMARY KEY(\"id\" AUTOINCREMENT))\r\n \"\"\"",
")",
"banco",
".",
"execute",
"(",
"\"\"\"CREATE TABLE IF NOT EXISTS consultas(\r\n id INTEGER,\r\n consulta\tINTEGER NOT NULL UNIQUE,\r\n ref\tTEXT NOT NULL,\r\n prioridade\tTEXT NOT NULL,\r\n esperado\tTEXT,\r\n entrada\tTEXT NOT NULL,\r\n origem\tTEXT NOT NULL,\r\n assunto\tTEXT NOT NULL,\r\n interessado\tTEXT NOT NULL,\r\n adv_cojur TEXT NOT NULL,\r\n emenda\tTEXT NOT NULL,\r\n saida\tTEXT,\r\n destino\tTEXT NOT NULL,\r\n PRIMARY KEY(\"id\" AUTOINCREMENT) \r\n )\r\n \"\"\"",
")",
"banco",
".",
"execute",
"(",
"\"\"\"CREATE TABLE IF NOT EXISTS ocorrencias (\r\n id INTEGER,\r\n caso INTEGER NOT NULL,\r\n data TEXT NOT NULL,\r\n descricao TEXT,\r\n valor TEXT NOT NULL,\r\n vr_atual TEXT NOT NULL, \r\n FOREIGN KEY(caso) REFERENCES processos (caso) ON DELETE CASCADE,\r\n PRIMARY KEY(\"id\" AUTOINCREMENT)\r\n)\r\n\"\"\"",
")",
"banco",
".",
"execute",
"(",
"\"\"\"CREATE TABLE IF NOT EXISTS cadastro (\r\n id INTEGER,\r\n usuario TEXT NOT NULL UNIQUE,\r\n senha TEXT NOT NULL,\r\n PRIMARY KEY(\"id\" AUTOINCREMENT)\r\n )\r\n \"\"\"",
")",
"banco",
".",
"persist",
"(",
")",
"banco",
".",
"disconnect",
"(",
")"
] | [
45,
0
] | [
124,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TableDrivenAgentProgram | (table) | return program | Esse agente seleciona uma ação baseada na sequência de percepção.
É prático apenas para domínios minúsculos.
Para personalizá-lo, forneça como tabela um dicionário de todos os pares
{Percept_sequence: action}.[ | Esse agente seleciona uma ação baseada na sequência de percepção.
É prático apenas para domínios minúsculos.
Para personalizá-lo, forneça como tabela um dicionário de todos os pares
{Percept_sequence: action}.[ | def TableDrivenAgentProgram(table):
"""Esse agente seleciona uma ação baseada na sequência de percepção.
É prático apenas para domínios minúsculos.
Para personalizá-lo, forneça como tabela um dicionário de todos os pares
{Percept_sequence: action}.["""
percepts = []
def program(percept):
percepts.append(percept)
action = table.get(tuple(percepts))
return action
return program | [
"def",
"TableDrivenAgentProgram",
"(",
"table",
")",
":",
"percepts",
"=",
"[",
"]",
"def",
"program",
"(",
"percept",
")",
":",
"percepts",
".",
"append",
"(",
"percept",
")",
"action",
"=",
"table",
".",
"get",
"(",
"tuple",
"(",
"percepts",
")",
")",
"return",
"action",
"return",
"program"
] | [
76,
0
] | [
87,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Classroom.plot_tree_pdde | (self, Estagios, Aberturas, caminhos, Nome_Arq) | Gera um pdf com estágios e aberturas.
Keyword arguments:
Cenario -- Especifique o cenario de afluencia a ser utilizado no primeiro estagio
Estagios -- Especifique a profundidade da árvore, ou seja, quantas camadas terá a árvore
Aberturas -- Especifique o número aberturas para cada nó
caminhos -- Lista com caminhos a serem destacados
Nome_Arq -- Especifique o Nome do arquivo de saída
| Gera um pdf com estágios e aberturas. | def plot_tree_pdde(self, Estagios, Aberturas, caminhos, Nome_Arq):
"""Gera um pdf com estágios e aberturas.
Keyword arguments:
Cenario -- Especifique o cenario de afluencia a ser utilizado no primeiro estagio
Estagios -- Especifique a profundidade da árvore, ou seja, quantas camadas terá a árvore
Aberturas -- Especifique o número aberturas para cada nó
caminhos -- Lista com caminhos a serem destacados
Nome_Arq -- Especifique o Nome do arquivo de saída
"""
if Aberturas > self.sistema["DGer"]["Nr_Cen"]:
print ("Número de Cenários Menor que Número de Aberturas")
print ("Método plot_tree interrompido!")
return
if Estagios > self.sistema["DGer"]["Nr_Est"]:
print ("Número de Estágios Superior aos dados informados no problema.")
print("Método plot_tree interrompido!")
return
def cria_tree(lista, CasoEstudo, Aberturas, Estagios):
if not lista:
estagio = 0
anterior = None
else:
estagio = lista[-1]["Estagio"] + 1
anterior = lista[-1]["Ordem"]
if estagio == Estagios:
return
for icen in range(Aberturas):
elemento = { "Anterior": anterior,
"Estagio": estagio,
"Afluencia": CasoEstudo.sistema["UHE"][0]["Afl"][estagio][icen],
"Ordem": len(lista),
}
lista.append(elemento)
cria_tree(lista, CasoEstudo, Aberturas, Estagios)
lista = []
cria_tree(lista, self, Aberturas, Estagios)
#
# Cria Grafo
#
g = Digraph('G', filename=Nome_Arq, strict=True)
#
# Cria nós do grafo com nome e label
#
for elemento in lista:
g.node(str(elemento["Ordem"]),label= " Afl: "+ str(elemento["Afluencia"]))
#
# Cria arestas do grafo ( o label é a probabilidade
#
for elemento in lista:
if (elemento["Anterior"] != None):
probabilidade = 100/(Aberturas**(elemento["Estagio"]+1))
g.edge(str(elemento["Anterior"]), str(elemento["Ordem"]),
label=str(round(probabilidade,2))+'%')
#g.node("0", style="filled", fillcolor="green")
Cor = 'red'
for iest in range(Estagios):
if (iest%2) == 0:
Preenche = 'green:cyan'
else:
Preenche = 'lightblue:cyan'
#
# Cria um cluster para cada estágio
#
with g.subgraph(name='cluster'+str(iest+1)) as c:
#
# Define parâmetros do cluster
#
c.attr(fillcolor=Preenche,
label='Estágio '+str(iest+1),
fontcolor=Cor,
style='filled',
gradientangle='270')
c.attr('node',
shape='box',
fillcolor='red:yellow',
style='filled',
gradientangle='90')
#
# Joga para dentro do cluster todos os nós do estágio iest
#
for elemento in lista:
if elemento["Estagio"]==iest:
c.node(str(elemento["Ordem"]))
g.attr("graph",pad="0.5", nodesep="1", ranksep="2")
#caminhos = [ 3, 7, 12, 15]
for posicao in caminhos:
contador = 0
for elemento in lista:
if elemento["Estagio"] == Estagios-1:
contador = contador + 1
if contador == posicao:
break
while elemento["Anterior"] != None:
probabilidade = 100 / (Aberturas ** (elemento["Estagio"] + 1))
g.edge(str(elemento["Anterior"]), str(elemento["Ordem"]),
label=str(round(probabilidade, 2)) + '%', fontcolor = 'red', color='red', penwidth='6.0')
for candidato in lista:
if candidato["Ordem"] == elemento["Anterior"]:
elemento = candidato
break
g.view() | [
"def",
"plot_tree_pdde",
"(",
"self",
",",
"Estagios",
",",
"Aberturas",
",",
"caminhos",
",",
"Nome_Arq",
")",
":",
"if",
"Aberturas",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Cen\"",
"]",
":",
"print",
"(",
"\"Número de Cenários Menor que Número de Aberturas\")",
"",
"print",
"(",
"\"Método plot_tree interrompido!\")",
"",
"return",
"if",
"Estagios",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Est\"",
"]",
":",
"print",
"(",
"\"Número de Estágios Superior aos dados informados no problema.\")",
"",
"print",
"(",
"\"Método plot_tree interrompido!\")",
"",
"return",
"def",
"cria_tree",
"(",
"lista",
",",
"CasoEstudo",
",",
"Aberturas",
",",
"Estagios",
")",
":",
"if",
"not",
"lista",
":",
"estagio",
"=",
"0",
"anterior",
"=",
"None",
"else",
":",
"estagio",
"=",
"lista",
"[",
"-",
"1",
"]",
"[",
"\"Estagio\"",
"]",
"+",
"1",
"anterior",
"=",
"lista",
"[",
"-",
"1",
"]",
"[",
"\"Ordem\"",
"]",
"if",
"estagio",
"==",
"Estagios",
":",
"return",
"for",
"icen",
"in",
"range",
"(",
"Aberturas",
")",
":",
"elemento",
"=",
"{",
"\"Anterior\"",
":",
"anterior",
",",
"\"Estagio\"",
":",
"estagio",
",",
"\"Afluencia\"",
":",
"CasoEstudo",
".",
"sistema",
"[",
"\"UHE\"",
"]",
"[",
"0",
"]",
"[",
"\"Afl\"",
"]",
"[",
"estagio",
"]",
"[",
"icen",
"]",
",",
"\"Ordem\"",
":",
"len",
"(",
"lista",
")",
",",
"}",
"lista",
".",
"append",
"(",
"elemento",
")",
"cria_tree",
"(",
"lista",
",",
"CasoEstudo",
",",
"Aberturas",
",",
"Estagios",
")",
"lista",
"=",
"[",
"]",
"cria_tree",
"(",
"lista",
",",
"self",
",",
"Aberturas",
",",
"Estagios",
")",
"#",
"# Cria Grafo",
"#",
"g",
"=",
"Digraph",
"(",
"'G'",
",",
"filename",
"=",
"Nome_Arq",
",",
"strict",
"=",
"True",
")",
"#",
"# Cria nós do grafo com nome e label",
"#",
"for",
"elemento",
"in",
"lista",
":",
"g",
".",
"node",
"(",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
",",
"label",
"=",
"\" Afl: \"",
"+",
"str",
"(",
"elemento",
"[",
"\"Afluencia\"",
"]",
")",
")",
"#",
"# Cria arestas do grafo ( o label é a probabilidade",
"#",
"for",
"elemento",
"in",
"lista",
":",
"if",
"(",
"elemento",
"[",
"\"Anterior\"",
"]",
"!=",
"None",
")",
":",
"probabilidade",
"=",
"100",
"/",
"(",
"Aberturas",
"**",
"(",
"elemento",
"[",
"\"Estagio\"",
"]",
"+",
"1",
")",
")",
"g",
".",
"edge",
"(",
"str",
"(",
"elemento",
"[",
"\"Anterior\"",
"]",
")",
",",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
",",
"label",
"=",
"str",
"(",
"round",
"(",
"probabilidade",
",",
"2",
")",
")",
"+",
"'%'",
")",
"#g.node(\"0\", style=\"filled\", fillcolor=\"green\")",
"Cor",
"=",
"'red'",
"for",
"iest",
"in",
"range",
"(",
"Estagios",
")",
":",
"if",
"(",
"iest",
"%",
"2",
")",
"==",
"0",
":",
"Preenche",
"=",
"'green:cyan'",
"else",
":",
"Preenche",
"=",
"'lightblue:cyan'",
"#",
"# Cria um cluster para cada estágio",
"#",
"with",
"g",
".",
"subgraph",
"(",
"name",
"=",
"'cluster'",
"+",
"str",
"(",
"iest",
"+",
"1",
")",
")",
"as",
"c",
":",
"#",
"# Define parâmetros do cluster",
"#",
"c",
".",
"attr",
"(",
"fillcolor",
"=",
"Preenche",
",",
"label",
"=",
"'Estágio '+",
"s",
"tr(",
"i",
"est+",
"1",
")",
",",
"",
"fontcolor",
"=",
"Cor",
",",
"style",
"=",
"'filled'",
",",
"gradientangle",
"=",
"'270'",
")",
"c",
".",
"attr",
"(",
"'node'",
",",
"shape",
"=",
"'box'",
",",
"fillcolor",
"=",
"'red:yellow'",
",",
"style",
"=",
"'filled'",
",",
"gradientangle",
"=",
"'90'",
")",
"#",
"# Joga para dentro do cluster todos os nós do estágio iest",
"#",
"for",
"elemento",
"in",
"lista",
":",
"if",
"elemento",
"[",
"\"Estagio\"",
"]",
"==",
"iest",
":",
"c",
".",
"node",
"(",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
")",
"g",
".",
"attr",
"(",
"\"graph\"",
",",
"pad",
"=",
"\"0.5\"",
",",
"nodesep",
"=",
"\"1\"",
",",
"ranksep",
"=",
"\"2\"",
")",
"#caminhos = [ 3, 7, 12, 15]",
"for",
"posicao",
"in",
"caminhos",
":",
"contador",
"=",
"0",
"for",
"elemento",
"in",
"lista",
":",
"if",
"elemento",
"[",
"\"Estagio\"",
"]",
"==",
"Estagios",
"-",
"1",
":",
"contador",
"=",
"contador",
"+",
"1",
"if",
"contador",
"==",
"posicao",
":",
"break",
"while",
"elemento",
"[",
"\"Anterior\"",
"]",
"!=",
"None",
":",
"probabilidade",
"=",
"100",
"/",
"(",
"Aberturas",
"**",
"(",
"elemento",
"[",
"\"Estagio\"",
"]",
"+",
"1",
")",
")",
"g",
".",
"edge",
"(",
"str",
"(",
"elemento",
"[",
"\"Anterior\"",
"]",
")",
",",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
",",
"label",
"=",
"str",
"(",
"round",
"(",
"probabilidade",
",",
"2",
")",
")",
"+",
"'%'",
",",
"fontcolor",
"=",
"'red'",
",",
"color",
"=",
"'red'",
",",
"penwidth",
"=",
"'6.0'",
")",
"for",
"candidato",
"in",
"lista",
":",
"if",
"candidato",
"[",
"\"Ordem\"",
"]",
"==",
"elemento",
"[",
"\"Anterior\"",
"]",
":",
"elemento",
"=",
"candidato",
"break",
"g",
".",
"view",
"(",
")"
] | [
2174,
4
] | [
2300,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Grafo.adicionaVertice | (self, rotulo) | Adiciona um vértice do grafo | Adiciona um vértice do grafo | def adicionaVertice(self, rotulo):
"""Adiciona um vértice do grafo"""
self.numVertices += 1
if(len(self.listaVertices) == 0):
# primeiro vertice cadastrado
aux = Vertice(rotulo)
aux.raiz = True
aux.distancia = 0
self.listaVertices.append(Vertice(rotulo)) | [
"def",
"adicionaVertice",
"(",
"self",
",",
"rotulo",
")",
":",
"self",
".",
"numVertices",
"+=",
"1",
"if",
"(",
"len",
"(",
"self",
".",
"listaVertices",
")",
"==",
"0",
")",
":",
"# primeiro vertice cadastrado",
"aux",
"=",
"Vertice",
"(",
"rotulo",
")",
"aux",
".",
"raiz",
"=",
"True",
"aux",
".",
"distancia",
"=",
"0",
"self",
".",
"listaVertices",
".",
"append",
"(",
"Vertice",
"(",
"rotulo",
")",
")"
] | [
20,
4
] | [
28,
50
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
IpEquipamento.create | (self, authenticated_user, ip_id, equipment_id) | Insere um relacionamento entre IP e Equipamento.
@return: Nothing.
@raise IpError: Falha ao inserir.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise IpNotFoundError: Ip não cadastrado.
@raise IpEquipamentoDuplicatedError: IP já cadastrado para o equipamento.
@raise EquipamentoError: Falha ao pesquisar o equipamento.
| Insere um relacionamento entre IP e Equipamento.
| def create(self, authenticated_user, ip_id, equipment_id):
"""Insere um relacionamento entre IP e Equipamento.
@return: Nothing.
@raise IpError: Falha ao inserir.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise IpNotFoundError: Ip não cadastrado.
@raise IpEquipamentoDuplicatedError: IP já cadastrado para o equipamento.
@raise EquipamentoError: Falha ao pesquisar o equipamento.
"""
equipamentoambiente = get_model('equipamento', 'EquipamentoAmbiente')
equipamento = get_model('equipamento', 'Equipamento')
self.equipamento = equipamento().get_by_pk(equipment_id)
self.ip = Ip().get_by_pk(ip_id)
# Valida o ip
self.__validate_ip()
try:
if self.equipamento not in [ea.equipamento for ea in self.ip.networkipv4.vlan.ambiente.equipamentoambiente_set.all().select_related('equipamento')]:
ea = equipamentoambiente(
ambiente=self.ip.networkipv4.vlan.ambiente, equipamento=self.equipamento)
ea.save(authenticated_user)
self.save()
except Exception, e:
self.log.error(u'Falha ao inserir um ip_equipamento.')
raise IpError(e, u'Falha ao inserir um ip_equipamento.') | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
",",
"ip_id",
",",
"equipment_id",
")",
":",
"equipamentoambiente",
"=",
"get_model",
"(",
"'equipamento'",
",",
"'EquipamentoAmbiente'",
")",
"equipamento",
"=",
"get_model",
"(",
"'equipamento'",
",",
"'Equipamento'",
")",
"self",
".",
"equipamento",
"=",
"equipamento",
"(",
")",
".",
"get_by_pk",
"(",
"equipment_id",
")",
"self",
".",
"ip",
"=",
"Ip",
"(",
")",
".",
"get_by_pk",
"(",
"ip_id",
")",
"# Valida o ip",
"self",
".",
"__validate_ip",
"(",
")",
"try",
":",
"if",
"self",
".",
"equipamento",
"not",
"in",
"[",
"ea",
".",
"equipamento",
"for",
"ea",
"in",
"self",
".",
"ip",
".",
"networkipv4",
".",
"vlan",
".",
"ambiente",
".",
"equipamentoambiente_set",
".",
"all",
"(",
")",
".",
"select_related",
"(",
"'equipamento'",
")",
"]",
":",
"ea",
"=",
"equipamentoambiente",
"(",
"ambiente",
"=",
"self",
".",
"ip",
".",
"networkipv4",
".",
"vlan",
".",
"ambiente",
",",
"equipamento",
"=",
"self",
".",
"equipamento",
")",
"ea",
".",
"save",
"(",
"authenticated_user",
")",
"self",
".",
"save",
"(",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir um ip_equipamento.'",
")",
"raise",
"IpError",
"(",
"e",
",",
"u'Falha ao inserir um ip_equipamento.'",
")"
] | [
2305,
4
] | [
2331,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
conta_numero | (numero,matriz) | return num_vezes | Recebe um número e uma matriz númerica,
procura na matriz por esse número dado como
entrada e retorna o a quantidade de vezes em
que ele ocorre
int, list -> int
| Recebe um número e uma matriz númerica,
procura na matriz por esse número dado como
entrada e retorna o a quantidade de vezes em
que ele ocorre
int, list -> int
| def conta_numero(numero,matriz):
""" Recebe um número e uma matriz númerica,
procura na matriz por esse número dado como
entrada e retorna o a quantidade de vezes em
que ele ocorre
int, list -> int
"""
num_vezes = 0
for linha in matriz:
for coluna in linha:
if coluna == numero:
num_vezes += 1
return num_vezes | [
"def",
"conta_numero",
"(",
"numero",
",",
"matriz",
")",
":",
"num_vezes",
"=",
"0",
"for",
"linha",
"in",
"matriz",
":",
"for",
"coluna",
"in",
"linha",
":",
"if",
"coluna",
"==",
"numero",
":",
"num_vezes",
"+=",
"1",
"return",
"num_vezes"
] | [
0,
0
] | [
14,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
busca | (setor,matriz) | return retorno_busca | Recebe o nome de um setor junto a uma matriz
que armazena os dados de funcionários e busca
os funcionários que pertecem a este setor
: str, list -> list
| Recebe o nome de um setor junto a uma matriz
que armazena os dados de funcionários e busca
os funcionários que pertecem a este setor
: str, list -> list
| def busca(setor,matriz):
"""Recebe o nome de um setor junto a uma matriz
que armazena os dados de funcionários e busca
os funcionários que pertecem a este setor
: str, list -> list
"""
retorno_busca = []
for linha in range(len(matriz)):
if matriz[linha][2] == setor:
item = [matriz[linha][0],matriz[linha][1],matriz[linha][3]]
retorno_busca.append(item)
return retorno_busca | [
"def",
"busca",
"(",
"setor",
",",
"matriz",
")",
":",
"retorno_busca",
"=",
"[",
"]",
"for",
"linha",
"in",
"range",
"(",
"len",
"(",
"matriz",
")",
")",
":",
"if",
"matriz",
"[",
"linha",
"]",
"[",
"2",
"]",
"==",
"setor",
":",
"item",
"=",
"[",
"matriz",
"[",
"linha",
"]",
"[",
"0",
"]",
",",
"matriz",
"[",
"linha",
"]",
"[",
"1",
"]",
",",
"matriz",
"[",
"linha",
"]",
"[",
"3",
"]",
"]",
"retorno_busca",
".",
"append",
"(",
"item",
")",
"return",
"retorno_busca"
] | [
0,
0
] | [
11,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
date_to_datetime | (date: str) | return datetime.strptime(date, "%Y-%m-%dT%H:%M:%S.%fZ") | Transforma datas no formato ISO em objetos datetime | Transforma datas no formato ISO em objetos datetime | def date_to_datetime(date: str) -> datetime:
"""Transforma datas no formato ISO em objetos datetime"""
return datetime.strptime(date, "%Y-%m-%dT%H:%M:%S.%fZ") | [
"def",
"date_to_datetime",
"(",
"date",
":",
"str",
")",
"->",
"datetime",
":",
"return",
"datetime",
".",
"strptime",
"(",
"date",
",",
"\"%Y-%m-%dT%H:%M:%S.%fZ\"",
")"
] | [
10,
0
] | [
12,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
run | (path: str, output_file: str = "", mongo=False) | Invoca o utilitário `isis2json` com os parâmetros adaptados para a
leitura de arquivos MST de acordo com as definições padrões utilizadas
pelo __main__ da ferramenta `isis2json`.
O resultado de saída pode ser escrito diretamente para um arquivo em disco
ou retornará uma lista contento as linhas passíveis de conversão para
JSON.
Exemplo:
>>> run("file.mst")
>>> [{"mfn": 1}, {"mfn": 2}]
>>> run("file.mst", output_file="/tmp/output.json")
>>> None
| Invoca o utilitário `isis2json` com os parâmetros adaptados para a
leitura de arquivos MST de acordo com as definições padrões utilizadas
pelo __main__ da ferramenta `isis2json`. | def run(path: str, output_file: str = "", mongo=False) -> Union[None, List[dict]]:
"""Invoca o utilitário `isis2json` com os parâmetros adaptados para a
leitura de arquivos MST de acordo com as definições padrões utilizadas
pelo __main__ da ferramenta `isis2json`.
O resultado de saída pode ser escrito diretamente para um arquivo em disco
ou retornará uma lista contento as linhas passíveis de conversão para
JSON.
Exemplo:
>>> run("file.mst")
>>> [{"mfn": 1}, {"mfn": 2}]
>>> run("file.mst", output_file="/tmp/output.json")
>>> None
"""
if not os.path.exists(path):
raise FileNotFoundError("File '%s' does not exist.")
if len(output_file) > 0:
output_file = open(output_file, "wb")
else:
output_file = OutputContainer()
isis2json.writeJsonArray(
iterRecords=isis2json.iterMstRecords,
file_name=path,
output=output_file,
qty=isis2json.DEFAULT_QTY,
skip=0,
id_tag=0,
gen_uuid=False,
mongo=mongo,
mfn=True,
isis_json_type=3,
prefix="v",
constant="",
)
output_file.close()
if isinstance(output_file, OutputContainer):
return output_file.lines | [
"def",
"run",
"(",
"path",
":",
"str",
",",
"output_file",
":",
"str",
"=",
"\"\"",
",",
"mongo",
"=",
"False",
")",
"->",
"Union",
"[",
"None",
",",
"List",
"[",
"dict",
"]",
"]",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
":",
"raise",
"FileNotFoundError",
"(",
"\"File '%s' does not exist.\"",
")",
"if",
"len",
"(",
"output_file",
")",
">",
"0",
":",
"output_file",
"=",
"open",
"(",
"output_file",
",",
"\"wb\"",
")",
"else",
":",
"output_file",
"=",
"OutputContainer",
"(",
")",
"isis2json",
".",
"writeJsonArray",
"(",
"iterRecords",
"=",
"isis2json",
".",
"iterMstRecords",
",",
"file_name",
"=",
"path",
",",
"output",
"=",
"output_file",
",",
"qty",
"=",
"isis2json",
".",
"DEFAULT_QTY",
",",
"skip",
"=",
"0",
",",
"id_tag",
"=",
"0",
",",
"gen_uuid",
"=",
"False",
",",
"mongo",
"=",
"mongo",
",",
"mfn",
"=",
"True",
",",
"isis_json_type",
"=",
"3",
",",
"prefix",
"=",
"\"v\"",
",",
"constant",
"=",
"\"\"",
",",
")",
"output_file",
".",
"close",
"(",
")",
"if",
"isinstance",
"(",
"output_file",
",",
"OutputContainer",
")",
":",
"return",
"output_file",
".",
"lines"
] | [
41,
0
] | [
84,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
configure_apm_agent | (app) | return ElasticAPM(app) | Configura e inicia o agente de introspecção do APM. | Configura e inicia o agente de introspecção do APM. | def configure_apm_agent(app):
"""Configura e inicia o agente de introspecção do APM."""
from .utils import asbool
if not app.config.get("APM_ENABLED"):
logger.debug(
"APM Agent is disabled. To enable it configure the APM_ENABLED option."
)
return
APM_CONFIG_KEYS_INFO = (
("SERVER_URL", True, str),
("SERVICE_NAME", False, str),
("SECRET_TOKEN", False, str),
("ENVIRONMENT", False, str),
("SERVICE_VERSION", False, str),
("FILTER_EXCEPTION_TYPES", False, str),
("TRANSACTIONS_IGNORE_PATTERNS", False, str),
("SERVER_TIMEOUT", False, str),
("HOSTNAME", False, str),
("COLLECT_LOCAL_VARIABLES", False, str),
("LOCAL_VAR_MAX_LENGTH", False, int),
("CAPTURE_BODY", False, str),
("CAPTURE_HEADERS", False, asbool),
("TRANSACTION_MAX_SPANS", False, int),
("STACK_TRACE_LIMIT", False, int),
("DEBUG", False, asbool),
("DISABLE_SEND", False, asbool),
("INSTRUMENT", False, asbool),
("VERIFY_SERVER_CERT", False, asbool),
)
apm_config = {}
for apm_key, required, cast in APM_CONFIG_KEYS_INFO:
key = "APM_%s" % apm_key
value = app.config.get(key)
if value is None or (isinstance(value, str) and len(value) == 0):
if required:
raise ValueError(
"Could not setup APM Agent. The key '%s' is required, "
"please configure it." % key
) from None
continue
try:
_value = cast(value)
except (ValueError, TypeError) as exc:
raise ValueError(
"Could not set the key '%s' with value '%s'. "
"The cast function raise the exception '%s'." % (key, value, exc)
)
apm_config[apm_key] = _value
app.config["ELASTIC_APM"] = apm_config
logger.debug("APM Agent enabled.")
return ElasticAPM(app) | [
"def",
"configure_apm_agent",
"(",
"app",
")",
":",
"from",
".",
"utils",
"import",
"asbool",
"if",
"not",
"app",
".",
"config",
".",
"get",
"(",
"\"APM_ENABLED\"",
")",
":",
"logger",
".",
"debug",
"(",
"\"APM Agent is disabled. To enable it configure the APM_ENABLED option.\"",
")",
"return",
"APM_CONFIG_KEYS_INFO",
"=",
"(",
"(",
"\"SERVER_URL\"",
",",
"True",
",",
"str",
")",
",",
"(",
"\"SERVICE_NAME\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"SECRET_TOKEN\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"ENVIRONMENT\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"SERVICE_VERSION\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"FILTER_EXCEPTION_TYPES\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"TRANSACTIONS_IGNORE_PATTERNS\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"SERVER_TIMEOUT\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"HOSTNAME\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"COLLECT_LOCAL_VARIABLES\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"LOCAL_VAR_MAX_LENGTH\"",
",",
"False",
",",
"int",
")",
",",
"(",
"\"CAPTURE_BODY\"",
",",
"False",
",",
"str",
")",
",",
"(",
"\"CAPTURE_HEADERS\"",
",",
"False",
",",
"asbool",
")",
",",
"(",
"\"TRANSACTION_MAX_SPANS\"",
",",
"False",
",",
"int",
")",
",",
"(",
"\"STACK_TRACE_LIMIT\"",
",",
"False",
",",
"int",
")",
",",
"(",
"\"DEBUG\"",
",",
"False",
",",
"asbool",
")",
",",
"(",
"\"DISABLE_SEND\"",
",",
"False",
",",
"asbool",
")",
",",
"(",
"\"INSTRUMENT\"",
",",
"False",
",",
"asbool",
")",
",",
"(",
"\"VERIFY_SERVER_CERT\"",
",",
"False",
",",
"asbool",
")",
",",
")",
"apm_config",
"=",
"{",
"}",
"for",
"apm_key",
",",
"required",
",",
"cast",
"in",
"APM_CONFIG_KEYS_INFO",
":",
"key",
"=",
"\"APM_%s\"",
"%",
"apm_key",
"value",
"=",
"app",
".",
"config",
".",
"get",
"(",
"key",
")",
"if",
"value",
"is",
"None",
"or",
"(",
"isinstance",
"(",
"value",
",",
"str",
")",
"and",
"len",
"(",
"value",
")",
"==",
"0",
")",
":",
"if",
"required",
":",
"raise",
"ValueError",
"(",
"\"Could not setup APM Agent. The key '%s' is required, \"",
"\"please configure it.\"",
"%",
"key",
")",
"from",
"None",
"continue",
"try",
":",
"_value",
"=",
"cast",
"(",
"value",
")",
"except",
"(",
"ValueError",
",",
"TypeError",
")",
"as",
"exc",
":",
"raise",
"ValueError",
"(",
"\"Could not set the key '%s' with value '%s'. \"",
"\"The cast function raise the exception '%s'.\"",
"%",
"(",
"key",
",",
"value",
",",
"exc",
")",
")",
"apm_config",
"[",
"apm_key",
"]",
"=",
"_value",
"app",
".",
"config",
"[",
"\"ELASTIC_APM\"",
"]",
"=",
"apm_config",
"logger",
".",
"debug",
"(",
"\"APM Agent enabled.\"",
")",
"return",
"ElasticAPM",
"(",
"app",
")"
] | [
55,
0
] | [
113,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Motors.drive | (self, left_command, right_command) | Envia um comando para os dois motores
Args:
left_command (int): Comando a ser enviado ao motor esquerdo,
de -255 (velocidade máxima, ré) até 255 (velocidade máxima, para frente)
right_command (int): Comando a ser enviado ao motor direito,
de -255 (velocidade máxima, ré) até 255 (velocidade máxima, para frente)
Raises:
ValueError: Se qualquer um dos comandos for maior em módulo do que 255
| Envia um comando para os dois motores | def drive(self, left_command, right_command):
"""Envia um comando para os dois motores
Args:
left_command (int): Comando a ser enviado ao motor esquerdo,
de -255 (velocidade máxima, ré) até 255 (velocidade máxima, para frente)
right_command (int): Comando a ser enviado ao motor direito,
de -255 (velocidade máxima, ré) até 255 (velocidade máxima, para frente)
Raises:
ValueError: Se qualquer um dos comandos for maior em módulo do que 255
"""
if abs(left_command) > 255:
raise ValueError(f"Comando de velocidade não pode ser maior que 255! Recebido {left_command}")
if abs(right_command) > 255:
raise ValueError(f"Comando de velocidade não pode ser maior que 255! Recebido {right_command}")
left_vel = int(left_command)/255*MAX_VEL
right_vel = int(right_command)/255*MAX_VEL
self.left_pub.publish(Float64(left_vel))
self.right_pub.publish(Float64(right_vel)) | [
"def",
"drive",
"(",
"self",
",",
"left_command",
",",
"right_command",
")",
":",
"if",
"abs",
"(",
"left_command",
")",
">",
"255",
":",
"raise",
"ValueError",
"(",
"f\"Comando de velocidade não pode ser maior que 255! Recebido {left_command}\")",
"",
"if",
"abs",
"(",
"right_command",
")",
">",
"255",
":",
"raise",
"ValueError",
"(",
"f\"Comando de velocidade não pode ser maior que 255! Recebido {right_command}\")",
"",
"left_vel",
"=",
"int",
"(",
"left_command",
")",
"/",
"255",
"*",
"MAX_VEL",
"right_vel",
"=",
"int",
"(",
"right_command",
")",
"/",
"255",
"*",
"MAX_VEL",
"self",
".",
"left_pub",
".",
"publish",
"(",
"Float64",
"(",
"left_vel",
")",
")",
"self",
".",
"right_pub",
".",
"publish",
"(",
"Float64",
"(",
"right_vel",
")",
")"
] | [
23,
4
] | [
44,
50
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
update | (id) | Atualiza uma emprestimo pelo seu respectivo id. | Atualiza uma emprestimo pelo seu respectivo id. | def update(id):
"""Atualiza uma emprestimo pelo seu respectivo id."""
emprestimo = get_emprestimo(id)
try:
livro = db.query_one('select * from livro where tombo = %s' % emprestimo['tombo'])
qtdlivro = livro['qtd']
qtdlivro += 1
atualiza_punicao_socio(id)
db.insert_bd('UPDATE livro SET status = "ESTANTE", qtd = "%s" WHERE tombo = "%s" ' % (qtdlivro, emprestimo['tombo']))
db.insert_bd('DELETE FROM emprestimo WHERE id = "%s"' % emprestimo['id'])
return redirect(url_for('emprestimo.index'))
except Exception as e:
print(e)
return render_template('404.html') | [
"def",
"update",
"(",
"id",
")",
":",
"emprestimo",
"=",
"get_emprestimo",
"(",
"id",
")",
"try",
":",
"livro",
"=",
"db",
".",
"query_one",
"(",
"'select * from livro where tombo = %s'",
"%",
"emprestimo",
"[",
"'tombo'",
"]",
")",
"qtdlivro",
"=",
"livro",
"[",
"'qtd'",
"]",
"qtdlivro",
"+=",
"1",
"atualiza_punicao_socio",
"(",
"id",
")",
"db",
".",
"insert_bd",
"(",
"'UPDATE livro SET status = \"ESTANTE\", qtd = \"%s\" WHERE tombo = \"%s\" '",
"%",
"(",
"qtdlivro",
",",
"emprestimo",
"[",
"'tombo'",
"]",
")",
")",
"db",
".",
"insert_bd",
"(",
"'DELETE FROM emprestimo WHERE id = \"%s\"'",
"%",
"emprestimo",
"[",
"'id'",
"]",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'emprestimo.index'",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
157,
0
] | [
171,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
prime | (x: int) | Verifica se o número é primo ou não
Args:
x (int): Número fornecido pelo usuário.
Returns:
[bool]: True se é primo e False caso contrário.
>>> prime(0)
False
>>> prime(1)
False
>>> prime(2)
True
>>> prime(29)
True
>>> prime(27)
False
>>> prime(641)
True
| Verifica se o número é primo ou não | def prime(x: int):
"""Verifica se o número é primo ou não
Args:
x (int): Número fornecido pelo usuário.
Returns:
[bool]: True se é primo e False caso contrário.
>>> prime(0)
False
>>> prime(1)
False
>>> prime(2)
True
>>> prime(29)
True
>>> prime(27)
False
>>> prime(641)
True
"""
# Definido pelo enunciado
if x in (0, 1):
return False
# Se for 2 é primo
elif x == 2:
return True
# Se for par paramos aqui
elif x % 2 == 0:
return False
else:
r_q = round(sqrt(x)) # Raiz quadrada de X
# Percorrendo todos números ímpares até a raiz quadrada de X
for i in range(3, r_q + 1, 2):
if x % i == 0:
return False
return True | [
"def",
"prime",
"(",
"x",
":",
"int",
")",
":",
"# Definido pelo enunciado",
"if",
"x",
"in",
"(",
"0",
",",
"1",
")",
":",
"return",
"False",
"# Se for 2 é primo",
"elif",
"x",
"==",
"2",
":",
"return",
"True",
"# Se for par paramos aqui",
"elif",
"x",
"%",
"2",
"==",
"0",
":",
"return",
"False",
"else",
":",
"r_q",
"=",
"round",
"(",
"sqrt",
"(",
"x",
")",
")",
"# Raiz quadrada de X",
"# Percorrendo todos números ímpares até a raiz quadrada de X",
"for",
"i",
"in",
"range",
"(",
"3",
",",
"r_q",
"+",
"1",
",",
"2",
")",
":",
"if",
"x",
"%",
"i",
"==",
"0",
":",
"return",
"False",
"return",
"True"
] | [
11,
0
] | [
51,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pyvidesk.persons | (self) | return Persons(token=self.token) | Retorna um objeto de persons do pyvidesk | Retorna um objeto de persons do pyvidesk | def persons(self):
"""Retorna um objeto de persons do pyvidesk"""
return Persons(token=self.token) | [
"def",
"persons",
"(",
"self",
")",
":",
"return",
"Persons",
"(",
"token",
"=",
"self",
".",
"token",
")"
] | [
22,
4
] | [
24,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
convert_local_urls | (r_response) | return content | Substitui urls locals para url remota para criar uma copia rasa recursiva de scripts e arquivos
param: requests.models.Response (object response requests)
Exemplo:
href="/static/file.css"
substitui por:
href="http://domain.com/static/file.css"
| Substitui urls locals para url remota para criar uma copia rasa recursiva de scripts e arquivos
param: requests.models.Response (object response requests) | def convert_local_urls(r_response):
"""Substitui urls locals para url remota para criar uma copia rasa recursiva de scripts e arquivos
param: requests.models.Response (object response requests)
Exemplo:
href="/static/file.css"
substitui por:
href="http://domain.com/static/file.css"
"""
url = urlsplit(r_response.url)
url = "{uri.scheme}://{uri.hostname}".format(uri=url)
content = r_response.text
content = content.replace('href="/', 'href="{}/'.format(url))
content = content.replace('src="/', 'src="{}/'.format(url))
return content | [
"def",
"convert_local_urls",
"(",
"r_response",
")",
":",
"url",
"=",
"urlsplit",
"(",
"r_response",
".",
"url",
")",
"url",
"=",
"\"{uri.scheme}://{uri.hostname}\"",
".",
"format",
"(",
"uri",
"=",
"url",
")",
"content",
"=",
"r_response",
".",
"text",
"content",
"=",
"content",
".",
"replace",
"(",
"'href=\"/'",
",",
"'href=\"{}/'",
".",
"format",
"(",
"url",
")",
")",
"content",
"=",
"content",
".",
"replace",
"(",
"'src=\"/'",
",",
"'src=\"{}/'",
".",
"format",
"(",
"url",
")",
")",
"return",
"content"
] | [
8,
0
] | [
23,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
insertion_sort | (values) | Ordena uma lista, em ordem crescente, usando o Insertion Sort.
O Insertion Sort é, consideravelmente mais eficiente que o Bubble
Sort e o Selection Sort. Sua estratégia consiste em "particionar" a
lista em duas, de modo que a lista à esquerda esteja ordenada, mas
a lista à direita não. Com essa abordagem, a cada iteração, o pri-
meiro valor da lista à direita é movido para a lista à esquerda e
inserido na posição adequada. Para que não seja necessário criar
novas listas, um valor-chave (key) é usado como delimitador entre
as partições, sendo movido a cada iteração.
Parameters
----------
values : list
A lista que deve ser ordenada
| Ordena uma lista, em ordem crescente, usando o Insertion Sort. | def insertion_sort(values):
""" Ordena uma lista, em ordem crescente, usando o Insertion Sort.
O Insertion Sort é, consideravelmente mais eficiente que o Bubble
Sort e o Selection Sort. Sua estratégia consiste em "particionar" a
lista em duas, de modo que a lista à esquerda esteja ordenada, mas
a lista à direita não. Com essa abordagem, a cada iteração, o pri-
meiro valor da lista à direita é movido para a lista à esquerda e
inserido na posição adequada. Para que não seja necessário criar
novas listas, um valor-chave (key) é usado como delimitador entre
as partições, sendo movido a cada iteração.
Parameters
----------
values : list
A lista que deve ser ordenada
"""
for i in range(1,len(values)):
key = values[i]
j = i - 1
while (j >= 0) and (values[j] > key):
values[j], values[j+1] = values[j+1], values[j]
j -= 1 | [
"def",
"insertion_sort",
"(",
"values",
")",
":",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"values",
")",
")",
":",
"key",
"=",
"values",
"[",
"i",
"]",
"j",
"=",
"i",
"-",
"1",
"while",
"(",
"j",
">=",
"0",
")",
"and",
"(",
"values",
"[",
"j",
"]",
">",
"key",
")",
":",
"values",
"[",
"j",
"]",
",",
"values",
"[",
"j",
"+",
"1",
"]",
"=",
"values",
"[",
"j",
"+",
"1",
"]",
",",
"values",
"[",
"j",
"]",
"j",
"-=",
"1"
] | [
51,
0
] | [
73,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
update_game_over | (screen, background_game_over, play_button) | Apresenta a tela de game-over com o botão de play | Apresenta a tela de game-over com o botão de play | def update_game_over(screen, background_game_over, play_button):
"""Apresenta a tela de game-over com o botão de play"""
# Tempo de transição de tela
sleep(3)
screen.blit(background_game_over, (0, 0))
play_button.draw_button()
# Atualiza a tela
pygame.display.flip() | [
"def",
"update_game_over",
"(",
"screen",
",",
"background_game_over",
",",
"play_button",
")",
":",
"# Tempo de transição de tela",
"sleep",
"(",
"3",
")",
"screen",
".",
"blit",
"(",
"background_game_over",
",",
"(",
"0",
",",
"0",
")",
")",
"play_button",
".",
"draw_button",
"(",
")",
"# Atualiza a tela",
"pygame",
".",
"display",
".",
"flip",
"(",
")"
] | [
123,
0
] | [
130,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CallbackEnquadramento.finaliza | (self, res=None) | Envia para a camada superior o quadro recebido | Envia para a camada superior o quadro recebido | def finaliza(self, res=None):
'''Envia para a camada superior o quadro recebido'''
if res is None:
if self.verificaCRC(self.buff):
quadro = Quadro(self.buff) # Monta um quadro para a camada superior
self.upper.recebe(quadro)
else:
print('Quadro descartado!') | [
"def",
"finaliza",
"(",
"self",
",",
"res",
"=",
"None",
")",
":",
"if",
"res",
"is",
"None",
":",
"if",
"self",
".",
"verificaCRC",
"(",
"self",
".",
"buff",
")",
":",
"quadro",
"=",
"Quadro",
"(",
"self",
".",
"buff",
")",
"# Monta um quadro para a camada superior",
"self",
".",
"upper",
".",
"recebe",
"(",
"quadro",
")",
"else",
":",
"print",
"(",
"'Quadro descartado!'",
")"
] | [
113,
4
] | [
120,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
test_get_departments | (client) | Teste get /departments/ - Compara quantidade de departments enviados com dados do banco e valida status_code 200 | Teste get /departments/ - Compara quantidade de departments enviados com dados do banco e valida status_code 200 | def test_get_departments(client):
"""Teste get /departments/ - Compara quantidade de departments enviados com dados do banco e valida status_code 200"""
access_token = get_access(client)
qtdDepartment = session.query(Department).count()
response = client.get('/departments', headers=make_headers(access_token))
data = json.loads(response.data)['data']
assert response.status_code == 200
assert len(data) == qtdDepartment | [
"def",
"test_get_departments",
"(",
"client",
")",
":",
"access_token",
"=",
"get_access",
"(",
"client",
")",
"qtdDepartment",
"=",
"session",
".",
"query",
"(",
"Department",
")",
".",
"count",
"(",
")",
"response",
"=",
"client",
".",
"get",
"(",
"'/departments'",
",",
"headers",
"=",
"make_headers",
"(",
"access_token",
")",
")",
"data",
"=",
"json",
".",
"loads",
"(",
"response",
".",
"data",
")",
"[",
"'data'",
"]",
"assert",
"response",
".",
"status_code",
"==",
"200",
"assert",
"len",
"(",
"data",
")",
"==",
"qtdDepartment"
] | [
3,
0
] | [
12,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DistanceSensor.get_range | (self) | return self.range | Método para obter o valor da última leitura de distância
Returns:
float: Distância em metros até o objeto mais próximo
| Método para obter o valor da última leitura de distância | def get_range(self):
"""Método para obter o valor da última leitura de distância
Returns:
float: Distância em metros até o objeto mais próximo
"""
return self.range | [
"def",
"get_range",
"(",
"self",
")",
":",
"return",
"self",
".",
"range"
] | [
31,
4
] | [
37,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_declaracao_funcao | (p) | declaracao_funcao : tipo cabecalho
| cabecalho
| declaracao_funcao : tipo cabecalho
| cabecalho
| def p_declaracao_funcao(p):
"""declaracao_funcao : tipo cabecalho
| cabecalho
"""
pai = MyNode(name='declaracao_funcao', type='DECLARACAO_FUNCAO')
p[0] = pai
p[1].parent = pai
if len(p) == 3:
p[2].parent = pai | [
"def",
"p_declaracao_funcao",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'declaracao_funcao'",
",",
"type",
"=",
"'DECLARACAO_FUNCAO'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai",
"if",
"len",
"(",
"p",
")",
"==",
"3",
":",
"p",
"[",
"2",
"]",
".",
"parent",
"=",
"pai"
] | [
225,
0
] | [
234,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SelectionSort.__recursiveBidirectionalSelectionSort | (self,array,leftIndex,rightIndex) | Implementação do método SelectionSort de forma recursiva 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 recursiva 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 __recursiveBidirectionalSelectionSort(self,array,leftIndex,rightIndex):
"""Implementação do método SelectionSort de forma recursiva 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
"""
if(leftIndex < rightIndex):
self.__recursiveGetMax(array, leftIndex, rightIndex, rightIndex, rightIndex)
self.__recursiveGetMin(array, leftIndex, rightIndex, leftIndex, leftIndex)
self.__recursiveBidirectionalSelectionSort(array, leftIndex + 1, rightIndex - 1) | [
"def",
"__recursiveBidirectionalSelectionSort",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
")",
":",
"if",
"(",
"leftIndex",
"<",
"rightIndex",
")",
":",
"self",
".",
"__recursiveGetMax",
"(",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"rightIndex",
",",
"rightIndex",
")",
"self",
".",
"__recursiveGetMin",
"(",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"leftIndex",
",",
"leftIndex",
")",
"self",
".",
"__recursiveBidirectionalSelectionSort",
"(",
"array",
",",
"leftIndex",
"+",
"1",
",",
"rightIndex",
"-",
"1",
")"
] | [
89,
1
] | [
100,
83
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Car.get_descriptive_name | (self) | return long_name.title() | Devolve um nome descritivo, formatado de modo elegante . | Devolve um nome descritivo, formatado de modo elegante . | def get_descriptive_name(self):
"""Devolve um nome descritivo, formatado de modo elegante ."""
long_name = str(self.year) + " " + self.make + " " + self.model
return long_name.title() | [
"def",
"get_descriptive_name",
"(",
"self",
")",
":",
"long_name",
"=",
"str",
"(",
"self",
".",
"year",
")",
"+",
"\" \"",
"+",
"self",
".",
"make",
"+",
"\" \"",
"+",
"self",
".",
"model",
"return",
"long_name",
".",
"title",
"(",
")"
] | [
15,
4
] | [
18,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RestResource.handle_post | (self, request, user, *args, **kwargs) | return self.not_implemented() | Trata uma requisição com o método POST | Trata uma requisição com o método POST | def handle_post(self, request, user, *args, **kwargs):
"""Trata uma requisição com o método POST"""
return self.not_implemented() | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"not_implemented",
"(",
")"
] | [
119,
4
] | [
121,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
completude | (context, campanha, username) | return '' | Obtém o valor de completude de uma campanha e
armazena na variável de template "porcentagem" | Obtém o valor de completude de uma campanha e
armazena na variável de template "porcentagem" | def completude(context, campanha, username):
"""Obtém o valor de completude de uma campanha e
armazena na variável de template "porcentagem" """
context['porcentagem'] = campanha.completude(username)
return '' | [
"def",
"completude",
"(",
"context",
",",
"campanha",
",",
"username",
")",
":",
"context",
"[",
"'porcentagem'",
"]",
"=",
"campanha",
".",
"completude",
"(",
"username",
")",
"return",
"''"
] | [
7,
0
] | [
11,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_events | (ai_settings, screen, stats, sb, play_button, ship, aliens, bullets) | Responde a eventos de pressionamento de teclas e de mouse. | Responde a eventos de pressionamento de teclas e de mouse. | def check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets):
"""Responde a eventos de pressionamento de teclas e de mouse."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
check_keydown_events(event, ai_settings, screen, stats, sb, ship, aliens, bullets)
elif event.type == pygame.KEYUP:
check_keyup_events(event, ship)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
check_play_button(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, mouse_x, mouse_y) | [
"def",
"check_events",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"play_button",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"for",
"event",
"in",
"pygame",
".",
"event",
".",
"get",
"(",
")",
":",
"if",
"event",
".",
"type",
"==",
"pygame",
".",
"QUIT",
":",
"sys",
".",
"exit",
"(",
")",
"elif",
"event",
".",
"type",
"==",
"pygame",
".",
"KEYDOWN",
":",
"check_keydown_events",
"(",
"event",
",",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
"elif",
"event",
".",
"type",
"==",
"pygame",
".",
"KEYUP",
":",
"check_keyup_events",
"(",
"event",
",",
"ship",
")",
"elif",
"event",
".",
"type",
"==",
"pygame",
".",
"MOUSEBUTTONDOWN",
":",
"mouse_x",
",",
"mouse_y",
"=",
"pygame",
".",
"mouse",
".",
"get_pos",
"(",
")",
"check_play_button",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"play_button",
",",
"ship",
",",
"aliens",
",",
"bullets",
",",
"mouse_x",
",",
"mouse_y",
")"
] | [
33,
0
] | [
45,
64
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CRC16.update | (self, data) | Acrescenta mais dados ao buffer interno | Acrescenta mais dados ao buffer interno | def update(self, data):
'''Acrescenta mais dados ao buffer interno'''
self.data += self.__convert__(data) | [
"def",
"update",
"(",
"self",
",",
"data",
")",
":",
"self",
".",
"data",
"+=",
"self",
".",
"__convert__",
"(",
"data",
")"
] | [
61,
2
] | [
63,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BayesNet.__init__ | (self, node_specs=[]) | Os nós devem ser ordenados com os pais antes das crianças. | Os nós devem ser ordenados com os pais antes das crianças. | def __init__(self, node_specs=[]):
"Os nós devem ser ordenados com os pais antes das crianças."
self.nodes = []
self.variables = []
for node_spec in node_specs:
self.add(node_spec) | [
"def",
"__init__",
"(",
"self",
",",
"node_specs",
"=",
"[",
"]",
")",
":",
"self",
".",
"nodes",
"=",
"[",
"]",
"self",
".",
"variables",
"=",
"[",
"]",
"for",
"node_spec",
"in",
"node_specs",
":",
"self",
".",
"add",
"(",
"node_spec",
")"
] | [
161,
4
] | [
166,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
velocidade | (funcao) | return interna | Função decoradora: Verifica o tempo que uma função leva para executar | Função decoradora: Verifica o tempo que uma função leva para executar | def velocidade(funcao):
""" Função decoradora: Verifica o tempo que uma função leva para executar """
def interna(*args, **kwargs):
""" Função que envolve e executa outra função """
# Tempo inicial
star_time = time()
resultado = funcao(*args, **kwargs)
# Executa a função
end_time = time()
# Tempo final
tempo = (end_time - star_time) * 1000
# Resultado de tempo em ms
print(f'A função {funcao.__name__} levou {tempo:.2f}ms para executar')
return interna | [
"def",
"velocidade",
"(",
"funcao",
")",
":",
"def",
"interna",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\" Função que envolve e executa outra função \"\"\"",
"# Tempo inicial",
"star_time",
"=",
"time",
"(",
")",
"resultado",
"=",
"funcao",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Executa a função",
"end_time",
"=",
"time",
"(",
")",
"# Tempo final",
"tempo",
"=",
"(",
"end_time",
"-",
"star_time",
")",
"*",
"1000",
"# Resultado de tempo em ms",
"print",
"(",
"f'A função {funcao.__name__} levou {tempo:.2f}ms para executar')",
"",
"return",
"interna"
] | [
28,
0
] | [
41,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_operador_logico | (p) | operador_logico : E_LOGICO
| OU_LOGICO
| operador_logico : E_LOGICO
| OU_LOGICO
| def p_operador_logico(p):
"""operador_logico : E_LOGICO
| OU_LOGICO
"""
if p[1] == "&&":
filho = MyNode(name='E_LOGICO', type='E_LOGICO')
filho_lexema = MyNode(name=p[1], type='SIMBOLO', parent=filho)
p[0] = MyNode(name='operador_logico',
type='OPERADOR_LOGICO', children=[filho])
else:
filho = MyNode(name='OU_LOGICO', type='OU_LOGICO')
filho_lexema = MyNode(name=p[1], type='SIMBOLO', parent=filho)
p[0] = MyNode(name='operador_logico',
type='OPERADOR_SOMA', children=[filho]) | [
"def",
"p_operador_logico",
"(",
"p",
")",
":",
"if",
"p",
"[",
"1",
"]",
"==",
"\"&&\"",
":",
"filho",
"=",
"MyNode",
"(",
"name",
"=",
"'E_LOGICO'",
",",
"type",
"=",
"'E_LOGICO'",
")",
"filho_lexema",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"1",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho",
")",
"p",
"[",
"0",
"]",
"=",
"MyNode",
"(",
"name",
"=",
"'operador_logico'",
",",
"type",
"=",
"'OPERADOR_LOGICO'",
",",
"children",
"=",
"[",
"filho",
"]",
")",
"else",
":",
"filho",
"=",
"MyNode",
"(",
"name",
"=",
"'OU_LOGICO'",
",",
"type",
"=",
"'OU_LOGICO'",
")",
"filho_lexema",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"1",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho",
")",
"p",
"[",
"0",
"]",
"=",
"MyNode",
"(",
"name",
"=",
"'operador_logico'",
",",
"type",
"=",
"'OPERADOR_SOMA'",
",",
"children",
"=",
"[",
"filho",
"]",
")"
] | [
654,
0
] | [
667,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
edit_entry | (request, entry_id) | return render(request, 'learning_logs/edit_entry.html', context) | Edita uma entrada existente. | Edita uma entrada existente. | def edit_entry(request, entry_id):
"""Edita uma entrada existente."""
entry = Entry.objects.get(id=entry_id)
topic = entry.topic
check_topic_owner(request, topic)
if request.method != 'POST':
# Requisição inicial; preenche previamente o formulário com a entrada atual
form = EntryForm(instance=entry)
else:
# Dados de POST submetidos; processa os dados
form = EntryForm(instance=entry, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('learning_logs:topic', args=[topic.id]))
context = {'entry': entry, 'topic': topic, 'form': form}
return render(request, 'learning_logs/edit_entry.html', context) | [
"def",
"edit_entry",
"(",
"request",
",",
"entry_id",
")",
":",
"entry",
"=",
"Entry",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"entry_id",
")",
"topic",
"=",
"entry",
".",
"topic",
"check_topic_owner",
"(",
"request",
",",
"topic",
")",
"if",
"request",
".",
"method",
"!=",
"'POST'",
":",
"# Requisição inicial; preenche previamente o formulário com a entrada atual",
"form",
"=",
"EntryForm",
"(",
"instance",
"=",
"entry",
")",
"else",
":",
"# Dados de POST submetidos; processa os dados",
"form",
"=",
"EntryForm",
"(",
"instance",
"=",
"entry",
",",
"data",
"=",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"form",
".",
"save",
"(",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'learning_logs:topic'",
",",
"args",
"=",
"[",
"topic",
".",
"id",
"]",
")",
")",
"context",
"=",
"{",
"'entry'",
":",
"entry",
",",
"'topic'",
":",
"topic",
",",
"'form'",
":",
"form",
"}",
"return",
"render",
"(",
"request",
",",
"'learning_logs/edit_entry.html'",
",",
"context",
")"
] | [
74,
0
] | [
89,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Correios.consulta_faixa | (self, localidade, uf) | return self._parse_faixa(html) | Consulta site e retorna faixa para localidade | Consulta site e retorna faixa para localidade | def consulta_faixa(self, localidade, uf):
"""Consulta site e retorna faixa para localidade"""
url = 'consultaFaixaCepAction.do'
data = {
'UF': uf,
'Localidade': localidade.encode('cp1252'),
'cfm': '1',
'Metodo': 'listaFaixaCEP',
'TipoConsulta': 'faixaCep',
'StartRow': '1',
'EndRow': '10',
}
html = self._url_open(url, data).read()
return self._parse_faixa(html) | [
"def",
"consulta_faixa",
"(",
"self",
",",
"localidade",
",",
"uf",
")",
":",
"url",
"=",
"'consultaFaixaCepAction.do'",
"data",
"=",
"{",
"'UF'",
":",
"uf",
",",
"'Localidade'",
":",
"localidade",
".",
"encode",
"(",
"'cp1252'",
")",
",",
"'cfm'",
":",
"'1'",
",",
"'Metodo'",
":",
"'listaFaixaCEP'",
",",
"'TipoConsulta'",
":",
"'faixaCep'",
",",
"'StartRow'",
":",
"'1'",
",",
"'EndRow'",
":",
"'10'",
",",
"}",
"html",
"=",
"self",
".",
"_url_open",
"(",
"url",
",",
"data",
")",
".",
"read",
"(",
")",
"return",
"self",
".",
"_parse_faixa",
"(",
"html",
")"
] | [
82,
4
] | [
95,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
known_path | (kb, loc, dest) | Retorna um caminho explorado para o destino. | Retorna um caminho explorado para o destino. | def known_path(kb, loc, dest):
"""Retorna um caminho explorado para o destino."""
path = [loc]
visited = set()
visited.add(loc)
# Retorna o caminho ou nenhum se o caminho não foi encontrado
if known_path_rec(kb, loc, dest, path, visited):
return tuple(path) | [
"def",
"known_path",
"(",
"kb",
",",
"loc",
",",
"dest",
")",
":",
"path",
"=",
"[",
"loc",
"]",
"visited",
"=",
"set",
"(",
")",
"visited",
".",
"add",
"(",
"loc",
")",
"# Retorna o caminho ou nenhum se o caminho não foi encontrado",
"if",
"known_path_rec",
"(",
"kb",
",",
"loc",
",",
"dest",
",",
"path",
",",
"visited",
")",
":",
"return",
"tuple",
"(",
"path",
")"
] | [
103,
0
] | [
113,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pesquisador.getDadosTitulacao | (self) | return result | Extrai informações de Titulacao do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos.
Returns:
type: Dataframe.
| Extrai informações de Titulacao do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos. | def getDadosTitulacao(self):
"""Extrai informações de Titulacao do pesquisador do XML do Lattes. Precisa da definição da raiz do XML que é realizada em getDadosBasicos.
Returns:
type: Dataframe.
"""
if self.__FLAG:
#----Ajustando informações para o bloco
TAGs = 'FORMACAO-ACADEMICA-TITULACAO'
#----Definindo quais campos são úteis
#--------Colunas com múltiplas equivalências.
cols_merge = ['TIPO', 'NOME-INSTITUICAO']
#--------Colunas que tem que mudar de nome
cols_equiv = {}
#--------Juntando todos os dados básicos e complementares.
cols_keep = []
#--------Jogue fora toda coluna com estes termos
cols_out = ['INGLES', 'CODIGO', 'FLAG', 'ORIENTADOR', 'OUTRA', 'TITULO']
cols_final = []
#----Parsing
lista = self.xml2dict(tag = TAGs)
df = df = pd.DataFrame(lista[0])
if not df.empty:
#----Tidying up
df = self.dfTidy(df, cols_keep=cols_keep, cols_merge = cols_merge, cols_equiv = cols_equiv, cols_out=cols_out, cols_final=cols_final)
result = df
else:
result = None
else:
result = None
return result | [
"def",
"getDadosTitulacao",
"(",
"self",
")",
":",
"if",
"self",
".",
"__FLAG",
":",
"#----Ajustando informações para o bloco",
"TAGs",
"=",
"'FORMACAO-ACADEMICA-TITULACAO'",
"#----Definindo quais campos são úteis",
"#--------Colunas com múltiplas equivalências.",
"cols_merge",
"=",
"[",
"'TIPO'",
",",
"'NOME-INSTITUICAO'",
"]",
"#--------Colunas que tem que mudar de nome",
"cols_equiv",
"=",
"{",
"}",
"#--------Juntando todos os dados básicos e complementares.",
"cols_keep",
"=",
"[",
"]",
"#--------Jogue fora toda coluna com estes termos",
"cols_out",
"=",
"[",
"'INGLES'",
",",
"'CODIGO'",
",",
"'FLAG'",
",",
"'ORIENTADOR'",
",",
"'OUTRA'",
",",
"'TITULO'",
"]",
"cols_final",
"=",
"[",
"]",
"#----Parsing",
"lista",
"=",
"self",
".",
"xml2dict",
"(",
"tag",
"=",
"TAGs",
")",
"df",
"=",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"0",
"]",
")",
"if",
"not",
"df",
".",
"empty",
":",
"#----Tidying up",
"df",
"=",
"self",
".",
"dfTidy",
"(",
"df",
",",
"cols_keep",
"=",
"cols_keep",
",",
"cols_merge",
"=",
"cols_merge",
",",
"cols_equiv",
"=",
"cols_equiv",
",",
"cols_out",
"=",
"cols_out",
",",
"cols_final",
"=",
"cols_final",
")",
"result",
"=",
"df",
"else",
":",
"result",
"=",
"None",
"else",
":",
"result",
"=",
"None",
"return",
"result"
] | [
747,
4
] | [
779,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Conta.__call__ | (self, x) | Permite que a instância de Conta também possa ser chamada | Permite que a instância de Conta também possa ser chamada | def __call__(self, x):
"""Permite que a instância de Conta também possa ser chamada"""
print(x) | [
"def",
"__call__",
"(",
"self",
",",
"x",
")",
":",
"print",
"(",
"x",
")"
] | [
27,
4
] | [
29,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
save_legacy_gazette | (item) | return gazette | Salva diários oficiais do executivo de antes de 2015.
Os diários oficiais eram publicados em um site diferente do atual e
também em jornais. Além disso, tinham um formato diferente, sendo um
arquivo para cada evento (decreto, leis etc).
Alguns não possuem data (especialmente os do ano de 2010). Por isso a
tentativa de extrair a data do título.
| Salva diários oficiais do executivo de antes de 2015. | def save_legacy_gazette(item):
"""Salva diários oficiais do executivo de antes de 2015.
Os diários oficiais eram publicados em um site diferente do atual e
também em jornais. Além disso, tinham um formato diferente, sendo um
arquivo para cada evento (decreto, leis etc).
Alguns não possuem data (especialmente os do ano de 2010). Por isso a
tentativa de extrair a data do título.
"""
notes = ""
if item["date"] is None:
extracted_date = _extract_date(item["title"])
if extracted_date:
item["date"] = extracted_date
notes = "Data extraída do título."
gazette, created = Gazette.objects.get_or_create(
date=item["date"],
power="executivo",
crawled_from=item["crawled_from"],
is_legacy=True,
defaults={"crawled_at": item["crawled_at"], "notes": notes},
)
if created and item.get("files"):
content_type = get_content_type_for_model(gazette)
for file_ in item["files"]:
save_file(file_, content_type, gazette.pk)
GazetteEvent.objects.create(
gazette=gazette,
title=item["title"],
crawled_from=item["crawled_from"],
summary=item["details"],
published_on=item["published_on"],
crawled_at=item["crawled_at"],
)
return gazette | [
"def",
"save_legacy_gazette",
"(",
"item",
")",
":",
"notes",
"=",
"\"\"",
"if",
"item",
"[",
"\"date\"",
"]",
"is",
"None",
":",
"extracted_date",
"=",
"_extract_date",
"(",
"item",
"[",
"\"title\"",
"]",
")",
"if",
"extracted_date",
":",
"item",
"[",
"\"date\"",
"]",
"=",
"extracted_date",
"notes",
"=",
"\"Data extraída do título.\"",
"gazette",
",",
"created",
"=",
"Gazette",
".",
"objects",
".",
"get_or_create",
"(",
"date",
"=",
"item",
"[",
"\"date\"",
"]",
",",
"power",
"=",
"\"executivo\"",
",",
"crawled_from",
"=",
"item",
"[",
"\"crawled_from\"",
"]",
",",
"is_legacy",
"=",
"True",
",",
"defaults",
"=",
"{",
"\"crawled_at\"",
":",
"item",
"[",
"\"crawled_at\"",
"]",
",",
"\"notes\"",
":",
"notes",
"}",
",",
")",
"if",
"created",
"and",
"item",
".",
"get",
"(",
"\"files\"",
")",
":",
"content_type",
"=",
"get_content_type_for_model",
"(",
"gazette",
")",
"for",
"file_",
"in",
"item",
"[",
"\"files\"",
"]",
":",
"save_file",
"(",
"file_",
",",
"content_type",
",",
"gazette",
".",
"pk",
")",
"GazetteEvent",
".",
"objects",
".",
"create",
"(",
"gazette",
"=",
"gazette",
",",
"title",
"=",
"item",
"[",
"\"title\"",
"]",
",",
"crawled_from",
"=",
"item",
"[",
"\"crawled_from\"",
"]",
",",
"summary",
"=",
"item",
"[",
"\"details\"",
"]",
",",
"published_on",
"=",
"item",
"[",
"\"published_on\"",
"]",
",",
"crawled_at",
"=",
"item",
"[",
"\"crawled_at\"",
"]",
",",
")",
"return",
"gazette"
] | [
38,
0
] | [
76,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Main.novo_gato | () | return ga, ge, ba | Retorna um Gatinho, Geladeira e Bau para um gato inicial. | Retorna um Gatinho, Geladeira e Bau para um gato inicial. | def novo_gato():
"""Retorna um Gatinho, Geladeira e Bau para um gato inicial."""
gen_c = choice(['F', 'M'])
gen_r = choice(['F', 'M'])
if gen_c == 'F':
um_c = 'a'
letra_c = um_c
pron_c = um_c
else:
um_c = ''
letra_c = 'o'
pron_c = 'e'
if gen_r == 'F':
um_r = 'a'
letra_r = um_r
pron_r = um_r
else:
um_r = ''
letra_r = 'o'
pron_r = 'e'
textos1 = [' Você está pensando em ter um gato.',
f' Um amigo seu conhece alguém que está vendendo um{um_c} gat{letra_c} bonitinh{letra_c}.',
f' Mas também tem um{um_r} gat{letra_r} que sempre têm andado pela vizinhança,',
f' e el{pron_r} parece muito simpátic{letra_r}.',
' Por outro lado, também existe um abrigo de gatos perto da sua casa.']
cfunc.limpar_tela()
janela = cjane.Janela()
j = 1
i = 0
while i < len(textos1):
janela.muda_linha(j, textos1[i], 'ljust')
if i == 2:
j += 1
janela.muda_linha(j, textos1[i+1], 'ljust')
print(janela)
input('(Aperte ENTER para continuar...)')
j += 2
i += 1 if i != 2 else 2
janela.muda_linha(10, ' Você deseja (C)omprar, (R)esgatar ou (A)dotar o gato?', 'ljust')
print(janela)
escolha = input('>>> ')
while escolha.lower() != 'c' and escolha.lower() != 'r' and escolha.lower() != 'a' \
and escolha.lower() != 'comprar' and escolha.lower() != 'resgatar' and escolha.lower() != 'adotar':
janela.muda_linha(11, ' Digite uma opção válida!', 'ljust')
print(janela)
escolha = input('>>> ')
janela.limpar_janela()
v = 0
if escolha[0] in 'Cc':
janela.muda_linha(1, f' Você conversou com o conhecido do seu amigo e comprou {letra_c} gatinh{letra_c}!', 'ljust')
idade = randint(2, 12)
fome = 100
energia = randint(75, 100)
saude = 100
feliz = randint(80, 100)
vac = True
ga = ogato.Comprado('', idade, fome, energia, saude, feliz, gen_c, vac)
elif escolha[0] in 'Rr':
janela.muda_linha(1, f' Você resgatou {letra_r} gatinh{letra_r}. Agora el{pron_r} tem um dono!', 'ljust')
idade = randint(0, 180)
fome = randint(10, 100)
energia = randint(10, 90)
saude = randint(10, 50)
feliz = randint(10, 90)
vac = False
ga = ogato.Resgatado('', idade, fome, energia, saude, feliz, gen_r, vac)
else:
v = 1
janela.muda_linha(1, ' Você quer adotar um gatinh(o) ou uma gatinh(a)?', 'ljust')
print(janela)
i = input('>>> ')
while i.lower() != 'o' and i.lower() != 'a' and i.lower() != 'gatinho' and i.lower() != 'gatinha':
janela.muda_linha(2, ' Digite uma opção válida!', 'ljust')
print(janela)
i = input('>>> ')
if i[-1].lower() == 'a':
gen_a = 'F'
um_a = 'a'
letra_a = um_a
pron_a = um_a
elif i[-1].lower() == 'o':
gen_a = 'M'
um_a = ''
letra_a = 'o'
pron_a = 'e'
janela.muda_linha(2, f' - Gatinh{letra_a}', 'ljust')
print(janela)
sleep(1)
janela.muda_linha(4, f' Você vai adotar um{um_a} gat{letra_a} (F)ilhote, (A)dult{letra_a} ou (I)dos{letra_a}?', 'ljust')
print(janela)
i = input('>>> ')
while i.lower() != 'f' and i.lower() != 'a' and i.lower() != 'i' \
and i.lower() != 'filhote' and i.lower() != 'adulto' and i.lower() != 'idoso':
janela.muda_linha(5, ' Digite uma opção válida!', 'ljust')
print(janela)
i = input('>>>')
if i[0].lower() == 'f':
idade = randint(3, 12)
janela.muda_linha(5, ' - Filhote', 'ljust')
elif i[0].lower() == 'a':
idade = randint(13, 84)
janela.muda_linha(5, f' - Adult{letra_a}', 'ljust')
elif i[0].lower() == 'i':
idade = randint(85, 180)
janela.muda_linha(5, f' - Idos{letra_a}', 'ljust')
print(janela)
sleep(2)
janela.limpar_janela()
janela.muda_linha(1, f' Você foi até o abrigo e escolheu um{um_a} gatinh{letra_a}.', 'ljust')
janela.muda_linha(2, f' Ou será que foi el{pron_a} quem te escolheu?', 'ljust')
fome = randint(60, 100)
energia = randint(70, 100)
saude = randint(70, 90)
feliz = randint(80, 100)
vac = choice([True, True, True, False, False]) # True: 60%, False: 40%
ga = ogato.Adotado('', idade, fome, energia, saude, feliz, gen_a, vac)
print(janela)
input('(Aperte ENTER para continuar...)')
l = ga.gens['letra']
p = ga.gens['pron']
janela.muda_linha(3+v, f' Hora de uma decisão difícil... Qual vai ser o nome del{p}?', 'ljust')
print(janela)
nome = input('>>> ')
while not cfunc.verificar_nome(nome):
if cfunc.existe_save(nome):
gatolino = csave.carregar_jogo(nome)[0]
l_antigo = gatolino.gens['letra']
p_antigo = gatolino.gens['pron']
janela.muda_linha(4+v, f' Ess{p_antigo} gatinh{l_antigo} já existe! Escolha outro nome.', 'ljust')
else:
janela.muda_linha(4+v, ' Digite um nome válido (e com tamanho menor que 32)!', 'ljust')
print(janela)
nome = input('>>> ')
ga.nome = nome
ge = ogela.Geladeira()
ba = obau.Bau()
return ga, ge, ba | [
"def",
"novo_gato",
"(",
")",
":",
"gen_c",
"=",
"choice",
"(",
"[",
"'F'",
",",
"'M'",
"]",
")",
"gen_r",
"=",
"choice",
"(",
"[",
"'F'",
",",
"'M'",
"]",
")",
"if",
"gen_c",
"==",
"'F'",
":",
"um_c",
"=",
"'a'",
"letra_c",
"=",
"um_c",
"pron_c",
"=",
"um_c",
"else",
":",
"um_c",
"=",
"''",
"letra_c",
"=",
"'o'",
"pron_c",
"=",
"'e'",
"if",
"gen_r",
"==",
"'F'",
":",
"um_r",
"=",
"'a'",
"letra_r",
"=",
"um_r",
"pron_r",
"=",
"um_r",
"else",
":",
"um_r",
"=",
"''",
"letra_r",
"=",
"'o'",
"pron_r",
"=",
"'e'",
"textos1",
"=",
"[",
"' Você está pensando em ter um gato.',",
"",
"f' Um amigo seu conhece alguém que está vendendo um{um_c} gat{letra_c} bonitinh{letra_c}.',",
"",
"f' Mas também tem um{um_r} gat{letra_r} que sempre têm andado pela vizinhança,',",
"",
"f' e el{pron_r} parece muito simpátic{letra_r}.',",
"",
"' Por outro lado, também existe um abrigo de gatos perto da sua casa.']",
"",
"cfunc",
".",
"limpar_tela",
"(",
")",
"janela",
"=",
"cjane",
".",
"Janela",
"(",
")",
"j",
"=",
"1",
"i",
"=",
"0",
"while",
"i",
"<",
"len",
"(",
"textos1",
")",
":",
"janela",
".",
"muda_linha",
"(",
"j",
",",
"textos1",
"[",
"i",
"]",
",",
"'ljust'",
")",
"if",
"i",
"==",
"2",
":",
"j",
"+=",
"1",
"janela",
".",
"muda_linha",
"(",
"j",
",",
"textos1",
"[",
"i",
"+",
"1",
"]",
",",
"'ljust'",
")",
"print",
"(",
"janela",
")",
"input",
"(",
"'(Aperte ENTER para continuar...)'",
")",
"j",
"+=",
"2",
"i",
"+=",
"1",
"if",
"i",
"!=",
"2",
"else",
"2",
"janela",
".",
"muda_linha",
"(",
"10",
",",
"' Você deseja (C)omprar, (R)esgatar ou (A)dotar o gato?',",
" ",
"ljust')",
"",
"print",
"(",
"janela",
")",
"escolha",
"=",
"input",
"(",
"'>>> '",
")",
"while",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'c'",
"and",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'r'",
"and",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'a'",
"and",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'comprar'",
"and",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'resgatar'",
"and",
"escolha",
".",
"lower",
"(",
")",
"!=",
"'adotar'",
":",
"janela",
".",
"muda_linha",
"(",
"11",
",",
"' Digite uma opção válida!', '",
"l",
"ust') ",
" ",
"print",
"(",
"janela",
")",
"escolha",
"=",
"input",
"(",
"'>>> '",
")",
"janela",
".",
"limpar_janela",
"(",
")",
"v",
"=",
"0",
"if",
"escolha",
"[",
"0",
"]",
"in",
"'Cc'",
":",
"janela",
".",
"muda_linha",
"(",
"1",
",",
"f' Você conversou com o conhecido do seu amigo e comprou {letra_c} gatinh{letra_c}!',",
" ",
"ljust')",
"",
"idade",
"=",
"randint",
"(",
"2",
",",
"12",
")",
"fome",
"=",
"100",
"energia",
"=",
"randint",
"(",
"75",
",",
"100",
")",
"saude",
"=",
"100",
"feliz",
"=",
"randint",
"(",
"80",
",",
"100",
")",
"vac",
"=",
"True",
"ga",
"=",
"ogato",
".",
"Comprado",
"(",
"''",
",",
"idade",
",",
"fome",
",",
"energia",
",",
"saude",
",",
"feliz",
",",
"gen_c",
",",
"vac",
")",
"elif",
"escolha",
"[",
"0",
"]",
"in",
"'Rr'",
":",
"janela",
".",
"muda_linha",
"(",
"1",
",",
"f' Você resgatou {letra_r} gatinh{letra_r}. Agora el{pron_r} tem um dono!',",
" ",
"ljust')",
"",
"idade",
"=",
"randint",
"(",
"0",
",",
"180",
")",
"fome",
"=",
"randint",
"(",
"10",
",",
"100",
")",
"energia",
"=",
"randint",
"(",
"10",
",",
"90",
")",
"saude",
"=",
"randint",
"(",
"10",
",",
"50",
")",
"feliz",
"=",
"randint",
"(",
"10",
",",
"90",
")",
"vac",
"=",
"False",
"ga",
"=",
"ogato",
".",
"Resgatado",
"(",
"''",
",",
"idade",
",",
"fome",
",",
"energia",
",",
"saude",
",",
"feliz",
",",
"gen_r",
",",
"vac",
")",
"else",
":",
"v",
"=",
"1",
"janela",
".",
"muda_linha",
"(",
"1",
",",
"' Você quer adotar um gatinh(o) ou uma gatinh(a)?',",
" ",
"ljust')",
"",
"print",
"(",
"janela",
")",
"i",
"=",
"input",
"(",
"'>>> '",
")",
"while",
"i",
".",
"lower",
"(",
")",
"!=",
"'o'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'a'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'gatinho'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'gatinha'",
":",
"janela",
".",
"muda_linha",
"(",
"2",
",",
"' Digite uma opção válida!', '",
"l",
"ust') ",
" ",
"print",
"(",
"janela",
")",
"i",
"=",
"input",
"(",
"'>>> '",
")",
"if",
"i",
"[",
"-",
"1",
"]",
".",
"lower",
"(",
")",
"==",
"'a'",
":",
"gen_a",
"=",
"'F'",
"um_a",
"=",
"'a'",
"letra_a",
"=",
"um_a",
"pron_a",
"=",
"um_a",
"elif",
"i",
"[",
"-",
"1",
"]",
".",
"lower",
"(",
")",
"==",
"'o'",
":",
"gen_a",
"=",
"'M'",
"um_a",
"=",
"''",
"letra_a",
"=",
"'o'",
"pron_a",
"=",
"'e'",
"janela",
".",
"muda_linha",
"(",
"2",
",",
"f' - Gatinh{letra_a}'",
",",
"'ljust'",
")",
"print",
"(",
"janela",
")",
"sleep",
"(",
"1",
")",
"janela",
".",
"muda_linha",
"(",
"4",
",",
"f' Você vai adotar um{um_a} gat{letra_a} (F)ilhote, (A)dult{letra_a} ou (I)dos{letra_a}?',",
" ",
"ljust')",
"",
"print",
"(",
"janela",
")",
"i",
"=",
"input",
"(",
"'>>> '",
")",
"while",
"i",
".",
"lower",
"(",
")",
"!=",
"'f'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'a'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'i'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'filhote'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'adulto'",
"and",
"i",
".",
"lower",
"(",
")",
"!=",
"'idoso'",
":",
"janela",
".",
"muda_linha",
"(",
"5",
",",
"' Digite uma opção válida!', '",
"l",
"ust')",
"",
"print",
"(",
"janela",
")",
"i",
"=",
"input",
"(",
"'>>>'",
")",
"if",
"i",
"[",
"0",
"]",
".",
"lower",
"(",
")",
"==",
"'f'",
":",
"idade",
"=",
"randint",
"(",
"3",
",",
"12",
")",
"janela",
".",
"muda_linha",
"(",
"5",
",",
"' - Filhote'",
",",
"'ljust'",
")",
"elif",
"i",
"[",
"0",
"]",
".",
"lower",
"(",
")",
"==",
"'a'",
":",
"idade",
"=",
"randint",
"(",
"13",
",",
"84",
")",
"janela",
".",
"muda_linha",
"(",
"5",
",",
"f' - Adult{letra_a}'",
",",
"'ljust'",
")",
"elif",
"i",
"[",
"0",
"]",
".",
"lower",
"(",
")",
"==",
"'i'",
":",
"idade",
"=",
"randint",
"(",
"85",
",",
"180",
")",
"janela",
".",
"muda_linha",
"(",
"5",
",",
"f' - Idos{letra_a}'",
",",
"'ljust'",
")",
"print",
"(",
"janela",
")",
"sleep",
"(",
"2",
")",
"janela",
".",
"limpar_janela",
"(",
")",
"janela",
".",
"muda_linha",
"(",
"1",
",",
"f' Você foi até o abrigo e escolheu um{um_a} gatinh{letra_a}.', ",
"'",
"just')",
"",
"janela",
".",
"muda_linha",
"(",
"2",
",",
"f' Ou será que foi el{pron_a} quem te escolheu?',",
" ",
"ljust')",
"",
"fome",
"=",
"randint",
"(",
"60",
",",
"100",
")",
"energia",
"=",
"randint",
"(",
"70",
",",
"100",
")",
"saude",
"=",
"randint",
"(",
"70",
",",
"90",
")",
"feliz",
"=",
"randint",
"(",
"80",
",",
"100",
")",
"vac",
"=",
"choice",
"(",
"[",
"True",
",",
"True",
",",
"True",
",",
"False",
",",
"False",
"]",
")",
"# True: 60%, False: 40%",
"ga",
"=",
"ogato",
".",
"Adotado",
"(",
"''",
",",
"idade",
",",
"fome",
",",
"energia",
",",
"saude",
",",
"feliz",
",",
"gen_a",
",",
"vac",
")",
"print",
"(",
"janela",
")",
"input",
"(",
"'(Aperte ENTER para continuar...)'",
")",
"l",
"=",
"ga",
".",
"gens",
"[",
"'letra'",
"]",
"p",
"=",
"ga",
".",
"gens",
"[",
"'pron'",
"]",
"janela",
".",
"muda_linha",
"(",
"3",
"+",
"v",
",",
"f' Hora de uma decisão difícil... Qual vai ser o nome del{p}?', ",
"'",
"just')",
"",
"print",
"(",
"janela",
")",
"nome",
"=",
"input",
"(",
"'>>> '",
")",
"while",
"not",
"cfunc",
".",
"verificar_nome",
"(",
"nome",
")",
":",
"if",
"cfunc",
".",
"existe_save",
"(",
"nome",
")",
":",
"gatolino",
"=",
"csave",
".",
"carregar_jogo",
"(",
"nome",
")",
"[",
"0",
"]",
"l_antigo",
"=",
"gatolino",
".",
"gens",
"[",
"'letra'",
"]",
"p_antigo",
"=",
"gatolino",
".",
"gens",
"[",
"'pron'",
"]",
"janela",
".",
"muda_linha",
"(",
"4",
"+",
"v",
",",
"f' Ess{p_antigo} gatinh{l_antigo} já existe! Escolha outro nome.',",
" ",
"ljust')",
"",
"else",
":",
"janela",
".",
"muda_linha",
"(",
"4",
"+",
"v",
",",
"' Digite um nome válido (e com tamanho menor que 32)!',",
" ",
"ljust')",
"",
"print",
"(",
"janela",
")",
"nome",
"=",
"input",
"(",
"'>>> '",
")",
"ga",
".",
"nome",
"=",
"nome",
"ge",
"=",
"ogela",
".",
"Geladeira",
"(",
")",
"ba",
"=",
"obau",
".",
"Bau",
"(",
")",
"return",
"ga",
",",
"ge",
",",
"ba"
] | [
129,
4
] | [
304,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_conf | (conf) | return json.load(open(conf_file,"r")) | Verifica se o conf passado por parametro existe. Existindo retorna o conf, caso contrario retorna False.
Keyword arguments:
conf -- nome do arquivo de configuracao sem o ".prod.conf"
| Verifica se o conf passado por parametro existe. Existindo retorna o conf, caso contrario retorna False.
Keyword arguments:
conf -- nome do arquivo de configuracao sem o ".prod.conf"
| def check_conf(conf):
"""Verifica se o conf passado por parametro existe. Existindo retorna o conf, caso contrario retorna False.
Keyword arguments:
conf -- nome do arquivo de configuracao sem o ".prod.conf"
"""
conf_file = "./cnab240/confs/"+conf+".prod.conf"
if(not os.path.isfile(conf_file)):
print ("Arquivo de configuracao passado não encontrado")
return False
return json.load(open(conf_file,"r")) | [
"def",
"check_conf",
"(",
"conf",
")",
":",
"conf_file",
"=",
"\"./cnab240/confs/\"",
"+",
"conf",
"+",
"\".prod.conf\"",
"if",
"(",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"conf_file",
")",
")",
":",
"print",
"(",
"\"Arquivo de configuracao passado não encontrado\")",
"\r",
"return",
"False",
"return",
"json",
".",
"load",
"(",
"open",
"(",
"conf_file",
",",
"\"r\"",
")",
")"
] | [
12,
0
] | [
24,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
BcraLiborScraperTestCase.test_libor_rates_has_values | (self) | Validar la existencia de valores dentro de rates | Validar la existencia de valores dentro de rates | def test_libor_rates_has_values(self):
"""Validar la existencia de valores dentro de rates"""
dict_config = {'libor': {'rates': {}}}
with mock.patch(
'builtins.open',
return_value=io.StringIO(json.dumps(dict_config))
):
with self.assertRaises(InvalidConfigurationError):
config = read_config("config_general.json", "libor")
validate_libor_rates_has_values(config) | [
"def",
"test_libor_rates_has_values",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'libor'",
":",
"{",
"'rates'",
":",
"{",
"}",
"}",
"}",
"with",
"mock",
".",
"patch",
"(",
"'builtins.open'",
",",
"return_value",
"=",
"io",
".",
"StringIO",
"(",
"json",
".",
"dumps",
"(",
"dict_config",
")",
")",
")",
":",
"with",
"self",
".",
"assertRaises",
"(",
"InvalidConfigurationError",
")",
":",
"config",
"=",
"read_config",
"(",
"\"config_general.json\"",
",",
"\"libor\"",
")",
"validate_libor_rates_has_values",
"(",
"config",
")"
] | [
638,
4
] | [
649,
55
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
meanDimensionsBoundingBox | (data) | return w_mean, h_mean | Función para calcular el ancho y alto medio
de las cajas englobantes del conjunto de datos
pasado como parámetro
Args:
data: conjunto de imágenes
Returns:
w_mean: ancho medio de las cajas englobantes
h_mean : altura media de las cajas englobantes
| Función para calcular el ancho y alto medio
de las cajas englobantes del conjunto de datos
pasado como parámetro
Args:
data: conjunto de imágenes
Returns:
w_mean: ancho medio de las cajas englobantes
h_mean : altura media de las cajas englobantes
| def meanDimensionsBoundingBox(data):
""" Función para calcular el ancho y alto medio
de las cajas englobantes del conjunto de datos
pasado como parámetro
Args:
data: conjunto de imágenes
Returns:
w_mean: ancho medio de las cajas englobantes
h_mean : altura media de las cajas englobantes
"""
w_mean, h_mean = 0.0, 0.0
for i in range(data.shape[0]):
x,y,w,h = boundingBox(data[i])
w_mean += w
h_mean += h
w_mean /= data.shape[0]
h_mean /= data.shape[0]
return w_mean, h_mean | [
"def",
"meanDimensionsBoundingBox",
"(",
"data",
")",
":",
"w_mean",
",",
"h_mean",
"=",
"0.0",
",",
"0.0",
"for",
"i",
"in",
"range",
"(",
"data",
".",
"shape",
"[",
"0",
"]",
")",
":",
"x",
",",
"y",
",",
"w",
",",
"h",
"=",
"boundingBox",
"(",
"data",
"[",
"i",
"]",
")",
"w_mean",
"+=",
"w",
"h_mean",
"+=",
"h",
"w_mean",
"/=",
"data",
".",
"shape",
"[",
"0",
"]",
"h_mean",
"/=",
"data",
".",
"shape",
"[",
"0",
"]",
"return",
"w_mean",
",",
"h_mean"
] | [
199,
0
] | [
218,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
coincidencias_elemento | () | return layout | Seccion con cuantas fichas jugar | Seccion con cuantas fichas jugar | def coincidencias_elemento():
""" Seccion con cuantas fichas jugar"""
values = [x for x in range(2, 100)]
layout = [
sg.Text('Coincidencias por elemento: ', font=[theme.FONT, 12], background_color=theme.PRIMARY_COLOR_VARIANT,
pad=(5, 6)),
sg.Spin(values, initial_value=2, key='-COINCIDENCES-', font=[theme.FONT, 12], pad=(5, 6))
]
return layout | [
"def",
"coincidencias_elemento",
"(",
")",
":",
"values",
"=",
"[",
"x",
"for",
"x",
"in",
"range",
"(",
"2",
",",
"100",
")",
"]",
"layout",
"=",
"[",
"sg",
".",
"Text",
"(",
"'Coincidencias por elemento: '",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Spin",
"(",
"values",
",",
"initial_value",
"=",
"2",
",",
"key",
"=",
"'-COINCIDENCES-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
"]",
"return",
"layout"
] | [
33,
0
] | [
43,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
MyDataset.__getitem__ | (self, idx:int) | return {
'input':{
'x':x,
},
'target':{
'y':y,
},
} | Obtiene una muestra desde el dataset completo. Funcion utilizada por la clase DataLoader.
| Obtiene una muestra desde el dataset completo. Funcion utilizada por la clase DataLoader.
| def __getitem__(self, idx:int):
''' Obtiene una muestra desde el dataset completo. Funcion utilizada por la clase DataLoader.
'''
x = self.x[idx] # (N,c,h,w) > (c,h,w)
x = self.norm_item(x) # (c,h,w)
x = self.apply_da(x) # (c,h,w)
y = self.y[idx] # (N) > ()
return {
'input':{
'x':x,
},
'target':{
'y':y,
},
} | [
"def",
"__getitem__",
"(",
"self",
",",
"idx",
":",
"int",
")",
":",
"x",
"=",
"self",
".",
"x",
"[",
"idx",
"]",
"# (N,c,h,w) > (c,h,w)",
"x",
"=",
"self",
".",
"norm_item",
"(",
"x",
")",
"# (c,h,w)",
"x",
"=",
"self",
".",
"apply_da",
"(",
"x",
")",
"# (c,h,w)",
"y",
"=",
"self",
".",
"y",
"[",
"idx",
"]",
"# (N) > ()",
"return",
"{",
"'input'",
":",
"{",
"'x'",
":",
"x",
",",
"}",
",",
"'target'",
":",
"{",
"'y'",
":",
"y",
",",
"}",
",",
"}"
] | [
72,
1
] | [
86,
4
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_inst_generales2 | (t) | instrucciones_generales : temporales | instrucciones_generales : temporales | def p_inst_generales2(t):
'''instrucciones_generales : temporales'''
arr = []
arr1 = []
arr1.append('encabezado')
arr1.append(t[1])
arr.append(arr1)
t[0] = arr | [
"def",
"p_inst_generales2",
"(",
"t",
")",
":",
"arr",
"=",
"[",
"]",
"arr1",
"=",
"[",
"]",
"arr1",
".",
"append",
"(",
"'encabezado'",
")",
"arr1",
".",
"append",
"(",
"t",
"[",
"1",
"]",
")",
"arr",
".",
"append",
"(",
"arr1",
")",
"t",
"[",
"0",
"]",
"=",
"arr"
] | [
2284,
0
] | [
2292,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
es_primo | (n: int) | return True | Determina si el número es primo o no.
:param n: Número a verificar
:type n: int
:returns: True si es primo, False si no lo es
:rtype: bool
>>> es_primo_(2)
True
>>> es_primo_(1)
False
| Determina si el número es primo o no. | def es_primo(n: int) -> bool:
"""Determina si el número es primo o no.
:param n: Número a verificar
:type n: int
:returns: True si es primo, False si no lo es
:rtype: bool
>>> es_primo_(2)
True
>>> es_primo_(1)
False
"""
if n == 2 or n == 3:
return True
if n % 2 == 0 or n < 2:
return False
for i in range(3, int(n**0.5)+1, 2):
if n % i == 0:
return False
return True | [
"def",
"es_primo",
"(",
"n",
":",
"int",
")",
"->",
"bool",
":",
"if",
"n",
"==",
"2",
"or",
"n",
"==",
"3",
":",
"return",
"True",
"if",
"n",
"%",
"2",
"==",
"0",
"or",
"n",
"<",
"2",
":",
"return",
"False",
"for",
"i",
"in",
"range",
"(",
"3",
",",
"int",
"(",
"n",
"**",
"0.5",
")",
"+",
"1",
",",
"2",
")",
":",
"if",
"n",
"%",
"i",
"==",
"0",
":",
"return",
"False",
"return",
"True"
] | [
20,
0
] | [
40,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sumatoria_cuadrados | (n: int) | Calcula la sumatoria de los cuadrados desde 1 hasta n.
:param n: número hasta el que se calcula la sumatoria.
:n type: int
:return: sumatoria de los cuadrados desde 1 hasta n.
:rtype: int
| Calcula la sumatoria de los cuadrados desde 1 hasta n. | def sumatoria_cuadrados(n: int) -> int:
"""Calcula la sumatoria de los cuadrados desde 1 hasta n.
:param n: número hasta el que se calcula la sumatoria.
:n type: int
:return: sumatoria de los cuadrados desde 1 hasta n.
:rtype: int
"""
if n == 1:
return 1
else:
return n**2 + sumatoria_cuadrados(n-1) | [
"def",
"sumatoria_cuadrados",
"(",
"n",
":",
"int",
")",
"->",
"int",
":",
"if",
"n",
"==",
"1",
":",
"return",
"1",
"else",
":",
"return",
"n",
"**",
"2",
"+",
"sumatoria_cuadrados",
"(",
"n",
"-",
"1",
")"
] | [
8,
0
] | [
19,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
fun_EnviarCorreo | (envio, correo=None, paraserver=1) | return ennvio | Arg: correo, si tiene texto este es el correo a enviar... | Arg: correo, si tiene texto este es el correo a enviar... | def fun_EnviarCorreo(envio, correo=None, paraserver=1):
'''Arg: correo, si tiene texto este es el correo a enviar...'''
from gluon.tools import Mail
from os.path import join as UNIR
print ('fun_EnviarCorreo:',correo, paraserver)
mail = Mail()
servercorreo=db(db.tbl_parametros.id_modulo==paraserver).select().first()
if not servercorreo:
print ("Error no esta especificado en parametros el modulo {}".format(paraserver))
return 0
# print ("EnviarCorreo")
# print ("Servidor", servercorreo)
# print ("Sitio",envio)
# print ("="*80)
mail.settings.server = '{}:{}'.format(servercorreo.servidor_correo,servercorreo.puerto) #'smtp.gmail.com:587'
mail.settings.login = '{}:{}'.format(servercorreo.usuario, servercorreo.password) #'[email protected]:Maquitodo2019'
mail.settings.tls = servercorreo.tls #True
mail.settings.sender = servercorreo.enviado_por #'[email protected]'
consulta=db(db.tbl_recepcion.id==envio).select().first()
print ("fun_EnviarCorreo",envio,consulta)
if not consulta: return 0
consulta.estado="Q"
consulta.fechaenvio=request.now
consulta.update_record()
db.commit()
copia=[]
if correo:
correo=[correo]
else:
correo=[consulta.id_cliente.correo1]
if consulta.id_cliente.correo2:
copia.append(consulta.id_cliente.correo2)
if consulta.id_cliente.correo3:
copia.append(consulta.id_cliente.correo3)
archpdf=UNIR(request.folder,"static",consulta.rutapdf)
#Arreglo a Windows
archpdf=archpdf.replace("\\","/")
print ("envio:",correo,archpdf)
ennvio = mail.send( to=correo,
cc=copia,
subject= servercorreo.asunto, #'comporbante de pago',
reply_to=servercorreo.devolver if servercorreo.devolver else "", #'[email protected]',
message=(servercorreo.cuerpo.format(consulta.valor),
servercorreo.cuerpohtml.format(consulta.valor)),
attachments = [
mail.Attachment(archpdf),
# mail.Attachment('/home/marco/workspace/virtualenv3/web2py/web2py/applications/siendo/static/images/logo.png',
# content_id='foto')
]
)
if ennvio:
consulta.estado="T"
consulta.fechaenvio=request.now
consulta.update_record()
db.commit()
return ennvio | [
"def",
"fun_EnviarCorreo",
"(",
"envio",
",",
"correo",
"=",
"None",
",",
"paraserver",
"=",
"1",
")",
":",
"from",
"gluon",
".",
"tools",
"import",
"Mail",
"from",
"os",
".",
"path",
"import",
"join",
"as",
"UNIR",
"print",
"(",
"'fun_EnviarCorreo:'",
",",
"correo",
",",
"paraserver",
")",
"mail",
"=",
"Mail",
"(",
")",
"servercorreo",
"=",
"db",
"(",
"db",
".",
"tbl_parametros",
".",
"id_modulo",
"==",
"paraserver",
")",
".",
"select",
"(",
")",
".",
"first",
"(",
")",
"if",
"not",
"servercorreo",
":",
"print",
"(",
"\"Error no esta especificado en parametros el modulo {}\"",
".",
"format",
"(",
"paraserver",
")",
")",
"return",
"0",
"# print (\"EnviarCorreo\")",
"# print (\"Servidor\", servercorreo)",
"# print (\"Sitio\",envio)",
"# print (\"=\"*80)",
"mail",
".",
"settings",
".",
"server",
"=",
"'{}:{}'",
".",
"format",
"(",
"servercorreo",
".",
"servidor_correo",
",",
"servercorreo",
".",
"puerto",
")",
"#'smtp.gmail.com:587'",
"mail",
".",
"settings",
".",
"login",
"=",
"'{}:{}'",
".",
"format",
"(",
"servercorreo",
".",
"usuario",
",",
"servercorreo",
".",
"password",
")",
"#'[email protected]:Maquitodo2019'",
"mail",
".",
"settings",
".",
"tls",
"=",
"servercorreo",
".",
"tls",
"#True",
"mail",
".",
"settings",
".",
"sender",
"=",
"servercorreo",
".",
"enviado_por",
"#'[email protected]'",
"consulta",
"=",
"db",
"(",
"db",
".",
"tbl_recepcion",
".",
"id",
"==",
"envio",
")",
".",
"select",
"(",
")",
".",
"first",
"(",
")",
"print",
"(",
"\"fun_EnviarCorreo\"",
",",
"envio",
",",
"consulta",
")",
"if",
"not",
"consulta",
":",
"return",
"0",
"consulta",
".",
"estado",
"=",
"\"Q\"",
"consulta",
".",
"fechaenvio",
"=",
"request",
".",
"now",
"consulta",
".",
"update_record",
"(",
")",
"db",
".",
"commit",
"(",
")",
"copia",
"=",
"[",
"]",
"if",
"correo",
":",
"correo",
"=",
"[",
"correo",
"]",
"else",
":",
"correo",
"=",
"[",
"consulta",
".",
"id_cliente",
".",
"correo1",
"]",
"if",
"consulta",
".",
"id_cliente",
".",
"correo2",
":",
"copia",
".",
"append",
"(",
"consulta",
".",
"id_cliente",
".",
"correo2",
")",
"if",
"consulta",
".",
"id_cliente",
".",
"correo3",
":",
"copia",
".",
"append",
"(",
"consulta",
".",
"id_cliente",
".",
"correo3",
")",
"archpdf",
"=",
"UNIR",
"(",
"request",
".",
"folder",
",",
"\"static\"",
",",
"consulta",
".",
"rutapdf",
")",
"#Arreglo a Windows",
"archpdf",
"=",
"archpdf",
".",
"replace",
"(",
"\"\\\\\"",
",",
"\"/\"",
")",
"print",
"(",
"\"envio:\"",
",",
"correo",
",",
"archpdf",
")",
"ennvio",
"=",
"mail",
".",
"send",
"(",
"to",
"=",
"correo",
",",
"cc",
"=",
"copia",
",",
"subject",
"=",
"servercorreo",
".",
"asunto",
",",
"#'comporbante de pago',",
"reply_to",
"=",
"servercorreo",
".",
"devolver",
"if",
"servercorreo",
".",
"devolver",
"else",
"\"\"",
",",
"#'[email protected]',",
"message",
"=",
"(",
"servercorreo",
".",
"cuerpo",
".",
"format",
"(",
"consulta",
".",
"valor",
")",
",",
"servercorreo",
".",
"cuerpohtml",
".",
"format",
"(",
"consulta",
".",
"valor",
")",
")",
",",
"attachments",
"=",
"[",
"mail",
".",
"Attachment",
"(",
"archpdf",
")",
",",
"# mail.Attachment('/home/marco/workspace/virtualenv3/web2py/web2py/applications/siendo/static/images/logo.png',",
"# content_id='foto')",
"]",
")",
"if",
"ennvio",
":",
"consulta",
".",
"estado",
"=",
"\"T\"",
"consulta",
".",
"fechaenvio",
"=",
"request",
".",
"now",
"consulta",
".",
"update_record",
"(",
")",
"db",
".",
"commit",
"(",
")",
"return",
"ennvio"
] | [
260,
0
] | [
324,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_metodos2 | (t) | METODOS : id para EXP parc
| METODOS : id para EXP parc
| def p_metodos2(t):
'''METODOS : id para EXP parc
'''
print("METODOS") | [
"def",
"p_metodos2",
"(",
"t",
")",
":",
"print",
"(",
"\"METODOS\"",
")"
] | [
297,
0
] | [
300,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
operaciones | (a=1, b=1) | return [a+b, a-b, a*b, a/b] | [Realiza todas las operaciones]
Args:
a (int, optional): [description]. Defaults to 1.
b (int, optional): [description]. Defaults to 1.
Returns:
[int, float]: [description]
| [Realiza todas las operaciones]
Args:
a (int, optional): [description]. Defaults to 1.
b (int, optional): [description]. Defaults to 1.
Returns:
[int, float]: [description]
| def operaciones(a=1, b=1) -> list:
"""[Realiza todas las operaciones]
Args:
a (int, optional): [description]. Defaults to 1.
b (int, optional): [description]. Defaults to 1.
Returns:
[int, float]: [description]
"""
print("Proceso terminado")
return [a+b, a-b, a*b, a/b] | [
"def",
"operaciones",
"(",
"a",
"=",
"1",
",",
"b",
"=",
"1",
")",
"->",
"list",
":",
"print",
"(",
"\"Proceso terminado\"",
")",
"return",
"[",
"a",
"+",
"b",
",",
"a",
"-",
"b",
",",
"a",
"*",
"b",
",",
"a",
"/",
"b",
"]"
] | [
1,
0
] | [
12,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DNARecord.gc_content | (self) | return gc_cont/(at_cont+gc_cont) | Obtiene el contenido de GC. | Obtiene el contenido de GC. | def gc_content(self):
"""Obtiene el contenido de GC."""
# Obtener cantidad de AT y GC
at_cont = self.seq.count('A') + self.seq.count('T')
gc_cont = self.seq.count('G') + self.seq.count('C')
return gc_cont/(at_cont+gc_cont) | [
"def",
"gc_content",
"(",
"self",
")",
":",
"# Obtener cantidad de AT y GC",
"at_cont",
"=",
"self",
".",
"seq",
".",
"count",
"(",
"'A'",
")",
"+",
"self",
".",
"seq",
".",
"count",
"(",
"'T'",
")",
"gc_cont",
"=",
"self",
".",
"seq",
".",
"count",
"(",
"'G'",
")",
"+",
"self",
".",
"seq",
".",
"count",
"(",
"'C'",
")",
"return",
"gc_cont",
"/",
"(",
"at_cont",
"+",
"gc_cont",
")"
] | [
126,
4
] | [
131,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ingresar_numero | (min_: int, max_: int, indicacion: str) | Pide un numero y lo devuelve.
:param min_: numero minimo
:min_ type: int
:param max_: numero maximo
:max_ type: int
:param indicacion: indicacion para el usuario
:indicacion type: str
:return: numero ingresado
:rtype: int
| Pide un numero y lo devuelve. | def ingresar_numero(min_: int, max_: int, indicacion: str) -> int:
"""Pide un numero y lo devuelve.
:param min_: numero minimo
:min_ type: int
:param max_: numero maximo
:max_ type: int
:param indicacion: indicacion para el usuario
:indicacion type: str
:return: numero ingresado
:rtype: int
"""
while True:
try:
numero = int(input(indicacion))
except ValueError:
print("El valor ingresado no es valido.")
continue
if numero < min_ or numero > max_:
print("El valor ingresado no es valido.")
continue
return numero | [
"def",
"ingresar_numero",
"(",
"min_",
":",
"int",
",",
"max_",
":",
"int",
",",
"indicacion",
":",
"str",
")",
"->",
"int",
":",
"while",
"True",
":",
"try",
":",
"numero",
"=",
"int",
"(",
"input",
"(",
"indicacion",
")",
")",
"except",
"ValueError",
":",
"print",
"(",
"\"El valor ingresado no es valido.\"",
")",
"continue",
"if",
"numero",
"<",
"min_",
"or",
"numero",
">",
"max_",
":",
"print",
"(",
"\"El valor ingresado no es valido.\"",
")",
"continue",
"return",
"numero"
] | [
9,
0
] | [
30,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
saludo | (update, context) | Manda un mensaje cuando el usuario ingresa /saludo | Manda un mensaje cuando el usuario ingresa /saludo | def saludo(update, context):
"""Manda un mensaje cuando el usuario ingresa /saludo """
update.message.reply_text('Hola! Soy el BOT de Análisis Matemático! Sirvo como un ayuda-memoria para la cursada')
update.message.reply_text('Estoy desarrollado por estudiantes de la universidad, no soy una herramienta oficial de la misma ni de la cátedra de Análisis Matemático.')
update.message.reply_text('Para más información, revisá [mi repositorio en github](https://github.com/matiasnoriega/bot-telegram-analisis)', parse_mode='MarkdownV2') | [
"def",
"saludo",
"(",
"update",
",",
"context",
")",
":",
"update",
".",
"message",
".",
"reply_text",
"(",
"'Hola! Soy el BOT de Análisis Matemático! Sirvo como un ayuda-memoria para la cursada')",
"",
"update",
".",
"message",
".",
"reply_text",
"(",
"'Estoy desarrollado por estudiantes de la universidad, no soy una herramienta oficial de la misma ni de la cátedra de Análisis Matemático.')",
"",
"update",
".",
"message",
".",
"reply_text",
"(",
"'Para más información, revisá [mi repositorio en github](https://github.com/matiasnoriega/bot-telegram-analisis)', p",
"a",
"se_mode='M",
"a",
"rkdownV2')",
""
] | [
20,
0
] | [
24,
172
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DominioAGTSP.generar_n | (self, n) | return soluciones | Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n listas, cada una representando
una posible solución al problema modelado por el objeto de dominio.
| Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema. | def generar_n(self, n):
"""Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n listas, cada una representando
una posible solución al problema modelado por el objeto de dominio.
"""
# IMPLEMENTACION
soluciones = []
for i in range(n):
soluciones.append(DominioTSP.generar(self))
return soluciones | [
"def",
"generar_n",
"(",
"self",
",",
"n",
")",
":",
"# IMPLEMENTACION",
"soluciones",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"soluciones",
".",
"append",
"(",
"DominioTSP",
".",
"generar",
"(",
"self",
")",
")",
"return",
"soluciones"
] | [
47,
4
] | [
64,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
IceCreamStand.show_flavors | (self) | Mostrar los sabores disponibles | Mostrar los sabores disponibles | def show_flavors(self):
"""Mostrar los sabores disponibles"""
print("\nSabores disponibles:")
for flavor in self.flavors:
print("- " + flavor.title()) | [
"def",
"show_flavors",
"(",
"self",
")",
":",
"print",
"(",
"\"\\nSabores disponibles:\"",
")",
"for",
"flavor",
"in",
"self",
".",
"flavors",
":",
"print",
"(",
"\"- \"",
"+",
"flavor",
".",
"title",
"(",
")",
")"
] | [
39,
4
] | [
43,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResult.mean_velocity | (self) | return FloatVector2D(*np.array(self.velocities).mean(axis=0)) | Calcula el vector de velocidad media.
:return: vector de velocidad media.
| Calcula el vector de velocidad media. | def mean_velocity(self) -> FloatVector2D:
"""Calcula el vector de velocidad media.
:return: vector de velocidad media.
"""
if len(self.velocities) == 0:
return FloatVector2D(0., 0.)
return FloatVector2D(*np.array(self.velocities).mean(axis=0)) | [
"def",
"mean_velocity",
"(",
"self",
")",
"->",
"FloatVector2D",
":",
"if",
"len",
"(",
"self",
".",
"velocities",
")",
"==",
"0",
":",
"return",
"FloatVector2D",
"(",
"0.",
",",
"0.",
")",
"return",
"FloatVector2D",
"(",
"*",
"np",
".",
"array",
"(",
"self",
".",
"velocities",
")",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
")"
] | [
31,
4
] | [
38,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ProcControl.create | (
self,
function: Callable[..., Any],
start: bool = True,
*args,
target: Optional[str] = None,
**kwargs
) | return targetObj.name | Crea un nuevo procedimiento
Dependiendo del objetivo usado, creará un proceso en paralelo o subproceso.
Args:
function:
Debe ser una función y debe poder ser invocada
start:
Al terminar de agregarla, **True** para invocarla, **False** si no.
*args:
Los argumentos variables usado por el objetivo.
Los cuales pueden ser `TheadSafe` o `multiprocessing.Process`
dependiendo de cómo esté configurado.
target:
Decide si ejecutarlo como un proceso o un subproceso.
Esta opción inválida la opción global definida por
`setTarget()` y no lo modifica.
**kwargs:
Los argumentos claves variables usados por el objetivo.
Returns:
El nombre del subproceso o proceso.
Raises:
ValueError: Cuando ya existe un nombre del subproceso o proceso.
TypeError: La función o el objeto a llamar no puede ser invocado
| Crea un nuevo procedimiento | def create(
self,
function: Callable[..., Any],
start: bool = True,
*args,
target: Optional[str] = None,
**kwargs
) -> str:
"""Crea un nuevo procedimiento
Dependiendo del objetivo usado, creará un proceso en paralelo o subproceso.
Args:
function:
Debe ser una función y debe poder ser invocada
start:
Al terminar de agregarla, **True** para invocarla, **False** si no.
*args:
Los argumentos variables usado por el objetivo.
Los cuales pueden ser `TheadSafe` o `multiprocessing.Process`
dependiendo de cómo esté configurado.
target:
Decide si ejecutarlo como un proceso o un subproceso.
Esta opción inválida la opción global definida por
`setTarget()` y no lo modifica.
**kwargs:
Los argumentos claves variables usados por el objetivo.
Returns:
El nombre del subproceso o proceso.
Raises:
ValueError: Cuando ya existe un nombre del subproceso o proceso.
TypeError: La función o el objeto a llamar no puede ser invocado
"""
if not (callable(function)):
raise TypeError(_("La función no puede ser llamada"))
target = self._get_target_name(target)
targetObj = self._get_target(target)(
*args, target=function, **kwargs
)
procs = super().__getitem__(target)
if (targetObj.name in procs):
raise ValueError(_("%s ya existe") % (targetObj.name))
if (start):
targetObj.start()
procs[targetObj.name] = targetObj
return targetObj.name | [
"def",
"create",
"(",
"self",
",",
"function",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
",",
"start",
":",
"bool",
"=",
"True",
",",
"*",
"args",
",",
"target",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
"->",
"str",
":",
"if",
"not",
"(",
"callable",
"(",
"function",
")",
")",
":",
"raise",
"TypeError",
"(",
"_",
"(",
"\"La función no puede ser llamada\")",
")",
"",
"target",
"=",
"self",
".",
"_get_target_name",
"(",
"target",
")",
"targetObj",
"=",
"self",
".",
"_get_target",
"(",
"target",
")",
"(",
"*",
"args",
",",
"target",
"=",
"function",
",",
"*",
"*",
"kwargs",
")",
"procs",
"=",
"super",
"(",
")",
".",
"__getitem__",
"(",
"target",
")",
"if",
"(",
"targetObj",
".",
"name",
"in",
"procs",
")",
":",
"raise",
"ValueError",
"(",
"_",
"(",
"\"%s ya existe\"",
")",
"%",
"(",
"targetObj",
".",
"name",
")",
")",
"if",
"(",
"start",
")",
":",
"targetObj",
".",
"start",
"(",
")",
"procs",
"[",
"targetObj",
".",
"name",
"]",
"=",
"targetObj",
"return",
"targetObj",
".",
"name"
] | [
116,
4
] | [
177,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AccountPayment._onchange_currency | (self) | return False | Anulamos metodo nativo que pisa el monto remanente que pasamos
por contexto TODO ver si podemos re-incorporar esto y hasta extender
_compute_payment_amount para que el monto se calcule bien aun usando
el save and new | Anulamos metodo nativo que pisa el monto remanente que pasamos
por contexto TODO ver si podemos re-incorporar esto y hasta extender
_compute_payment_amount para que el monto se calcule bien aun usando
el save and new | def _onchange_currency(self):
""" Anulamos metodo nativo que pisa el monto remanente que pasamos
por contexto TODO ver si podemos re-incorporar esto y hasta extender
_compute_payment_amount para que el monto se calcule bien aun usando
el save and new"""
return False | [
"def",
"_onchange_currency",
"(",
"self",
")",
":",
"return",
"False"
] | [
110,
4
] | [
115,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_service | (
file: str,
autoreload: bool = False,
basename: bool = False,
only_name: bool = False
) | Importa un archivo de python jutno con información relevante
Args:
file:
La ruta del archivo a importar
autoreload:
**True** para autorecargar el módulo al ser modificado.
Tiene que estar habilitado con `tornado.autoreload.start()`
basename:
Usar el nombre del servicio y no su ruta completa
only_name:
**True** para mostrar solo el nombre.
Esta opción no carga el archivo en memoria, simplemente busca
y parsea el nombre.
Returns:
Una tupla con la información extraida
| Importa un archivo de python jutno con información relevante | def get_service(
file: str,
autoreload: bool = False,
basename: bool = False,
only_name: bool = False
) -> Tuple[str, object]:
"""Importa un archivo de python jutno con información relevante
Args:
file:
La ruta del archivo a importar
autoreload:
**True** para autorecargar el módulo al ser modificado.
Tiene que estar habilitado con `tornado.autoreload.start()`
basename:
Usar el nombre del servicio y no su ruta completa
only_name:
**True** para mostrar solo el nombre.
Esta opción no carga el archivo en memoria, simplemente busca
y parsea el nombre.
Returns:
Una tupla con la información extraida
"""
result = get_module(file, return_name=True, only_name=only_name)
if not (only_name):
(service_name, service_object) = result
if (basename):
service_name = os.path.basename(service_name)
return (service_name, service_object)
else:
if (basename):
result = os.path.basename(result)
return result | [
"def",
"get_service",
"(",
"file",
":",
"str",
",",
"autoreload",
":",
"bool",
"=",
"False",
",",
"basename",
":",
"bool",
"=",
"False",
",",
"only_name",
":",
"bool",
"=",
"False",
")",
"->",
"Tuple",
"[",
"str",
",",
"object",
"]",
":",
"result",
"=",
"get_module",
"(",
"file",
",",
"return_name",
"=",
"True",
",",
"only_name",
"=",
"only_name",
")",
"if",
"not",
"(",
"only_name",
")",
":",
"(",
"service_name",
",",
"service_object",
")",
"=",
"result",
"if",
"(",
"basename",
")",
":",
"service_name",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"service_name",
")",
"return",
"(",
"service_name",
",",
"service_object",
")",
"else",
":",
"if",
"(",
"basename",
")",
":",
"result",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"result",
")",
"return",
"result"
] | [
141,
0
] | [
184,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones60 | (p) | funciones : PIPE tipo_numero | funciones : PIPE tipo_numero | def p_funciones60(p):
'funciones : PIPE tipo_numero' | [
"def",
"p_funciones60",
"(",
"p",
")",
":"
] | [
478,
0
] | [
479,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
GraphNanopub.__json_html | (self) | return {
"@prefixs": list(
map((lambda prefix: format_text_to_html(prefix)), prefixs)
),
"@assertion": format_text_to_html(assertion.group(0)),
"@provenance": format_text_to_html(provenance.group(0)),
"@pubInfo": format_text_to_html(pub_info.group(0)),
"@Head": format_text_to_html(head.group(0)),
"exact": nanopub_trig,
} | realiza el proceso de serializacion de la nanopublicacion en un formato 'json-html'
en el cual cada componente de la nanopublicacion esta separada por una en un formato json
para presentar esta en html\n
{
\n
'@prefixs': list
'@assertion': list
'@provenance': list
'@pubInfo': list
'@Head': list
'exact': str
\n
}
| realiza el proceso de serializacion de la nanopublicacion en un formato 'json-html'
en el cual cada componente de la nanopublicacion esta separada por una en un formato json
para presentar esta en html\n
{
\n
' | def __json_html(self):
"""realiza el proceso de serializacion de la nanopublicacion en un formato 'json-html'
en el cual cada componente de la nanopublicacion esta separada por una en un formato json
para presentar esta en html\n
{
\n
'@prefixs': list
'@assertion': list
'@provenance': list
'@pubInfo': list
'@Head': list
'exact': str
\n
}
"""
nanopub_trig = self.serialize("trig")
prefixs = re.findall(r"\@prefix(.*).", nanopub_trig)
assertion = re.search(r":assertion {.*?\}\n", nanopub_trig, re.DOTALL)
provenance = re.search(r":provenance {.*?\}\n", nanopub_trig, re.DOTALL)
pub_info = re.search(r":pubInfo {.*?\}\n", nanopub_trig, re.DOTALL)
head = re.search(r":Head {.*?\}\n", nanopub_trig, re.DOTALL)
return {
"@prefixs": list(
map((lambda prefix: format_text_to_html(prefix)), prefixs)
),
"@assertion": format_text_to_html(assertion.group(0)),
"@provenance": format_text_to_html(provenance.group(0)),
"@pubInfo": format_text_to_html(pub_info.group(0)),
"@Head": format_text_to_html(head.group(0)),
"exact": nanopub_trig,
} | [
"def",
"__json_html",
"(",
"self",
")",
":",
"nanopub_trig",
"=",
"self",
".",
"serialize",
"(",
"\"trig\"",
")",
"prefixs",
"=",
"re",
".",
"findall",
"(",
"r\"\\@prefix(.*).\"",
",",
"nanopub_trig",
")",
"assertion",
"=",
"re",
".",
"search",
"(",
"r\":assertion {.*?\\}\\n\"",
",",
"nanopub_trig",
",",
"re",
".",
"DOTALL",
")",
"provenance",
"=",
"re",
".",
"search",
"(",
"r\":provenance {.*?\\}\\n\"",
",",
"nanopub_trig",
",",
"re",
".",
"DOTALL",
")",
"pub_info",
"=",
"re",
".",
"search",
"(",
"r\":pubInfo {.*?\\}\\n\"",
",",
"nanopub_trig",
",",
"re",
".",
"DOTALL",
")",
"head",
"=",
"re",
".",
"search",
"(",
"r\":Head {.*?\\}\\n\"",
",",
"nanopub_trig",
",",
"re",
".",
"DOTALL",
")",
"return",
"{",
"\"@prefixs\"",
":",
"list",
"(",
"map",
"(",
"(",
"lambda",
"prefix",
":",
"format_text_to_html",
"(",
"prefix",
")",
")",
",",
"prefixs",
")",
")",
",",
"\"@assertion\"",
":",
"format_text_to_html",
"(",
"assertion",
".",
"group",
"(",
"0",
")",
")",
",",
"\"@provenance\"",
":",
"format_text_to_html",
"(",
"provenance",
".",
"group",
"(",
"0",
")",
")",
",",
"\"@pubInfo\"",
":",
"format_text_to_html",
"(",
"pub_info",
".",
"group",
"(",
"0",
")",
")",
",",
"\"@Head\"",
":",
"format_text_to_html",
"(",
"head",
".",
"group",
"(",
"0",
")",
")",
",",
"\"exact\"",
":",
"nanopub_trig",
",",
"}"
] | [
135,
4
] | [
165,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones40 | (p) | funciones : DEGREES PABRE expresion PCIERRA | funciones : DEGREES PABRE expresion PCIERRA | def p_funciones40(p):
'funciones : DEGREES PABRE expresion PCIERRA' | [
"def",
"p_funciones40",
"(",
"p",
")",
":"
] | [
418,
0
] | [
419,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cars_path | () | return os.path.join(DATASETS_PATH, 'cars.csv') | path de los autos | path de los autos | def cars_path():
"""path de los autos"""
return os.path.join(DATASETS_PATH, 'cars.csv') | [
"def",
"cars_path",
"(",
")",
":",
"return",
"os",
".",
"path",
".",
"join",
"(",
"DATASETS_PATH",
",",
"'cars.csv'",
")"
] | [
12,
0
] | [
14,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_crear_procedure | (t) | crear : CREATE reemplazar PROCEDURE ID PAR_A lparametros PAR_C lenguaje_funcion AS dollar_var cuerpo_funcion dollar_var | crear : CREATE reemplazar PROCEDURE ID PAR_A lparametros PAR_C lenguaje_funcion AS dollar_var cuerpo_funcion dollar_var | def p_crear_procedure(t):
'''crear : CREATE reemplazar PROCEDURE ID PAR_A lparametros PAR_C lenguaje_funcion AS dollar_var cuerpo_funcion dollar_var'''
t[0] = Procedimiento(t[2],t[4],t[6],t[11]) | [
"def",
"p_crear_procedure",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Procedimiento",
"(",
"t",
"[",
"2",
"]",
",",
"t",
"[",
"4",
"]",
",",
"t",
"[",
"6",
"]",
",",
"t",
"[",
"11",
"]",
")"
] | [
1386,
0
] | [
1388,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Dominio.fcosto | (self, sol) | Calcula el costo asociado con una solución dada.
Entradas:
sol (estructura de datos)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
| Calcula el costo asociado con una solución dada. | def fcosto(self, sol):
"""Calcula el costo asociado con una solución dada.
Entradas:
sol (estructura de datos)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
"""
pass | [
"def",
"fcosto",
"(",
"self",
",",
"sol",
")",
":",
"pass"
] | [
42,
4
] | [
53,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_condiciones_recursivo | (t) | condiciones : condiciones comparacionlogica condiciones | condiciones : condiciones comparacionlogica condiciones | def p_condiciones_recursivo(t):
'condiciones : condiciones comparacionlogica condiciones'
t[0] = logic.Logicas(t[1], t[3], t[2]) | [
"def",
"p_condiciones_recursivo",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"logic",
".",
"Logicas",
"(",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"3",
"]",
",",
"t",
"[",
"2",
"]",
")"
] | [
972,
0
] | [
974,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
OptimizedResultsExtractor.scrap | (self) | return places_found | Función principal que se encargará de acceder a una url de búsqueda por código postal y tipos de locales y
navegar por las distintas páginas de resultados extrayendo los nombres de los locales comerciales.
Returns
-------
dict
devuelve un diccionario cuyas claves son los nombres de los locales y cuyos valores son las urls para cada
nombre de local comercial
| Función principal que se encargará de acceder a una url de búsqueda por código postal y tipos de locales y
navegar por las distintas páginas de resultados extrayendo los nombres de los locales comerciales. | def scrap(self):
"""Función principal que se encargará de acceder a una url de búsqueda por código postal y tipos de locales y
navegar por las distintas páginas de resultados extrayendo los nombres de los locales comerciales.
Returns
-------
dict
devuelve un diccionario cuyas claves son los nombres de los locales y cuyos valores son las urls para cada
nombre de local comercial
"""
driver = self.get_driver()
places_found = []
total_time = 0
try:
# se accede a la url de búsqueda de resultados para un código postal teniendo ya añadido los tipos de
# locales que se quieren buscar.
driver.get(self._results_url)
for n_page in range(self._num_pages):
init_page_time = time.time()
self.logger.info("-{postal_code}-: page number: -{n_page}-".format(
postal_code=self._postal_code, n_page=n_page))
driver.wait.until(
ec.presence_of_all_elements_located((By.XPATH, self._places_element_xpath_query))
)
self.force_sleep(self.sleep_m)
# Se extraen los nombres de los locales encontrados en los resultados y se generan dinámicamente las
# urls de acceso directo para cada uno de estos locales.
page_elements = driver.find_elements_by_xpath(self._places_element_xpath_query)
# se actualiza el listado de resultados con el par nombre-url. Se usa un diccionario para evitar
# posibles duplicados
places_found += [self.get_basic_info(result) for result in page_elements]
# si existe botón de de siguiente página, se intenta seguir, en caso contrario, se sale del bucle
next_button = self.get_info_obj(self._next_button_xpath)
if next_button:
driver.execute_script("arguments[0].click();", next_button)
driver.wait.until(ec.url_changes(driver.current_url))
else:
self.logger.warning("-{postal_code}-: next page not found...something went wrong. aborting bucle")
break
end_page_time = time.time()
elapsed = int(end_page_time - init_page_time)
total_time += elapsed
self.logger.debug(
"-{postal_code}-: iteration -{it_number}- was executed in: -{elapsed}- seconds".format(
postal_code=self._postal_code, it_number=n_page, elapsed=elapsed))
except Exception as e:
self.logger.error("-{postal_code}-: something went wrong during places names and url extraction".format(
postal_code=self._postal_code))
self.logger.warning("-{postal_code}-: found {total} places".format(postal_code=self._postal_code,
total=len(places_found)))
self.logger.error(e)
self.logger.error(str(e))
finally:
self.finish()
self.logger.info("-{postal_code}-: found {total} places".format(postal_code=self._postal_code,
total=len(places_found)))
self.logger.info("-{postal_code}-: total time elapsed: -{elapsed}- seconds".format(
postal_code=self._postal_code, elapsed=total_time))
return places_found | [
"def",
"scrap",
"(",
"self",
")",
":",
"driver",
"=",
"self",
".",
"get_driver",
"(",
")",
"places_found",
"=",
"[",
"]",
"total_time",
"=",
"0",
"try",
":",
"# se accede a la url de búsqueda de resultados para un código postal teniendo ya añadido los tipos de",
"# locales que se quieren buscar.",
"driver",
".",
"get",
"(",
"self",
".",
"_results_url",
")",
"for",
"n_page",
"in",
"range",
"(",
"self",
".",
"_num_pages",
")",
":",
"init_page_time",
"=",
"time",
".",
"time",
"(",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: page number: -{n_page}-\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"n_page",
"=",
"n_page",
")",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"presence_of_all_elements_located",
"(",
"(",
"By",
".",
"XPATH",
",",
"self",
".",
"_places_element_xpath_query",
")",
")",
")",
"self",
".",
"force_sleep",
"(",
"self",
".",
"sleep_m",
")",
"# Se extraen los nombres de los locales encontrados en los resultados y se generan dinámicamente las",
"# urls de acceso directo para cada uno de estos locales.",
"page_elements",
"=",
"driver",
".",
"find_elements_by_xpath",
"(",
"self",
".",
"_places_element_xpath_query",
")",
"# se actualiza el listado de resultados con el par nombre-url. Se usa un diccionario para evitar",
"# posibles duplicados",
"places_found",
"+=",
"[",
"self",
".",
"get_basic_info",
"(",
"result",
")",
"for",
"result",
"in",
"page_elements",
"]",
"# si existe botón de de siguiente página, se intenta seguir, en caso contrario, se sale del bucle",
"next_button",
"=",
"self",
".",
"get_info_obj",
"(",
"self",
".",
"_next_button_xpath",
")",
"if",
"next_button",
":",
"driver",
".",
"execute_script",
"(",
"\"arguments[0].click();\"",
",",
"next_button",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"url_changes",
"(",
"driver",
".",
"current_url",
")",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{postal_code}-: next page not found...something went wrong. aborting bucle\"",
")",
"break",
"end_page_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed",
"=",
"int",
"(",
"end_page_time",
"-",
"init_page_time",
")",
"total_time",
"+=",
"elapsed",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: iteration -{it_number}- was executed in: -{elapsed}- seconds\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"it_number",
"=",
"n_page",
",",
"elapsed",
"=",
"elapsed",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{postal_code}-: something went wrong during places names and url extraction\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
")",
")",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{postal_code}-: found {total} places\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"total",
"=",
"len",
"(",
"places_found",
")",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"e",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"finally",
":",
"self",
".",
"finish",
"(",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: found {total} places\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"total",
"=",
"len",
"(",
"places_found",
")",
")",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: total time elapsed: -{elapsed}- seconds\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"elapsed",
"=",
"total_time",
")",
")",
"return",
"places_found"
] | [
126,
4
] | [
186,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_input | (case_name) | return os.path.join(os.path.join(BASE_DIR, "input"), file_name) | Retorna el path al csv que se debe limpiar. | Retorna el path al csv que se debe limpiar. | def get_input(case_name):
"""Retorna el path al csv que se debe limpiar."""
file_name = "to_clean_" + case_name + ".csv"
return os.path.join(os.path.join(BASE_DIR, "input"), file_name) | [
"def",
"get_input",
"(",
"case_name",
")",
":",
"file_name",
"=",
"\"to_clean_\"",
"+",
"case_name",
"+",
"\".csv\"",
"return",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"join",
"(",
"BASE_DIR",
",",
"\"input\"",
")",
",",
"file_name",
")"
] | [
30,
0
] | [
33,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationModel.convert_distance_vector_from_pixels | (self, distance_vector: FloatVector2D) | return distance_vector | Convierte el vector de distancia desde píxeles a la unidad especificada al instanciar la
clase.
:param distance_vector: vector de distancia en píxeles.
:return: cantidad de espacio en la unidad especificada al instanciar la clase.
| Convierte el vector de distancia desde píxeles a la unidad especificada al instanciar la
clase. | def convert_distance_vector_from_pixels(self, distance_vector: FloatVector2D) -> FloatVector2D:
"""Convierte el vector de distancia desde píxeles a la unidad especificada al instanciar la
clase.
:param distance_vector: vector de distancia en píxeles.
:return: cantidad de espacio en la unidad especificada al instanciar la clase.
"""
if self.length_unit == self.LengthUnit.METER:
distance_x = distance_vector.x * self.pixel_to_meters.x
distance_y = distance_vector.y * self.pixel_to_meters.y
return FloatVector2D(distance_x, distance_y)
elif self.length_unit == self.LengthUnit.KILOMETER:
distance_x = distance_vector.x * self.pixel_to_meters.x / 1000
distance_y = distance_vector.y * self.pixel_to_meters.y / 1000
return FloatVector2D(distance_x, distance_y)
return distance_vector | [
"def",
"convert_distance_vector_from_pixels",
"(",
"self",
",",
"distance_vector",
":",
"FloatVector2D",
")",
"->",
"FloatVector2D",
":",
"if",
"self",
".",
"length_unit",
"==",
"self",
".",
"LengthUnit",
".",
"METER",
":",
"distance_x",
"=",
"distance_vector",
".",
"x",
"*",
"self",
".",
"pixel_to_meters",
".",
"x",
"distance_y",
"=",
"distance_vector",
".",
"y",
"*",
"self",
".",
"pixel_to_meters",
".",
"y",
"return",
"FloatVector2D",
"(",
"distance_x",
",",
"distance_y",
")",
"elif",
"self",
".",
"length_unit",
"==",
"self",
".",
"LengthUnit",
".",
"KILOMETER",
":",
"distance_x",
"=",
"distance_vector",
".",
"x",
"*",
"self",
".",
"pixel_to_meters",
".",
"x",
"/",
"1000",
"distance_y",
"=",
"distance_vector",
".",
"y",
"*",
"self",
".",
"pixel_to_meters",
".",
"y",
"/",
"1000",
"return",
"FloatVector2D",
"(",
"distance_x",
",",
"distance_y",
")",
"return",
"distance_vector"
] | [
213,
4
] | [
228,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
crearListaNodosArbol | (lista_sucesores, nodo_actual, prof_max, estrategia) | return lista_nodos_arbol | Crea una lista objetos NodoArbol los cuales
son los sucesores del nodo introducido.
Antes de crear esta lista, se comprueba que la
profundidad de los sucesores no sea mayor a la
profundidad limite.
Argumentos:
lista_sucesores: Lista de ESTADOS sucesores (no son NodosArbol).
nodo_actual: Nodo padre de los sucesores.
prof_max: Profundidad limite del arbol.
estrategia: Segun la estrategia, el valor de f sera distinto.
Returns:
lista_nodos_arbol: Lista de objetos NodoArbol
que contiene los sucesores creados.
| Crea una lista objetos NodoArbol los cuales
son los sucesores del nodo introducido.
Antes de crear esta lista, se comprueba que la
profundidad de los sucesores no sea mayor a la
profundidad limite. | def crearListaNodosArbol(lista_sucesores, nodo_actual, prof_max, estrategia):
'''Crea una lista objetos NodoArbol los cuales
son los sucesores del nodo introducido.
Antes de crear esta lista, se comprueba que la
profundidad de los sucesores no sea mayor a la
profundidad limite.
Argumentos:
lista_sucesores: Lista de ESTADOS sucesores (no son NodosArbol).
nodo_actual: Nodo padre de los sucesores.
prof_max: Profundidad limite del arbol.
estrategia: Segun la estrategia, el valor de f sera distinto.
Returns:
lista_nodos_arbol: Lista de objetos NodoArbol
que contiene los sucesores creados.
'''
lista_nodos_arbol = []
if not nodo_actual.profundidad >= prof_max:
for sucesor in lista_sucesores:
nuevoNodoArbol = NodoArbol(
nodo_actual, sucesor[1], nodo_actual.profundidad + 1, nodo_actual.coste + sucesor[2], 0, 0)
nuevoNodoArbol.accion = sucesor[0]
if estrategia == "anchura":
nuevoNodoArbol.f = nuevoNodoArbol.profundidad
elif estrategia == "profundidad":
nuevoNodoArbol.f = -(nuevoNodoArbol.profundidad)
elif estrategia == "costo":
nuevoNodoArbol.f = nuevoNodoArbol.coste
elif estrategia == "Aestrella":
nuevoNodoArbol.calcularHeuristica()
nuevoNodoArbol.f = nuevoNodoArbol.coste + nuevoNodoArbol.heuristica
elif estrategia == "voraz":
nuevoNodoArbol.calcularHeuristica()
nuevoNodoArbol.f = nuevoNodoArbol.heuristica
lista_nodos_arbol.append(nuevoNodoArbol)
return lista_nodos_arbol | [
"def",
"crearListaNodosArbol",
"(",
"lista_sucesores",
",",
"nodo_actual",
",",
"prof_max",
",",
"estrategia",
")",
":",
"lista_nodos_arbol",
"=",
"[",
"]",
"if",
"not",
"nodo_actual",
".",
"profundidad",
">=",
"prof_max",
":",
"for",
"sucesor",
"in",
"lista_sucesores",
":",
"nuevoNodoArbol",
"=",
"NodoArbol",
"(",
"nodo_actual",
",",
"sucesor",
"[",
"1",
"]",
",",
"nodo_actual",
".",
"profundidad",
"+",
"1",
",",
"nodo_actual",
".",
"coste",
"+",
"sucesor",
"[",
"2",
"]",
",",
"0",
",",
"0",
")",
"nuevoNodoArbol",
".",
"accion",
"=",
"sucesor",
"[",
"0",
"]",
"if",
"estrategia",
"==",
"\"anchura\"",
":",
"nuevoNodoArbol",
".",
"f",
"=",
"nuevoNodoArbol",
".",
"profundidad",
"elif",
"estrategia",
"==",
"\"profundidad\"",
":",
"nuevoNodoArbol",
".",
"f",
"=",
"-",
"(",
"nuevoNodoArbol",
".",
"profundidad",
")",
"elif",
"estrategia",
"==",
"\"costo\"",
":",
"nuevoNodoArbol",
".",
"f",
"=",
"nuevoNodoArbol",
".",
"coste",
"elif",
"estrategia",
"==",
"\"Aestrella\"",
":",
"nuevoNodoArbol",
".",
"calcularHeuristica",
"(",
")",
"nuevoNodoArbol",
".",
"f",
"=",
"nuevoNodoArbol",
".",
"coste",
"+",
"nuevoNodoArbol",
".",
"heuristica",
"elif",
"estrategia",
"==",
"\"voraz\"",
":",
"nuevoNodoArbol",
".",
"calcularHeuristica",
"(",
")",
"nuevoNodoArbol",
".",
"f",
"=",
"nuevoNodoArbol",
".",
"heuristica",
"lista_nodos_arbol",
".",
"append",
"(",
"nuevoNodoArbol",
")",
"return",
"lista_nodos_arbol"
] | [
73,
0
] | [
108,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
InitSession.source | (self) | return to_raw(generate(self._sk_src)) | La clave pública y privada del remitente | La clave pública y privada del remitente | def source(self) -> bytes:
"""La clave pública y privada del remitente"""
return to_raw(generate(self._sk_src)) | [
"def",
"source",
"(",
"self",
")",
"->",
"bytes",
":",
"return",
"to_raw",
"(",
"generate",
"(",
"self",
".",
"_sk_src",
")",
")"
] | [
94,
4
] | [
97,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_cuerpo_crear_tabla_2 | (t) | cuerpo_creartabla : cuerpo_creartabla_p | cuerpo_creartabla : cuerpo_creartabla_p | def p_cuerpo_crear_tabla_2(t):
'''cuerpo_creartabla : cuerpo_creartabla_p '''
nuevo = Start("CUERPO_CREAR_TABLA")
nuevo.addChild(t[1])
t[0]=nuevo | [
"def",
"p_cuerpo_crear_tabla_2",
"(",
"t",
")",
":",
"nuevo",
"=",
"Start",
"(",
"\"CUERPO_CREAR_TABLA\"",
")",
"nuevo",
".",
"addChild",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"nuevo"
] | [
488,
0
] | [
492,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.mail_format | (self, field, sufix=None,
keep_original=False, inplace=False) | return series | Regla para dar formato a las direcciones de correo electronico.
Lleva todas las cadenas a minusculas y luego si hay varias las separa
por comas.
Args:
field (str): Campo a limpiar
Returns:
pandas.Series: Serie de strings limpios
| Regla para dar formato a las direcciones de correo electronico. | def mail_format(self, field, sufix=None,
keep_original=False, inplace=False):
"""Regla para dar formato a las direcciones de correo electronico.
Lleva todas las cadenas a minusculas y luego si hay varias las separa
por comas.
Args:
field (str): Campo a limpiar
Returns:
pandas.Series: Serie de strings limpios
"""
sufix = sufix or self.DEFAULT_SUFIX
field = self._normalize_field(field)
series = self.df[field].str.lower()
series = series.str.findall('[a-z_0-9\.]+@[a-z_0-9\.]+').str.join(", ")
if inplace:
self._update_series(field=field, sufix=sufix,
keep_original=keep_original,
new_series=series)
return series | [
"def",
"mail_format",
"(",
"self",
",",
"field",
",",
"sufix",
"=",
"None",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"sufix",
"=",
"sufix",
"or",
"self",
".",
"DEFAULT_SUFIX",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
".",
"str",
".",
"lower",
"(",
")",
"series",
"=",
"series",
".",
"str",
".",
"findall",
"(",
"'[a-z_0-9\\.]+@[a-z_0-9\\.]+'",
")",
".",
"str",
".",
"join",
"(",
"\", \"",
")",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"sufix",
"=",
"sufix",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"series",
")",
"return",
"series"
] | [
419,
4
] | [
442,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects.remove_objects_with_less_detections_than | (self,
minimum_detections: int) | return to_remove | Elimina los objetos que tienen un número de detecciones menor al indicado.
:param minimum_detections: número mínimo de detecciones que deben tener los objetos.
:return: tupla con el identificador y número de detecciones de cada objeto eliminado.
| Elimina los objetos que tienen un número de detecciones menor al indicado. | def remove_objects_with_less_detections_than(self,
minimum_detections: int) -> List[Tuple[int, int]]:
"""Elimina los objetos que tienen un número de detecciones menor al indicado.
:param minimum_detections: número mínimo de detecciones que deben tener los objetos.
:return: tupla con el identificador y número de detecciones de cada objeto eliminado.
"""
to_remove = [(tracked_object.id, len(tracked_object))
for tracked_object in self._tracked_objects
if len(tracked_object) < minimum_detections]
if len(to_remove) > 0:
to_remove_ids, _ = zip(*to_remove)
self.purge_objects(to_remove_ids)
return to_remove | [
"def",
"remove_objects_with_less_detections_than",
"(",
"self",
",",
"minimum_detections",
":",
"int",
")",
"->",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
":",
"to_remove",
"=",
"[",
"(",
"tracked_object",
".",
"id",
",",
"len",
"(",
"tracked_object",
")",
")",
"for",
"tracked_object",
"in",
"self",
".",
"_tracked_objects",
"if",
"len",
"(",
"tracked_object",
")",
"<",
"minimum_detections",
"]",
"if",
"len",
"(",
"to_remove",
")",
">",
"0",
":",
"to_remove_ids",
",",
"_",
"=",
"zip",
"(",
"*",
"to_remove",
")",
"self",
".",
"purge_objects",
"(",
"to_remove_ids",
")",
"return",
"to_remove"
] | [
337,
4
] | [
350,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AbstractGMapsExtractor.auto_boot | (self) | Función de arranque para inicializar el chromedriver | Función de arranque para inicializar el chromedriver | def auto_boot(self):
"""Función de arranque para inicializar el chromedriver"""
self._driver_options = self._get_driver_config()
self._driver = self._build_driver(provided_driver_location=self._driver_location,
driver_options=self._driver_options) | [
"def",
"auto_boot",
"(",
"self",
")",
":",
"self",
".",
"_driver_options",
"=",
"self",
".",
"_get_driver_config",
"(",
")",
"self",
".",
"_driver",
"=",
"self",
".",
"_build_driver",
"(",
"provided_driver_location",
"=",
"self",
".",
"_driver_location",
",",
"driver_options",
"=",
"self",
".",
"_driver_options",
")"
] | [
275,
4
] | [
279,
78
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
preprocess | (data) | return out | Fundión para preprocesar todas las imágenes
del conjunto de datos pasado como parámetro en paralelo
Args:
data:conjunto de imágenes a preprocesar
Returns:
Conjunto de imágenes preprocesado
| Fundión para preprocesar todas las imágenes
del conjunto de datos pasado como parámetro en paralelo
Args:
data:conjunto de imágenes a preprocesar
Returns:
Conjunto de imágenes preprocesado
| def preprocess(data):
""" Fundión para preprocesar todas las imágenes
del conjunto de datos pasado como parámetro en paralelo
Args:
data:conjunto de imágenes a preprocesar
Returns:
Conjunto de imágenes preprocesado
"""
out = Parallel(n_jobs=-1)(map(delayed(preprocessImage),data)) #Preprocesamos en paralelo cada una de las imágenes
out = np.array(out,np.float32)
return out | [
"def",
"preprocess",
"(",
"data",
")",
":",
"out",
"=",
"Parallel",
"(",
"n_jobs",
"=",
"-",
"1",
")",
"(",
"map",
"(",
"delayed",
"(",
"preprocessImage",
")",
",",
"data",
")",
")",
"#Preprocesamos en paralelo cada una de las imágenes",
"out",
"=",
"np",
".",
"array",
"(",
"out",
",",
"np",
".",
"float32",
")",
"return",
"out"
] | [
248,
0
] | [
260,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DatabaseModel.__init__ | (self,db_name) | Crea una base de datos con el nombre db_name | Crea una base de datos con el nombre db_name | def __init__(self,db_name):
"""Crea una base de datos con el nombre db_name"""
self.database = db.connect(db_name,'.db')
print "Base de datos %s creada" % db_name | [
"def",
"__init__",
"(",
"self",
",",
"db_name",
")",
":",
"self",
".",
"database",
"=",
"db",
".",
"connect",
"(",
"db_name",
",",
"'.db'",
")",
"print",
"\"Base de datos %s creada\"",
"%",
"db_name"
] | [
11,
4
] | [
14,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Bsignal.sety | (self, fun) | r""" sety : set y vector
Parameters
----------
fun : function
| r""" sety : set y vector | def sety(self, fun):
r""" sety : set y vector
Parameters
----------
fun : function
"""
self.y = fun(self.x) | [
"def",
"sety",
"(",
"self",
",",
"fun",
")",
":",
"self",
".",
"y",
"=",
"fun",
"(",
"self",
".",
"x",
")"
] | [
444,
4
] | [
453,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
validar_codigos | (n: int) | return codigos | Valida que los códigos a ingresar no contengan duplicados.
Retorna una lista de códigos sin duplicados.
:param n: Cantidad de códigos
:n type: int
:return: Lista de códigos sin duplicados
:rtype: List[int]
| Valida que los códigos a ingresar no contengan duplicados.
Retorna una lista de códigos sin duplicados. | def validar_codigos(n: int) -> List[int]:
"""Valida que los códigos a ingresar no contengan duplicados.
Retorna una lista de códigos sin duplicados.
:param n: Cantidad de códigos
:n type: int
:return: Lista de códigos sin duplicados
:rtype: List[int]
"""
codigos = []
i = 1
while i <= n:
codigo = int(input(f"Código {i}: "))
if codigo in codigos:
print("Error, código duplicado")
continue
codigos.append(codigo)
i += 1
return codigos | [
"def",
"validar_codigos",
"(",
"n",
":",
"int",
")",
"->",
"List",
"[",
"int",
"]",
":",
"codigos",
"=",
"[",
"]",
"i",
"=",
"1",
"while",
"i",
"<=",
"n",
":",
"codigo",
"=",
"int",
"(",
"input",
"(",
"f\"Código {i}: \")",
")",
"",
"if",
"codigo",
"in",
"codigos",
":",
"print",
"(",
"\"Error, código duplicado\")",
"",
"continue",
"codigos",
".",
"append",
"(",
"codigo",
")",
"i",
"+=",
"1",
"return",
"codigos"
] | [
22,
0
] | [
40,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NanopubRequest.splitAnnotations | (args: list) | return request | realiza el proceso de divicion de la lista de anotaciones pasadas a una lista NanopubRequest validas | realiza el proceso de divicion de la lista de anotaciones pasadas a una lista NanopubRequest validas | def splitAnnotations(args: list) -> list:
""" realiza el proceso de divicion de la lista de anotaciones pasadas a una lista NanopubRequest validas"""
request = []
for annotation in args:
try:
if NanopubRequest.tagInAnnotation(AnnotationTag.step, annotation):
request.append(NanopubRequest.splitDeep(annotation, args))
except:
pass
return request | [
"def",
"splitAnnotations",
"(",
"args",
":",
"list",
")",
"->",
"list",
":",
"request",
"=",
"[",
"]",
"for",
"annotation",
"in",
"args",
":",
"try",
":",
"if",
"NanopubRequest",
".",
"tagInAnnotation",
"(",
"AnnotationTag",
".",
"step",
",",
"annotation",
")",
":",
"request",
".",
"append",
"(",
"NanopubRequest",
".",
"splitDeep",
"(",
"annotation",
",",
"args",
")",
")",
"except",
":",
"pass",
"return",
"request"
] | [
56,
4
] | [
65,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instruccion_execute | (t) | instruccion : EXECUTE llamada PUNTO_COMA
| instruccion : EXECUTE llamada PUNTO_COMA
| def p_instruccion_execute(t):
'''instruccion : EXECUTE llamada PUNTO_COMA
'''
strGram = "<instruccion> ::= EXECUTE <llamada>"
t[0] = Execute.Execute(t[2].nombre, t[2].parametros, strGram, t.lexer.lineno, t.lexer.lexpos) | [
"def",
"p_instruccion_execute",
"(",
"t",
")",
":",
"strGram",
"=",
"\"<instruccion> ::= EXECUTE <llamada>\"",
"t",
"[",
"0",
"]",
"=",
"Execute",
".",
"Execute",
"(",
"t",
"[",
"2",
"]",
".",
"nombre",
",",
"t",
"[",
"2",
"]",
".",
"parametros",
",",
"strGram",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"t",
".",
"lexer",
".",
"lexpos",
")"
] | [
245,
0
] | [
249,
97
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TarjetaCredito.cargar | (self, precio: float) | Carga el precio dado a la tarjeta de credito asumiendo que
tiene saldo.
:param precio: Precio a cargar.
:precio type: float
:return: True si se pudo cargar, False en caso contrario.
:rtype: bool
| Carga el precio dado a la tarjeta de credito asumiendo que
tiene saldo. | def cargar(self, precio: float) -> bool:
"""Carga el precio dado a la tarjeta de credito asumiendo que
tiene saldo.
:param precio: Precio a cargar.
:precio type: float
:return: True si se pudo cargar, False en caso contrario.
:rtype: bool
"""
precio = validate_float(precio)
if precio + self._balance > self._limite:
return False
else:
self._balance += precio
return True | [
"def",
"cargar",
"(",
"self",
",",
"precio",
":",
"float",
")",
"->",
"bool",
":",
"precio",
"=",
"validate_float",
"(",
"precio",
")",
"if",
"precio",
"+",
"self",
".",
"_balance",
">",
"self",
".",
"_limite",
":",
"return",
"False",
"else",
":",
"self",
".",
"_balance",
"+=",
"precio",
"return",
"True"
] | [
82,
4
] | [
96,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AccountVatLedger._get_partner_document_code_and_number | (self, partner) | return doc_code, doc_number.rjust(20, '0') | Para un partner devolver codigo de identificación y numero de
identificación con el formato esperado por los txt | Para un partner devolver codigo de identificación y numero de
identificación con el formato esperado por los txt | def _get_partner_document_code_and_number(self, partner):
"""Para un partner devolver codigo de identificación y numero de
identificación con el formato esperado por los txt """
# se exige cuit para todo menos consumidor final
if partner.l10n_ar_afip_responsibility_type_id.code == '5':
doc_code = "{:0>2d}".format(
int(partner.l10n_latam_identification_type_id.\
l10n_ar_afip_code))
doc_number = partner.vat or ''
# limpiamos letras que no son soportadas
doc_number = re.sub("[^0-9]", "", doc_number)
elif partner.l10n_ar_afip_responsibility_type_id.code == '9':
commercial_partner = partner.commercial_partner_id
doc_number = partner.l10n_ar_vat or commercial_partner.country_id.\
l10n_ar_legal_entity_vat if commercial_partner.is_company \
else commercial_partner.country_id.l10n_ar_natural_vat
doc_code = '80'
else:
doc_number = partner.ensure_vat()
doc_code = '80'
return doc_code, doc_number.rjust(20, '0') | [
"def",
"_get_partner_document_code_and_number",
"(",
"self",
",",
"partner",
")",
":",
"# se exige cuit para todo menos consumidor final",
"if",
"partner",
".",
"l10n_ar_afip_responsibility_type_id",
".",
"code",
"==",
"'5'",
":",
"doc_code",
"=",
"\"{:0>2d}\"",
".",
"format",
"(",
"int",
"(",
"partner",
".",
"l10n_latam_identification_type_id",
".",
"l10n_ar_afip_code",
")",
")",
"doc_number",
"=",
"partner",
".",
"vat",
"or",
"''",
"# limpiamos letras que no son soportadas",
"doc_number",
"=",
"re",
".",
"sub",
"(",
"\"[^0-9]\"",
",",
"\"\"",
",",
"doc_number",
")",
"elif",
"partner",
".",
"l10n_ar_afip_responsibility_type_id",
".",
"code",
"==",
"'9'",
":",
"commercial_partner",
"=",
"partner",
".",
"commercial_partner_id",
"doc_number",
"=",
"partner",
".",
"l10n_ar_vat",
"or",
"commercial_partner",
".",
"country_id",
".",
"l10n_ar_legal_entity_vat",
"if",
"commercial_partner",
".",
"is_company",
"else",
"commercial_partner",
".",
"country_id",
".",
"l10n_ar_natural_vat",
"doc_code",
"=",
"'80'",
"else",
":",
"doc_number",
"=",
"partner",
".",
"ensure_vat",
"(",
")",
"doc_code",
"=",
"'80'",
"return",
"doc_code",
",",
"doc_number",
".",
"rjust",
"(",
"20",
",",
"'0'",
")"
] | [
145,
4
] | [
165,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Composite.append_child | (self, child) | Método para agregar un nuevo child item | Método para agregar un nuevo child item | def append_child(self, child):
"""Método para agregar un nuevo child item"""
self.children.append(child) | [
"def",
"append_child",
"(",
"self",
",",
"child",
")",
":",
"self",
".",
"children",
".",
"append",
"(",
"child",
")"
] | [
36,
4
] | [
38,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
normalize_word | (word, lower_words=None) | return word.title() | Normaliza una palabra, capitalizándola cuando corresponde.
Si contiene signos de puntacion se capitaliza dentro de esas strings.
Args:
word (str): Palabra
Returns:
str: Palabra normalizada
| Normaliza una palabra, capitalizándola cuando corresponde. | def normalize_word(word, lower_words=None):
"""Normaliza una palabra, capitalizándola cuando corresponde.
Si contiene signos de puntacion se capitaliza dentro de esas strings.
Args:
word (str): Palabra
Returns:
str: Palabra normalizada
"""
lower_words = lower_words or LOWER_WORDS
for character in string.punctuation:
if character in word:
return capitalize(word, sep=character)
if word.lower() in IGNORE_WORDS:
return word
if word.lower() in lower_words:
return word.lower()
return word.title() | [
"def",
"normalize_word",
"(",
"word",
",",
"lower_words",
"=",
"None",
")",
":",
"lower_words",
"=",
"lower_words",
"or",
"LOWER_WORDS",
"for",
"character",
"in",
"string",
".",
"punctuation",
":",
"if",
"character",
"in",
"word",
":",
"return",
"capitalize",
"(",
"word",
",",
"sep",
"=",
"character",
")",
"if",
"word",
".",
"lower",
"(",
")",
"in",
"IGNORE_WORDS",
":",
"return",
"word",
"if",
"word",
".",
"lower",
"(",
")",
"in",
"lower_words",
":",
"return",
"word",
".",
"lower",
"(",
")",
"return",
"word",
".",
"title",
"(",
")"
] | [
20,
0
] | [
40,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.