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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Button.prep_msg | (self, msg) | Transforma msg em imagem renderizada e centraliza o texto no botão | Transforma msg em imagem renderizada e centraliza o texto no botão | def prep_msg(self, msg):
"""Transforma msg em imagem renderizada e centraliza o texto no botão"""
self.msg_image = self.font.render(msg, True, self.text_color, self.button_color)
self.msg_image_rect = self.msg_image.get_rect()
self.msg_image_rect.center = self.rect.center | [
"def",
"prep_msg",
"(",
"self",
",",
"msg",
")",
":",
"self",
".",
"msg_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"msg",
",",
"True",
",",
"self",
".",
"text_color",
",",
"self",
".",
"button_color",
")",
"self",
".",
"msg_image_rect",
"=",
"self",
".",
"msg_image",
".",
"get_rect",
"(",
")",
"self",
".",
"msg_image_rect",
".",
"center",
"=",
"self",
".",
"rect",
".",
"center"
] | [
23,
4
] | [
27,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RestResource.handle_request | (self, request, *args, **kwargs) | return response | Recebe a requisição e redireciona para o método apropriado.
Antes de redirecionar para o método, é feita a autenticação do usuário.
| Recebe a requisição e redireciona para o método apropriado. | def handle_request(self, request, *args, **kwargs):
"""Recebe a requisição e redireciona para o método apropriado.
Antes de redirecionar para o método, é feita a autenticação do usuário.
"""
response = None
try:
user = RestResource.authenticate_user(request)
if (user is None):
response = self.not_authenticated()
else:
if request.method == 'GET':
response = self.handle_get(request, user, args, **kwargs)
elif request.method == 'POST':
response = self.handle_post(request, user, args, **kwargs)
elif request.method == 'DELETE':
response = self.handle_delete(
request, user, args, **kwargs)
elif request.method == 'PUT':
response = self.handle_put(request, user, args, **kwargs)
except AuthenticationFailed:
self.log.error(u'Authentication failed.')
response = self.not_authenticated()
except (LockNotAcquiredError, OperationalError), e:
self.log.error(u'Lock wait timeout exceeded.')
return self.response_error(273)
except XMLError, e:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, e)
except Exception, e:
self.log.exception(u'Erro não esperado.')
response = self.response_error(1)
finally:
username, password, user_ldap = RestResource.read_user_data(
request)
# password = '****'
if response is not None:
if response.status_code == 200:
transaction.commit()
else:
transaction.rollback()
else:
transaction.rollback()
self.log.debug(u'Requisição concluída com falha.')
return response | [
"def",
"handle_request",
"(",
"self",
",",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"response",
"=",
"None",
"try",
":",
"user",
"=",
"RestResource",
".",
"authenticate_user",
"(",
"request",
")",
"if",
"(",
"user",
"is",
"None",
")",
":",
"response",
"=",
"self",
".",
"not_authenticated",
"(",
")",
"else",
":",
"if",
"request",
".",
"method",
"==",
"'GET'",
":",
"response",
"=",
"self",
".",
"handle_get",
"(",
"request",
",",
"user",
",",
"args",
",",
"*",
"*",
"kwargs",
")",
"elif",
"request",
".",
"method",
"==",
"'POST'",
":",
"response",
"=",
"self",
".",
"handle_post",
"(",
"request",
",",
"user",
",",
"args",
",",
"*",
"*",
"kwargs",
")",
"elif",
"request",
".",
"method",
"==",
"'DELETE'",
":",
"response",
"=",
"self",
".",
"handle_delete",
"(",
"request",
",",
"user",
",",
"args",
",",
"*",
"*",
"kwargs",
")",
"elif",
"request",
".",
"method",
"==",
"'PUT'",
":",
"response",
"=",
"self",
".",
"handle_put",
"(",
"request",
",",
"user",
",",
"args",
",",
"*",
"*",
"kwargs",
")",
"except",
"AuthenticationFailed",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Authentication failed.'",
")",
"response",
"=",
"self",
".",
"not_authenticated",
"(",
")",
"except",
"(",
"LockNotAcquiredError",
",",
"OperationalError",
")",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Lock wait timeout exceeded.'",
")",
"return",
"self",
".",
"response_error",
"(",
"273",
")",
"except",
"XMLError",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Error reading the XML request.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"e",
")",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log",
".",
"exception",
"(",
"u'Erro não esperado.')",
"",
"response",
"=",
"self",
".",
"response_error",
"(",
"1",
")",
"finally",
":",
"username",
",",
"password",
",",
"user_ldap",
"=",
"RestResource",
".",
"read_user_data",
"(",
"request",
")",
"# password = '****'",
"if",
"response",
"is",
"not",
"None",
":",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"transaction",
".",
"commit",
"(",
")",
"else",
":",
"transaction",
".",
"rollback",
"(",
")",
"else",
":",
"transaction",
".",
"rollback",
"(",
")",
"self",
".",
"log",
".",
"debug",
"(",
"u'Requisição concluída com falha.')",
"",
"return",
"response"
] | [
67,
4
] | [
113,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
update_screen | (ai_setting, screen, ship) | Atualiza as imagens na tela e alterna para a nova tela. | Atualiza as imagens na tela e alterna para a nova tela. | def update_screen(ai_setting, screen, ship):
'''Atualiza as imagens na tela e alterna para a nova tela.'''
# Redesenha a tela a cada passagem pelo laço
screen.fill(ai_setting.bg_color)
ship.blitme()
# Deixa a tela mais recente visível
pygame.display.flip() | [
"def",
"update_screen",
"(",
"ai_setting",
",",
"screen",
",",
"ship",
")",
":",
"# Redesenha a tela a cada passagem pelo laço",
"screen",
".",
"fill",
"(",
"ai_setting",
".",
"bg_color",
")",
"ship",
".",
"blitme",
"(",
")",
"# Deixa a tela mais recente visível",
"pygame",
".",
"display",
".",
"flip",
"(",
")"
] | [
32,
0
] | [
39,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
describe_pet | (pet_name, animal_type = 'dog') | Exibe informação sobre um animal de estimação. | Exibe informação sobre um animal de estimação. | def describe_pet(pet_name, animal_type = 'dog'):
"""Exibe informação sobre um animal de estimação."""
print("\nI have a " + animal_type + ".")
print("My " + animal_type + "'s name is " + pet_name.title() + ".") | [
"def",
"describe_pet",
"(",
"pet_name",
",",
"animal_type",
"=",
"'dog'",
")",
":",
"print",
"(",
"\"\\nI have a \"",
"+",
"animal_type",
"+",
"\".\"",
")",
"print",
"(",
"\"My \"",
"+",
"animal_type",
"+",
"\"'s name is \"",
"+",
"pet_name",
".",
"title",
"(",
")",
"+",
"\".\"",
")"
] | [
5,
0
] | [
8,
71
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
aCDOM_300 | (S_275_to_295) | return aCDOM_300 | Funcao que retorna aCDOM(300) (1/m) com base nos valores de S(275-295)
Referência do cálculo :
CAO, F. et al. Remote sensing retrievals of colored
dissolved organic matter and dissolved organic carbon
dynamics in North American estuaries and their margins.
Remote Sensing of Environment, v. 205, n. April 2017,
p. 151–165, 2018.
| Funcao que retorna aCDOM(300) (1/m) com base nos valores de S(275-295)
Referência do cálculo : | def aCDOM_300 (S_275_to_295):
""" Funcao que retorna aCDOM(300) (1/m) com base nos valores de S(275-295)
Referência do cálculo :
CAO, F. et al. Remote sensing retrievals of colored
dissolved organic matter and dissolved organic carbon
dynamics in North American estuaries and their margins.
Remote Sensing of Environment, v. 205, n. April 2017,
p. 151–165, 2018.
"""
aCDOM_300 = (exp( -15.05 - 33.95 * S_275_to_295)
+ exp(-1.502 - 104.3 * S_275_to_295)
return aCDOM_300 | [
"def",
"aCDOM_300",
"(",
"S_275_to_295",
")",
":",
"aCDOM_300",
"=",
"(",
"exp",
"(",
"-",
"15.05",
"-",
"33.95",
"*",
"S_275_to_295",
")",
"+",
"exp",
"(",
"-",
"1.502",
"-",
"104.3",
"*",
"S_275_to_295",
")",
"return",
"aCDOM_300"
] | [
3,
0
] | [
20,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
associate | (op, args) | Dada uma op associativa, retornar uma expressão com o mesmo
significado como Expr (op, * args), ou seja, com instâncias aninhadas
do mesmo grupo promovido ao nível superior.
>>> associate('&', [(A&B),(B|C),(B&C)])
(A & B & (B | C) & B & C)
>>> associate('|', [A|(B|(C|(A&B)))])
(A | B | C | (A & B))
| Dada uma op associativa, retornar uma expressão com o mesmo
significado como Expr (op, * args), ou seja, com instâncias aninhadas
do mesmo grupo promovido ao nível superior.
>>> associate('&', [(A&B),(B|C),(B&C)])
(A & B & (B | C) & B & C)
>>> associate('|', [A|(B|(C|(A&B)))])
(A | B | C | (A & B))
| def associate(op, args):
"""Dada uma op associativa, retornar uma expressão com o mesmo
significado como Expr (op, * args), ou seja, com instâncias aninhadas
do mesmo grupo promovido ao nível superior.
>>> associate('&', [(A&B),(B|C),(B&C)])
(A & B & (B | C) & B & C)
>>> associate('|', [A|(B|(C|(A&B)))])
(A | B | C | (A & B))
"""
args = dissociate(op, args)
if len(args) == 0:
return _op_identity[op]
elif len(args) == 1:
return args[0]
else:
return Expr(op, *args) | [
"def",
"associate",
"(",
"op",
",",
"args",
")",
":",
"args",
"=",
"dissociate",
"(",
"op",
",",
"args",
")",
"if",
"len",
"(",
"args",
")",
"==",
"0",
":",
"return",
"_op_identity",
"[",
"op",
"]",
"elif",
"len",
"(",
"args",
")",
"==",
"1",
":",
"return",
"args",
"[",
"0",
"]",
"else",
":",
"return",
"Expr",
"(",
"op",
",",
"*",
"args",
")"
] | [
358,
0
] | [
373,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
build_profile | (first, last, **user_info) | return profile | Constrói um dicionário contendo tudo que sabemos sobre um usuário. | Constrói um dicionário contendo tudo que sabemos sobre um usuário. | def build_profile(first, last, **user_info):
"""Constrói um dicionário contendo tudo que sabemos sobre um usuário."""
profile = {}
profile['first_name'] = first
profile['last_name'] = last
for key, value in user_info.items():
profile[key] = value
return profile | [
"def",
"build_profile",
"(",
"first",
",",
"last",
",",
"*",
"*",
"user_info",
")",
":",
"profile",
"=",
"{",
"}",
"profile",
"[",
"'first_name'",
"]",
"=",
"first",
"profile",
"[",
"'last_name'",
"]",
"=",
"last",
"for",
"key",
",",
"value",
"in",
"user_info",
".",
"items",
"(",
")",
":",
"profile",
"[",
"key",
"]",
"=",
"value",
"return",
"profile"
] | [
5,
0
] | [
12,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EletricCar.__init__ | (self, make, model, year) | Inicializa os atributos da classe pai. Em seguida, inicializa os atributos
específicos de um carro elétrico. | Inicializa os atributos da classe pai. Em seguida, inicializa os atributos
específicos de um carro elétrico. | def __init__(self, make, model, year):
"""Inicializa os atributos da classe pai. Em seguida, inicializa os atributos
específicos de um carro elétrico."""
super().__init__(make, model, year)
self.battery = Battery()
self.details_car = 'details_car' | [
"def",
"__init__",
"(",
"self",
",",
"make",
",",
"model",
",",
"year",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"make",
",",
"model",
",",
"year",
")",
"self",
".",
"battery",
"=",
"Battery",
"(",
")",
"self",
".",
"details_car",
"=",
"'details_car'"
] | [
68,
4
] | [
74,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Messenger.__get_target__ | (self, target) | Método interno da classe para recuperar o nome do contato do destinatário. Não deve ser utilizado no programa
principal. Apenas dentro da classe. | Método interno da classe para recuperar o nome do contato do destinatário. Não deve ser utilizado no programa
principal. Apenas dentro da classe. | def __get_target__(self, target):
"""Método interno da classe para recuperar o nome do contato do destinatário. Não deve ser utilizado no programa
principal. Apenas dentro da classe."""
__barra = self._browser.find_element_by_class_name('_3qx7_')
__barra.click()
__barra = self._browser.find_element_by_class_name('_3FRCZ.copyable-text.selectable-text')
__barra.send_keys(target)
sleep(0.5)
self._browser.find_element_by_class_name('_210SC').click()
self._browser.find_element_by_class_name('_3uMse').click() | [
"def",
"__get_target__",
"(",
"self",
",",
"target",
")",
":",
"__barra",
"=",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_3qx7_'",
")",
"__barra",
".",
"click",
"(",
")",
"__barra",
"=",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_3FRCZ.copyable-text.selectable-text'",
")",
"__barra",
".",
"send_keys",
"(",
"target",
")",
"sleep",
"(",
"0.5",
")",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_210SC'",
")",
".",
"click",
"(",
")",
"self",
".",
"_browser",
".",
"find_element_by_class_name",
"(",
"'_3uMse'",
")",
".",
"click",
"(",
")"
] | [
19,
4
] | [
30,
66
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
num_de_amigos | (user) | return len(user["friends"]) | QUantos amigos o usuario tem? | QUantos amigos o usuario tem? | def num_de_amigos(user):
"QUantos amigos o usuario tem?"
return len(user["friends"]) # Tamanho da Lista de Amigos | [
"def",
"num_de_amigos",
"(",
"user",
")",
":",
"return",
"len",
"(",
"user",
"[",
"\"friends\"",
"]",
")",
"# Tamanho da Lista de Amigos"
] | [
31,
0
] | [
33,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoGrupo.remove | (cls, authenticated_user, equip_id, egroup_id) | Pesquisa e remove uma associação entre um Equipamento e um Grupo.
@return: Nothing
@raise EquipamentoGrupoNotFoundError: Associação entre o equipamento e o grupo não cadastrada.
@raise EquipamentoError: Falha ao remover uma associação entre um Equipamento e um Grupo.
| Pesquisa e remove uma associação entre um Equipamento e um Grupo. | def remove(cls, authenticated_user, equip_id, egroup_id):
"""Pesquisa e remove uma associação entre um Equipamento e um Grupo.
@return: Nothing
@raise EquipamentoGrupoNotFoundError: Associação entre o equipamento e o grupo não cadastrada.
@raise EquipamentoError: Falha ao remover uma associação entre um Equipamento e um Grupo.
"""
equip_group = EquipamentoGrupo().get_by_equipment_group(
equip_id, egroup_id)
equipments = EquipamentoGrupo.get_by_equipment(equip_id)
if len(equipments) > 1:
try:
equip_group.delete()
except Exception as e:
cls.log.error(
u'Falha ao remover uma associação entre um Equipamento e um Grupo.')
raise EquipamentoError(
e, u'Falha ao remover uma associação entre um Equipamento e um Grupo.')
else:
raise EquipmentDontRemoveError(
u'Failure to remove an association between an equipment and a group because the group is related only to a group.') | [
"def",
"remove",
"(",
"cls",
",",
"authenticated_user",
",",
"equip_id",
",",
"egroup_id",
")",
":",
"equip_group",
"=",
"EquipamentoGrupo",
"(",
")",
".",
"get_by_equipment_group",
"(",
"equip_id",
",",
"egroup_id",
")",
"equipments",
"=",
"EquipamentoGrupo",
".",
"get_by_equipment",
"(",
"equip_id",
")",
"if",
"len",
"(",
"equipments",
")",
">",
"1",
":",
"try",
":",
"equip_group",
".",
"delete",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao remover uma associação entre um Equipamento e um Grupo.')",
"",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao remover uma associação entre um Equipamento e um Grupo.')",
"",
"else",
":",
"raise",
"EquipmentDontRemoveError",
"(",
"u'Failure to remove an association between an equipment and a group because the group is related only to a group.'",
")"
] | [
1625,
4
] | [
1649,
131
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
my_sum | (values) | return result | Soma os elementos de uma lista.
Soma os valores contidos em uma lista e retorna o resultado da soma.
O retorno dessa função pode ser do tipo int ou float, de acordo com
os valores contidos na lista a ser somada.
Parameters
----------
values : list
A lista cujos elementos serão somados
Return
------
result : int | float
Resultado da soma dos elementos da lista
| Soma os elementos de uma lista. | def my_sum(values):
""" Soma os elementos de uma lista.
Soma os valores contidos em uma lista e retorna o resultado da soma.
O retorno dessa função pode ser do tipo int ou float, de acordo com
os valores contidos na lista a ser somada.
Parameters
----------
values : list
A lista cujos elementos serão somados
Return
------
result : int | float
Resultado da soma dos elementos da lista
"""
result = 0
for i in range(0, len(values)):
result += values[i]
return result | [
"def",
"my_sum",
"(",
"values",
")",
":",
"result",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"values",
")",
")",
":",
"result",
"+=",
"values",
"[",
"i",
"]",
"return",
"result"
] | [
45,
0
] | [
66,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
restoreDatabase | (infile, database) | Efetua o restore de infile em database | Efetua o restore de infile em database | def restoreDatabase(infile, database):
'Efetua o restore de infile em database'
if DBConfig['pass'] != '':
adminUser = '-u %s' % DBConfig['user']
else:
adminUser = '-u root'
if DBConfig['pass'] != '':
adminPass = '-p%s' % DBConfig['pass']
else:
adminPass = ''
mysqlDump = 'mysql %s %s' % (adminUser, adminPass)
basename = infile.split('.')
basename.reverse()
if len(basename) > 0 and basename[0] == 'sql':
cmd = '%s %s < %s' % (mysqlDump, database, infile)
elif len(basename) > 1 and basename[1] == 'sql':
if basename[0] == 'gz':
cmd = 'gunzip < %s | %s %s' % (infile, mysqlDump, database)
elif basename[0] == 'bz2':
cmd = 'bunzip2 < %s | %s %s' % (infile, mysqlDump, database)
else:
print 'Tipo de arquivo não confere com os suportados (.sql, .sql.gz, .sql.bz2)'
sys.exit(1)
else:
print 'Tipo de arquivo não confere com os suportados (.sql, .sql.gz, .sql.bz2)'
sys.exit(1)
res = commands.getstatusoutput(cmd)
if res[0] == 0:
print 'Backup restaurado do arquivo %s com sucesso!' % infile
else:
print 'Erro ao restaurar backup do arquivo %s: %s' % (infile, res[1]) | [
"def",
"restoreDatabase",
"(",
"infile",
",",
"database",
")",
":",
"if",
"DBConfig",
"[",
"'pass'",
"]",
"!=",
"''",
":",
"adminUser",
"=",
"'-u %s'",
"%",
"DBConfig",
"[",
"'user'",
"]",
"else",
":",
"adminUser",
"=",
"'-u root'",
"if",
"DBConfig",
"[",
"'pass'",
"]",
"!=",
"''",
":",
"adminPass",
"=",
"'-p%s'",
"%",
"DBConfig",
"[",
"'pass'",
"]",
"else",
":",
"adminPass",
"=",
"''",
"mysqlDump",
"=",
"'mysql %s %s'",
"%",
"(",
"adminUser",
",",
"adminPass",
")",
"basename",
"=",
"infile",
".",
"split",
"(",
"'.'",
")",
"basename",
".",
"reverse",
"(",
")",
"if",
"len",
"(",
"basename",
")",
">",
"0",
"and",
"basename",
"[",
"0",
"]",
"==",
"'sql'",
":",
"cmd",
"=",
"'%s %s < %s'",
"%",
"(",
"mysqlDump",
",",
"database",
",",
"infile",
")",
"elif",
"len",
"(",
"basename",
")",
">",
"1",
"and",
"basename",
"[",
"1",
"]",
"==",
"'sql'",
":",
"if",
"basename",
"[",
"0",
"]",
"==",
"'gz'",
":",
"cmd",
"=",
"'gunzip < %s | %s %s'",
"%",
"(",
"infile",
",",
"mysqlDump",
",",
"database",
")",
"elif",
"basename",
"[",
"0",
"]",
"==",
"'bz2'",
":",
"cmd",
"=",
"'bunzip2 < %s | %s %s'",
"%",
"(",
"infile",
",",
"mysqlDump",
",",
"database",
")",
"else",
":",
"print",
"'Tipo de arquivo não confere com os suportados (.sql, .sql.gz, .sql.bz2)'",
"sys",
".",
"exit",
"(",
"1",
")",
"else",
":",
"print",
"'Tipo de arquivo não confere com os suportados (.sql, .sql.gz, .sql.bz2)'",
"sys",
".",
"exit",
"(",
"1",
")",
"res",
"=",
"commands",
".",
"getstatusoutput",
"(",
"cmd",
")",
"if",
"res",
"[",
"0",
"]",
"==",
"0",
":",
"print",
"'Backup restaurado do arquivo %s com sucesso!'",
"%",
"infile",
"else",
":",
"print",
"'Erro ao restaurar backup do arquivo %s: %s'",
"%",
"(",
"infile",
",",
"res",
"[",
"1",
"]",
")"
] | [
41,
0
] | [
71,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_bundle_id | (issn_id: str, doc_info: dict) | return scielo_ids_generator.any_bundle_id(
issn_id,
doc_info.get("year"),
doc_info.get("volume"),
doc_info.get("number"),
doc_info.get("supplement"),
) | Obtém o bundle ID através dos dados presentes em `doc_info`, utilizando funções
do módulo scielo_ids_generator.
`issn_id`: ISSN ID do Periódico
`doc_info`: dados de um registro do arquivo JSON resultado da importação
Returns:
str: ID do bundle de fascículo ou do bundle AOP
| Obtém o bundle ID através dos dados presentes em `doc_info`, utilizando funções
do módulo scielo_ids_generator.
`issn_id`: ISSN ID do Periódico
`doc_info`: dados de um registro do arquivo JSON resultado da importação
Returns:
str: ID do bundle de fascículo ou do bundle AOP
| def get_bundle_id(issn_id: str, doc_info: dict) -> None:
"""Obtém o bundle ID através dos dados presentes em `doc_info`, utilizando funções
do módulo scielo_ids_generator.
`issn_id`: ISSN ID do Periódico
`doc_info`: dados de um registro do arquivo JSON resultado da importação
Returns:
str: ID do bundle de fascículo ou do bundle AOP
"""
return scielo_ids_generator.any_bundle_id(
issn_id,
doc_info.get("year"),
doc_info.get("volume"),
doc_info.get("number"),
doc_info.get("supplement"),
) | [
"def",
"get_bundle_id",
"(",
"issn_id",
":",
"str",
",",
"doc_info",
":",
"dict",
")",
"->",
"None",
":",
"return",
"scielo_ids_generator",
".",
"any_bundle_id",
"(",
"issn_id",
",",
"doc_info",
".",
"get",
"(",
"\"year\"",
")",
",",
"doc_info",
".",
"get",
"(",
"\"volume\"",
")",
",",
"doc_info",
".",
"get",
"(",
"\"number\"",
")",
",",
"doc_info",
".",
"get",
"(",
"\"supplement\"",
")",
",",
")"
] | [
122,
0
] | [
136,
5
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
delete | (id) | Deleta um socio de acordo com seu id | Deleta um socio de acordo com seu id | def delete(id):
"""Deleta um socio de acordo com seu id"""
try:
socio = get_socio(id)
sql = 'DELETE from socio where id = %d' % id
db.insert_bd(sql)
return redirect(url_for('socio.index'))
except Exception as e:
print(e)
return render_template('404.html') | [
"def",
"delete",
"(",
"id",
")",
":",
"try",
":",
"socio",
"=",
"get_socio",
"(",
"id",
")",
"sql",
"=",
"'DELETE from socio where id = %d'",
"%",
"id",
"db",
".",
"insert_bd",
"(",
"sql",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'socio.index'",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
207,
0
] | [
216,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MainCompras.FormCompras | (self) | Chamanda de funções localizadas no arquivo comercial.py na pasta Funcoes | Chamanda de funções localizadas no arquivo comercial.py na pasta Funcoes | def FormCompras(self):
self.DesativaBotaoCompras()
self.LimpaFrame(self.ct_containerCompras)
super(MainCompras, self).setFormCompras(self.ct_containerCompras)
self.fr_FormCompra.show()
# Setando Foco no Cliente id TX
self.tx_Id.setFocus()
# Checando se existe ID válido
self.IdCheckCompra()
""" Chamanda de funções localizadas no arquivo comercial.py na pasta Funcoes """
# Setando Datas
self.setDatas()
# Setando Validação
self.validaCampos()
# Definindo acao de calculo de frete e desconto
self.acaoCalculo()
# setando Icone Botoes
self.setIcones()
# Setando tamanho das tabelas
self.tamanhoTabelas()
# setando autocompleye
self.setAutocomplete()
# Gerar Parcelas
self.bt_GerarParcela.clicked.connect(
partial(self.gerarParcela,
"Pagar"))
# Auto COmplete Produto
self.tx_BuscaItem.textEdited.connect(self.autocompleteProduto)
# Add Item Tabela
self.tx_ObsItem.returnPressed.connect(self.ValidaFormAdd)
self.bt_IncluirItem.clicked.connect(self.ValidaFormAdd)
""" Fim das chamandas comercial.py"""
""" Chamanda de funções localizadas no arquivo fornecedor.py na pasta Funcoes """
# Campo Busca por nome e Autocompletar Fornecedor
self.tx_NomeFantasia.textEdited.connect(self.autocompleFornecedor)
self.tx_NomeFantasia.returnPressed.connect(
partial(self.BuscaFornecedorNome, self.tx_IdBuscaItem))
# Return Press Busca Id Fornecedor
self.tx_Id.returnPressed.connect(
partial(self.BuscaFornecedorId, self.tx_IdBuscaItem))
""" Fim chamada fornecedor.py """
""" Chamanda de funções localizadas no arquivo FormaPagamento.py na pasta Funcoes """
# Populando combobox Forma de Pagamento
self.CboxFPagamento(self.cb_FormaPagamento)
""" Fim Chamanda FormaPagamento.py """
# Adicionando numero parcelas
self.cboxParcelas(self.cb_QtdeParcela)
# Return Press Busca Id Produto
self.tx_IdBuscaItem.returnPressed.connect(self.BuscaProdutoIdCompra)
# Busca Produto por nome
self.tx_BuscaItem.returnPressed.connect(self.BuscaProdutoNomeCompra)
# Calculo total produto por qtde item
self.tx_QntdItem.returnPressed.connect(self.TotalItemCompra)
self.tx_ValorUnitarioItem.returnPressed.connect(self.TotalItemCompra)
# Focando campos Obs apos valor do Item
self.tx_ValorUnitarioItem.returnPressed.connect(
self.tx_ObsItem.setFocus)
# Entregar
self.bt_Entregar.clicked.connect(self.ReceberProduto)
# Botao Salvar
self.bt_Salvar.clicked.connect(self.CadCompra)
# Botao Cancelar
self.bt_Voltar.clicked.connect(self.janelaCompras)
#Bota Imprimir
self.bt_Imprimir.clicked.connect(self.imprimirCompra) | [
"def",
"FormCompras",
"(",
"self",
")",
":",
"self",
".",
"DesativaBotaoCompras",
"(",
")",
"self",
".",
"LimpaFrame",
"(",
"self",
".",
"ct_containerCompras",
")",
"super",
"(",
"MainCompras",
",",
"self",
")",
".",
"setFormCompras",
"(",
"self",
".",
"ct_containerCompras",
")",
"self",
".",
"fr_FormCompra",
".",
"show",
"(",
")",
"# Setando Foco no Cliente id TX",
"self",
".",
"tx_Id",
".",
"setFocus",
"(",
")",
"# Checando se existe ID válido",
"self",
".",
"IdCheckCompra",
"(",
")",
"# Setando Datas",
"self",
".",
"setDatas",
"(",
")",
"# Setando Validação",
"self",
".",
"validaCampos",
"(",
")",
"# Definindo acao de calculo de frete e desconto",
"self",
".",
"acaoCalculo",
"(",
")",
"# setando Icone Botoes",
"self",
".",
"setIcones",
"(",
")",
"# Setando tamanho das tabelas",
"self",
".",
"tamanhoTabelas",
"(",
")",
"# setando autocompleye",
"self",
".",
"setAutocomplete",
"(",
")",
"# Gerar Parcelas",
"self",
".",
"bt_GerarParcela",
".",
"clicked",
".",
"connect",
"(",
"partial",
"(",
"self",
".",
"gerarParcela",
",",
"\"Pagar\"",
")",
")",
"# Auto COmplete Produto",
"self",
".",
"tx_BuscaItem",
".",
"textEdited",
".",
"connect",
"(",
"self",
".",
"autocompleteProduto",
")",
"# Add Item Tabela",
"self",
".",
"tx_ObsItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"ValidaFormAdd",
")",
"self",
".",
"bt_IncluirItem",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ValidaFormAdd",
")",
"\"\"\" Fim das chamandas comercial.py\"\"\"",
"\"\"\" Chamanda de funções localizadas no arquivo fornecedor.py na pasta Funcoes \"\"\"",
"# Campo Busca por nome e Autocompletar Fornecedor",
"self",
".",
"tx_NomeFantasia",
".",
"textEdited",
".",
"connect",
"(",
"self",
".",
"autocompleFornecedor",
")",
"self",
".",
"tx_NomeFantasia",
".",
"returnPressed",
".",
"connect",
"(",
"partial",
"(",
"self",
".",
"BuscaFornecedorNome",
",",
"self",
".",
"tx_IdBuscaItem",
")",
")",
"# Return Press Busca Id Fornecedor",
"self",
".",
"tx_Id",
".",
"returnPressed",
".",
"connect",
"(",
"partial",
"(",
"self",
".",
"BuscaFornecedorId",
",",
"self",
".",
"tx_IdBuscaItem",
")",
")",
"\"\"\" Fim chamada fornecedor.py \"\"\"",
"\"\"\" Chamanda de funções localizadas no arquivo FormaPagamento.py na pasta Funcoes \"\"\"",
"# Populando combobox Forma de Pagamento",
"self",
".",
"CboxFPagamento",
"(",
"self",
".",
"cb_FormaPagamento",
")",
"\"\"\" Fim Chamanda FormaPagamento.py \"\"\"",
"# Adicionando numero parcelas",
"self",
".",
"cboxParcelas",
"(",
"self",
".",
"cb_QtdeParcela",
")",
"# Return Press Busca Id Produto",
"self",
".",
"tx_IdBuscaItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"BuscaProdutoIdCompra",
")",
"# Busca Produto por nome",
"self",
".",
"tx_BuscaItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"BuscaProdutoNomeCompra",
")",
"# Calculo total produto por qtde item",
"self",
".",
"tx_QntdItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"TotalItemCompra",
")",
"self",
".",
"tx_ValorUnitarioItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"TotalItemCompra",
")",
"# Focando campos Obs apos valor do Item",
"self",
".",
"tx_ValorUnitarioItem",
".",
"returnPressed",
".",
"connect",
"(",
"self",
".",
"tx_ObsItem",
".",
"setFocus",
")",
"# Entregar",
"self",
".",
"bt_Entregar",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ReceberProduto",
")",
"# Botao Salvar",
"self",
".",
"bt_Salvar",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"CadCompra",
")",
"# Botao Cancelar",
"self",
".",
"bt_Voltar",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"janelaCompras",
")",
"#Bota Imprimir",
"self",
".",
"bt_Imprimir",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"imprimirCompra",
")"
] | [
124,
4
] | [
211,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_lock | () | Obtém lock para evitar que várias mensagens sejam sobrepostas no log | Obtém lock para evitar que várias mensagens sejam sobrepostas no log | def get_lock():
"""Obtém lock para evitar que várias mensagens sejam sobrepostas no log"""
try:
from django.core.cache import cache
cache.default_timeout = 0
if cache._cache and hasattr(cache._cache, 'get_stats'):
stats = cache._cache.get_stats()
else:
stats = []
if stats:
while cache.add('logger_lock', 1, 1) == 0:
time.sleep(0.1)
pass
except ImportError:
dump_file = open('/tmp/networkapi_log_error_dump', 'a')
traceback.print_exc(file=dump_file)
dump_file.close()
pass | [
"def",
"get_lock",
"(",
")",
":",
"try",
":",
"from",
"django",
".",
"core",
".",
"cache",
"import",
"cache",
"cache",
".",
"default_timeout",
"=",
"0",
"if",
"cache",
".",
"_cache",
"and",
"hasattr",
"(",
"cache",
".",
"_cache",
",",
"'get_stats'",
")",
":",
"stats",
"=",
"cache",
".",
"_cache",
".",
"get_stats",
"(",
")",
"else",
":",
"stats",
"=",
"[",
"]",
"if",
"stats",
":",
"while",
"cache",
".",
"add",
"(",
"'logger_lock'",
",",
"1",
",",
"1",
")",
"==",
"0",
":",
"time",
".",
"sleep",
"(",
"0.1",
")",
"pass",
"except",
"ImportError",
":",
"dump_file",
"=",
"open",
"(",
"'/tmp/networkapi_log_error_dump'",
",",
"'a'",
")",
"traceback",
".",
"print_exc",
"(",
"file",
"=",
"dump_file",
")",
"dump_file",
".",
"close",
"(",
")",
"pass"
] | [
38,
0
] | [
58,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
p_OpNegativo | (p) | E : menos E %prec umenos | E : menos E %prec umenos | def p_OpNegativo(p):
''' E : menos E %prec umenos '''
p[0] = SExpresion(p[2], Expresion.NEGATIVO) | [
"def",
"p_OpNegativo",
"(",
"p",
")",
":",
"p",
"[",
"0",
"]",
"=",
"SExpresion",
"(",
"p",
"[",
"2",
"]",
",",
"Expresion",
".",
"NEGATIVO",
")"
] | [
926,
0
] | [
928,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
to_ip | (address) | return socket.gethostbyname(address) | Resolve o endereço IP caso address seja um hostname.
:param address: Hostname ou endereço IP.
:return: Endereço IP correspondente ao endereço informado.
| Resolve o endereço IP caso address seja um hostname. | def to_ip(address):
"""Resolve o endereço IP caso address seja um hostname.
:param address: Hostname ou endereço IP.
:return: Endereço IP correspondente ao endereço informado.
"""
if is_valid_ip(address):
# Se for um ip válido retorna
return address
# Se não for um ip válido tenta resolver o ip considerando que address é
# um hostname
return socket.gethostbyname(address) | [
"def",
"to_ip",
"(",
"address",
")",
":",
"if",
"is_valid_ip",
"(",
"address",
")",
":",
"# Se for um ip válido retorna",
"return",
"address",
"# Se não for um ip válido tenta resolver o ip considerando que address é",
"# um hostname",
"return",
"socket",
".",
"gethostbyname",
"(",
"address",
")"
] | [
87,
0
] | [
99,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Ambiente.update | (cls, authenticated_user, pk, **kwargs) | Efetua a alteração de um Ambiente.
@return: Nothing
@raise AmbienteDuplicatedError: Ambiente duplicado.
@raise AmbienteError: Falha ao alterar o Ambiente.
@raise AmbienteNotFoundError: Não existe um Ambiente para a pk pesquisada.
@raise AmbienteLogicoNotFoundError: Não existe um Ambiente Lógico para a pk pesquisada.
@raise GrupoL3.DoesNotExist: Não existe um Grupo Layer 3 para a pk pesquisada.
@raise DivisaoDcNotFoundError: Não existe uma Divisão DataCenter para a pk pesquisada.
@raise CannotDissociateFilterError: Filter in use, can't be dissociated.
| Efetua a alteração de um Ambiente. | def update(cls, authenticated_user, pk, **kwargs):
"""Efetua a alteração de um Ambiente.
@return: Nothing
@raise AmbienteDuplicatedError: Ambiente duplicado.
@raise AmbienteError: Falha ao alterar o Ambiente.
@raise AmbienteNotFoundError: Não existe um Ambiente para a pk pesquisada.
@raise AmbienteLogicoNotFoundError: Não existe um Ambiente Lógico para a pk pesquisada.
@raise GrupoL3.DoesNotExist: Não existe um Grupo Layer 3 para a pk pesquisada.
@raise DivisaoDcNotFoundError: Não existe uma Divisão DataCenter para a pk pesquisada.
@raise CannotDissociateFilterError: Filter in use, can't be dissociated.
"""
environment = Ambiente().get_by_pk(pk)
old_logic_environment_id = environment.ambiente_logico_id
try:
logic_environment_id = kwargs['ambiente_logico_id']
if (logic_environment_id != environment.ambiente_logico_id):
environment.ambiente_logico = AmbienteLogico.get_by_pk(
logic_environment_id)
except (KeyError):
logic_environment_id = environment.ambiente_logico_id
pass
old_dc_division_id = environment.divisao_dc_id
try:
dc_division_id = kwargs['divisao_dc_id']
if dc_division_id != environment.divisao_dc_id:
environment.divisao_dc = DivisaoDc.get_by_pk(dc_division_id)
except (KeyError):
dc_division_id = environment.divisao_dc_id
pass
old_l3_group_id = environment.grupo_l3_id
try:
l3_group_id = kwargs['grupo_l3_id']
if l3_group_id != environment.grupo_l3_id:
environment.grupo_l3 = GrupoL3.get_by_pk(l3_group_id)
except (KeyError):
l3_group_id = environment.grupo_l3_id
pass
if kwargs['father_environment_id']:
environment.father_environment = Ambiente.get_by_pk(
kwargs['father_environment_id'])
else:
environment.father_environment = None
vrf_model = get_model('api_vrf', 'Vrf')
environment.default_vrf = vrf_model.get_by_pk(
kwargs['default_vrf'])
try:
try:
if not (l3_group_id == old_l3_group_id and
logic_environment_id == old_logic_environment_id and
dc_division_id == old_dc_division_id):
Ambiente.objects.get(grupo_l3__id=l3_group_id,
ambiente_logico__id=logic_environment_id,
divisao_dc__id=dc_division_id)
raise AmbienteDuplicatedError(None, u'Ambiente duplicado.')
except Ambiente.DoesNotExist:
pass
from networkapi.filter.models import check_filter_use
filter_id = kwargs.get('filter_id')
if filter_id != environment.filter_id:
environment = check_filter_use(filter_id, environment)
environment.__dict__.update(kwargs)
environment.save(authenticated_user)
delete_cached_searches_list(ENVIRONMENT_CACHE_ENTRY)
except AmbienteDuplicatedError, e:
raise e
except CannotDissociateFilterError, e:
raise CannotDissociateFilterError(e.cause, e.message)
except Exception, e:
cls.log.error(u'Falha ao alterar Ambiente.')
raise AmbienteError(u'Falha ao alterar Ambiente.') | [
"def",
"update",
"(",
"cls",
",",
"authenticated_user",
",",
"pk",
",",
"*",
"*",
"kwargs",
")",
":",
"environment",
"=",
"Ambiente",
"(",
")",
".",
"get_by_pk",
"(",
"pk",
")",
"old_logic_environment_id",
"=",
"environment",
".",
"ambiente_logico_id",
"try",
":",
"logic_environment_id",
"=",
"kwargs",
"[",
"'ambiente_logico_id'",
"]",
"if",
"(",
"logic_environment_id",
"!=",
"environment",
".",
"ambiente_logico_id",
")",
":",
"environment",
".",
"ambiente_logico",
"=",
"AmbienteLogico",
".",
"get_by_pk",
"(",
"logic_environment_id",
")",
"except",
"(",
"KeyError",
")",
":",
"logic_environment_id",
"=",
"environment",
".",
"ambiente_logico_id",
"pass",
"old_dc_division_id",
"=",
"environment",
".",
"divisao_dc_id",
"try",
":",
"dc_division_id",
"=",
"kwargs",
"[",
"'divisao_dc_id'",
"]",
"if",
"dc_division_id",
"!=",
"environment",
".",
"divisao_dc_id",
":",
"environment",
".",
"divisao_dc",
"=",
"DivisaoDc",
".",
"get_by_pk",
"(",
"dc_division_id",
")",
"except",
"(",
"KeyError",
")",
":",
"dc_division_id",
"=",
"environment",
".",
"divisao_dc_id",
"pass",
"old_l3_group_id",
"=",
"environment",
".",
"grupo_l3_id",
"try",
":",
"l3_group_id",
"=",
"kwargs",
"[",
"'grupo_l3_id'",
"]",
"if",
"l3_group_id",
"!=",
"environment",
".",
"grupo_l3_id",
":",
"environment",
".",
"grupo_l3",
"=",
"GrupoL3",
".",
"get_by_pk",
"(",
"l3_group_id",
")",
"except",
"(",
"KeyError",
")",
":",
"l3_group_id",
"=",
"environment",
".",
"grupo_l3_id",
"pass",
"if",
"kwargs",
"[",
"'father_environment_id'",
"]",
":",
"environment",
".",
"father_environment",
"=",
"Ambiente",
".",
"get_by_pk",
"(",
"kwargs",
"[",
"'father_environment_id'",
"]",
")",
"else",
":",
"environment",
".",
"father_environment",
"=",
"None",
"vrf_model",
"=",
"get_model",
"(",
"'api_vrf'",
",",
"'Vrf'",
")",
"environment",
".",
"default_vrf",
"=",
"vrf_model",
".",
"get_by_pk",
"(",
"kwargs",
"[",
"'default_vrf'",
"]",
")",
"try",
":",
"try",
":",
"if",
"not",
"(",
"l3_group_id",
"==",
"old_l3_group_id",
"and",
"logic_environment_id",
"==",
"old_logic_environment_id",
"and",
"dc_division_id",
"==",
"old_dc_division_id",
")",
":",
"Ambiente",
".",
"objects",
".",
"get",
"(",
"grupo_l3__id",
"=",
"l3_group_id",
",",
"ambiente_logico__id",
"=",
"logic_environment_id",
",",
"divisao_dc__id",
"=",
"dc_division_id",
")",
"raise",
"AmbienteDuplicatedError",
"(",
"None",
",",
"u'Ambiente duplicado.'",
")",
"except",
"Ambiente",
".",
"DoesNotExist",
":",
"pass",
"from",
"networkapi",
".",
"filter",
".",
"models",
"import",
"check_filter_use",
"filter_id",
"=",
"kwargs",
".",
"get",
"(",
"'filter_id'",
")",
"if",
"filter_id",
"!=",
"environment",
".",
"filter_id",
":",
"environment",
"=",
"check_filter_use",
"(",
"filter_id",
",",
"environment",
")",
"environment",
".",
"__dict__",
".",
"update",
"(",
"kwargs",
")",
"environment",
".",
"save",
"(",
"authenticated_user",
")",
"delete_cached_searches_list",
"(",
"ENVIRONMENT_CACHE_ENTRY",
")",
"except",
"AmbienteDuplicatedError",
",",
"e",
":",
"raise",
"e",
"except",
"CannotDissociateFilterError",
",",
"e",
":",
"raise",
"CannotDissociateFilterError",
"(",
"e",
".",
"cause",
",",
"e",
".",
"message",
")",
"except",
"Exception",
",",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao alterar Ambiente.'",
")",
"raise",
"AmbienteError",
"(",
"u'Falha ao alterar Ambiente.'",
")"
] | [
1181,
4
] | [
1271,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
pathHandler | (PATH="") | return newPath | Função global do módulo para construir caminhos relativos ao caminho do módulo
Args:
PATH (type): Caminho relativo `PATH`. Defaults to "".
Returns:
type: Caminho absoluto
| Função global do módulo para construir caminhos relativos ao caminho do módulo | def pathHandler(PATH=""):
"""Função global do módulo para construir caminhos relativos ao caminho do módulo
Args:
PATH (type): Caminho relativo `PATH`. Defaults to "".
Returns:
type: Caminho absoluto
"""
parentDir = os.path.dirname(__file__)
newPath = os.path.join(parentDir, os.path.abspath(PATH))
return newPath | [
"def",
"pathHandler",
"(",
"PATH",
"=",
"\"\"",
")",
":",
"parentDir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
"newPath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"parentDir",
",",
"os",
".",
"path",
".",
"abspath",
"(",
"PATH",
")",
")",
"return",
"newPath"
] | [
57,
0
] | [
69,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
BayesNode.sample | (self, event) | return probability(self.p(True, event)) | Amostra da distribuição para esta variável condicionada
Em valores de eventos para as variáveis_de_mãe. Ou seja, retornar True / False
Aleatoriamente de acordo com a probabilidade condicional dada a
parentes. | Amostra da distribuição para esta variável condicionada
Em valores de eventos para as variáveis_de_mãe. Ou seja, retornar True / False
Aleatoriamente de acordo com a probabilidade condicional dada a
parentes. | def sample(self, event):
"""Amostra da distribuição para esta variável condicionada
Em valores de eventos para as variáveis_de_mãe. Ou seja, retornar True / False
Aleatoriamente de acordo com a probabilidade condicional dada a
parentes."""
return probability(self.p(True, event)) | [
"def",
"sample",
"(",
"self",
",",
"event",
")",
":",
"return",
"probability",
"(",
"self",
".",
"p",
"(",
"True",
",",
"event",
")",
")"
] | [
249,
4
] | [
254,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Correios.detalhe | (self, posicao=0) | return self._parse_detalhe(html) | Retorna o detalhe de um CEP da última lista de resultados | Retorna o detalhe de um CEP da última lista de resultados | def detalhe(self, posicao=0):
"""Retorna o detalhe de um CEP da última lista de resultados"""
handle = self._url_open('detalheCEPAction.do', {'Metodo': 'detalhe',
'TipoCep': 2,
'Posicao': posicao + 1,
'CEP': ''})
html = handle.read()
return self._parse_detalhe(html) | [
"def",
"detalhe",
"(",
"self",
",",
"posicao",
"=",
"0",
")",
":",
"handle",
"=",
"self",
".",
"_url_open",
"(",
"'detalheCEPAction.do'",
",",
"{",
"'Metodo'",
":",
"'detalhe'",
",",
"'TipoCep'",
":",
"2",
",",
"'Posicao'",
":",
"posicao",
"+",
"1",
",",
"'CEP'",
":",
"''",
"}",
")",
"html",
"=",
"handle",
".",
"read",
"(",
")",
"return",
"self",
".",
"_parse_detalhe",
"(",
"html",
")"
] | [
73,
4
] | [
80,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Log.__init_log | (self,
log_file_name,
number_of_days_to_log,
log_level,
log_format,
use_stdout,
max_line_size) | Cria o logger com os parâmetros especificados | Cria o logger com os parâmetros especificados | def __init_log(self,
log_file_name,
number_of_days_to_log,
log_level,
log_format,
use_stdout,
max_line_size):
"""Cria o logger com os parâmetros especificados"""
# obtém o logger
self.logger = logging.getLogger()
my_filter = ExtraLoggingFilter('extra_logging')
self.logger.addFilter(my_filter)
if len(self.logger.handlers) == 0:
# if not self.__is_handler_added(self.logger, MultiprocessTimedRotatingFileHandler):
# LOG.info("#### initializing handler
# MultiprocessTimedRotatingFileHandler log...")
log_dir = os.path.split(log_file_name)[0]
if not os.path.exists(log_dir):
os.makedirs(log_dir, mode=0755)
fh = MultiprocessTimedRotatingFileHandler(log_file_name,
'midnight',
backupCount=number_of_days_to_log,
encoding='utf-8')
fmt = NetworkAPILogFormatter(log_format)
fh.addFilter(my_filter)
fh.setFormatter(fmt)
self.logger.setLevel(log_level)
self.logger.addHandler(fh)
if use_stdout:
sh = logging.StreamHandler(sys.stdout)
sh.addFilter(my_filter)
sh.setFormatter(fmt)
self.logger.addHandler(sh) | [
"def",
"__init_log",
"(",
"self",
",",
"log_file_name",
",",
"number_of_days_to_log",
",",
"log_level",
",",
"log_format",
",",
"use_stdout",
",",
"max_line_size",
")",
":",
"# obtém o logger",
"self",
".",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"my_filter",
"=",
"ExtraLoggingFilter",
"(",
"'extra_logging'",
")",
"self",
".",
"logger",
".",
"addFilter",
"(",
"my_filter",
")",
"if",
"len",
"(",
"self",
".",
"logger",
".",
"handlers",
")",
"==",
"0",
":",
"# if not self.__is_handler_added(self.logger, MultiprocessTimedRotatingFileHandler):",
"# LOG.info(\"#### initializing handler",
"# MultiprocessTimedRotatingFileHandler log...\")",
"log_dir",
"=",
"os",
".",
"path",
".",
"split",
"(",
"log_file_name",
")",
"[",
"0",
"]",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"log_dir",
")",
":",
"os",
".",
"makedirs",
"(",
"log_dir",
",",
"mode",
"=",
"0755",
")",
"fh",
"=",
"MultiprocessTimedRotatingFileHandler",
"(",
"log_file_name",
",",
"'midnight'",
",",
"backupCount",
"=",
"number_of_days_to_log",
",",
"encoding",
"=",
"'utf-8'",
")",
"fmt",
"=",
"NetworkAPILogFormatter",
"(",
"log_format",
")",
"fh",
".",
"addFilter",
"(",
"my_filter",
")",
"fh",
".",
"setFormatter",
"(",
"fmt",
")",
"self",
".",
"logger",
".",
"setLevel",
"(",
"log_level",
")",
"self",
".",
"logger",
".",
"addHandler",
"(",
"fh",
")",
"if",
"use_stdout",
":",
"sh",
"=",
"logging",
".",
"StreamHandler",
"(",
"sys",
".",
"stdout",
")",
"sh",
".",
"addFilter",
"(",
"my_filter",
")",
"sh",
".",
"setFormatter",
"(",
"fmt",
")",
"self",
".",
"logger",
".",
"addHandler",
"(",
"sh",
")"
] | [
163,
4
] | [
200,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
describe_city | (city, country = 'Brasil') | Exibe informções de localização de uma cidade | Exibe informções de localização de uma cidade | def describe_city(city, country = 'Brasil'):
"""Exibe informções de localização de uma cidade"""
print(f'{city} está localizada no(a) {country}!') | [
"def",
"describe_city",
"(",
"city",
",",
"country",
"=",
"'Brasil'",
")",
":",
"print",
"(",
"f'{city} está localizada no(a) {country}!')",
""
] | [
5,
0
] | [
7,
54
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
packing_assets | (asset_replacements, pkg_path, incomplete_pkg_path, pkg_name,
scielo_pid_v2) | return pkg_path | Tem a responsabilidade de ``empacotar`` os ativos digitais e retorna o
path do pacote.
Args:
asset_replacements: lista com os ativos
pkg_path: caminho do pacote
incomplete_pkg_path: caminho para os pacotes incompletos
pkg_name: nome do pacote
scielo_pid_v2: PID v2
Retornos:
retorna o caminho ``pkg_path`` ou incomplete_pkg_path
Exceções:
Não lança exceções.
| Tem a responsabilidade de ``empacotar`` os ativos digitais e retorna o
path do pacote. | def packing_assets(asset_replacements, pkg_path, incomplete_pkg_path, pkg_name,
scielo_pid_v2):
"""Tem a responsabilidade de ``empacotar`` os ativos digitais e retorna o
path do pacote.
Args:
asset_replacements: lista com os ativos
pkg_path: caminho do pacote
incomplete_pkg_path: caminho para os pacotes incompletos
pkg_name: nome do pacote
scielo_pid_v2: PID v2
Retornos:
retorna o caminho ``pkg_path`` ou incomplete_pkg_path
Exceções:
Não lança exceções.
"""
errors = []
if not os.path.isdir(pkg_path):
files.make_empty_dir(pkg_path)
for old_path, new_fname in asset_replacements:
try:
get_asset(old_path, new_fname, pkg_path)
except AssetNotFoundError as e:
logger.error(
"%s", {
"pid": scielo_pid_v2,
"pkg_name": pkg_name,
"old_path": old_path,
"new_fname": new_fname,
"msg": str(e),
})
errors.append((old_path, new_fname, str(e)))
if len(errors) > 0:
# garante que existe pastas diferentes para
# pacotes completos e incompletos
if pkg_path == incomplete_pkg_path:
incomplete_pkg_path += "_INCOMPLETE"
# move pacote incompleto para a pasta de pacotes incompletos
files.make_empty_dir(incomplete_pkg_path)
for item in os.listdir(pkg_path):
shutil.move(os.path.join(pkg_path, item), incomplete_pkg_path)
shutil.rmtree(pkg_path)
# gera relatorio de erros
errors_filename = os.path.join(incomplete_pkg_path, "%s.err" % pkg_name)
error_messages = "\n".join(["%s %s %s" % _err for _err in errors])
files.write_file(errors_filename, error_messages)
return incomplete_pkg_path
return pkg_path | [
"def",
"packing_assets",
"(",
"asset_replacements",
",",
"pkg_path",
",",
"incomplete_pkg_path",
",",
"pkg_name",
",",
"scielo_pid_v2",
")",
":",
"errors",
"=",
"[",
"]",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"pkg_path",
")",
":",
"files",
".",
"make_empty_dir",
"(",
"pkg_path",
")",
"for",
"old_path",
",",
"new_fname",
"in",
"asset_replacements",
":",
"try",
":",
"get_asset",
"(",
"old_path",
",",
"new_fname",
",",
"pkg_path",
")",
"except",
"AssetNotFoundError",
"as",
"e",
":",
"logger",
".",
"error",
"(",
"\"%s\"",
",",
"{",
"\"pid\"",
":",
"scielo_pid_v2",
",",
"\"pkg_name\"",
":",
"pkg_name",
",",
"\"old_path\"",
":",
"old_path",
",",
"\"new_fname\"",
":",
"new_fname",
",",
"\"msg\"",
":",
"str",
"(",
"e",
")",
",",
"}",
")",
"errors",
".",
"append",
"(",
"(",
"old_path",
",",
"new_fname",
",",
"str",
"(",
"e",
")",
")",
")",
"if",
"len",
"(",
"errors",
")",
">",
"0",
":",
"# garante que existe pastas diferentes para",
"# pacotes completos e incompletos",
"if",
"pkg_path",
"==",
"incomplete_pkg_path",
":",
"incomplete_pkg_path",
"+=",
"\"_INCOMPLETE\"",
"# move pacote incompleto para a pasta de pacotes incompletos",
"files",
".",
"make_empty_dir",
"(",
"incomplete_pkg_path",
")",
"for",
"item",
"in",
"os",
".",
"listdir",
"(",
"pkg_path",
")",
":",
"shutil",
".",
"move",
"(",
"os",
".",
"path",
".",
"join",
"(",
"pkg_path",
",",
"item",
")",
",",
"incomplete_pkg_path",
")",
"shutil",
".",
"rmtree",
"(",
"pkg_path",
")",
"# gera relatorio de erros",
"errors_filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"incomplete_pkg_path",
",",
"\"%s.err\"",
"%",
"pkg_name",
")",
"error_messages",
"=",
"\"\\n\"",
".",
"join",
"(",
"[",
"\"%s %s %s\"",
"%",
"_err",
"for",
"_err",
"in",
"errors",
"]",
")",
"files",
".",
"write_file",
"(",
"errors_filename",
",",
"error_messages",
")",
"return",
"incomplete_pkg_path",
"return",
"pkg_path"
] | [
194,
0
] | [
245,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ListaBemLoka.__lshift__ | (self, val) | Fazer append na lista usando << | Fazer append na lista usando << | def __lshift__(self, val):
"""Fazer append na lista usando <<"""
self.append(val) | [
"def",
"__lshift__",
"(",
"self",
",",
"val",
")",
":",
"self",
".",
"append",
"(",
"val",
")"
] | [
5,
4
] | [
7,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Telnet.session_close | (self) | Encerra a sessão. | Encerra a sessão. | def session_close(self):
"""Encerra a sessão."""
if self.telnet:
self.telnet.close()
return f'TELNET: Sessão telnet encerrada em {self.router}.'
else:
return f'TELNET: Sessão já finalizada em {self.router}.' | [
"def",
"session_close",
"(",
"self",
")",
":",
"if",
"self",
".",
"telnet",
":",
"self",
".",
"telnet",
".",
"close",
"(",
")",
"return",
"f'TELNET: Sessão telnet encerrada em {self.router}.'",
"else",
":",
"return",
"f'TELNET: Sessão já finalizada em {self.router}.'"
] | [
49,
4
] | [
58,
70
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
suma | (a: float, b: float) | return a + b | Suma dos números.
:param a: Primer número.
:a type: float
:param b: Segundo número.
:b type: float
:return: La suma de los dos números.
:rtype: float
| Suma dos números. | def suma(a: float, b: float) -> float:
"""Suma dos números.
:param a: Primer número.
:a type: float
:param b: Segundo número.
:b type: float
:return: La suma de los dos números.
:rtype: float
"""
return a + b | [
"def",
"suma",
"(",
"a",
":",
"float",
",",
"b",
":",
"float",
")",
"->",
"float",
":",
"return",
"a",
"+",
"b"
] | [
6,
0
] | [
16,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
CreateVipResource.handle_put | (self, request, user, *args, **kwargs) | Trata as requisições de PUT para atualizar/criar uma requisição de VIP.
URLs: vip/<id_vip>/, vip/<id_vip>/criar/
| Trata as requisições de PUT para atualizar/criar uma requisição de VIP. | def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para atualizar/criar uma requisição de VIP.
URLs: vip/<id_vip>/, vip/<id_vip>/criar/
"""
try:
vip_id = kwargs.get('id_vip')
if vip_id is None:
return self.response_error(243)
return self.__create_vip(vip_id, user)
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except (RequisicaoVipsNotFoundError):
return self.response_error(152)
except (RequisicaoVipsError, GrupoError, HealthcheckExpectError, EquipamentoError, IpError):
return self.response_error(1) | [
"def",
"handle_put",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"vip_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_vip'",
")",
"if",
"vip_id",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"243",
")",
"return",
"self",
".",
"__create_vip",
"(",
"vip_id",
",",
"user",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"(",
"RequisicaoVipsNotFoundError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"152",
")",
"except",
"(",
"RequisicaoVipsError",
",",
"GrupoError",
",",
"HealthcheckExpectError",
",",
"EquipamentoError",
",",
"IpError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
174,
4
] | [
192,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
create_mixed_citation_element | (citation_text: str) | return new_mixed_citation | Cria um elemento `mixed-citation` a partir do texto informado.
Durante a criação do elemento `mixed-citation` são aplicados tratamentos no
texto para normatizar os elementos interiores.
Params:
citation_text (str): Texto da citação
Returns:
new_mixed_citation (etree.Element): Nova citação produzida a partir do
texto informado.
| Cria um elemento `mixed-citation` a partir do texto informado. | def create_mixed_citation_element(citation_text: str) -> etree.Element:
"""Cria um elemento `mixed-citation` a partir do texto informado.
Durante a criação do elemento `mixed-citation` são aplicados tratamentos no
texto para normatizar os elementos interiores.
Params:
citation_text (str): Texto da citação
Returns:
new_mixed_citation (etree.Element): Nova citação produzida a partir do
texto informado.
"""
new_mixed_citation = etree.parse(
StringIO(html_safe_decode(citation_text)), parser=etree.HTMLParser()
)
convert_html_tags_to_jats(new_mixed_citation)
convert_ahref_to_extlink(new_mixed_citation)
if new_mixed_citation.find(".//p") is not None:
new_mixed_citation = new_mixed_citation.find(".//p")
elif new_mixed_citation.find(".//body") is not None:
new_mixed_citation = new_mixed_citation.find(".//body")
new_mixed_citation.tag = "mixed-citation"
return new_mixed_citation | [
"def",
"create_mixed_citation_element",
"(",
"citation_text",
":",
"str",
")",
"->",
"etree",
".",
"Element",
":",
"new_mixed_citation",
"=",
"etree",
".",
"parse",
"(",
"StringIO",
"(",
"html_safe_decode",
"(",
"citation_text",
")",
")",
",",
"parser",
"=",
"etree",
".",
"HTMLParser",
"(",
")",
")",
"convert_html_tags_to_jats",
"(",
"new_mixed_citation",
")",
"convert_ahref_to_extlink",
"(",
"new_mixed_citation",
")",
"if",
"new_mixed_citation",
".",
"find",
"(",
"\".//p\"",
")",
"is",
"not",
"None",
":",
"new_mixed_citation",
"=",
"new_mixed_citation",
".",
"find",
"(",
"\".//p\"",
")",
"elif",
"new_mixed_citation",
".",
"find",
"(",
"\".//body\"",
")",
"is",
"not",
"None",
":",
"new_mixed_citation",
"=",
"new_mixed_citation",
".",
"find",
"(",
"\".//body\"",
")",
"new_mixed_citation",
".",
"tag",
"=",
"\"mixed-citation\"",
"return",
"new_mixed_citation"
] | [
177,
0
] | [
204,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
update_screen | (ai_settings, screen, stats, sb, ship, aliens, bullets, play_button) | Atualiza as imagens na tela e alterna para a nova tela | Atualiza as imagens na tela e alterna para a nova tela | def update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button):
"""Atualiza as imagens na tela e alterna para a nova tela"""
# Redesenha a tela a cada passagem pelo laco
screen.fill(ai_settings.bg_color)
# Desenha a informacao sobre pontuacao
sb.show_score()
# Redesenha todos os projeteis atras da espaconave e dos alienigenas
for bullet in bullets.sprites():
bullet.draw_bullet()
ship.blitme()
aliens.draw(screen)
# Desenha o botao Play se o jogo estiver inativo
if not stats.game_active:
play_button.draw_button()
# Deixa a tela mais recente visivel
pygame.display.flip() | [
"def",
"update_screen",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
",",
"play_button",
")",
":",
"# Redesenha a tela a cada passagem pelo laco",
"screen",
".",
"fill",
"(",
"ai_settings",
".",
"bg_color",
")",
"# Desenha a informacao sobre pontuacao",
"sb",
".",
"show_score",
"(",
")",
"# Redesenha todos os projeteis atras da espaconave e dos alienigenas",
"for",
"bullet",
"in",
"bullets",
".",
"sprites",
"(",
")",
":",
"bullet",
".",
"draw_bullet",
"(",
")",
"ship",
".",
"blitme",
"(",
")",
"aliens",
".",
"draw",
"(",
"screen",
")",
"# Desenha o botao Play se o jogo estiver inativo",
"if",
"not",
"stats",
".",
"game_active",
":",
"play_button",
".",
"draw_button",
"(",
")",
"# Deixa a tela mais recente visivel",
"pygame",
".",
"display",
".",
"flip",
"(",
")"
] | [
80,
0
] | [
100,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_nome | (id) | Pega o nome de um socio pelo id. | Pega o nome de um socio pelo id. | def get_nome(id):
"""Pega o nome de um socio pelo id."""
if request.method == 'GET':
try:
socio = get_socio(id)
return json.dumps({ 'nome': socio['nome'] })
except Exception as e:
return json.dumps({ 'msg': 'Sócio não encontrado' })
| [
"def",
"get_nome",
"(",
"id",
")",
":",
"if",
"request",
".",
"method",
"==",
"'GET'",
":",
"try",
":",
"socio",
"=",
"get_socio",
"(",
"id",
")",
"return",
"json",
".",
"dumps",
"(",
"{",
"'nome'",
":",
"socio",
"[",
"'nome'",
"]",
"}",
")",
"except",
"Exception",
"as",
"e",
":",
"return",
"json",
".",
"dumps",
"(",
"{",
"'msg'",
":",
"'Sócio não encontrado' }",
"\r",
""
] | [
59,
0
] | [
67,
66
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
list_caixas | (request) | return render(request, "list_caixas.html", dados) | Lista Vendas do caixa do Funcionário | Lista Vendas do caixa do Funcionário | def list_caixas(request):
""" Lista Vendas do caixa do Funcionário"""
usuario = request.user
dados = {}
try:
funcionario = Funcionario.objects.get(usuario_fun=usuario)
except Exception:
raise Http404()
if funcionario:
#id pesquisa
termo_pesquisa = request.GET.get('pesquisa', None)
# Datas não esta sendo usado.
termo_data_inicial = request.GET.get('data_inicial', None)
termo_data_final = request.GET.get('data_final', None)
# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO
if termo_pesquisa:
caixas = Ven_Caixa.objects.all()
#__icontains sem case sensitive
caixas = caixas.filter(nome_caixa__icontains=termo_pesquisa)
elif termo_data_inicial or termo_data_final:
caixas = Ven_Caixa.objects.all()
if termo_data_inicial == "":
termo_data_inicial = '2000-01-01'
if termo_data_final == "":
termo_data_final = datetime.now().strftime('%Y-%m-%d')
if termo_data_inicial > termo_data_final:
messages.error(request,
"Data inicial não pode ser maior que data final.")
caixas = caixas.filter(
data__range=[termo_data_inicial, termo_data_final])
else:
caixas_list = Ven_Caixa.objects.filter().order_by(
'-referencial')
paginator = Paginator(caixas_list, 10)
page = request.GET.get('page')
caixas = paginator.get_page(page)
dados = {"funcionario": funcionario, "caixas": caixas}
else:
raise Http404()
return render(request, "list_caixas.html", dados) | [
"def",
"list_caixas",
"(",
"request",
")",
":",
"usuario",
"=",
"request",
".",
"user",
"dados",
"=",
"{",
"}",
"try",
":",
"funcionario",
"=",
"Funcionario",
".",
"objects",
".",
"get",
"(",
"usuario_fun",
"=",
"usuario",
")",
"except",
"Exception",
":",
"raise",
"Http404",
"(",
")",
"if",
"funcionario",
":",
"#id pesquisa",
"termo_pesquisa",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'pesquisa'",
",",
"None",
")",
"# Datas não esta sendo usado.",
"termo_data_inicial",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'data_inicial'",
",",
"None",
")",
"termo_data_final",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'data_final'",
",",
"None",
")",
"# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO",
"if",
"termo_pesquisa",
":",
"caixas",
"=",
"Ven_Caixa",
".",
"objects",
".",
"all",
"(",
")",
"#__icontains sem case sensitive",
"caixas",
"=",
"caixas",
".",
"filter",
"(",
"nome_caixa__icontains",
"=",
"termo_pesquisa",
")",
"elif",
"termo_data_inicial",
"or",
"termo_data_final",
":",
"caixas",
"=",
"Ven_Caixa",
".",
"objects",
".",
"all",
"(",
")",
"if",
"termo_data_inicial",
"==",
"\"\"",
":",
"termo_data_inicial",
"=",
"'2000-01-01'",
"if",
"termo_data_final",
"==",
"\"\"",
":",
"termo_data_final",
"=",
"datetime",
".",
"now",
"(",
")",
".",
"strftime",
"(",
"'%Y-%m-%d'",
")",
"if",
"termo_data_inicial",
">",
"termo_data_final",
":",
"messages",
".",
"error",
"(",
"request",
",",
"\"Data inicial não pode ser maior que data final.\")",
"",
"caixas",
"=",
"caixas",
".",
"filter",
"(",
"data__range",
"=",
"[",
"termo_data_inicial",
",",
"termo_data_final",
"]",
")",
"else",
":",
"caixas_list",
"=",
"Ven_Caixa",
".",
"objects",
".",
"filter",
"(",
")",
".",
"order_by",
"(",
"'-referencial'",
")",
"paginator",
"=",
"Paginator",
"(",
"caixas_list",
",",
"10",
")",
"page",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'page'",
")",
"caixas",
"=",
"paginator",
".",
"get_page",
"(",
"page",
")",
"dados",
"=",
"{",
"\"funcionario\"",
":",
"funcionario",
",",
"\"caixas\"",
":",
"caixas",
"}",
"else",
":",
"raise",
"Http404",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"list_caixas.html\"",
",",
"dados",
")"
] | [
826,
0
] | [
868,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
validate_cpf | (cpf) | return False | Rotina para validação do CPF - Cadastro Nacional
de Pessoa Física.
:Return: True or False
:Parameters:
- 'cpf': CPF to be validate.
| Rotina para validação do CPF - Cadastro Nacional
de Pessoa Física.
:Return: True or False
:Parameters:
- 'cpf': CPF to be validate.
| def validate_cpf(cpf):
"""Rotina para validação do CPF - Cadastro Nacional
de Pessoa Física.
:Return: True or False
:Parameters:
- 'cpf': CPF to be validate.
"""
cpf = re.sub('[^0-9]', '', cpf)
if len(cpf) != 11 or cpf == cpf[0] * len(cpf):
return False
# Pega apenas os 9 primeiros dígitos do CPF e gera os 2 dígitos que faltam
cpf = list(map(int, cpf))
novo = cpf[:9]
while len(novo) < 11:
r = sum([(len(novo) + 1 - i) * v for i, v in enumerate(novo)]) % 11
if r > 1:
f = 11 - r
else:
f = 0
novo.append(f)
# Se o número gerado coincidir com o número original, é válido
if novo == cpf:
return True
return False | [
"def",
"validate_cpf",
"(",
"cpf",
")",
":",
"cpf",
"=",
"re",
".",
"sub",
"(",
"'[^0-9]'",
",",
"''",
",",
"cpf",
")",
"if",
"len",
"(",
"cpf",
")",
"!=",
"11",
"or",
"cpf",
"==",
"cpf",
"[",
"0",
"]",
"*",
"len",
"(",
"cpf",
")",
":",
"return",
"False",
"# Pega apenas os 9 primeiros dígitos do CPF e gera os 2 dígitos que faltam",
"cpf",
"=",
"list",
"(",
"map",
"(",
"int",
",",
"cpf",
")",
")",
"novo",
"=",
"cpf",
"[",
":",
"9",
"]",
"while",
"len",
"(",
"novo",
")",
"<",
"11",
":",
"r",
"=",
"sum",
"(",
"[",
"(",
"len",
"(",
"novo",
")",
"+",
"1",
"-",
"i",
")",
"*",
"v",
"for",
"i",
",",
"v",
"in",
"enumerate",
"(",
"novo",
")",
"]",
")",
"%",
"11",
"if",
"r",
">",
"1",
":",
"f",
"=",
"11",
"-",
"r",
"else",
":",
"f",
"=",
"0",
"novo",
".",
"append",
"(",
"f",
")",
"# Se o número gerado coincidir com o número original, é válido",
"if",
"novo",
"==",
"cpf",
":",
"return",
"True",
"return",
"False"
] | [
453,
0
] | [
481,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
create_fleet | (ai_settings, screen, ship, aliens) | Cria uma frota completa de alienigenas | Cria uma frota completa de alienigenas | def create_fleet(ai_settings, screen, ship, aliens):
"""Cria uma frota completa de alienigenas"""
# Cria um alien e calcula o número de aliens em uma linha
# O espaçamento entre os aliens é igual à largura de um alienigena
alien = Alien(ai_settings, screen)
number_aliens_x = get_number_aliens_x(ai_settings, alien.rect.width)
number_rows = get_number_rows(ai_settings, ship.rect.height, alien.rect.height)
#Cria a frota de alienigenas
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
create_aliens(ai_settings, screen, aliens, alien_number, row_number) | [
"def",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
":",
"# Cria um alien e calcula o número de aliens em uma linha",
"# O espaçamento entre os aliens é igual à largura de um alienigena",
"alien",
"=",
"Alien",
"(",
"ai_settings",
",",
"screen",
")",
"number_aliens_x",
"=",
"get_number_aliens_x",
"(",
"ai_settings",
",",
"alien",
".",
"rect",
".",
"width",
")",
"number_rows",
"=",
"get_number_rows",
"(",
"ai_settings",
",",
"ship",
".",
"rect",
".",
"height",
",",
"alien",
".",
"rect",
".",
"height",
")",
"#Cria a frota de alienigenas",
"for",
"row_number",
"in",
"range",
"(",
"number_rows",
")",
":",
"for",
"alien_number",
"in",
"range",
"(",
"number_aliens_x",
")",
":",
"create_aliens",
"(",
"ai_settings",
",",
"screen",
",",
"aliens",
",",
"alien_number",
",",
"row_number",
")"
] | [
219,
0
] | [
230,
80
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
pack_article_xml | (file_xml_path, poison_pill=PoisonPill()) | Empacoda um xml e seus ativos digitais.
Args:
file_xml_path: Caminho para o XML
poison_pill: Injeta um PosionPill()
Retornos:
Sem retornos.
Persiste o XML no ``package_path``
Exemplo:
packing.pack_article_xml(
os.path.join("S0044-59672003000300002.xml")
)
Exceções:
Não lança exceções.
| Empacoda um xml e seus ativos digitais. | def pack_article_xml(file_xml_path, poison_pill=PoisonPill()):
"""Empacoda um xml e seus ativos digitais.
Args:
file_xml_path: Caminho para o XML
poison_pill: Injeta um PosionPill()
Retornos:
Sem retornos.
Persiste o XML no ``package_path``
Exemplo:
packing.pack_article_xml(
os.path.join("S0044-59672003000300002.xml")
)
Exceções:
Não lança exceções.
"""
if poison_pill.poisoned:
return
original_filename, ign = files.extract_filename_ext_by_path(file_xml_path)
obj_xml = xml.file2objXML(file_xml_path)
sps_package = SPS_Package(obj_xml, original_filename)
sps_package.fix(
"article_id_which_id_type_is_other",
sps_package.scielo_pid_v2 and sps_package.scielo_pid_v2[-5:],
silently=True
)
new_issns = ISSNs and ISSNs.get(sps_package.scielo_pid_v2[1:10])
if new_issns:
sps_package.fix("issns", new_issns, silently=True)
SPS_PKG_PATH = config.get("SPS_PKG_PATH")
INCOMPLETE_SPS_PKG_PATH = config.get("INCOMPLETE_SPS_PKG_PATH")
pkg_path = os.path.join(SPS_PKG_PATH, original_filename)
incomplete_pkg_path = os.path.join(INCOMPLETE_SPS_PKG_PATH, original_filename)
asset_replacements = list(set(sps_package.replace_assets_names()))
logger.debug("%s possui %s ativos digitais", file_xml_path, len(asset_replacements))
source_json = get_source_json(sps_package.scielo_pid_v2)
renditions, renditions_metadata = source_json.get_renditions_metadata()
logger.debug("%s possui %s renditions", file_xml_path, len(renditions))
package_path = packing_assets(
asset_replacements + renditions,
pkg_path,
incomplete_pkg_path,
sps_package.package_name,
sps_package.scielo_pid_v2,
)
files.write_file(
os.path.join(package_path, "manifest.json"),
json.dumps(renditions_metadata)
)
xml.objXML2file(
os.path.join(package_path, "%s.xml" % (sps_package.package_name)), obj_xml
) | [
"def",
"pack_article_xml",
"(",
"file_xml_path",
",",
"poison_pill",
"=",
"PoisonPill",
"(",
")",
")",
":",
"if",
"poison_pill",
".",
"poisoned",
":",
"return",
"original_filename",
",",
"ign",
"=",
"files",
".",
"extract_filename_ext_by_path",
"(",
"file_xml_path",
")",
"obj_xml",
"=",
"xml",
".",
"file2objXML",
"(",
"file_xml_path",
")",
"sps_package",
"=",
"SPS_Package",
"(",
"obj_xml",
",",
"original_filename",
")",
"sps_package",
".",
"fix",
"(",
"\"article_id_which_id_type_is_other\"",
",",
"sps_package",
".",
"scielo_pid_v2",
"and",
"sps_package",
".",
"scielo_pid_v2",
"[",
"-",
"5",
":",
"]",
",",
"silently",
"=",
"True",
")",
"new_issns",
"=",
"ISSNs",
"and",
"ISSNs",
".",
"get",
"(",
"sps_package",
".",
"scielo_pid_v2",
"[",
"1",
":",
"10",
"]",
")",
"if",
"new_issns",
":",
"sps_package",
".",
"fix",
"(",
"\"issns\"",
",",
"new_issns",
",",
"silently",
"=",
"True",
")",
"SPS_PKG_PATH",
"=",
"config",
".",
"get",
"(",
"\"SPS_PKG_PATH\"",
")",
"INCOMPLETE_SPS_PKG_PATH",
"=",
"config",
".",
"get",
"(",
"\"INCOMPLETE_SPS_PKG_PATH\"",
")",
"pkg_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"SPS_PKG_PATH",
",",
"original_filename",
")",
"incomplete_pkg_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"INCOMPLETE_SPS_PKG_PATH",
",",
"original_filename",
")",
"asset_replacements",
"=",
"list",
"(",
"set",
"(",
"sps_package",
".",
"replace_assets_names",
"(",
")",
")",
")",
"logger",
".",
"debug",
"(",
"\"%s possui %s ativos digitais\"",
",",
"file_xml_path",
",",
"len",
"(",
"asset_replacements",
")",
")",
"source_json",
"=",
"get_source_json",
"(",
"sps_package",
".",
"scielo_pid_v2",
")",
"renditions",
",",
"renditions_metadata",
"=",
"source_json",
".",
"get_renditions_metadata",
"(",
")",
"logger",
".",
"debug",
"(",
"\"%s possui %s renditions\"",
",",
"file_xml_path",
",",
"len",
"(",
"renditions",
")",
")",
"package_path",
"=",
"packing_assets",
"(",
"asset_replacements",
"+",
"renditions",
",",
"pkg_path",
",",
"incomplete_pkg_path",
",",
"sps_package",
".",
"package_name",
",",
"sps_package",
".",
"scielo_pid_v2",
",",
")",
"files",
".",
"write_file",
"(",
"os",
".",
"path",
".",
"join",
"(",
"package_path",
",",
"\"manifest.json\"",
")",
",",
"json",
".",
"dumps",
"(",
"renditions_metadata",
")",
")",
"xml",
".",
"objXML2file",
"(",
"os",
".",
"path",
".",
"join",
"(",
"package_path",
",",
"\"%s.xml\"",
"%",
"(",
"sps_package",
".",
"package_name",
")",
")",
",",
"obj_xml",
")"
] | [
36,
0
] | [
100,
5
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Poller.despache_simples | (self) | return True | Espera por um único evento, tratando-o com seu callback. Retorna True se
tratou um evento, e False se nenhum evento foi gerado porque os callbacks
estão desativados. | Espera por um único evento, tratando-o com seu callback. Retorna True se
tratou um evento, e False se nenhum evento foi gerado porque os callbacks
estão desativados. | def despache_simples(self):
'''Espera por um único evento, tratando-o com seu callback. Retorna True se
tratou um evento, e False se nenhum evento foi gerado porque os callbacks
estão desativados.'''
t1 = time.time()
cb_to = self._timeout()
if cb_to != None:
tout = cb_to.timeout
else:
tout = None
eventos = self._get_events(tout)
if eventos == None: # fim: nada a fazer !!
return False
fired = set()
if not eventos: # timeout !
if cb_to != None:
fired.add(cb_to)
cb_to.handle_timeout()
cb_to.reload_timeout()
else:
for key, mask in eventos:
cb = key.data # este é o callback !
fired.add(cb)
cb.handle()
cb.reload_timeout()
dt = time.time() - t1
for cb in self.cbs_to:
if not cb in fired: cb.update(dt)
for cb in self.cbs:
if not cb in fired: cb.update(dt)
return True | [
"def",
"despache_simples",
"(",
"self",
")",
":",
"t1",
"=",
"time",
".",
"time",
"(",
")",
"cb_to",
"=",
"self",
".",
"_timeout",
"(",
")",
"if",
"cb_to",
"!=",
"None",
":",
"tout",
"=",
"cb_to",
".",
"timeout",
"else",
":",
"tout",
"=",
"None",
"eventos",
"=",
"self",
".",
"_get_events",
"(",
"tout",
")",
"if",
"eventos",
"==",
"None",
":",
"# fim: nada a fazer !!",
"return",
"False",
"fired",
"=",
"set",
"(",
")",
"if",
"not",
"eventos",
":",
"# timeout !",
"if",
"cb_to",
"!=",
"None",
":",
"fired",
".",
"add",
"(",
"cb_to",
")",
"cb_to",
".",
"handle_timeout",
"(",
")",
"cb_to",
".",
"reload_timeout",
"(",
")",
"else",
":",
"for",
"key",
",",
"mask",
"in",
"eventos",
":",
"cb",
"=",
"key",
".",
"data",
"# este é o callback !",
"fired",
".",
"add",
"(",
"cb",
")",
"cb",
".",
"handle",
"(",
")",
"cb",
".",
"reload_timeout",
"(",
")",
"dt",
"=",
"time",
".",
"time",
"(",
")",
"-",
"t1",
"for",
"cb",
"in",
"self",
".",
"cbs_to",
":",
"if",
"not",
"cb",
"in",
"fired",
":",
"cb",
".",
"update",
"(",
"dt",
")",
"for",
"cb",
"in",
"self",
".",
"cbs",
":",
"if",
"not",
"cb",
"in",
"fired",
":",
"cb",
".",
"update",
"(",
"dt",
")",
"return",
"True"
] | [
146,
4
] | [
176,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
CallbackEnquadramento.enquadra | (self, dado) | return self.flag + msg + self.flag | Realiza o enquadramento | Realiza o enquadramento | def enquadra(self, dado):
'''Realiza o enquadramento'''
msg = bytearray()
for c in dado:
byteC = (c.to_bytes(1, 'little'))
if byteC == self.flag:
c = self.esc + self.e
msg += c
elif byteC == self.esc:
c = self.esc + self.d
msg += c
else:
msg.append(c)
return self.flag + msg + self.flag | [
"def",
"enquadra",
"(",
"self",
",",
"dado",
")",
":",
"msg",
"=",
"bytearray",
"(",
")",
"for",
"c",
"in",
"dado",
":",
"byteC",
"=",
"(",
"c",
".",
"to_bytes",
"(",
"1",
",",
"'little'",
")",
")",
"if",
"byteC",
"==",
"self",
".",
"flag",
":",
"c",
"=",
"self",
".",
"esc",
"+",
"self",
".",
"e",
"msg",
"+=",
"c",
"elif",
"byteC",
"==",
"self",
".",
"esc",
":",
"c",
"=",
"self",
".",
"esc",
"+",
"self",
".",
"d",
"msg",
"+=",
"c",
"else",
":",
"msg",
".",
"append",
"(",
"c",
")",
"return",
"self",
".",
"flag",
"+",
"msg",
"+",
"self",
".",
"flag"
] | [
40,
4
] | [
53,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RestResource.response_error | (self, code, *args) | return http_res | Cria um HttpResponse com o XML de erro. | Cria um HttpResponse com o XML de erro. | def response_error(self, code, *args):
"""Cria um HttpResponse com o XML de erro."""
http_res = HttpResponse(
error_dumps(code, *args),
status=500,
content_type='text/plain')
http_res['X-Request-Id'] = local.request_id
http_res['X-Request-Context'] = local.request_context
return http_res | [
"def",
"response_error",
"(",
"self",
",",
"code",
",",
"*",
"args",
")",
":",
"http_res",
"=",
"HttpResponse",
"(",
"error_dumps",
"(",
"code",
",",
"*",
"args",
")",
",",
"status",
"=",
"500",
",",
"content_type",
"=",
"'text/plain'",
")",
"http_res",
"[",
"'X-Request-Id'",
"]",
"=",
"local",
".",
"request_id",
"http_res",
"[",
"'X-Request-Context'",
"]",
"=",
"local",
".",
"request_context",
"return",
"http_res"
] | [
194,
4
] | [
204,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
spins | (source, direction, destination) | return rot | Obtém o número de rotações necessárias para ter a sala de destino à frente. | Obtém o número de rotações necessárias para ter a sala de destino à frente. | def spins(source, direction, destination):
"""Obtém o número de rotações necessárias para ter a sala de destino à frente."""
assert source in neighbors(destination)
# Calcula a diferença entre os locais
diff = tuple([a - b for a, b in zip(destination, source)])
rot = DELTA.index(diff) - direction
rot = rot if rot != 3 else -1
# Retorna o número mínimo de rotações (sentido horário vs sentido anti-horário)
return rot | [
"def",
"spins",
"(",
"source",
",",
"direction",
",",
"destination",
")",
":",
"assert",
"source",
"in",
"neighbors",
"(",
"destination",
")",
"# Calcula a diferença entre os locais",
"diff",
"=",
"tuple",
"(",
"[",
"a",
"-",
"b",
"for",
"a",
",",
"b",
"in",
"zip",
"(",
"destination",
",",
"source",
")",
"]",
")",
"rot",
"=",
"DELTA",
".",
"index",
"(",
"diff",
")",
"-",
"direction",
"rot",
"=",
"rot",
"if",
"rot",
"!=",
"3",
"else",
"-",
"1",
"# Retorna o número mínimo de rotações (sentido horário vs sentido anti-horário)",
"return",
"rot"
] | [
60,
0
] | [
72,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RestClient.get | (self, url, auth_map=None) | Envia uma requisição GET para a url informada.
Retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
| Envia uma requisição GET para a url informada.
Retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
| def get(self, url, auth_map=None):
"""Envia uma requisição GET para a url informada.
Retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
"""
try:
request = Request(url)
if auth_map is None:
request.add_header('NETWORKAPI_USERNAME', 'ORQUESTRACAO')
request.add_header(
'NETWORKAPI_PASSWORD', '93522a36bf2a18e0cc25857e06bbfe8b')
else:
for key, value in auth_map.iteritems():
request.add_header(key, value)
content = urlopen(request).read()
response_code = 200
return response_code, content
except HTTPError, e:
response_code = e.code
content = e.read()
return response_code, content
except Exception, e:
raise RestError(e, e.message) | [
"def",
"get",
"(",
"self",
",",
"url",
",",
"auth_map",
"=",
"None",
")",
":",
"try",
":",
"request",
"=",
"Request",
"(",
"url",
")",
"if",
"auth_map",
"is",
"None",
":",
"request",
".",
"add_header",
"(",
"'NETWORKAPI_USERNAME'",
",",
"'ORQUESTRACAO'",
")",
"request",
".",
"add_header",
"(",
"'NETWORKAPI_PASSWORD'",
",",
"'93522a36bf2a18e0cc25857e06bbfe8b'",
")",
"else",
":",
"for",
"key",
",",
"value",
"in",
"auth_map",
".",
"iteritems",
"(",
")",
":",
"request",
".",
"add_header",
"(",
"key",
",",
"value",
")",
"content",
"=",
"urlopen",
"(",
"request",
")",
".",
"read",
"(",
")",
"response_code",
"=",
"200",
"return",
"response_code",
",",
"content",
"except",
"HTTPError",
",",
"e",
":",
"response_code",
"=",
"e",
".",
"code",
"content",
"=",
"e",
".",
"read",
"(",
")",
"return",
"response_code",
",",
"content",
"except",
"Exception",
",",
"e",
":",
"raise",
"RestError",
"(",
"e",
",",
"e",
".",
"message",
")"
] | [
50,
4
] | [
73,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RestClient.put | (self, url, request_data, content_type=None, auth_map=None) | Envia uma requisição PUT.
Envia o parâmetro request_data no corpo da requisição e
retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
| Envia uma requisição PUT.
Envia o parâmetro request_data no corpo da requisição e
retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
| def put(self, url, request_data, content_type=None, auth_map=None):
"""Envia uma requisição PUT.
Envia o parâmetro request_data no corpo da requisição e
retorna uma tupla contendo:
(<código de resposta http>, <corpo da resposta>).
"""
try:
parsed_url = urlparse(url)
connection = HTTPConnection(parsed_url.hostname, parsed_url.port)
headers_map = dict()
if auth_map is None:
headers_map['NETWORKAPI_USERNAME'] = 'ORQUESTRACAO'
headers_map[
'NETWORKAPI_PASSWORD'] = '93522a36bf2a18e0cc25857e06bbfe8b'
else:
headers_map.update(auth_map)
if content_type is not None:
headers_map['Content-Type'] = content_type
connection.request(
"PUT", parsed_url.path, request_data, headers_map)
response = connection.getresponse()
return response.status, response.read()
except Exception, e:
raise RestError(e, e.message)
finally:
connection.close() | [
"def",
"put",
"(",
"self",
",",
"url",
",",
"request_data",
",",
"content_type",
"=",
"None",
",",
"auth_map",
"=",
"None",
")",
":",
"try",
":",
"parsed_url",
"=",
"urlparse",
"(",
"url",
")",
"connection",
"=",
"HTTPConnection",
"(",
"parsed_url",
".",
"hostname",
",",
"parsed_url",
".",
"port",
")",
"headers_map",
"=",
"dict",
"(",
")",
"if",
"auth_map",
"is",
"None",
":",
"headers_map",
"[",
"'NETWORKAPI_USERNAME'",
"]",
"=",
"'ORQUESTRACAO'",
"headers_map",
"[",
"'NETWORKAPI_PASSWORD'",
"]",
"=",
"'93522a36bf2a18e0cc25857e06bbfe8b'",
"else",
":",
"headers_map",
".",
"update",
"(",
"auth_map",
")",
"if",
"content_type",
"is",
"not",
"None",
":",
"headers_map",
"[",
"'Content-Type'",
"]",
"=",
"content_type",
"connection",
".",
"request",
"(",
"\"PUT\"",
",",
"parsed_url",
".",
"path",
",",
"request_data",
",",
"headers_map",
")",
"response",
"=",
"connection",
".",
"getresponse",
"(",
")",
"return",
"response",
".",
"status",
",",
"response",
".",
"read",
"(",
")",
"except",
"Exception",
",",
"e",
":",
"raise",
"RestError",
"(",
"e",
",",
"e",
".",
"message",
")",
"finally",
":",
"connection",
".",
"close",
"(",
")"
] | [
136,
4
] | [
165,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
index | () | return render_template('home/index.html') | Rota para a nossa pagna Home | Rota para a nossa pagna Home | def index():
"""Rota para a nossa pagna Home"""
return render_template('home/index.html') | [
"def",
"index",
"(",
")",
":",
"return",
"render_template",
"(",
"'home/index.html'",
")"
] | [
6,
0
] | [
8,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
set_metadata | (date: str, data: any) | return [[date, data]] | Retorna a estrutura básica de um `campo` de metadata
no formato do Kernel | Retorna a estrutura básica de um `campo` de metadata
no formato do Kernel | def set_metadata(date: str, data: any) -> List[List]:
"""Retorna a estrutura básica de um `campo` de metadata
no formato do Kernel"""
return [[date, data]] | [
"def",
"set_metadata",
"(",
"date",
":",
"str",
",",
"data",
":",
"any",
")",
"->",
"List",
"[",
"List",
"]",
":",
"return",
"[",
"[",
"date",
",",
"data",
"]",
"]"
] | [
84,
0
] | [
88,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoRoteiro.create | (self, authenticated_user) | Insere uma nova associação entre um Equipamento e um Roteiro.
@return: Nothing
@raise RoteiroNotFoundError: Roteiro não cadastrado.
@raise RoteiroError: Falha ao pesquisar o roteiro.
@raise EquipamentoRoteiroDuplicatedError: Equipamento já está associado ao roteiro.
@raise EquipamentoError: Falha ao inserir o equipamento no roteiro.
| Insere uma nova associação entre um Equipamento e um Roteiro. | def create(self, authenticated_user):
"""Insere uma nova associação entre um Equipamento e um Roteiro.
@return: Nothing
@raise RoteiroNotFoundError: Roteiro não cadastrado.
@raise RoteiroError: Falha ao pesquisar o roteiro.
@raise EquipamentoRoteiroDuplicatedError: Equipamento já está associado ao roteiro.
@raise EquipamentoError: Falha ao inserir o equipamento no roteiro.
"""
self.equipamento = Equipamento().get_by_pk(self.equipamento.id)
self.roteiro = Roteiro.get_by_pk(self.roteiro.id)
try:
try:
EquipamentoRoteiro.objects.get(
equipamento__id=self.equipamento.id, roteiro__id=self.roteiro.id)
raise EquipamentoRoteiroDuplicatedError(
None, u'Equipamento já está associado ao roteiro.')
except ObjectDoesNotExist:
pass
self.save()
except EquipamentoRoteiroDuplicatedError as e:
raise e
except Exception as e:
self.log.error(u'Falha ao inserir a associação equipamento/roteiro: %s/%s.' %
(self.equipamento.id, self.roteiro.id))
raise EquipamentoError(
e, u'Falha ao inserir a associação equipamento/roteiro: %s/%s.' % (self.equipamento.id, self.roteiro.id)) | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
")",
":",
"self",
".",
"equipamento",
"=",
"Equipamento",
"(",
")",
".",
"get_by_pk",
"(",
"self",
".",
"equipamento",
".",
"id",
")",
"self",
".",
"roteiro",
"=",
"Roteiro",
".",
"get_by_pk",
"(",
"self",
".",
"roteiro",
".",
"id",
")",
"try",
":",
"try",
":",
"EquipamentoRoteiro",
".",
"objects",
".",
"get",
"(",
"equipamento__id",
"=",
"self",
".",
"equipamento",
".",
"id",
",",
"roteiro__id",
"=",
"self",
".",
"roteiro",
".",
"id",
")",
"raise",
"EquipamentoRoteiroDuplicatedError",
"(",
"None",
",",
"u'Equipamento já está associado ao roteiro.')",
"",
"except",
"ObjectDoesNotExist",
":",
"pass",
"self",
".",
"save",
"(",
")",
"except",
"EquipamentoRoteiroDuplicatedError",
"as",
"e",
":",
"raise",
"e",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir a associação equipamento/roteiro: %s/%s.' %",
"",
"(",
"self",
".",
"equipamento",
".",
"id",
",",
"self",
".",
"roteiro",
".",
"id",
")",
")",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao inserir a associação equipamento/roteiro: %s/%s.' %",
"(",
"e",
"lf.e",
"q",
"uipamento.i",
"d",
", ",
"s",
"lf.r",
"o",
"teiro.i",
"d",
"))",
"",
""
] | [
1848,
4
] | [
1880,
123
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
AmbienteResource.handle_delete | (self, request, user, *args, **kwargs) | Trata requisições DELETE para remover um Ambiente.
URL: ambiente/<id_ambiente>/
| Trata requisições DELETE para remover um Ambiente. | def handle_delete(self, request, user, *args, **kwargs):
"""Trata requisições DELETE para remover um Ambiente.
URL: ambiente/<id_ambiente>/
"""
try:
environment_id = kwargs.get('id_ambiente')
# Valid ID Environment
if not is_valid_int_greater_zero_param(environment_id):
self.log.error(
u'The environment_id parameter is not a valid value: %s.', environment_id)
raise InvalidValueError(None, 'environment_id', environment_id)
if not has_perm(user,
AdminPermission.ENVIRONMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_ENVIRONMENT % environment_id):
# Delete vlan's cache
key_list_db = Vlan.objects.filter(ambiente__pk=environment_id)
key_list = []
for key in key_list_db:
key_list.append(key.id)
destroy_cache_function(key_list)
# Destroy equipment's cache
equip_id_list = []
envr = Ambiente.get_by_pk(environment_id)
for equipment in envr.equipamentoambiente_set.all():
equip_id_list.append(equipment.equipamento_id)
destroy_cache_function(equip_id_list, True)
Ambiente.remove(user, environment_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except AmbienteNotFoundError:
return self.response_error(112)
except AmbienteUsedByEquipmentVlanError, e:
# dict sent when a vlan cant be removed because of vip request
# created
if type(e.cause) is dict:
return self.response_error(323, environment_id, e.cause['Net'], e.cause['Vlan'], e.cause['ReqVip'])
# str sent when a vlan cant be removed because its active
elif type(e.cause) is str:
return self.response_error(324, environment_id, e.cause)
else:
return self.response_error(220, environment_id)
except (GrupoError, AmbienteError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"environment_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_ambiente'",
")",
"# Valid ID Environment",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"environment_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The environment_id parameter is not a valid value: %s.'",
",",
"environment_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'environment_id'",
",",
"environment_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"ENVIRONMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"with",
"distributedlock",
"(",
"LOCK_ENVIRONMENT",
"%",
"environment_id",
")",
":",
"# Delete vlan's cache",
"key_list_db",
"=",
"Vlan",
".",
"objects",
".",
"filter",
"(",
"ambiente__pk",
"=",
"environment_id",
")",
"key_list",
"=",
"[",
"]",
"for",
"key",
"in",
"key_list_db",
":",
"key_list",
".",
"append",
"(",
"key",
".",
"id",
")",
"destroy_cache_function",
"(",
"key_list",
")",
"# Destroy equipment's cache",
"equip_id_list",
"=",
"[",
"]",
"envr",
"=",
"Ambiente",
".",
"get_by_pk",
"(",
"environment_id",
")",
"for",
"equipment",
"in",
"envr",
".",
"equipamentoambiente_set",
".",
"all",
"(",
")",
":",
"equip_id_list",
".",
"append",
"(",
"equipment",
".",
"equipamento_id",
")",
"destroy_cache_function",
"(",
"equip_id_list",
",",
"True",
")",
"Ambiente",
".",
"remove",
"(",
"user",
",",
"environment_id",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"AmbienteNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"112",
")",
"except",
"AmbienteUsedByEquipmentVlanError",
",",
"e",
":",
"# dict sent when a vlan cant be removed because of vip request",
"# created",
"if",
"type",
"(",
"e",
".",
"cause",
")",
"is",
"dict",
":",
"return",
"self",
".",
"response_error",
"(",
"323",
",",
"environment_id",
",",
"e",
".",
"cause",
"[",
"'Net'",
"]",
",",
"e",
".",
"cause",
"[",
"'Vlan'",
"]",
",",
"e",
".",
"cause",
"[",
"'ReqVip'",
"]",
")",
"# str sent when a vlan cant be removed because its active",
"elif",
"type",
"(",
"e",
".",
"cause",
")",
"is",
"str",
":",
"return",
"self",
".",
"response_error",
"(",
"324",
",",
"environment_id",
",",
"e",
".",
"cause",
")",
"else",
":",
"return",
"self",
".",
"response_error",
"(",
"220",
",",
"environment_id",
")",
"except",
"(",
"GrupoError",
",",
"AmbienteError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
595,
4
] | [
652,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pesquisador.defaultValues | () | return kwDefault | método estático: Define os valores padrões para todos os caminhos de arquivos necessários.
Returns:
type: Retorna um dicionário com os caminhos.
| método estático: Define os valores padrões para todos os caminhos de arquivos necessários. | def defaultValues():
""" método estático: Define os valores padrões para todos os caminhos de arquivos necessários.
Returns:
type: Retorna um dicionário com os caminhos.
"""
kwDefault = {'pathCAPES' : '../data/TABELA_EQUIVALENCIA_CNPQ_CAPES.csv',
'pathQualis' : '../data/Qualis_2013-2016.zip',
'pathPontos' : '../data/pontuacao.xlsx',
'pathUFCG' : '../../data/external/SERVIDORES_UFCG.xls',
'pathSAAP' : '../../data/external/SAAP_UFCG.xls'}
return kwDefault | [
"def",
"defaultValues",
"(",
")",
":",
"kwDefault",
"=",
"{",
"'pathCAPES'",
":",
"'../data/TABELA_EQUIVALENCIA_CNPQ_CAPES.csv'",
",",
"'pathQualis'",
":",
"'../data/Qualis_2013-2016.zip'",
",",
"'pathPontos'",
":",
"'../data/pontuacao.xlsx'",
",",
"'pathUFCG'",
":",
"'../../data/external/SERVIDORES_UFCG.xls'",
",",
"'pathSAAP'",
":",
"'../../data/external/SAAP_UFCG.xls'",
"}",
"return",
"kwDefault"
] | [
247,
4
] | [
259,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
countdown | (n: int) | Faz uma contagem regressiva usando recursão;
Args:
n (int): Contagem regressiva de 'n' até 1.
| Faz uma contagem regressiva usando recursão; | def countdown(n: int):
"""Faz uma contagem regressiva usando recursão;
Args:
n (int): Contagem regressiva de 'n' até 1.
"""
if n <= 0:
print(f"Blastoff!")
else:
print(n)
countdown(n - 1) | [
"def",
"countdown",
"(",
"n",
":",
"int",
")",
":",
"if",
"n",
"<=",
"0",
":",
"print",
"(",
"f\"Blastoff!\"",
")",
"else",
":",
"print",
"(",
"n",
")",
"countdown",
"(",
"n",
"-",
"1",
")"
] | [
0,
0
] | [
10,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
cria_receita | (request) | Usuário cria uma nova receita | Usuário cria uma nova receita | def cria_receita(request):
"""Usuário cria uma nova receita"""
if request.method == 'POST':
nome_receita = request.POST['nome_receita']
ingredientes = request.POST['ingredientes']
modo_preparo = request.POST['modo_preparo']
tempo_preparo = request.POST['tempo_preparo']
rendimento = request.POST['rendimento']
categoria = request.POST['categoria']
foto_receita = request.FILES['foto_receita']
# requisição passando o id do autor para user
user = get_object_or_404(User, pk=request.user.id)
receita = Receita.objects.create(autor=user,
nome_receita=nome_receita,
ingredientes=ingredientes,
modo_de_preparo=modo_preparo,
tempo_de_preparo=tempo_preparo,
rendimento=rendimento,
categoria=categoria,
foto_receita=foto_receita)
# salvando a receita no banco de dados
receita.save()
return redirect('dashboard')
else:
return render(request, 'receitas/cria_receita.html') | [
"def",
"cria_receita",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"nome_receita",
"=",
"request",
".",
"POST",
"[",
"'nome_receita'",
"]",
"ingredientes",
"=",
"request",
".",
"POST",
"[",
"'ingredientes'",
"]",
"modo_preparo",
"=",
"request",
".",
"POST",
"[",
"'modo_preparo'",
"]",
"tempo_preparo",
"=",
"request",
".",
"POST",
"[",
"'tempo_preparo'",
"]",
"rendimento",
"=",
"request",
".",
"POST",
"[",
"'rendimento'",
"]",
"categoria",
"=",
"request",
".",
"POST",
"[",
"'categoria'",
"]",
"foto_receita",
"=",
"request",
".",
"FILES",
"[",
"'foto_receita'",
"]",
"# requisição passando o id do autor para user",
"user",
"=",
"get_object_or_404",
"(",
"User",
",",
"pk",
"=",
"request",
".",
"user",
".",
"id",
")",
"receita",
"=",
"Receita",
".",
"objects",
".",
"create",
"(",
"autor",
"=",
"user",
",",
"nome_receita",
"=",
"nome_receita",
",",
"ingredientes",
"=",
"ingredientes",
",",
"modo_de_preparo",
"=",
"modo_preparo",
",",
"tempo_de_preparo",
"=",
"tempo_preparo",
",",
"rendimento",
"=",
"rendimento",
",",
"categoria",
"=",
"categoria",
",",
"foto_receita",
"=",
"foto_receita",
")",
"# salvando a receita no banco de dados",
"receita",
".",
"save",
"(",
")",
"return",
"redirect",
"(",
"'dashboard'",
")",
"else",
":",
"return",
"render",
"(",
"request",
",",
"'receitas/cria_receita.html'",
")"
] | [
26,
0
] | [
50,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
update_csv | (streamers) | return | Função encarregue de guardar as modificações num .csv | Função encarregue de guardar as modificações num .csv | def update_csv(streamers):
""" Função encarregue de guardar as modificações num .csv"""
os.remove(FILE)
streamers.to_csv(FILE, sep=",", index=False)
return | [
"def",
"update_csv",
"(",
"streamers",
")",
":",
"os",
".",
"remove",
"(",
"FILE",
")",
"streamers",
".",
"to_csv",
"(",
"FILE",
",",
"sep",
"=",
"\",\"",
",",
"index",
"=",
"False",
")",
"return"
] | [
81,
0
] | [
86,
10
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
linha.__ge__ | (self, outro) | Compara o .recuo ou a diferença de indentação se o outro objeto tiver, caso contrário, compara igualdade ou se .__str__ é maior | Compara o .recuo ou a diferença de indentação se o outro objeto tiver, caso contrário, compara igualdade ou se .__str__ é maior | def __ge__ (self, outro):
'''Compara o .recuo ou a diferença de indentação se o outro objeto tiver, caso contrário, compara igualdade ou se .__str__ é maior'''
try:
return self.recuo >= outro.recuo or self.indentar() >= outro.indentar()
except AttributeError:
return self.__str__() > str(outro) or self.__eq__(outro) | [
"def",
"__ge__",
"(",
"self",
",",
"outro",
")",
":",
"try",
":",
"return",
"self",
".",
"recuo",
">=",
"outro",
".",
"recuo",
"or",
"self",
".",
"indentar",
"(",
")",
">=",
"outro",
".",
"indentar",
"(",
")",
"except",
"AttributeError",
":",
"return",
"self",
".",
"__str__",
"(",
")",
">",
"str",
"(",
"outro",
")",
"or",
"self",
".",
"__eq__",
"(",
"outro",
")"
] | [
391,
1
] | [
396,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
InterfaceResource.handle_get | (self, request, user, *args, **kwargs) | Método responsável por tratar as requisições GET para consultar as interfaces.
URL: /interface/<nome_interface>/equipamento/<id_equipamento>
URL: /interface/equipamento/<id_equipamento>
| Método responsável por tratar as requisições GET para consultar as interfaces. | def handle_get(self, request, user, *args, **kwargs):
"""Método responsável por tratar as requisições GET para consultar as interfaces.
URL: /interface/<nome_interface>/equipamento/<id_equipamento>
URL: /interface/equipamento/<id_equipamento>
"""
# Get url parameters
equipment_id = kwargs.get('id_equipamento')
interface_name = kwargs.get('nome_interface')
# Temporário, remover. Fazer de outra forma.
if isinstance(interface_name, basestring):
interface_name = interface_name.replace('s2it_replace', '/')
is_new = kwargs.get('new')
try:
# Valid id_equipamento value
if not is_valid_int_greater_zero_param(equipment_id):
self.log.error(
u'Parameter equipment_id is invalid. Value: %s', equipment_id)
raise InvalidValueError(None, 'equipment_id', equipment_id)
# Valid interface_name value
if not is_valid_string_minsize(interface_name, 1, required=False) or not is_valid_string_maxsize(interface_name, 20, required=False):
self.log.error(
u'Parameter interface_name is invalid. Value: %s', interface_name)
raise InvalidValueError(None, 'interface_name', interface_name)
# Check permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION, None,
equipment_id, AdminPermission.EQUIP_READ_OPERATION):
return self.not_authorized()
# Check interface and call search method
if interface_name is None:
return self.search_interface_of_equipment(equipment_id, is_new)
else:
return self.search_interface_by_name_and_equipment(equipment_id, interface_name, is_new)
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EquipamentoNotFoundError:
return self.response_error(117, equipment_id)
except InterfaceNotFoundError:
return self.response_error(141)
except (EquipamentoError, GrupoError, InterfaceError):
return self.response_error(1) | [
"def",
"handle_get",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Get url parameters",
"equipment_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_equipamento'",
")",
"interface_name",
"=",
"kwargs",
".",
"get",
"(",
"'nome_interface'",
")",
"# Temporário, remover. Fazer de outra forma.",
"if",
"isinstance",
"(",
"interface_name",
",",
"basestring",
")",
":",
"interface_name",
"=",
"interface_name",
".",
"replace",
"(",
"'s2it_replace'",
",",
"'/'",
")",
"is_new",
"=",
"kwargs",
".",
"get",
"(",
"'new'",
")",
"try",
":",
"# Valid id_equipamento value",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equipment_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Parameter equipment_id is invalid. Value: %s'",
",",
"equipment_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equipment_id'",
",",
"equipment_id",
")",
"# Valid interface_name value",
"if",
"not",
"is_valid_string_minsize",
"(",
"interface_name",
",",
"1",
",",
"required",
"=",
"False",
")",
"or",
"not",
"is_valid_string_maxsize",
"(",
"interface_name",
",",
"20",
",",
"required",
"=",
"False",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Parameter interface_name is invalid. Value: %s'",
",",
"interface_name",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'interface_name'",
",",
"interface_name",
")",
"# Check permission",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"READ_OPERATION",
",",
"None",
",",
"equipment_id",
",",
"AdminPermission",
".",
"EQUIP_READ_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"# Check interface and call search method",
"if",
"interface_name",
"is",
"None",
":",
"return",
"self",
".",
"search_interface_of_equipment",
"(",
"equipment_id",
",",
"is_new",
")",
"else",
":",
"return",
"self",
".",
"search_interface_by_name_and_equipment",
"(",
"equipment_id",
",",
"interface_name",
",",
"is_new",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equipment_id",
")",
"except",
"InterfaceNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"141",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
",",
"InterfaceError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
56,
4
] | [
104,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
test_retorna_datas_data_maior_hoje | (d_ini, d_fim) | Test se data passada eh maior do que hoje. | Test se data passada eh maior do que hoje. | def test_retorna_datas_data_maior_hoje(d_ini, d_fim):
"""Test se data passada eh maior do que hoje."""
fundosbr.msg = Mock()
fundosbr.log = Mock()
datetime = Mock(return_value=202105)
fundosbr.retorna_datas(d_ini, d_fim)
fundosbr.msg.assert_called_with(
"red", "Erro data de inicio ou fim maior que data de hoje", 1
) | [
"def",
"test_retorna_datas_data_maior_hoje",
"(",
"d_ini",
",",
"d_fim",
")",
":",
"fundosbr",
".",
"msg",
"=",
"Mock",
"(",
")",
"fundosbr",
".",
"log",
"=",
"Mock",
"(",
")",
"datetime",
"=",
"Mock",
"(",
"return_value",
"=",
"202105",
")",
"fundosbr",
".",
"retorna_datas",
"(",
"d_ini",
",",
"d_fim",
")",
"fundosbr",
".",
"msg",
".",
"assert_called_with",
"(",
"\"red\"",
",",
"\"Erro data de inicio ou fim maior que data de hoje\"",
",",
"1",
")"
] | [
43,
0
] | [
51,
5
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DistanceSensor.get_limits | (self) | return (self.max_range,self.min_range) | Método para retornar o limite inferior e superior da leitura
Returns:
(float, float): Limite inferior e superior da leitura
| Método para retornar o limite inferior e superior da leitura | def get_limits(self):
"""Método para retornar o limite inferior e superior da leitura
Returns:
(float, float): Limite inferior e superior da leitura
"""
return (self.max_range,self.min_range) | [
"def",
"get_limits",
"(",
"self",
")",
":",
"return",
"(",
"self",
".",
"max_range",
",",
"self",
".",
"min_range",
")"
] | [
39,
4
] | [
45,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_documents_availability_in_website | (
pids: List[str], target_string: str, output: IO = None
) | Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis.
Params:
pids (List[str]): Lista de pids para verificar.
target_string (str): Endereço da página de artigo no site algo.
output (IO): Arquivo onde as URLs não disponíveis serão registradas.
Return:
None
| Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis. | def check_documents_availability_in_website(
pids: List[str], target_string: str, output: IO = None
) -> None:
""" Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis.
Params:
pids (List[str]): Lista de pids para verificar.
target_string (str): Endereço da página de artigo no site algo.
output (IO): Arquivo onde as URLs não disponíveis serão registradas.
Return:
None
"""
template = string.Template(target_string)
if "$id" not in target_string:
return logger.error(
"The target string must contain a $id variable. If you are facing"
"troubles try to scape the variable e.g '\$id'."
)
def access_website_and_report(url, output, poison_pill):
"""Acessa uma URL e reporta o seu status de resposta"""
if poison_pill.poisoned:
return
response = requests.head(url)
if response.status_code not in (200, 301, 302):
logger.error(
"The URL '%s' is not available. Returned the status code '%s'.",
url,
response.status_code,
)
if output is not None:
try:
output.write('%s %s \n' % (url, response.status_code))
except IOError as exc:
logger.error(
"Cannot write in the file. The exception '%s' was raided ", exc
)
jobs = [
{"url": template.substitute({"id": pid.strip()}), "output": output}
for pid in pids
]
with tqdm(total=len(jobs)) as pbar:
def update_bar(pbar=pbar):
pbar.update(1)
def exception_callback(exception, job, logger=logger, output=output):
logger.error(
"Could not check availability for URL '%s'. The following exception "
"was raised: '%s'.",
job["url"],
exception,
)
logger.exception(exception)
DoJobsConcurrently(
access_website_and_report,
jobs,
max_workers=int(config.get("THREADPOOL_MAX_WORKERS")),
exception_callback=exception_callback,
update_bar=update_bar,
) | [
"def",
"check_documents_availability_in_website",
"(",
"pids",
":",
"List",
"[",
"str",
"]",
",",
"target_string",
":",
"str",
",",
"output",
":",
"IO",
"=",
"None",
")",
"->",
"None",
":",
"template",
"=",
"string",
".",
"Template",
"(",
"target_string",
")",
"if",
"\"$id\"",
"not",
"in",
"target_string",
":",
"return",
"logger",
".",
"error",
"(",
"\"The target string must contain a $id variable. If you are facing\"",
"\"troubles try to scape the variable e.g '\\$id'.\"",
")",
"def",
"access_website_and_report",
"(",
"url",
",",
"output",
",",
"poison_pill",
")",
":",
"\"\"\"Acessa uma URL e reporta o seu status de resposta\"\"\"",
"if",
"poison_pill",
".",
"poisoned",
":",
"return",
"response",
"=",
"requests",
".",
"head",
"(",
"url",
")",
"if",
"response",
".",
"status_code",
"not",
"in",
"(",
"200",
",",
"301",
",",
"302",
")",
":",
"logger",
".",
"error",
"(",
"\"The URL '%s' is not available. Returned the status code '%s'.\"",
",",
"url",
",",
"response",
".",
"status_code",
",",
")",
"if",
"output",
"is",
"not",
"None",
":",
"try",
":",
"output",
".",
"write",
"(",
"'%s %s \\n'",
"%",
"(",
"url",
",",
"response",
".",
"status_code",
")",
")",
"except",
"IOError",
"as",
"exc",
":",
"logger",
".",
"error",
"(",
"\"Cannot write in the file. The exception '%s' was raided \"",
",",
"exc",
")",
"jobs",
"=",
"[",
"{",
"\"url\"",
":",
"template",
".",
"substitute",
"(",
"{",
"\"id\"",
":",
"pid",
".",
"strip",
"(",
")",
"}",
")",
",",
"\"output\"",
":",
"output",
"}",
"for",
"pid",
"in",
"pids",
"]",
"with",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"jobs",
")",
")",
"as",
"pbar",
":",
"def",
"update_bar",
"(",
"pbar",
"=",
"pbar",
")",
":",
"pbar",
".",
"update",
"(",
"1",
")",
"def",
"exception_callback",
"(",
"exception",
",",
"job",
",",
"logger",
"=",
"logger",
",",
"output",
"=",
"output",
")",
":",
"logger",
".",
"error",
"(",
"\"Could not check availability for URL '%s'. The following exception \"",
"\"was raised: '%s'.\"",
",",
"job",
"[",
"\"url\"",
"]",
",",
"exception",
",",
")",
"logger",
".",
"exception",
"(",
"exception",
")",
"DoJobsConcurrently",
"(",
"access_website_and_report",
",",
"jobs",
",",
"max_workers",
"=",
"int",
"(",
"config",
".",
"get",
"(",
"\"THREADPOOL_MAX_WORKERS\"",
")",
")",
",",
"exception_callback",
"=",
"exception_callback",
",",
"update_bar",
"=",
"update_bar",
",",
")"
] | [
13,
0
] | [
86,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SelectionSort.__recursiveGetMax | (self, array, leftIndex, rightIndex, maxValue, index) | Método auxiliar de recursão
Este método pega o maior elemento do array e troca de posição com o indíce a direita
Parametros:
array: Lista a ser ordenada
leftIndex: Índice limítrofe a esquerda do array para ordenação parcial
rightIndex: Índice limítrofe a direita do array para ordenação parcial
maxValue: Maior valor encontrado entre os limites esquerdo e direito
index: Índice do elemento a ser comparado
| Método auxiliar de recursão
Este método pega o maior elemento do array e troca de posição com o indíce a direita
Parametros:
array: Lista a ser ordenada
leftIndex: Índice limítrofe a esquerda do array para ordenação parcial
rightIndex: Índice limítrofe a direita do array para ordenação parcial
maxValue: Maior valor encontrado entre os limites esquerdo e direito
index: Índice do elemento a ser comparado
| def __recursiveGetMax(self, array, leftIndex, rightIndex, maxValue, index):
""" Método auxiliar de recursão
Este método pega o maior elemento do array e troca de posição com o indíce a direita
Parametros:
array: Lista a ser ordenada
leftIndex: Índice limítrofe a esquerda do array para ordenação parcial
rightIndex: Índice limítrofe a direita do array para ordenação parcial
maxValue: Maior valor encontrado entre os limites esquerdo e direito
index: Índice do elemento a ser comparado
"""
if(index >= leftIndex):
if(array[maxValue] < array[index]):
maxValue = index
self.__recursiveGetMax(array, leftIndex, rightIndex, maxValue, index - 1)
else:
array[maxValue], array[rightIndex] = array[rightIndex] , array[maxValue] | [
"def",
"__recursiveGetMax",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"maxValue",
",",
"index",
")",
":",
"if",
"(",
"index",
">=",
"leftIndex",
")",
":",
"if",
"(",
"array",
"[",
"maxValue",
"]",
"<",
"array",
"[",
"index",
"]",
")",
":",
"maxValue",
"=",
"index",
"self",
".",
"__recursiveGetMax",
"(",
"array",
",",
"leftIndex",
",",
"rightIndex",
",",
"maxValue",
",",
"index",
"-",
"1",
")",
"else",
":",
"array",
"[",
"maxValue",
"]",
",",
"array",
"[",
"rightIndex",
"]",
"=",
"array",
"[",
"rightIndex",
"]",
",",
"array",
"[",
"maxValue",
"]"
] | [
103,
1
] | [
119,
75
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CNS._change_cns | (self, cns: list, i: int, val: int) | return self._change_cns(cns, i, val) | Altera o CNS recursivamente para que atenda as especificações de validade dele. | Altera o CNS recursivamente para que atenda as especificações de validade dele. | def _change_cns(self, cns: list, i: int, val: int) -> list:
"""Altera o CNS recursivamente para que atenda as especificações de validade dele."""
if val == 0:
if self._check_cns_valid(cns):
return cns
else:
sum = self._sum_algorithm(cns)
diff = 15 - (sum % 11)
return self._change_cns(cns, 15 - diff, diff)
if 15 - i > val:
i += 1
return self._change_cns(cns, i, val)
if not cns[i] == '9':
cns[i] = str(int(cns[i]) + 1)
val -= (15 - i)
else:
val += (15 - i)
cns[i] = str(int(cns[i]) - 1)
i -= 1
return self._change_cns(cns, i, val) | [
"def",
"_change_cns",
"(",
"self",
",",
"cns",
":",
"list",
",",
"i",
":",
"int",
",",
"val",
":",
"int",
")",
"->",
"list",
":",
"if",
"val",
"==",
"0",
":",
"if",
"self",
".",
"_check_cns_valid",
"(",
"cns",
")",
":",
"return",
"cns",
"else",
":",
"sum",
"=",
"self",
".",
"_sum_algorithm",
"(",
"cns",
")",
"diff",
"=",
"15",
"-",
"(",
"sum",
"%",
"11",
")",
"return",
"self",
".",
"_change_cns",
"(",
"cns",
",",
"15",
"-",
"diff",
",",
"diff",
")",
"if",
"15",
"-",
"i",
">",
"val",
":",
"i",
"+=",
"1",
"return",
"self",
".",
"_change_cns",
"(",
"cns",
",",
"i",
",",
"val",
")",
"if",
"not",
"cns",
"[",
"i",
"]",
"==",
"'9'",
":",
"cns",
"[",
"i",
"]",
"=",
"str",
"(",
"int",
"(",
"cns",
"[",
"i",
"]",
")",
"+",
"1",
")",
"val",
"-=",
"(",
"15",
"-",
"i",
")",
"else",
":",
"val",
"+=",
"(",
"15",
"-",
"i",
")",
"cns",
"[",
"i",
"]",
"=",
"str",
"(",
"int",
"(",
"cns",
"[",
"i",
"]",
")",
"-",
"1",
")",
"i",
"-=",
"1",
"return",
"self",
".",
"_change_cns",
"(",
"cns",
",",
"i",
",",
"val",
")"
] | [
96,
4
] | [
118,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Fun.randomban | (self, ctx) | Bane alguém aleatóriamente | Bane alguém aleatóriamente | async def randomban(self, ctx):
"""Bane alguém aleatóriamente"""
client = self.client
msg = await ctx.send("Fique atento de que o bot vai **realmente banir alguém**...\nPronto?")
await msg.add_reaction("👎")
await msg.add_reaction("👍")
try:
def react(reaction, user):
return reaction.emoji in ["👍", "👎"] and user.id == ctx.author.id and reaction.message.id == msg.id
reaction, user = await client.wait_for("reaction_add", check=react, timeout=30.0)
except asyncio.TimeoutError:
return
else:
if reaction.emoji == "👎":
await ctx.send("comando cancelado.")
return
invite = random.choice(await ctx.guild.invites())
# só pegar membros que tem cargo menor que o do bot (para evitar erros)
memb = random.choice(list(filter(lambda member : member.top_role < ctx.me.top_role, ctx.guild.members)))
await ctx.send(f"Eu escolhi {memb} pra ser banido :smiling_imp:...")
await memb.send(f"Oi, você foi banido do `{ctx.guild.name}`, pelo comando banrandom, "
"daqui a 5 segundos, tente entrar no servidor usando esse convite: {invite.url}")
await memb.ban(reason=f"Banido devido ao comando ,banrandom executado por {ctx.author}")
await ctx.send(f"{ctx.author.mention} ele foi banido.")
await asyncio.sleep(5)
await ctx.guild.unban(memb, reason="Tinha sido banido pelo ,banrandom") | [
"async",
"def",
"randomban",
"(",
"self",
",",
"ctx",
")",
":",
"client",
"=",
"self",
".",
"client",
"msg",
"=",
"await",
"ctx",
".",
"send",
"(",
"\"Fique atento de que o bot vai **realmente banir alguém**...\\nPronto?\")",
"\r",
"await",
"msg",
".",
"add_reaction",
"(",
"\"👎\")\r",
"",
"await",
"msg",
".",
"add_reaction",
"(",
"\"👍\")\r",
"",
"try",
":",
"def",
"react",
"(",
"reaction",
",",
"user",
")",
":",
"return",
"reaction",
".",
"emoji",
"in",
"[",
"\"👍\", \"",
"👎",
"] and ",
"u",
"er.",
"d ==",
" ",
"ct",
".a",
"tho",
"r",
".id an",
"d",
" r",
"act",
"on.messa",
"g",
"e.id ==",
" ",
"ms",
".i",
"\r",
"",
"",
"reaction",
",",
"user",
"=",
"await",
"client",
".",
"wait_for",
"(",
"\"reaction_add\"",
",",
"check",
"=",
"react",
",",
"timeout",
"=",
"30.0",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"return",
"else",
":",
"if",
"reaction",
".",
"emoji",
"==",
"\"👎\":\r",
"",
"await",
"ctx",
".",
"send",
"(",
"\"comando cancelado.\"",
")",
"return",
"invite",
"=",
"random",
".",
"choice",
"(",
"await",
"ctx",
".",
"guild",
".",
"invites",
"(",
")",
")",
"# só pegar membros que tem cargo menor que o do bot (para evitar erros)\r",
"memb",
"=",
"random",
".",
"choice",
"(",
"list",
"(",
"filter",
"(",
"lambda",
"member",
":",
"member",
".",
"top_role",
"<",
"ctx",
".",
"me",
".",
"top_role",
",",
"ctx",
".",
"guild",
".",
"members",
")",
")",
")",
"await",
"ctx",
".",
"send",
"(",
"f\"Eu escolhi {memb} pra ser banido :smiling_imp:...\"",
")",
"await",
"memb",
".",
"send",
"(",
"f\"Oi, você foi banido do `{ctx.guild.name}`, pelo comando banrandom, \"\r",
"\"daqui a 5 segundos, tente entrar no servidor usando esse convite: {invite.url}\"",
")",
"await",
"memb",
".",
"ban",
"(",
"reason",
"=",
"f\"Banido devido ao comando ,banrandom executado por {ctx.author}\"",
")",
"await",
"ctx",
".",
"send",
"(",
"f\"{ctx.author.mention} ele foi banido.\"",
")",
"await",
"asyncio",
".",
"sleep",
"(",
"5",
")",
"await",
"ctx",
".",
"guild",
".",
"unban",
"(",
"memb",
",",
"reason",
"=",
"\"Tinha sido banido pelo ,banrandom\"",
")"
] | [
182,
4
] | [
215,
83
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Basics.get_default_server_ip | (cls) | return _position['server_ip'] | Retorna server_ip definido em basics de routers.yaml. | Retorna server_ip definido em basics de routers.yaml. | def get_default_server_ip(cls):
"""Retorna server_ip definido em basics de routers.yaml."""
_position = cls.basic_parameters[1]
return _position['server_ip'] | [
"def",
"get_default_server_ip",
"(",
"cls",
")",
":",
"_position",
"=",
"cls",
".",
"basic_parameters",
"[",
"1",
"]",
"return",
"_position",
"[",
"'server_ip'",
"]"
] | [
29,
4
] | [
34,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
LinkedList.__len__ | (self) | return self._size | Retorna o tamanho da lista | Retorna o tamanho da lista | def __len__(self):
""" Retorna o tamanho da lista """
return self._size | [
"def",
"__len__",
"(",
"self",
")",
":",
"return",
"self",
".",
"_size"
] | [
139,
4
] | [
141,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Entity.describe | (self) | Metodo que descreve a entidade e suas principais propriedades | Metodo que descreve a entidade e suas principais propriedades | def describe(self):
"""Metodo que descreve a entidade e suas principais propriedades"""
def _describe(properties, escape_code=""):
"""
Funcao que introduz uma recursão na hora de buscarmos todas as propriedades da entity.
Args:
properties (dict): Dicionário com nome e objeto das propriedades.
escape_code (str): Utilizado quando queremos tabular uma propriedade
e facilitar a visualização de propriedades complexas.
"""
for property_name, property_obj in properties.items():
print(escape_code + f"Propriedade: {property_name}")
print(escape_code + f"Tipo: {property_obj.alias}")
print(
escape_code + f"Descrição: {property_obj.get_description()}",
)
if isinstance(property_obj, ComplexProperty):
_describe(
properties=property_obj.get_properties(),
escape_code=escape_code + "\t",
)
print("\n")
print(
"\n\n\t\t------------------------------------"
f"Descrição da entidade {self.__class__.__name__}"
"------------------------------------------------------\n\n"
)
_describe(properties=self.get_properties())
print(
"\n\n----------------------------------------------------------------------"
"--------------------------------------------------------------------------\n\n"
) | [
"def",
"describe",
"(",
"self",
")",
":",
"def",
"_describe",
"(",
"properties",
",",
"escape_code",
"=",
"\"\"",
")",
":",
"\"\"\"\n Funcao que introduz uma recursão na hora de buscarmos todas as propriedades da entity.\n\n Args:\n properties (dict): Dicionário com nome e objeto das propriedades.\n escape_code (str): Utilizado quando queremos tabular uma propriedade\n e facilitar a visualização de propriedades complexas.\n \"\"\"",
"for",
"property_name",
",",
"property_obj",
"in",
"properties",
".",
"items",
"(",
")",
":",
"print",
"(",
"escape_code",
"+",
"f\"Propriedade: {property_name}\"",
")",
"print",
"(",
"escape_code",
"+",
"f\"Tipo: {property_obj.alias}\"",
")",
"print",
"(",
"escape_code",
"+",
"f\"Descrição: {property_obj.get_description()}\",",
"",
")",
"if",
"isinstance",
"(",
"property_obj",
",",
"ComplexProperty",
")",
":",
"_describe",
"(",
"properties",
"=",
"property_obj",
".",
"get_properties",
"(",
")",
",",
"escape_code",
"=",
"escape_code",
"+",
"\"\\t\"",
",",
")",
"print",
"(",
"\"\\n\"",
")",
"print",
"(",
"\"\\n\\n\\t\\t------------------------------------\"",
"f\"Descrição da entidade {self.__class__.__name__}\"",
"\"------------------------------------------------------\\n\\n\"",
")",
"_describe",
"(",
"properties",
"=",
"self",
".",
"get_properties",
"(",
")",
")",
"print",
"(",
"\"\\n\\n----------------------------------------------------------------------\"",
"\"--------------------------------------------------------------------------\\n\\n\"",
")"
] | [
67,
4
] | [
101,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Campanha.obter_trabalho | (self, usuario) | return Trabalho.objects.filter(
tarefas__campanha__id=self.id,
username=usuario).order_by('-id').first() | Obtém o último trabalho de respostas do usuário | Obtém o último trabalho de respostas do usuário | def obter_trabalho(self, usuario):
"""Obtém o último trabalho de respostas do usuário"""
return Trabalho.objects.filter(
tarefas__campanha__id=self.id,
username=usuario).order_by('-id').first() | [
"def",
"obter_trabalho",
"(",
"self",
",",
"usuario",
")",
":",
"return",
"Trabalho",
".",
"objects",
".",
"filter",
"(",
"tarefas__campanha__id",
"=",
"self",
".",
"id",
",",
"username",
"=",
"usuario",
")",
".",
"order_by",
"(",
"'-id'",
")",
".",
"first",
"(",
")"
] | [
45,
4
] | [
49,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
separa_palavras | (frase) | return frase.split() | A funcao recebe uma frase e devolve uma lista das palavras dentro da frase | A funcao recebe uma frase e devolve uma lista das palavras dentro da frase | def separa_palavras(frase):
'''A funcao recebe uma frase e devolve uma lista das palavras dentro da frase'''
return frase.split() | [
"def",
"separa_palavras",
"(",
"frase",
")",
":",
"return",
"frase",
".",
"split",
"(",
")"
] | [
39,
0
] | [
41,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DrivvoSensor.update | (self) | Atualiza os dados fazendo requisição na API. | Atualiza os dados fazendo requisição na API. | def update(self):
"""Atualiza os dados fazendo requisição na API."""
self._supplies = get_data(self._email, self._password, self._id_vehicle) | [
"def",
"update",
"(",
"self",
")",
":",
"self",
".",
"_supplies",
"=",
"get_data",
"(",
"self",
".",
"_email",
",",
"self",
".",
"_password",
",",
"self",
".",
"_id_vehicle",
")"
] | [
166,
4
] | [
168,
80
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pesquisador.getApresentacoes | (self) | return result | Obtem as informações da seção OUTRA-PRODUCAO do currículo do pesquisador
Returns:
type: Dataframe.
| Obtem as informações da seção OUTRA-PRODUCAO do currículo do pesquisador | def getApresentacoes(self):
"""Obtem as informações da seção OUTRA-PRODUCAO do currículo do pesquisador
Returns:
type: Dataframe.
"""
if self.__FLAG:
#----Ajustando informações para o bloco
TAGs = 'PRODUCAO-TECNICA'
#----Definindo quais campos são úteis
#--------Colunas com múltiplas equivalências.
cols_merge = ['ANO', 'TITULO','PAIS']
#--------Colunas que tem que mudar de nome
cols_equiv = {}
#--------Juntando todos os dados básicos e complementares.
cols_keep = ['PRODUCAO', 'SEQUENCIA-PRODUCAO', 'NATUREZA', 'TITULO', 'ANO', 'PAIS', 'IDIOMA', 'DOI','PRODUCAO', 'SEQUENCIA-PRODUCAO', 'TIPO-DE-ORIENTACAO', 'NOME-DO-ORIENTANDO', 'NOME-DA-AGENCIA']
#--------Jogue fora toda coluna com estes termos
cols_out = ['INGLES', 'CODIGO', 'FLAG', 'HOME', 'CIDADE','PAGINA']
cols_final = ['SEQUENCIA-PRODUCAO', 'PRODUCAO', 'TIPO','NATUREZA', 'TITULO','ANO', 'PAIS', 'IDIOMA', 'DOI']
#----Parsing
lista = self.xml2dict(tag = TAGs)
df = pd.concat([pd.DataFrame(lista[0]), pd.DataFrame(lista[1])], ignore_index=True)
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)
#----Filtrando
df = df[df['ANO'].isin(self.periodo)]
df["ID"] = self.ID
result = df
else:
result = None
else:
result = None
return result | [
"def",
"getApresentacoes",
"(",
"self",
")",
":",
"if",
"self",
".",
"__FLAG",
":",
"#----Ajustando informações para o bloco",
"TAGs",
"=",
"'PRODUCAO-TECNICA'",
"#----Definindo quais campos são úteis",
"#--------Colunas com múltiplas equivalências.",
"cols_merge",
"=",
"[",
"'ANO'",
",",
"'TITULO'",
",",
"'PAIS'",
"]",
"#--------Colunas que tem que mudar de nome",
"cols_equiv",
"=",
"{",
"}",
"#--------Juntando todos os dados básicos e complementares.",
"cols_keep",
"=",
"[",
"'PRODUCAO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'IDIOMA'",
",",
"'DOI'",
",",
"'PRODUCAO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'TIPO-DE-ORIENTACAO'",
",",
"'NOME-DO-ORIENTANDO'",
",",
"'NOME-DA-AGENCIA'",
"]",
"#--------Jogue fora toda coluna com estes termos",
"cols_out",
"=",
"[",
"'INGLES'",
",",
"'CODIGO'",
",",
"'FLAG'",
",",
"'HOME'",
",",
"'CIDADE'",
",",
"'PAGINA'",
"]",
"cols_final",
"=",
"[",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'TIPO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'IDIOMA'",
",",
"'DOI'",
"]",
"#----Parsing",
"lista",
"=",
"self",
".",
"xml2dict",
"(",
"tag",
"=",
"TAGs",
")",
"df",
"=",
"pd",
".",
"concat",
"(",
"[",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"0",
"]",
")",
",",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"1",
"]",
")",
"]",
",",
"ignore_index",
"=",
"True",
")",
"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",
")",
"#----Filtrando",
"df",
"=",
"df",
"[",
"df",
"[",
"'ANO'",
"]",
".",
"isin",
"(",
"self",
".",
"periodo",
")",
"]",
"df",
"[",
"\"ID\"",
"]",
"=",
"self",
".",
"ID",
"result",
"=",
"df",
"else",
":",
"result",
"=",
"None",
"else",
":",
"result",
"=",
"None",
"return",
"result"
] | [
879,
4
] | [
913,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
range_sum_query | (tree, index=None) | return soma | Retorna a soma entre um intervalo
:param tree: estrutura aonde está guardado os dados
:param index=None: indice para realizar a soma do indice até o indece 1.
| Retorna a soma entre um intervalo
:param tree: estrutura aonde está guardado os dados
:param index=None: indice para realizar a soma do indice até o indece 1.
| def range_sum_query(tree, index=None):
""" Retorna a soma entre um intervalo
:param tree: estrutura aonde está guardado os dados
:param index=None: indice para realizar a soma do indice até o indece 1.
"""
if index is None:
index = len(tree) - 1
soma = 0
while index > 0:
soma += tree[index]
index -= (index & -index)
return soma | [
"def",
"range_sum_query",
"(",
"tree",
",",
"index",
"=",
"None",
")",
":",
"if",
"index",
"is",
"None",
":",
"index",
"=",
"len",
"(",
"tree",
")",
"-",
"1",
"soma",
"=",
"0",
"while",
"index",
">",
"0",
":",
"soma",
"+=",
"tree",
"[",
"index",
"]",
"index",
"-=",
"(",
"index",
"&",
"-",
"index",
")",
"return",
"soma"
] | [
28,
0
] | [
43,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
UGrupo.delete | (self) | Sobrescreve o método do Django para remover o grupo de usuário.
Além de remover o grupo também remove as permissões administrativas do grupo,
os relacionamentos do grupo com usuários e os relacionamentos do grupo com
grupos de equipamento.
| Sobrescreve o método do Django para remover o grupo de usuário. | def delete(self):
"""Sobrescreve o método do Django para remover o grupo de usuário.
Além de remover o grupo também remove as permissões administrativas do grupo,
os relacionamentos do grupo com usuários e os relacionamentos do grupo com
grupos de equipamento.
"""
for p in self.permissaoadministrativa_set.all():
p.delete()
for ug in self.usuariogrupo_set.all():
ug.delete()
for d in self.direitosgrupoequipamento_set.all():
d.delete()
super(UGrupo, self).delete() | [
"def",
"delete",
"(",
"self",
")",
":",
"for",
"p",
"in",
"self",
".",
"permissaoadministrativa_set",
".",
"all",
"(",
")",
":",
"p",
".",
"delete",
"(",
")",
"for",
"ug",
"in",
"self",
".",
"usuariogrupo_set",
".",
"all",
"(",
")",
":",
"ug",
".",
"delete",
"(",
")",
"for",
"d",
"in",
"self",
".",
"direitosgrupoequipamento_set",
".",
"all",
"(",
")",
":",
"d",
".",
"delete",
"(",
")",
"super",
"(",
"UGrupo",
",",
"self",
")",
".",
"delete",
"(",
")"
] | [
131,
4
] | [
145,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
make_great | (nomes) | return magicians | Exibe uma alteração na lista de mágicos exibida. | Exibe uma alteração na lista de mágicos exibida. | def make_great(nomes):
"""Exibe uma alteração na lista de mágicos exibida."""
magicians = 'O(A) grande ' + nome.title()
return magicians | [
"def",
"make_great",
"(",
"nomes",
")",
":",
"magicians",
"=",
"'O(A) grande '",
"+",
"nome",
".",
"title",
"(",
")",
"return",
"magicians"
] | [
24,
0
] | [
27,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PesquisaAnonima.__init__ | (self, pergunta) | Armazena uma pergunta e se prepara para armazenar as respostas. | Armazena uma pergunta e se prepara para armazenar as respostas. | def __init__(self, pergunta):
"""Armazena uma pergunta e se prepara para armazenar as respostas."""
self.pergunta = pergunta
self.respostas = [] | [
"def",
"__init__",
"(",
"self",
",",
"pergunta",
")",
":",
"self",
".",
"pergunta",
"=",
"pergunta",
"self",
".",
"respostas",
"=",
"[",
"]"
] | [
3,
4
] | [
6,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BayesNet.add | (self, node_spec) | Adicione um nó à rede. Seus pais já devem estar no
Sua variável não deve ser. | Adicione um nó à rede. Seus pais já devem estar no
Sua variável não deve ser. | def add(self, node_spec):
"""Adicione um nó à rede. Seus pais já devem estar no
Sua variável não deve ser."""
node = BayesNode(*node_spec)
assert node.variable not in self.variables
assert all((parent in self.variables) for parent in node.parents)
self.nodes.append(node)
self.variables.append(node.variable)
for parent in node.parents:
self.variable_node(parent).children.append(node) | [
"def",
"add",
"(",
"self",
",",
"node_spec",
")",
":",
"node",
"=",
"BayesNode",
"(",
"*",
"node_spec",
")",
"assert",
"node",
".",
"variable",
"not",
"in",
"self",
".",
"variables",
"assert",
"all",
"(",
"(",
"parent",
"in",
"self",
".",
"variables",
")",
"for",
"parent",
"in",
"node",
".",
"parents",
")",
"self",
".",
"nodes",
".",
"append",
"(",
"node",
")",
"self",
".",
"variables",
".",
"append",
"(",
"node",
".",
"variable",
")",
"for",
"parent",
"in",
"node",
".",
"parents",
":",
"self",
".",
"variable_node",
"(",
"parent",
")",
".",
"children",
".",
"append",
"(",
"node",
")"
] | [
168,
4
] | [
177,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GnomeSort.__recursiveGnomeSort | (self,array,leftIndex,pivot,rightIndex) | Implementação do método GnomeSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| Implementação do método GnomeSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
| def __recursiveGnomeSort(self,array,leftIndex,pivot,rightIndex):
"""Implementação do método GnomeSort de forma recursiva
Parametros:
array: Lista a ser ordenada
leftIndex(Opcional): Índice limítrofe a esquerda do array para ordenação parcial
rightIndex(Opcional): Índice limítrofe a direita do array para ordenação parcial
"""
if(pivot <= rightIndex):
if(array[pivot] >= array[pivot - 1]):
self.__recursiveGnomeSort(array,leftIndex,pivot + 1 , rightIndex)
else:
array[pivot] , array[pivot - 1] = array[pivot - 1] ,array[pivot]
if(pivot > leftIndex + 1):
self.__recursiveGnomeSort(array,leftIndex,pivot - 1 ,rightIndex)
else:
self.__recursiveGnomeSort(array,leftIndex,pivot + 1 ,rightIndex) | [
"def",
"__recursiveGnomeSort",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"pivot",
",",
"rightIndex",
")",
":",
"if",
"(",
"pivot",
"<=",
"rightIndex",
")",
":",
"if",
"(",
"array",
"[",
"pivot",
"]",
">=",
"array",
"[",
"pivot",
"-",
"1",
"]",
")",
":",
"self",
".",
"__recursiveGnomeSort",
"(",
"array",
",",
"leftIndex",
",",
"pivot",
"+",
"1",
",",
"rightIndex",
")",
"else",
":",
"array",
"[",
"pivot",
"]",
",",
"array",
"[",
"pivot",
"-",
"1",
"]",
"=",
"array",
"[",
"pivot",
"-",
"1",
"]",
",",
"array",
"[",
"pivot",
"]",
"if",
"(",
"pivot",
">",
"leftIndex",
"+",
"1",
")",
":",
"self",
".",
"__recursiveGnomeSort",
"(",
"array",
",",
"leftIndex",
",",
"pivot",
"-",
"1",
",",
"rightIndex",
")",
"else",
":",
"self",
".",
"__recursiveGnomeSort",
"(",
"array",
",",
"leftIndex",
",",
"pivot",
"+",
"1",
",",
"rightIndex",
")"
] | [
58,
1
] | [
74,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OverlapCommunity.fitness_no | (self, no, modulo, grafo) | return fitness_com_no - fitness_sem_no | Realiza o calculo do fitness do no | Realiza o calculo do fitness do no | def fitness_no(self, no, modulo, grafo):
"""Realiza o calculo do fitness do no"""
if no in modulo:
# o no já esta no modulo.
return 0
# fitness do no
sem_no = modulo
com_no = modulo + [no]
# print("Sem o Nó")
fitness_sem_no = self.calcula_fitness_v2(sem_no, grafo)
# print("-----\nCom o Nó")
fitness_com_no = self.calcula_fitness_v2(com_no, grafo)
# print("-------\n")
return fitness_com_no - fitness_sem_no | [
"def",
"fitness_no",
"(",
"self",
",",
"no",
",",
"modulo",
",",
"grafo",
")",
":",
"if",
"no",
"in",
"modulo",
":",
"# o no já esta no modulo.",
"return",
"0",
"# fitness do no",
"sem_no",
"=",
"modulo",
"com_no",
"=",
"modulo",
"+",
"[",
"no",
"]",
"# print(\"Sem o Nó\")",
"fitness_sem_no",
"=",
"self",
".",
"calcula_fitness_v2",
"(",
"sem_no",
",",
"grafo",
")",
"# print(\"-----\\nCom o Nó\")",
"fitness_com_no",
"=",
"self",
".",
"calcula_fitness_v2",
"(",
"com_no",
",",
"grafo",
")",
"# print(\"-------\\n\")",
"return",
"fitness_com_no",
"-",
"fitness_sem_no"
] | [
118,
4
] | [
132,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
new_topic | (request) | return render(request, 'learning_logs/new_topic.html', context) | Adiciona um novo assunto. | Adiciona um novo assunto. | def new_topic(request):
"""Adiciona um novo assunto."""
if request.method != 'POST':
# Nenhum dado submetido; cria um foemulário em branco
form = TopicForm()
else:
# Dados de POST submetidos; processa os dados
form = TopicForm(request.POST)
if form.is_valid():
new_topic = form.save(commit=False)
new_topic.owner = request.user
new_topic.save()
return HttpResponseRedirect(reverse('learning_logs:topics'))
context = {'form': form}
return render(request, 'learning_logs/new_topic.html', context) | [
"def",
"new_topic",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"!=",
"'POST'",
":",
"# Nenhum dado submetido; cria um foemulário em branco",
"form",
"=",
"TopicForm",
"(",
")",
"else",
":",
"# Dados de POST submetidos; processa os dados",
"form",
"=",
"TopicForm",
"(",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"new_topic",
"=",
"form",
".",
"save",
"(",
"commit",
"=",
"False",
")",
"new_topic",
".",
"owner",
"=",
"request",
".",
"user",
"new_topic",
".",
"save",
"(",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'learning_logs:topics'",
")",
")",
"context",
"=",
"{",
"'form'",
":",
"form",
"}",
"return",
"render",
"(",
"request",
",",
"'learning_logs/new_topic.html'",
",",
"context",
")"
] | [
35,
0
] | [
49,
67
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Room.is_explored | (self) | return self.gold != Status.Unknown | Retorna True é a sala já foi explorada. | Retorna True é a sala já foi explorada. | def is_explored(self):
"""Retorna True é a sala já foi explorada."""
assert self.gold != Status.LikelyPresent
return self.gold != Status.Unknown | [
"def",
"is_explored",
"(",
"self",
")",
":",
"assert",
"self",
".",
"gold",
"!=",
"Status",
".",
"LikelyPresent",
"return",
"self",
".",
"gold",
"!=",
"Status",
".",
"Unknown"
] | [
80,
2
] | [
85,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Log.__emit | (self, method, msg, args) | Emite uma mensagem de log | Emite uma mensagem de log | def __emit(self, method, msg, args):
"""Emite uma mensagem de log"""
try:
get_lock()
msg = (msg % args)
if len(msg) > self._MAX_LINE_SIZE:
msg = msg[0:self._MAX_LINE_SIZE] + '...'
method(msg, extra={'module_name': self.module_name})
finally:
release_lock() | [
"def",
"__emit",
"(",
"self",
",",
"method",
",",
"msg",
",",
"args",
")",
":",
"try",
":",
"get_lock",
"(",
")",
"msg",
"=",
"(",
"msg",
"%",
"args",
")",
"if",
"len",
"(",
"msg",
")",
">",
"self",
".",
"_MAX_LINE_SIZE",
":",
"msg",
"=",
"msg",
"[",
"0",
":",
"self",
".",
"_MAX_LINE_SIZE",
"]",
"+",
"'...'",
"method",
"(",
"msg",
",",
"extra",
"=",
"{",
"'module_name'",
":",
"self",
".",
"module_name",
"}",
")",
"finally",
":",
"release_lock",
"(",
")"
] | [
217,
4
] | [
226,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Statistics.generate_sentencelist | (self) | return self.list_sentences | [Gera uma lista de sentenças.]
Returns:
[type] -- [description]
| [Gera uma lista de sentenças.] | def generate_sentencelist(self):
"""[Gera uma lista de sentenças.]
Returns:
[type] -- [description]
"""
for sentence in self._documents['sentences']:
self.list_sentences.append(
PreProcessing().remove_special_characters(sentence))
return self.list_sentences | [
"def",
"generate_sentencelist",
"(",
"self",
")",
":",
"for",
"sentence",
"in",
"self",
".",
"_documents",
"[",
"'sentences'",
"]",
":",
"self",
".",
"list_sentences",
".",
"append",
"(",
"PreProcessing",
"(",
")",
".",
"remove_special_characters",
"(",
"sentence",
")",
")",
"return",
"self",
".",
"list_sentences"
] | [
52,
4
] | [
62,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoResource.handle_post | (self, request, user, *args, **kwargs) | Trata uma requisicao POST para inserir um equipamento.
URL: equipamento/
| Trata uma requisicao POST para inserir um equipamento. | def handle_post(self, request, user, *args, **kwargs):
"""Trata uma requisicao POST para inserir um equipamento.
URL: equipamento/
"""
try:
xml_map, attrs_map = loads(request.raw_post_data)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisicao.')
return self.response_error(3, x)
self.log.debug('XML_MAP: %s', xml_map)
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
return self.response_error(3, u'Não existe valor para a tag networkapi do XML de requisição.')
equipment_map = networkapi_map.get('equipamento')
if equipment_map is None:
return self.response_error(3, u'Não existe valor para a tag equipamento do XML de requisição.')
try:
response = insert_equipment(equipment_map, user)
if response[0] == 0:
networkapi_map = dict()
equipment_map = dict()
equipment_map['id'] = response[2].id
equipment_group_map = dict()
equipment_group_map['id'] = response[1]
networkapi_map['equipamento'] = equipment_map
networkapi_map['equipamento_grupo'] = equipment_group_map
add_script(user, response[2])
return self.response(dumps_networkapi(networkapi_map))
else:
if len(response) > 1:
return self.response_error(response[0], response[1:len(response)])
return self.response_error(response[0])
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except InvalidGroupToEquipmentTypeError:
return self.response_error(107)
except TipoEquipamentoNotFoundError:
return self.response_error(100)
except ModeloNotFoundError:
return self.response_error(101)
except EquipamentoNameDuplicatedError:
return self.response_error(149)
except EGrupoNotFoundError:
return self.response_error(102)
except UserNotAuthorizedError:
return self.not_authorized()
except (EquipamentoError, GrupoError):
return self.response_error(1) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisicao.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"self",
".",
"log",
".",
"debug",
"(",
"'XML_MAP: %s'",
",",
"xml_map",
")",
"networkapi_map",
"=",
"xml_map",
".",
"get",
"(",
"'networkapi'",
")",
"if",
"networkapi_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag networkapi do XML de requisição.')",
"",
"equipment_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'equipamento'",
")",
"if",
"equipment_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag equipamento do XML de requisição.')",
"",
"try",
":",
"response",
"=",
"insert_equipment",
"(",
"equipment_map",
",",
"user",
")",
"if",
"response",
"[",
"0",
"]",
"==",
"0",
":",
"networkapi_map",
"=",
"dict",
"(",
")",
"equipment_map",
"=",
"dict",
"(",
")",
"equipment_map",
"[",
"'id'",
"]",
"=",
"response",
"[",
"2",
"]",
".",
"id",
"equipment_group_map",
"=",
"dict",
"(",
")",
"equipment_group_map",
"[",
"'id'",
"]",
"=",
"response",
"[",
"1",
"]",
"networkapi_map",
"[",
"'equipamento'",
"]",
"=",
"equipment_map",
"networkapi_map",
"[",
"'equipamento_grupo'",
"]",
"=",
"equipment_group_map",
"add_script",
"(",
"user",
",",
"response",
"[",
"2",
"]",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"networkapi_map",
")",
")",
"else",
":",
"if",
"len",
"(",
"response",
")",
">",
"1",
":",
"return",
"self",
".",
"response_error",
"(",
"response",
"[",
"0",
"]",
",",
"response",
"[",
"1",
":",
"len",
"(",
"response",
")",
"]",
")",
"return",
"self",
".",
"response_error",
"(",
"response",
"[",
"0",
"]",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"InvalidGroupToEquipmentTypeError",
":",
"return",
"self",
".",
"response_error",
"(",
"107",
")",
"except",
"TipoEquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"100",
")",
"except",
"ModeloNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"101",
")",
"except",
"EquipamentoNameDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"149",
")",
"except",
"EGrupoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"102",
")",
"except",
"UserNotAuthorizedError",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
184,
4
] | [
243,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pesquisador.getProducaoBibliografica | (self) | return result | Extrai informações de Producao Bibliografica do pesquisador do XML do Lattes. Insere informação de ISSN e ISBN, verifica validade e ajusta fator QUALIS. Precisa da definição da raiz do XML que é realizada em getDadosBasicos.
Returns:
type: Dataframe.
| Extrai informações de Producao Bibliografica do pesquisador do XML do Lattes. Insere informação de ISSN e ISBN, verifica validade e ajusta fator QUALIS. Precisa da definição da raiz do XML que é realizada em getDadosBasicos. | def getProducaoBibliografica(self):
"""Extrai informações de Producao Bibliografica do pesquisador do XML do Lattes. Insere informação de ISSN e ISBN, verifica validade e ajusta fator QUALIS. 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 = 'PRODUCAO-BIBLIOGRAFICA'
#----Definindo quais campos são úteis
#--------Colunas dos Dados Básicos
cols_BIB_basicos = ['PRODUCAO', 'TIPO', 'NATUREZA','TITULO', 'ANO', 'PAIS', 'MEIO', 'DOI', 'REVISTA' ]
#--------Colunas dos dados complementares.
cols_BIB_complementares = ['CLASSIFICACAO', 'NOME', 'EDITORA', 'ISSN-ISBN', 'ISSN', 'ISBN']
#--------Colunas com múltiplas equivalências.
cols_merge = ['ANO', 'TITULO','PAIS', 'REVISTA', 'MEIO', 'ISSN-ISBN']
#--------Colunas que tem que mudar de nome
cols_equiv = {'TITULO-DO-PERIODICO-OU-REVISTA':'REVISTA', 'TITULO-DOS-ANAIS-OU-PROCEEDINGS':'REVISTA-PROC', 'TITULO-DO-JORNAL-OU-REVISTA':'REVISTA-JORNAL', 'ISBN':'ISSN-ISBN-1', 'ISSN':'ISSN-ISBN-2'}
#--------Juntando todos os dados básicos e complementares.
cols_keep = list(OrderedDict.fromkeys([*cols_BIB_basicos, *cols_BIB_complementares]))
#--------Jogue fora toda coluna com estes termos
cols_out = ['INGLES', 'CODIGO', 'FLAG', 'HOME', 'CIDADE','PAGINA']
cols_final = ['SEQUENCIA-PRODUCAO', 'PRODUCAO', 'NATUREZA', 'CLASSIFICACAO', 'TIPO', 'TITULO', 'ANO', 'PAIS', 'REVISTA','DOI', 'ISBN' ,'NOME']
#----Parsing
lista = self.xml2dict(tag = TAGs)
df = pd.concat([pd.DataFrame(lista[0]), pd.DataFrame(lista[1])], ignore_index=True)
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)
#----Filtrando
df = df[df['ANO'].isin(self.periodo)]
# #----Validando ISSN/ISBN
# if 'ISSN-ISBN' not in df.columns.tolist():
# if 'ISSN' not in df.columns.tolist():
# if 'ISBN' in df.columns.tolist():
# df.rename(columns = {'ISBN':'ISSN-ISBN'})
# else:
# df['ISSN-ISBN'] = ""
# else:
# df.rename(columns = {'ISSN':'ISSN-ISBN'})
# df['ISSN-ISBN'] = df['ISSN-ISBN'].apply(self.validaISSN_ISBN)
# df['ISSN-ISBN'] = df['ISSN-ISBN'].apply(lambda val: ''.join(val))
# #---- QUALIS
# AREA_CNPQ = self.getArea()
# AREA_CAPES = self.getAreaCAPES(AREA_CNPQ)
# try:
# df['QUALIS'] = df.apply(lambda val: self.setQualis(AREA_CAPES, val['ISSN-ISBN']) if val['ISSN-ISBN']!='INVALIDO' else '', axis = 1)
# except ValueError as error:
# df['QUALIS'] = 'ERRO'
# #----doi
# #DOI = self.validaDoi(df.DOI)
df["ID"] = self.ID
result = df
else:
result = None
else:
result = None
return result | [
"def",
"getProducaoBibliografica",
"(",
"self",
")",
":",
"if",
"self",
".",
"__FLAG",
":",
"#----Ajustando informações para o bloco",
"TAGs",
"=",
"'PRODUCAO-BIBLIOGRAFICA'",
"#----Definindo quais campos são úteis",
"#--------Colunas dos Dados Básicos",
"cols_BIB_basicos",
"=",
"[",
"'PRODUCAO'",
",",
"'TIPO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'MEIO'",
",",
"'DOI'",
",",
"'REVISTA'",
"]",
"#--------Colunas dos dados complementares.",
"cols_BIB_complementares",
"=",
"[",
"'CLASSIFICACAO'",
",",
"'NOME'",
",",
"'EDITORA'",
",",
"'ISSN-ISBN'",
",",
"'ISSN'",
",",
"'ISBN'",
"]",
"#--------Colunas com múltiplas equivalências.",
"cols_merge",
"=",
"[",
"'ANO'",
",",
"'TITULO'",
",",
"'PAIS'",
",",
"'REVISTA'",
",",
"'MEIO'",
",",
"'ISSN-ISBN'",
"]",
"#--------Colunas que tem que mudar de nome",
"cols_equiv",
"=",
"{",
"'TITULO-DO-PERIODICO-OU-REVISTA'",
":",
"'REVISTA'",
",",
"'TITULO-DOS-ANAIS-OU-PROCEEDINGS'",
":",
"'REVISTA-PROC'",
",",
"'TITULO-DO-JORNAL-OU-REVISTA'",
":",
"'REVISTA-JORNAL'",
",",
"'ISBN'",
":",
"'ISSN-ISBN-1'",
",",
"'ISSN'",
":",
"'ISSN-ISBN-2'",
"}",
"#--------Juntando todos os dados básicos e complementares.",
"cols_keep",
"=",
"list",
"(",
"OrderedDict",
".",
"fromkeys",
"(",
"[",
"*",
"cols_BIB_basicos",
",",
"*",
"cols_BIB_complementares",
"]",
")",
")",
"#--------Jogue fora toda coluna com estes termos",
"cols_out",
"=",
"[",
"'INGLES'",
",",
"'CODIGO'",
",",
"'FLAG'",
",",
"'HOME'",
",",
"'CIDADE'",
",",
"'PAGINA'",
"]",
"cols_final",
"=",
"[",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'NATUREZA'",
",",
"'CLASSIFICACAO'",
",",
"'TIPO'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'REVISTA'",
",",
"'DOI'",
",",
"'ISBN'",
",",
"'NOME'",
"]",
"#----Parsing",
"lista",
"=",
"self",
".",
"xml2dict",
"(",
"tag",
"=",
"TAGs",
")",
"df",
"=",
"pd",
".",
"concat",
"(",
"[",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"0",
"]",
")",
",",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"1",
"]",
")",
"]",
",",
"ignore_index",
"=",
"True",
")",
"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",
")",
"#----Filtrando",
"df",
"=",
"df",
"[",
"df",
"[",
"'ANO'",
"]",
".",
"isin",
"(",
"self",
".",
"periodo",
")",
"]",
"# #----Validando ISSN/ISBN",
"# if 'ISSN-ISBN' not in df.columns.tolist():",
"# if 'ISSN' not in df.columns.tolist():",
"# if 'ISBN' in df.columns.tolist():",
"# df.rename(columns = {'ISBN':'ISSN-ISBN'})",
"# else:",
"# df['ISSN-ISBN'] = \"\"",
"# else:",
"# df.rename(columns = {'ISSN':'ISSN-ISBN'})",
"# df['ISSN-ISBN'] = df['ISSN-ISBN'].apply(self.validaISSN_ISBN)",
"# df['ISSN-ISBN'] = df['ISSN-ISBN'].apply(lambda val: ''.join(val))",
"# #---- QUALIS",
"# AREA_CNPQ = self.getArea()",
"# AREA_CAPES = self.getAreaCAPES(AREA_CNPQ)",
"# try:",
"# df['QUALIS'] = df.apply(lambda val: self.setQualis(AREA_CAPES, val['ISSN-ISBN']) if val['ISSN-ISBN']!='INVALIDO' else '', axis = 1)",
"# except ValueError as error:",
"# df['QUALIS'] = 'ERRO'",
"# #----doi",
"# #DOI = self.validaDoi(df.DOI)",
"df",
"[",
"\"ID\"",
"]",
"=",
"self",
".",
"ID",
"result",
"=",
"df",
"else",
":",
"result",
"=",
"None",
"else",
":",
"result",
"=",
"None",
"return",
"result"
] | [
781,
4
] | [
839,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Solution.vars_to_solution | (model: Model, G: Graph, T: int) | return Solution(defended, burned, iteration, T, int(model.objVal),
optimal) | Função para traduzir variáveis do Gurobi para Solution. | Função para traduzir variáveis do Gurobi para Solution. | def vars_to_solution(model: Model, G: Graph, T: int):
''' Função para traduzir variáveis do Gurobi para Solution.'''
b, d = model._b, model._d
defended, burned = set(), set()
n = G.number_of_nodes()
iteration = [inf for _ in range(n)]
# Converter variáveis para conjuntos/listas
for v in range(n):
for t in range(T+1):
# Quando um nó é queimado ou defendido,
# guarda a iteração e vai para o próximo.
if b[v, t].X == 1.0:
burned.add(v)
iteration[v] = t
break
elif d[v, t].X == 1.0:
defended.add(v)
iteration[v] = t
break
optimal = model.status == GRB.Status.OPTIMAL
return Solution(defended, burned, iteration, T, int(model.objVal),
optimal) | [
"def",
"vars_to_solution",
"(",
"model",
":",
"Model",
",",
"G",
":",
"Graph",
",",
"T",
":",
"int",
")",
":",
"b",
",",
"d",
"=",
"model",
".",
"_b",
",",
"model",
".",
"_d",
"defended",
",",
"burned",
"=",
"set",
"(",
")",
",",
"set",
"(",
")",
"n",
"=",
"G",
".",
"number_of_nodes",
"(",
")",
"iteration",
"=",
"[",
"inf",
"for",
"_",
"in",
"range",
"(",
"n",
")",
"]",
"# Converter variáveis para conjuntos/listas",
"for",
"v",
"in",
"range",
"(",
"n",
")",
":",
"for",
"t",
"in",
"range",
"(",
"T",
"+",
"1",
")",
":",
"# Quando um nó é queimado ou defendido,",
"# guarda a iteração e vai para o próximo.",
"if",
"b",
"[",
"v",
",",
"t",
"]",
".",
"X",
"==",
"1.0",
":",
"burned",
".",
"add",
"(",
"v",
")",
"iteration",
"[",
"v",
"]",
"=",
"t",
"break",
"elif",
"d",
"[",
"v",
",",
"t",
"]",
".",
"X",
"==",
"1.0",
":",
"defended",
".",
"add",
"(",
"v",
")",
"iteration",
"[",
"v",
"]",
"=",
"t",
"break",
"optimal",
"=",
"model",
".",
"status",
"==",
"GRB",
".",
"Status",
".",
"OPTIMAL",
"return",
"Solution",
"(",
"defended",
",",
"burned",
",",
"iteration",
",",
"T",
",",
"int",
"(",
"model",
".",
"objVal",
")",
",",
"optimal",
")"
] | [
118,
4
] | [
143,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
load_all_extensions | (*, folder=None) | Carrega todas as extensões. | Carrega todas as extensões. | def load_all_extensions(*, folder=None):
"""Carrega todas as extensões."""
for ext in get_all_extensions(folder=folder):
client.load_extension(ext) | [
"def",
"load_all_extensions",
"(",
"*",
",",
"folder",
"=",
"None",
")",
":",
"for",
"ext",
"in",
"get_all_extensions",
"(",
"folder",
"=",
"folder",
")",
":",
"client",
".",
"load_extension",
"(",
"ext",
")"
] | [
63,
0
] | [
66,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
fire_bullet | (ai_settings, screen, ship, bullets) | Dispara um projetil se o limite ainda não for alcançado | Dispara um projetil se o limite ainda não for alcançado | def fire_bullet(ai_settings, screen, ship, bullets):
"""Dispara um projetil se o limite ainda não for alcançado"""
# Cria um novo projetil e o adiciona no grupo dos projeteis
if len(bullets) < ai_settings.bullets_allowed:
new_bullet = Bullet(ai_settings, screen, ship)
bullets.add(new_bullet)
# Tocando o som de tiro laser
shoot_sound = pygame.mixer.Sound('Sounds/shoot.wav')
pygame.mixer.Sound.set_volume(shoot_sound, 0.1)
shoot_sound.play() | [
"def",
"fire_bullet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"bullets",
")",
":",
"# Cria um novo projetil e o adiciona no grupo dos projeteis",
"if",
"len",
"(",
"bullets",
")",
"<",
"ai_settings",
".",
"bullets_allowed",
":",
"new_bullet",
"=",
"Bullet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
")",
"bullets",
".",
"add",
"(",
"new_bullet",
")",
"# Tocando o som de tiro laser",
"shoot_sound",
"=",
"pygame",
".",
"mixer",
".",
"Sound",
"(",
"'Sounds/shoot.wav'",
")",
"pygame",
".",
"mixer",
".",
"Sound",
".",
"set_volume",
"(",
"shoot_sound",
",",
"0.1",
")",
"shoot_sound",
".",
"play",
"(",
")"
] | [
46,
0
] | [
55,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
start_game | (ai_settings, screen, stats, sb, ship, aliens, bullets) | Exercicio 14.1 INICIA O JOGO COM A TECLA P | Exercicio 14.1 INICIA O JOGO COM A TECLA P | def start_game(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Exercicio 14.1 INICIA O JOGO COM A TECLA P"""
if not stats.game_active:
# Reinicia as configuracoes do jogo
ai_settings.initialize_dynamic_settings()
# Oculta o cursos do mouse
pygame.mouse.set_visible(False)
# Reinicia os dados estatisticos do jogo
stats.reset_stats()
stats.high_score = int(load_max_point()) if load_max_point() != '' else 0
stats.game_active = True
# Reinicia as imagens do painel de pontuacao
sb.prep_images()
# Esvazia a lista de alienigenas e de projeteis
aliens.empty()
bullets.empty()
# Cria uma nova frota e centraliza a espaconave
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship() | [
"def",
"start_game",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"if",
"not",
"stats",
".",
"game_active",
":",
"# Reinicia as configuracoes do jogo",
"ai_settings",
".",
"initialize_dynamic_settings",
"(",
")",
"# Oculta o cursos do mouse",
"pygame",
".",
"mouse",
".",
"set_visible",
"(",
"False",
")",
"# Reinicia os dados estatisticos do jogo",
"stats",
".",
"reset_stats",
"(",
")",
"stats",
".",
"high_score",
"=",
"int",
"(",
"load_max_point",
"(",
")",
")",
"if",
"load_max_point",
"(",
")",
"!=",
"''",
"else",
"0",
"stats",
".",
"game_active",
"=",
"True",
"# Reinicia as imagens do painel de pontuacao",
"sb",
".",
"prep_images",
"(",
")",
"# Esvazia a lista de alienigenas e de projeteis",
"aliens",
".",
"empty",
"(",
")",
"bullets",
".",
"empty",
"(",
")",
"# Cria uma nova frota e centraliza a espaconave",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
"ship",
".",
"center_ship",
"(",
")"
] | [
55,
0
] | [
78,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RestResource.response | (self, content, status=200, content_type='text/plain') | return http_res | Cria um HttpResponse com os dados informados | Cria um HttpResponse com os dados informados | def response(self, content, status=200, content_type='text/plain'):
"""Cria um HttpResponse com os dados informados"""
http_res = HttpResponse(
content,
status=status,
content_type=content_type)
http_res['X-Request-Id'] = local.request_id
http_res['X-Request-Context'] = local.request_context
return http_res | [
"def",
"response",
"(",
"self",
",",
"content",
",",
"status",
"=",
"200",
",",
"content_type",
"=",
"'text/plain'",
")",
":",
"http_res",
"=",
"HttpResponse",
"(",
"content",
",",
"status",
"=",
"status",
",",
"content_type",
"=",
"content_type",
")",
"http_res",
"[",
"'X-Request-Id'",
"]",
"=",
"local",
".",
"request_id",
"http_res",
"[",
"'X-Request-Context'",
"]",
"=",
"local",
".",
"request_context",
"return",
"http_res"
] | [
206,
4
] | [
217,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Ship.blitme | (self) | Desenha a espaçonave em sua posição atual | Desenha a espaçonave em sua posição atual | def blitme(self):
"""Desenha a espaçonave em sua posição atual"""
self.screen.blit(self.image, self.rect) | [
"def",
"blitme",
"(",
"self",
")",
":",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"image",
",",
"self",
".",
"rect",
")"
] | [
50,
4
] | [
52,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
division | (a: float, b: float) | Divide dos números.
:param a: Primer número.
:a type: float
:param b: Segundo número.
:b type: float
:raises ZeroDivisionError: Si el segundo número es cero.
:return: La división de los dos números.
:rtype: float
| Divide dos números. | def division(a: float, b: float) -> float:
"""Divide dos números.
:param a: Primer número.
:a type: float
:param b: Segundo número.
:b type: float
:raises ZeroDivisionError: Si el segundo número es cero.
:return: La división de los dos números.
:rtype: float
"""
try:
return a / b
except ZeroDivisionError:
return "No se puede dividir entre cero" | [
"def",
"division",
"(",
"a",
":",
"float",
",",
"b",
":",
"float",
")",
"->",
"float",
":",
"try",
":",
"return",
"a",
"/",
"b",
"except",
"ZeroDivisionError",
":",
"return",
"\"No se puede dividir entre cero\""
] | [
45,
0
] | [
59,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
mongodb_parser | (args) | return parser | Parser utilizado para capturar informações sobre conexão
com o MongoDB | Parser utilizado para capturar informações sobre conexão
com o MongoDB | def mongodb_parser(args):
"""Parser utilizado para capturar informações sobre conexão
com o MongoDB"""
parser = argparse.ArgumentParser(add_help=False)
parser.add_argument(
"--uri",
required=True,
help="""URI to connect at MongoDB where the import
will be done, e.g: "mongodb://user:password@mongodb-host/?authSource=admin" """,
)
parser.add_argument("--db", required=True, help="Database name to import registers")
return parser | [
"def",
"mongodb_parser",
"(",
"args",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"add_help",
"=",
"False",
")",
"parser",
".",
"add_argument",
"(",
"\"--uri\"",
",",
"required",
"=",
"True",
",",
"help",
"=",
"\"\"\"URI to connect at MongoDB where the import\n will be done, e.g: \"mongodb://user:password@mongodb-host/?authSource=admin\" \"\"\"",
",",
")",
"parser",
".",
"add_argument",
"(",
"\"--db\"",
",",
"required",
"=",
"True",
",",
"help",
"=",
"\"Database name to import registers\"",
")",
"return",
"parser"
] | [
15,
0
] | [
28,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ListaBemLoka.__add__ | (self, val) | return ListaBemLoka([x + val for x in self]) | Soma todos os ítens da lista com val | Soma todos os ítens da lista com val | def __add__(self, val):
"""Soma todos os ítens da lista com val"""
return ListaBemLoka([x + val for x in self]) | [
"def",
"__add__",
"(",
"self",
",",
"val",
")",
":",
"return",
"ListaBemLoka",
"(",
"[",
"x",
"+",
"val",
"for",
"x",
"in",
"self",
"]",
")"
] | [
1,
4
] | [
3,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
validate_cnpj | (cnpj) | return False | Rotina para validação do CNPJ - Cadastro Nacional
de Pessoa Juridica.
:param string cnpj: CNPJ para ser validado
:return bool: True or False
| Rotina para validação do CNPJ - Cadastro Nacional
de Pessoa Juridica.
:param string cnpj: CNPJ para ser validado
:return bool: True or False
| def validate_cnpj(cnpj):
""" Rotina para validação do CNPJ - Cadastro Nacional
de Pessoa Juridica.
:param string cnpj: CNPJ para ser validado
:return bool: True or False
"""
# Limpando o cnpj
if not cnpj.isdigit():
cnpj = re.sub('[^0-9]', '', cnpj)
# verificando o tamano do cnpj
if len(cnpj) != 14:
return False
# Pega apenas os 12 primeiros dígitos do CNPJ e gera os digitos
cnpj = list(map(int, cnpj))
novo = cnpj[:12]
prod = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
while len(novo) < 14:
r = sum([x * y for (x, y) in zip(novo, prod)]) % 11
if r > 1:
f = 11 - r
else:
f = 0
novo.append(f)
prod.insert(0, 6)
# Se o número gerado coincidir com o número original, é válido
if novo == cnpj:
return True
return False | [
"def",
"validate_cnpj",
"(",
"cnpj",
")",
":",
"# Limpando o cnpj",
"if",
"not",
"cnpj",
".",
"isdigit",
"(",
")",
":",
"cnpj",
"=",
"re",
".",
"sub",
"(",
"'[^0-9]'",
",",
"''",
",",
"cnpj",
")",
"# verificando o tamano do cnpj",
"if",
"len",
"(",
"cnpj",
")",
"!=",
"14",
":",
"return",
"False",
"# Pega apenas os 12 primeiros dígitos do CNPJ e gera os digitos",
"cnpj",
"=",
"list",
"(",
"map",
"(",
"int",
",",
"cnpj",
")",
")",
"novo",
"=",
"cnpj",
"[",
":",
"12",
"]",
"prod",
"=",
"[",
"5",
",",
"4",
",",
"3",
",",
"2",
",",
"9",
",",
"8",
",",
"7",
",",
"6",
",",
"5",
",",
"4",
",",
"3",
",",
"2",
"]",
"while",
"len",
"(",
"novo",
")",
"<",
"14",
":",
"r",
"=",
"sum",
"(",
"[",
"x",
"*",
"y",
"for",
"(",
"x",
",",
"y",
")",
"in",
"zip",
"(",
"novo",
",",
"prod",
")",
"]",
")",
"%",
"11",
"if",
"r",
">",
"1",
":",
"f",
"=",
"11",
"-",
"r",
"else",
":",
"f",
"=",
"0",
"novo",
".",
"append",
"(",
"f",
")",
"prod",
".",
"insert",
"(",
"0",
",",
"6",
")",
"# Se o número gerado coincidir com o número original, é válido",
"if",
"novo",
"==",
"cnpj",
":",
"return",
"True",
"return",
"False"
] | [
418,
0
] | [
450,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
is_off | (bs_day) | return bs_day.text.strip().split()[1] in ['sáb', 'dom'] | Diz se um dia é útil ou não. | Diz se um dia é útil ou não. | def is_off(bs_day):
"""Diz se um dia é útil ou não."""
if bs_day.find('div', {'class': 'list-holiday-dayweek holiday'}):
return True
return bs_day.text.strip().split()[1] in ['sáb', 'dom'] | [
"def",
"is_off",
"(",
"bs_day",
")",
":",
"if",
"bs_day",
".",
"find",
"(",
"'div'",
",",
"{",
"'class'",
":",
"'list-holiday-dayweek holiday'",
"}",
")",
":",
"return",
"True",
"return",
"bs_day",
".",
"text",
".",
"strip",
"(",
")",
".",
"split",
"(",
")",
"[",
"1",
"]",
"in",
"[",
"'sáb',",
" ",
"dom']",
""
] | [
11,
0
] | [
15,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
adicionar_session_id | (whatsapp, session_id) | return db.collection(u'sessions_flow').document().set(data) | cria documento com o whatsapp e a sessao no watson | cria documento com o whatsapp e a sessao no watson | def adicionar_session_id(whatsapp, session_id):
"""cria documento com o whatsapp e a sessao no watson"""
data = {
u'usuario': whatsapp,
u'session_id': session_id,
u'timestamp': datetime.datetime.now() - datetime.timedelta(hours=-3)
}
return db.collection(u'sessions_flow').document().set(data) | [
"def",
"adicionar_session_id",
"(",
"whatsapp",
",",
"session_id",
")",
":",
"data",
"=",
"{",
"u'usuario'",
":",
"whatsapp",
",",
"u'session_id'",
":",
"session_id",
",",
"u'timestamp'",
":",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"-",
"datetime",
".",
"timedelta",
"(",
"hours",
"=",
"-",
"3",
")",
"}",
"return",
"db",
".",
"collection",
"(",
"u'sessions_flow'",
")",
".",
"document",
"(",
")",
".",
"set",
"(",
"data",
")"
] | [
13,
0
] | [
22,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Scoreboard.prep_score | (self) | Transforma a pontuação em uma imagem renderizada | Transforma a pontuação em uma imagem renderizada | def prep_score(self):
"""Transforma a pontuação em uma imagem renderizada"""
rounded_score = round(self.stats.score, -1)
score_str = f'Score: {rounded_score:,}'
self.score_image = self.font.render(score_str, True, self.text_color, (20, 24, 33))
# Exibe a pontuação na parte superior direita da tela
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 5 | [
"def",
"prep_score",
"(",
"self",
")",
":",
"rounded_score",
"=",
"round",
"(",
"self",
".",
"stats",
".",
"score",
",",
"-",
"1",
")",
"score_str",
"=",
"f'Score: {rounded_score:,}'",
"self",
".",
"score_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"score_str",
",",
"True",
",",
"self",
".",
"text_color",
",",
"(",
"20",
",",
"24",
",",
"33",
")",
")",
"# Exibe a pontuação na parte superior direita da tela",
"self",
".",
"score_rect",
"=",
"self",
".",
"score_image",
".",
"get_rect",
"(",
")",
"self",
".",
"score_rect",
".",
"right",
"=",
"self",
".",
"screen_rect",
".",
"right",
"-",
"20",
"self",
".",
"score_rect",
".",
"top",
"=",
"5"
] | [
25,
4
] | [
35,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
consistent_with | (event, evidence) | return all(evidence.get(k, v) == v for k, v in event.items()) | O evento é consistente com a evidência fornecida? | O evento é consistente com a evidência fornecida? | def consistent_with(event, evidence):
"O evento é consistente com a evidência fornecida?"
return all(evidence.get(k, v) == v for k, v in event.items()) | [
"def",
"consistent_with",
"(",
"event",
",",
"evidence",
")",
":",
"return",
"all",
"(",
"evidence",
".",
"get",
"(",
"k",
",",
"v",
")",
"==",
"v",
"for",
"k",
",",
"v",
"in",
"event",
".",
"items",
"(",
")",
")"
] | [
445,
0
] | [
447,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Historico.adiciona_estado | (self, estado: Estado) | Adiciona em uma list um Estado do contrato no historico dos
contratatos. | Adiciona em uma list um Estado do contrato no historico dos
contratatos. | def adiciona_estado(self, estado: Estado):
"""Adiciona em uma list um Estado do contrato no historico dos
contratatos."""
self.__estados_salvos.append(estado) | [
"def",
"adiciona_estado",
"(",
"self",
",",
"estado",
":",
"Estado",
")",
":",
"self",
".",
"__estados_salvos",
".",
"append",
"(",
"estado",
")"
] | [
114,
4
] | [
117,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType21.unit_info | (self) | return bin2str(self.data[20 : 20 + self._text1_len]) | Retorna o campo TEXT1 que contém o ‘unit_info’ no arquivo cfg. | Retorna o campo TEXT1 que contém o ‘unit_info’ no arquivo cfg. | def unit_info(self) -> str:
"""Retorna o campo TEXT1 que contém o ‘unit_info’ no arquivo cfg."""
return bin2str(self.data[20 : 20 + self._text1_len]) | [
"def",
"unit_info",
"(",
"self",
")",
"->",
"str",
":",
"return",
"bin2str",
"(",
"self",
".",
"data",
"[",
"20",
":",
"20",
"+",
"self",
".",
"_text1_len",
"]",
")"
] | [
466,
4
] | [
468,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Ship.__init__ | (self, ai_settings, screen) | Inicializando a espaçonave e define sua posição inicial. | Inicializando a espaçonave e define sua posição inicial. | def __init__(self, ai_settings, screen):
'''Inicializando a espaçonave e define sua posição inicial.'''
self.screen = screen
self.ai_settings = ai_settings
# Carrega a imagem da espaçonave e obtém seu rect
self.image = pygame.image.load('Imagens/ship.png')
self.rect = self.image.get_rect()
self.screen_rect = screen.get_rect()
# Inicia cada nova espaçonave na parte inferior central da tela
self.rect.centerx = self.screen_rect.centerx
self.rect.bottom = self.screen_rect.bottom
# Armazena um valor decimal para o centro da espaçonave
self.center = float(self.rect.centerx)
#Flag de movimento
self.moving_right = False
self.moving_left = False | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
")",
":",
"self",
".",
"screen",
"=",
"screen",
"self",
".",
"ai_settings",
"=",
"ai_settings",
"# Carrega a imagem da espaçonave e obtém seu rect",
"self",
".",
"image",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Imagens/ship.png'",
")",
"self",
".",
"rect",
"=",
"self",
".",
"image",
".",
"get_rect",
"(",
")",
"self",
".",
"screen_rect",
"=",
"screen",
".",
"get_rect",
"(",
")",
"# Inicia cada nova espaçonave na parte inferior central da tela",
"self",
".",
"rect",
".",
"centerx",
"=",
"self",
".",
"screen_rect",
".",
"centerx",
"self",
".",
"rect",
".",
"bottom",
"=",
"self",
".",
"screen_rect",
".",
"bottom",
"# Armazena um valor decimal para o centro da espaçonave",
"self",
".",
"center",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"centerx",
")",
"#Flag de movimento",
"self",
".",
"moving_right",
"=",
"False",
"self",
".",
"moving_left",
"=",
"False"
] | [
4,
1
] | [
23,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RequisicaoVips.valida | (self, authenticated_user, validado) | Valida uma Requisicao VIP.
@return: Nothing.
@raise RequisicaoVipsError: Erro ao validar Requisição de VIP.
| Valida uma Requisicao VIP. | def valida(self, authenticated_user, validado):
"""Valida uma Requisicao VIP.
@return: Nothing.
@raise RequisicaoVipsError: Erro ao validar Requisição de VIP.
"""
try:
self.validado = validado
self.save()
except RequisicaoVipsError, e:
self.log.error(u'Falha ao validar a requisição de vip.')
raise RequisicaoVipsError(
e, u'Falha ao validar a requisição de vip.') | [
"def",
"valida",
"(",
"self",
",",
"authenticated_user",
",",
"validado",
")",
":",
"try",
":",
"self",
".",
"validado",
"=",
"validado",
"self",
".",
"save",
"(",
")",
"except",
"RequisicaoVipsError",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao validar a requisição de vip.')",
"",
"raise",
"RequisicaoVipsError",
"(",
"e",
",",
"u'Falha ao validar a requisição de vip.')",
""
] | [
1382,
4
] | [
1396,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_document_renditions | (
folder: str, file_prefix: str, storage: object
) | return _renditions | Faz o envio das manifestações do pacote com base no arquivo
manifest.json e retorna o resultado do envio destas manifestações
para o object store. | Faz o envio das manifestações do pacote com base no arquivo
manifest.json e retorna o resultado do envio destas manifestações
para o object store. | def get_document_renditions(
folder: str, file_prefix: str, storage: object
) -> List[dict]:
"""Faz o envio das manifestações do pacote com base no arquivo
manifest.json e retorna o resultado do envio destas manifestações
para o object store."""
mimetypes = MimeTypes()
_renditions = []
try:
_manifest_json = json.loads(
files.read_file(os.path.join(folder, "manifest.json"))
)
except Exception as exc:
logger.error("Could not read manifest: %s", str(exc))
else:
_manifest = {lang: urlparse(url).path for lang, url in _manifest_json.items()}
logger.debug("Renditions lang and legacy url: %s", _manifest)
for lang, legacy_url in _manifest.items():
rendition = os.path.basename(legacy_url)
_mimetype = mimetypes.guess_type(rendition)[0]
_rendition_path = os.path.join(folder, rendition)
_rendition = {
"filename": rendition,
"url": storage.register(
_rendition_path, file_prefix, _manifest.get(lang)
),
"size_bytes": os.path.getsize(_rendition_path),
"mimetype": _mimetype,
"lang": lang,
}
_renditions.append(_rendition)
return _renditions | [
"def",
"get_document_renditions",
"(",
"folder",
":",
"str",
",",
"file_prefix",
":",
"str",
",",
"storage",
":",
"object",
")",
"->",
"List",
"[",
"dict",
"]",
":",
"mimetypes",
"=",
"MimeTypes",
"(",
")",
"_renditions",
"=",
"[",
"]",
"try",
":",
"_manifest_json",
"=",
"json",
".",
"loads",
"(",
"files",
".",
"read_file",
"(",
"os",
".",
"path",
".",
"join",
"(",
"folder",
",",
"\"manifest.json\"",
")",
")",
")",
"except",
"Exception",
"as",
"exc",
":",
"logger",
".",
"error",
"(",
"\"Could not read manifest: %s\"",
",",
"str",
"(",
"exc",
")",
")",
"else",
":",
"_manifest",
"=",
"{",
"lang",
":",
"urlparse",
"(",
"url",
")",
".",
"path",
"for",
"lang",
",",
"url",
"in",
"_manifest_json",
".",
"items",
"(",
")",
"}",
"logger",
".",
"debug",
"(",
"\"Renditions lang and legacy url: %s\"",
",",
"_manifest",
")",
"for",
"lang",
",",
"legacy_url",
"in",
"_manifest",
".",
"items",
"(",
")",
":",
"rendition",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"legacy_url",
")",
"_mimetype",
"=",
"mimetypes",
".",
"guess_type",
"(",
"rendition",
")",
"[",
"0",
"]",
"_rendition_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"folder",
",",
"rendition",
")",
"_rendition",
"=",
"{",
"\"filename\"",
":",
"rendition",
",",
"\"url\"",
":",
"storage",
".",
"register",
"(",
"_rendition_path",
",",
"file_prefix",
",",
"_manifest",
".",
"get",
"(",
"lang",
")",
")",
",",
"\"size_bytes\"",
":",
"os",
".",
"path",
".",
"getsize",
"(",
"_rendition_path",
")",
",",
"\"mimetype\"",
":",
"_mimetype",
",",
"\"lang\"",
":",
"lang",
",",
"}",
"_renditions",
".",
"append",
"(",
"_rendition",
")",
"return",
"_renditions"
] | [
45,
0
] | [
81,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
max_recursivo | (vetor, maximo, indice) | return maximo | Busca o valor máximo através usando recursão. | Busca o valor máximo através usando recursão. | def max_recursivo(vetor, maximo, indice):
"""Busca o valor máximo através usando recursão."""
if vetor[indice] > maximo:
maximo = vetor[indice]
if indice < len(vetor) - 1:
maximo = max_recursivo(vetor, maximo, indice+1)
return maximo | [
"def",
"max_recursivo",
"(",
"vetor",
",",
"maximo",
",",
"indice",
")",
":",
"if",
"vetor",
"[",
"indice",
"]",
">",
"maximo",
":",
"maximo",
"=",
"vetor",
"[",
"indice",
"]",
"if",
"indice",
"<",
"len",
"(",
"vetor",
")",
"-",
"1",
":",
"maximo",
"=",
"max_recursivo",
"(",
"vetor",
",",
"maximo",
",",
"indice",
"+",
"1",
")",
"return",
"maximo"
] | [
3,
0
] | [
9,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RestResource.handle_put | (self, request, user, *args, **kwargs) | return self.not_implemented() | Trata uma requisição com o método PUT | Trata uma requisição com o método PUT | def handle_put(self, request, user, *args, **kwargs):
"""Trata uma requisição com o método PUT"""
return self.not_implemented() | [
"def",
"handle_put",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"self",
".",
"not_implemented",
"(",
")"
] | [
127,
4
] | [
129,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.