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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BoletoPDF.drawBoletoCarne | (self, boleto_dados, y) | return x, d[1] | Imprime apenas dos boletos do carnê.
Esta função não deve ser chamada diretamente, ao invés disso use a
drawBoletoCarneDuplo.
:param boleto_dados: Objeto com os dados do boleto a ser preenchido.
Deve ser subclasse de :class:`pyboleto.data.BoletoData`
:type boleto_dados: :class:`pyboleto.data.BoletoData`
| Imprime apenas dos boletos do carnê. | def drawBoletoCarne(self, boleto_dados, y):
"""Imprime apenas dos boletos do carnê.
Esta função não deve ser chamada diretamente, ao invés disso use a
drawBoletoCarneDuplo.
:param boleto_dados: Objeto com os dados do boleto a ser preenchido.
Deve ser subclasse de :class:`pyboleto.data.BoletoData`
:type boleto_dados: :class:`pyboleto.data.BoletoData`
"""
x = 15 * mm
d = self._draw_recibo_sacado_canhoto(boleto_dados, x, y)
x += d[0] + 8 * mm
self._drawVerticalCorteLine(x, y, d[1])
x += 8 * mm
d = self._drawReciboCaixa(boleto_dados, x, y)
x += d[0]
return x, d[1] | [
"def",
"drawBoletoCarne",
"(",
"self",
",",
"boleto_dados",
",",
"y",
")",
":",
"x",
"=",
"15",
"*",
"mm",
"d",
"=",
"self",
".",
"_draw_recibo_sacado_canhoto",
"(",
"boleto_dados",
",",
"x",
",",
"y",
")",
"x",
"+=",
"d",
"[",
"0",
"]",
"+",
"8",
"*",
"mm",
"self",
".",
"_drawVerticalCorteLine",
"(",
"x",
",",
"y",
",",
"d",
"[",
"1",
"]",
")",
"x",
"+=",
"8",
"*",
"mm",
"d",
"=",
"self",
".",
"_drawReciboCaixa",
"(",
"boleto_dados",
",",
"x",
",",
"y",
")",
"x",
"+=",
"d",
"[",
"0",
"]",
"return",
"x",
",",
"d",
"[",
"1",
"]"
] | [
779,
4
] | [
796,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_article_result_dict | (sps: SPS_Package) | return dict(article_metadata) | Produz um dictionário contento informações sobre o artigo.
O dicionário produzido com informações relevantes para recuperação
do fascículo ao qual o documento está relacionado e a sua posição de registro ou
posição na lista de artigos do site (order). | Produz um dictionário contento informações sobre o artigo. | def get_article_result_dict(sps: SPS_Package) -> dict:
"""Produz um dictionário contento informações sobre o artigo.
O dicionário produzido com informações relevantes para recuperação
do fascículo ao qual o documento está relacionado e a sua posição de registro ou
posição na lista de artigos do site (order)."""
def _format_str(value):
if value and value.isdigit():
return value.zfill(5)
return value or ""
article_metadata = {}
article_meta = dict(sps.parse_article_meta)
journal_meta = dict(sps.journal_meta)
attributes = (
("pid_v3", sps.scielo_pid_v3),
("eissn", journal_meta.get("eissn")),
("pissn", journal_meta.get("pissn")),
("issn", journal_meta.get("issn")),
("acron", journal_meta.get("acron")),
("pid", sps.scielo_pid_v2),
("year", sps.year),
("volume", sps.volume),
("number", sps.number),
("supplement", sps.supplement),
("order", sps.order),
)
for key, value in attributes:
if value is not None:
article_metadata[key] = "%s" % value
return dict(article_metadata) | [
"def",
"get_article_result_dict",
"(",
"sps",
":",
"SPS_Package",
")",
"->",
"dict",
":",
"def",
"_format_str",
"(",
"value",
")",
":",
"if",
"value",
"and",
"value",
".",
"isdigit",
"(",
")",
":",
"return",
"value",
".",
"zfill",
"(",
"5",
")",
"return",
"value",
"or",
"\"\"",
"article_metadata",
"=",
"{",
"}",
"article_meta",
"=",
"dict",
"(",
"sps",
".",
"parse_article_meta",
")",
"journal_meta",
"=",
"dict",
"(",
"sps",
".",
"journal_meta",
")",
"attributes",
"=",
"(",
"(",
"\"pid_v3\"",
",",
"sps",
".",
"scielo_pid_v3",
")",
",",
"(",
"\"eissn\"",
",",
"journal_meta",
".",
"get",
"(",
"\"eissn\"",
")",
")",
",",
"(",
"\"pissn\"",
",",
"journal_meta",
".",
"get",
"(",
"\"pissn\"",
")",
")",
",",
"(",
"\"issn\"",
",",
"journal_meta",
".",
"get",
"(",
"\"issn\"",
")",
")",
",",
"(",
"\"acron\"",
",",
"journal_meta",
".",
"get",
"(",
"\"acron\"",
")",
")",
",",
"(",
"\"pid\"",
",",
"sps",
".",
"scielo_pid_v2",
")",
",",
"(",
"\"year\"",
",",
"sps",
".",
"year",
")",
",",
"(",
"\"volume\"",
",",
"sps",
".",
"volume",
")",
",",
"(",
"\"number\"",
",",
"sps",
".",
"number",
")",
",",
"(",
"\"supplement\"",
",",
"sps",
".",
"supplement",
")",
",",
"(",
"\"order\"",
",",
"sps",
".",
"order",
")",
",",
")",
"for",
"key",
",",
"value",
"in",
"attributes",
":",
"if",
"value",
"is",
"not",
"None",
":",
"article_metadata",
"[",
"key",
"]",
"=",
"\"%s\"",
"%",
"value",
"return",
"dict",
"(",
"article_metadata",
")"
] | [
145,
0
] | [
177,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Grafo.dfs | (self, start: int) | return visitados | Executa a busca em profundidade a partir do vértice start
Args:
start (int): vértice start
Returns:
list: lista com a ordem de vértices visitados
| Executa a busca em profundidade a partir do vértice start
Args:
start (int): vértice start
Returns:
list: lista com a ordem de vértices visitados
| def dfs(self, start: int) -> list:
"""Executa a busca em profundidade a partir do vértice start
Args:
start (int): vértice start
Returns:
list: lista com a ordem de vértices visitados
"""
visitados = []
visitados.append(start)
pilha = [start]
while pilha:
u = pilha.pop()
if u not in visitados:
visitados.append(u)
for v in self.adj[u][::-1]:
if v not in visitados:
pilha.append(v)
return visitados | [
"def",
"dfs",
"(",
"self",
",",
"start",
":",
"int",
")",
"->",
"list",
":",
"visitados",
"=",
"[",
"]",
"visitados",
".",
"append",
"(",
"start",
")",
"pilha",
"=",
"[",
"start",
"]",
"while",
"pilha",
":",
"u",
"=",
"pilha",
".",
"pop",
"(",
")",
"if",
"u",
"not",
"in",
"visitados",
":",
"visitados",
".",
"append",
"(",
"u",
")",
"for",
"v",
"in",
"self",
".",
"adj",
"[",
"u",
"]",
"[",
":",
":",
"-",
"1",
"]",
":",
"if",
"v",
"not",
"in",
"visitados",
":",
"pilha",
".",
"append",
"(",
"v",
")",
"return",
"visitados"
] | [
66,
4
] | [
89,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
run_game | () | Inicializa o jogo e cria um objeto para a tela - 1200/700 | Inicializa o jogo e cria um objeto para a tela - 1200/700 | def run_game():
"""Inicializa o jogo e cria um objeto para a tela - 1200/700"""
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
# Definindo Telas
pygame.display.set_caption(f'Alien-Invasion')
pygame.display.set_icon(pygame.image.load('Assets/aliens/alien3.bmp'))
background_start = pygame.image.load('Assets/menu/apresentacao.bmp')
background_menu = pygame.image.load('Assets/menu/menu.bmp')
background_game_over = pygame.image.load('Assets/menu/game-over.bmp')
background = pygame.image.load('Assets/background/fundo.bmp')
# Cria uma instância para armazenar dados estatísticos do jogo e cria o painel de pontuação
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Cria a espaçonave, um grupo de projéteis e um grupo de alienígenas
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
# Cria a frota de alienigenas
gf.create_fleet(ai_settings, screen, ship, aliens)
# Cria o botão play
play_button = Button(ai_settings, screen, "P to Play or esc or quit")
# Definindo a imagem inicial
gf.update_start(screen, background_start)
pygame.mouse.set_visible(False)
# Iniciando o som inicial
menu_sound = pygame.mixer.Sound('Sounds/game_sound2.mp3')
pygame.mixer.Sound.set_volume(menu_sound, 0.5)
menu_sound.play(-1)
while True:
"""Inicializa o laço principal do jogo"""
gf.check_events(ai_settings, screen, stats, sb, play_button, ship, aliens, bullets)
if stats.game_start:
gf.update_menu(screen, background_menu, play_button)
elif stats.game_active:
menu_sound.stop()
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button, background)
ship.update()
bullets.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens, bullets)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets)
elif stats.game_over:
gf.update_game_over(screen, background_game_over, play_button)
pygame.mixer.Sound.play(menu_sound) | [
"def",
"run_game",
"(",
")",
":",
"pygame",
".",
"init",
"(",
")",
"ai_settings",
"=",
"Settings",
"(",
")",
"screen",
"=",
"pygame",
".",
"display",
".",
"set_mode",
"(",
"(",
"ai_settings",
".",
"screen_width",
",",
"ai_settings",
".",
"screen_height",
")",
")",
"# Definindo Telas",
"pygame",
".",
"display",
".",
"set_caption",
"(",
"f'Alien-Invasion'",
")",
"pygame",
".",
"display",
".",
"set_icon",
"(",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/aliens/alien3.bmp'",
")",
")",
"background_start",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/menu/apresentacao.bmp'",
")",
"background_menu",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/menu/menu.bmp'",
")",
"background_game_over",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/menu/game-over.bmp'",
")",
"background",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/background/fundo.bmp'",
")",
"# Cria uma instância para armazenar dados estatísticos do jogo e cria o painel de pontuação",
"stats",
"=",
"GameStats",
"(",
"ai_settings",
")",
"sb",
"=",
"Scoreboard",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
")",
"# Cria a espaçonave, um grupo de projéteis e um grupo de alienígenas",
"ship",
"=",
"Ship",
"(",
"ai_settings",
",",
"screen",
")",
"bullets",
"=",
"Group",
"(",
")",
"aliens",
"=",
"Group",
"(",
")",
"# Cria a frota de alienigenas",
"gf",
".",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
"# Cria o botão play",
"play_button",
"=",
"Button",
"(",
"ai_settings",
",",
"screen",
",",
"\"P to Play or esc or quit\"",
")",
"# Definindo a imagem inicial",
"gf",
".",
"update_start",
"(",
"screen",
",",
"background_start",
")",
"pygame",
".",
"mouse",
".",
"set_visible",
"(",
"False",
")",
"# Iniciando o som inicial",
"menu_sound",
"=",
"pygame",
".",
"mixer",
".",
"Sound",
"(",
"'Sounds/game_sound2.mp3'",
")",
"pygame",
".",
"mixer",
".",
"Sound",
".",
"set_volume",
"(",
"menu_sound",
",",
"0.5",
")",
"menu_sound",
".",
"play",
"(",
"-",
"1",
")",
"while",
"True",
":",
"\"\"\"Inicializa o laço principal do jogo\"\"\"",
"gf",
".",
"check_events",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"play_button",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
"if",
"stats",
".",
"game_start",
":",
"gf",
".",
"update_menu",
"(",
"screen",
",",
"background_menu",
",",
"play_button",
")",
"elif",
"stats",
".",
"game_active",
":",
"menu_sound",
".",
"stop",
"(",
")",
"gf",
".",
"update_screen",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
",",
"play_button",
",",
"background",
")",
"ship",
".",
"update",
"(",
")",
"bullets",
".",
"update",
"(",
")",
"gf",
".",
"update_bullets",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
"gf",
".",
"update_aliens",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
"elif",
"stats",
".",
"game_over",
":",
"gf",
".",
"update_game_over",
"(",
"screen",
",",
"background_game_over",
",",
"play_button",
")",
"pygame",
".",
"mixer",
".",
"Sound",
".",
"play",
"(",
"menu_sound",
")"
] | [
14,
0
] | [
67,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
httpStatusCode | (stCode) | return ret | retorna texto do status code | retorna texto do status code | def httpStatusCode(stCode):
''' retorna texto do status code '''
ret = ''
stCode = int(stCode)
if stCode in HTTP_STATUS_CODE.keys():
ret = HTTP_STATUS_CODE[stCode]
else:
ret = HTTP_STATUS_CODE[1000]
return ret | [
"def",
"httpStatusCode",
"(",
"stCode",
")",
":",
"ret",
"=",
"''",
"stCode",
"=",
"int",
"(",
"stCode",
")",
"if",
"stCode",
"in",
"HTTP_STATUS_CODE",
".",
"keys",
"(",
")",
":",
"ret",
"=",
"HTTP_STATUS_CODE",
"[",
"stCode",
"]",
"else",
":",
"ret",
"=",
"HTTP_STATUS_CODE",
"[",
"1000",
"]",
"return",
"ret"
] | [
270,
0
] | [
278,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
campanha | (request, idcampanha, pedirnovo=False) | return render(
request,
'labeler/pergunta.html', {
'campanha': campanha_ativa,
'tarefa': tarefa,
'form': form
}) | Tela para responder tarefas de campanha | Tela para responder tarefas de campanha | def campanha(request, idcampanha, pedirnovo=False):
"Tela para responder tarefas de campanha"
campanha_ativa = get_object_or_404(Campanha, id=idcampanha)
form = RespostaForm(campos=campanha_ativa.formulario.estrutura['campos'])
tarefa = campanha_ativa.obter_tarefa(request.user.username, pedirnovo)
if request.method == 'POST':
form = RespostaForm(
request.POST,
campos=campanha_ativa.formulario.estrutura['campos'])
form.is_valid()
respostas = []
for campo in form.fields:
respostas += [{
'nomecampo': campo,
'resposta': str(form.cleaned_data[campo])
}]
tarefa.votar(request.user.username, respostas)
tarefa = campanha_ativa.obter_tarefa(request.user.username)
form = RespostaForm(
campos=campanha_ativa.formulario.estrutura['campos'])
if not tarefa:
return render(
request,
'labeler/finalizado.html',
{'campanha': campanha_ativa})
return render(
request,
'labeler/pergunta.html', {
'campanha': campanha_ativa,
'tarefa': tarefa,
'form': form
}) | [
"def",
"campanha",
"(",
"request",
",",
"idcampanha",
",",
"pedirnovo",
"=",
"False",
")",
":",
"campanha_ativa",
"=",
"get_object_or_404",
"(",
"Campanha",
",",
"id",
"=",
"idcampanha",
")",
"form",
"=",
"RespostaForm",
"(",
"campos",
"=",
"campanha_ativa",
".",
"formulario",
".",
"estrutura",
"[",
"'campos'",
"]",
")",
"tarefa",
"=",
"campanha_ativa",
".",
"obter_tarefa",
"(",
"request",
".",
"user",
".",
"username",
",",
"pedirnovo",
")",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"form",
"=",
"RespostaForm",
"(",
"request",
".",
"POST",
",",
"campos",
"=",
"campanha_ativa",
".",
"formulario",
".",
"estrutura",
"[",
"'campos'",
"]",
")",
"form",
".",
"is_valid",
"(",
")",
"respostas",
"=",
"[",
"]",
"for",
"campo",
"in",
"form",
".",
"fields",
":",
"respostas",
"+=",
"[",
"{",
"'nomecampo'",
":",
"campo",
",",
"'resposta'",
":",
"str",
"(",
"form",
".",
"cleaned_data",
"[",
"campo",
"]",
")",
"}",
"]",
"tarefa",
".",
"votar",
"(",
"request",
".",
"user",
".",
"username",
",",
"respostas",
")",
"tarefa",
"=",
"campanha_ativa",
".",
"obter_tarefa",
"(",
"request",
".",
"user",
".",
"username",
")",
"form",
"=",
"RespostaForm",
"(",
"campos",
"=",
"campanha_ativa",
".",
"formulario",
".",
"estrutura",
"[",
"'campos'",
"]",
")",
"if",
"not",
"tarefa",
":",
"return",
"render",
"(",
"request",
",",
"'labeler/finalizado.html'",
",",
"{",
"'campanha'",
":",
"campanha_ativa",
"}",
")",
"return",
"render",
"(",
"request",
",",
"'labeler/pergunta.html'",
",",
"{",
"'campanha'",
":",
"campanha_ativa",
",",
"'tarefa'",
":",
"tarefa",
",",
"'form'",
":",
"form",
"}",
")"
] | [
21,
0
] | [
61,
10
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
interpolation_search | (array, x) | return -1 | Executa a busca por interpolação
Args:
array (list): lista com os elementos
x (int): elemento a ser encontrado
Returns:
int: posição do elemento
| Executa a busca por interpolação
Args:
array (list): lista com os elementos
x (int): elemento a ser encontrado
Returns:
int: posição do elemento
| def interpolation_search(array, x):
"""Executa a busca por interpolação
Args:
array (list): lista com os elementos
x (int): elemento a ser encontrado
Returns:
int: posição do elemento
"""
low = 0
high = len(array) - 1
array_low = array[low]
array_high = array[high]
while ((low <= high) and (x >= array_low) and (x <= array_high)):
array_low = array[low]
array_high = array[high]
pos = (int)(low + ((high - low)/(array_high - array_low))*(x - array_low))
if array[pos] < x:
low = pos+1
elif array[pos] > x:
high = pos-1
else:
return pos
return -1 | [
"def",
"interpolation_search",
"(",
"array",
",",
"x",
")",
":",
"low",
"=",
"0",
"high",
"=",
"len",
"(",
"array",
")",
"-",
"1",
"array_low",
"=",
"array",
"[",
"low",
"]",
"array_high",
"=",
"array",
"[",
"high",
"]",
"while",
"(",
"(",
"low",
"<=",
"high",
")",
"and",
"(",
"x",
">=",
"array_low",
")",
"and",
"(",
"x",
"<=",
"array_high",
")",
")",
":",
"array_low",
"=",
"array",
"[",
"low",
"]",
"array_high",
"=",
"array",
"[",
"high",
"]",
"pos",
"=",
"(",
"int",
")",
"(",
"low",
"+",
"(",
"(",
"high",
"-",
"low",
")",
"/",
"(",
"array_high",
"-",
"array_low",
")",
")",
"*",
"(",
"x",
"-",
"array_low",
")",
")",
"if",
"array",
"[",
"pos",
"]",
"<",
"x",
":",
"low",
"=",
"pos",
"+",
"1",
"elif",
"array",
"[",
"pos",
"]",
">",
"x",
":",
"high",
"=",
"pos",
"-",
"1",
"else",
":",
"return",
"pos",
"return",
"-",
"1"
] | [
4,
0
] | [
34,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
MeuJogador.fim_da_rodada | (self, recompensa, m, numero_de_cacadores) | A cada fim de rodada, recebemos os resultados | A cada fim de rodada, recebemos os resultados | def fim_da_rodada(self, recompensa, m, numero_de_cacadores):
""" A cada fim de rodada, recebemos os resultados """
#print('Jogador 1 {}'.format(self.comida_atual))
pass | [
"def",
"fim_da_rodada",
"(",
"self",
",",
"recompensa",
",",
"m",
",",
"numero_de_cacadores",
")",
":",
"#print('Jogador 1 {}'.format(self.comida_atual))",
"pass"
] | [
25,
4
] | [
28,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cadastral.fundo_gestor_nome | (self, cnpj) | return self.busca_fundo_cnpj(cnpj)["GESTOR"] | Retorna o nome do gestor do fundo. | Retorna o nome do gestor do fundo. | def fundo_gestor_nome(self, cnpj):
"""Retorna o nome do gestor do fundo."""
return self.busca_fundo_cnpj(cnpj)["GESTOR"] | [
"def",
"fundo_gestor_nome",
"(",
"self",
",",
"cnpj",
")",
":",
"return",
"self",
".",
"busca_fundo_cnpj",
"(",
"cnpj",
")",
"[",
"\"GESTOR\"",
"]"
] | [
285,
4
] | [
287,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ListaDuplamenteEncadeada.acrescentar | (self, dado) | Acrescenta um novo no a lista. | Acrescenta um novo no a lista. | def acrescentar(self, dado):
""" Acrescenta um novo no a lista. """
# Cria um novo no apontando para None (anterior e proximo)
novo_no = No(dado, None, None)
# Se a cabeca eh None a lista esta vazia
# Tanto a cabeca quanto o rabo recebem o novo no
if self.cabeca is None:
self.cabeca = novo_no
self.rabo = novo_no
# Caso contrario, se ja existir algum valor na lista
else:
# O anterior 'aponta' para o rabo (ultimo no adicionado)
novo_no.anterior = self.rabo
# O proximo sempre aponta para None
novo_no.proximo = None
# O proximo do rabo sempre aponta para o novo no
self.rabo.proximo = novo_no
# O rabo agora eh o novo no
self.rabo = novo_no | [
"def",
"acrescentar",
"(",
"self",
",",
"dado",
")",
":",
"# Cria um novo no apontando para None (anterior e proximo)",
"novo_no",
"=",
"No",
"(",
"dado",
",",
"None",
",",
"None",
")",
"# Se a cabeca eh None a lista esta vazia",
"# Tanto a cabeca quanto o rabo recebem o novo no",
"if",
"self",
".",
"cabeca",
"is",
"None",
":",
"self",
".",
"cabeca",
"=",
"novo_no",
"self",
".",
"rabo",
"=",
"novo_no",
"# Caso contrario, se ja existir algum valor na lista",
"else",
":",
"# O anterior 'aponta' para o rabo (ultimo no adicionado)",
"novo_no",
".",
"anterior",
"=",
"self",
".",
"rabo",
"# O proximo sempre aponta para None",
"novo_no",
".",
"proximo",
"=",
"None",
"# O proximo do rabo sempre aponta para o novo no",
"self",
".",
"rabo",
".",
"proximo",
"=",
"novo_no",
"# O rabo agora eh o novo no",
"self",
".",
"rabo",
"=",
"novo_no"
] | [
25,
4
] | [
44,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ListaDuplamenteEncadeada.remover | (self, dado) | Remove um no da lista. | Remove um no da lista. | def remover(self, dado):
""" Remove um no da lista. """
# O no atual eh o primeiro no da lista
no_atual = self.cabeca
# Vamos procurar pelo dado que queremos remover
# Equanto o no atual for valido
while no_atual is not None:
# Verifica se eh o dado que estamos buscando
if no_atual.dado == dado:
# Se o dado que estamos buscando esta no primeiro no
# da lista, nao temos anterior
if no_atual.anterior is None:
# A cabeca 'aponta' para o proximo no da lista
self.cabeca = no_atual.proximo
# E o anterior do proximo no aponta para None
no_atual.proximo.anterior = None
else:
# Exemplo: Removendo o valor 5
# ... <---> | 2 | <---> | 5 | <---> | 12 | <---> ...
#
# O proximo do valor 2 passa a apontar para o 12 e
# o anterior do valor 12 passa a apontar para o 2
# ---------------
# ... <---> | 2 | <---|--- | 5 | ---|---> | 12 | <---> ...
no_atual.anterior.proximo = no_atual.proximo
no_atual.proximo.anterior = no_atual.anterior
# Se nao eh o no que estamos buscando va para o proximo
no_atual = no_atual.proximo | [
"def",
"remover",
"(",
"self",
",",
"dado",
")",
":",
"# O no atual eh o primeiro no da lista",
"no_atual",
"=",
"self",
".",
"cabeca",
"# Vamos procurar pelo dado que queremos remover",
"# Equanto o no atual for valido",
"while",
"no_atual",
"is",
"not",
"None",
":",
"# Verifica se eh o dado que estamos buscando",
"if",
"no_atual",
".",
"dado",
"==",
"dado",
":",
"# Se o dado que estamos buscando esta no primeiro no",
"# da lista, nao temos anterior",
"if",
"no_atual",
".",
"anterior",
"is",
"None",
":",
"# A cabeca 'aponta' para o proximo no da lista",
"self",
".",
"cabeca",
"=",
"no_atual",
".",
"proximo",
"# E o anterior do proximo no aponta para None",
"no_atual",
".",
"proximo",
".",
"anterior",
"=",
"None",
"else",
":",
"# Exemplo: Removendo o valor 5",
"# ... <---> | 2 | <---> | 5 | <---> | 12 | <---> ...",
"#",
"# O proximo do valor 2 passa a apontar para o 12 e",
"# o anterior do valor 12 passa a apontar para o 2",
"# ---------------",
"# ... <---> | 2 | <---|--- | 5 | ---|---> | 12 | <---> ...",
"no_atual",
".",
"anterior",
".",
"proximo",
"=",
"no_atual",
".",
"proximo",
"no_atual",
".",
"proximo",
".",
"anterior",
"=",
"no_atual",
".",
"anterior",
"# Se nao eh o no que estamos buscando va para o proximo",
"no_atual",
"=",
"no_atual",
".",
"proximo"
] | [
46,
4
] | [
75,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DiarioGC.editar | (self) | funcao para escolher um ficheiro ja escrito e abri-lo para editar | funcao para escolher um ficheiro ja escrito e abri-lo para editar | def editar(self):
"""funcao para escolher um ficheiro ja escrito e abri-lo para editar"""
nome_file_open = QFileDialog.getOpenFileName(parent=self.ferramentas, directory=f'DIARIOGC-{self.nome.text()}/pensamentos', filter='Ficheiros (*.gc-txt)')
try:
with open(nome_file_open[0], 'r+') as file_decod:
file_ = file_decod.readlines()
file = decrypt(file_[0], file_[1])
janela8 = QWidget()
layout = QVBoxLayout()
texto = QTextEdit()
texto.setFont(QFont('cambria', 10))
texto.insertPlainText(file)
layout.addWidget(texto)
def guardar():
with open(nome_file_open[0], 'w+') as file_enc:
doc1, doc2 = encrypt(texto.toPlainText())
file_enc.write(str(doc1) + '\n' + str(doc2))
QMessageBox.information(self.ferramentas, 'Concluido', 'Codificação Bem Sucedida..')
self.tab.removeTab(1)
self.diario0()
guardarBotao = QPushButton('Guardar')
guardarBotao.setToolTip('RECODIFICADO')
guardarBotao.clicked.connect(guardar)
layout.addWidget(guardarBotao)
fechar = lambda: self.tab.removeTab(1)
fechar_botao = QPushButton('Fechar')
fechar_botao.clicked.connect(fechar)
layout.addWidget(fechar_botao)
janela8.setLayout(layout)
self.tab.addTab(janela8, 'Editando-Arquivo')
self.tab.setCurrentWidget(janela8)
except FileNotFoundError:
QMessageBox.warning(self.ferramentas, 'Falha', 'Ficheiro Não Encontrado ou Processo Cancelado!')
warning('ficheiro nao encontrado ou processo cancelado!') | [
"def",
"editar",
"(",
"self",
")",
":",
"nome_file_open",
"=",
"QFileDialog",
".",
"getOpenFileName",
"(",
"parent",
"=",
"self",
".",
"ferramentas",
",",
"directory",
"=",
"f'DIARIOGC-{self.nome.text()}/pensamentos'",
",",
"filter",
"=",
"'Ficheiros (*.gc-txt)'",
")",
"try",
":",
"with",
"open",
"(",
"nome_file_open",
"[",
"0",
"]",
",",
"'r+'",
")",
"as",
"file_decod",
":",
"file_",
"=",
"file_decod",
".",
"readlines",
"(",
")",
"file",
"=",
"decrypt",
"(",
"file_",
"[",
"0",
"]",
",",
"file_",
"[",
"1",
"]",
")",
"janela8",
"=",
"QWidget",
"(",
")",
"layout",
"=",
"QVBoxLayout",
"(",
")",
"texto",
"=",
"QTextEdit",
"(",
")",
"texto",
".",
"setFont",
"(",
"QFont",
"(",
"'cambria'",
",",
"10",
")",
")",
"texto",
".",
"insertPlainText",
"(",
"file",
")",
"layout",
".",
"addWidget",
"(",
"texto",
")",
"def",
"guardar",
"(",
")",
":",
"with",
"open",
"(",
"nome_file_open",
"[",
"0",
"]",
",",
"'w+'",
")",
"as",
"file_enc",
":",
"doc1",
",",
"doc2",
"=",
"encrypt",
"(",
"texto",
".",
"toPlainText",
"(",
")",
")",
"file_enc",
".",
"write",
"(",
"str",
"(",
"doc1",
")",
"+",
"'\\n'",
"+",
"str",
"(",
"doc2",
")",
")",
"QMessageBox",
".",
"information",
"(",
"self",
".",
"ferramentas",
",",
"'Concluido'",
",",
"'Codificação Bem Sucedida..')",
"",
"self",
".",
"tab",
".",
"removeTab",
"(",
"1",
")",
"self",
".",
"diario0",
"(",
")",
"guardarBotao",
"=",
"QPushButton",
"(",
"'Guardar'",
")",
"guardarBotao",
".",
"setToolTip",
"(",
"'RECODIFICADO'",
")",
"guardarBotao",
".",
"clicked",
".",
"connect",
"(",
"guardar",
")",
"layout",
".",
"addWidget",
"(",
"guardarBotao",
")",
"fechar",
"=",
"lambda",
":",
"self",
".",
"tab",
".",
"removeTab",
"(",
"1",
")",
"fechar_botao",
"=",
"QPushButton",
"(",
"'Fechar'",
")",
"fechar_botao",
".",
"clicked",
".",
"connect",
"(",
"fechar",
")",
"layout",
".",
"addWidget",
"(",
"fechar_botao",
")",
"janela8",
".",
"setLayout",
"(",
"layout",
")",
"self",
".",
"tab",
".",
"addTab",
"(",
"janela8",
",",
"'Editando-Arquivo'",
")",
"self",
".",
"tab",
".",
"setCurrentWidget",
"(",
"janela8",
")",
"except",
"FileNotFoundError",
":",
"QMessageBox",
".",
"warning",
"(",
"self",
".",
"ferramentas",
",",
"'Falha'",
",",
"'Ficheiro Não Encontrado ou Processo Cancelado!')",
"",
"warning",
"(",
"'ficheiro nao encontrado ou processo cancelado!'",
")"
] | [
410,
4
] | [
451,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Tun.get_frame | (self) | return proto,payload | Recebe dados da tun. Retorna uma tupla (proto,dados):
dados: buffer com os bytes recebido (tipo bytes)
proto: número do protocolo | Recebe dados da tun. Retorna uma tupla (proto,dados):
dados: buffer com os bytes recebido (tipo bytes)
proto: número do protocolo | def get_frame(self):
'''Recebe dados da tun. Retorna uma tupla (proto,dados):
dados: buffer com os bytes recebido (tipo bytes)
proto: número do protocolo'''
dados = os.read(self.fd, self.mtu+4)
flags,proto,payload = struct.unpack('!HH%ds' % (len(dados)-4), dados)
return proto,payload | [
"def",
"get_frame",
"(",
"self",
")",
":",
"dados",
"=",
"os",
".",
"read",
"(",
"self",
".",
"fd",
",",
"self",
".",
"mtu",
"+",
"4",
")",
"flags",
",",
"proto",
",",
"payload",
"=",
"struct",
".",
"unpack",
"(",
"'!HH%ds'",
"%",
"(",
"len",
"(",
"dados",
")",
"-",
"4",
")",
",",
"dados",
")",
"return",
"proto",
",",
"payload"
] | [
79,
4
] | [
85,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
trocar_ambiente | (whatsapp, novo_ambiente) | esta função substitui o documento que acusa o ambiente no qual o usuário está no momento
caso ele seja direcionado para o atendimento humanizado ou a fila de espera | esta função substitui o documento que acusa o ambiente no qual o usuário está no momento
caso ele seja direcionado para o atendimento humanizado ou a fila de espera | def trocar_ambiente(whatsapp, novo_ambiente):
"""esta função substitui o documento que acusa o ambiente no qual o usuário está no momento
caso ele seja direcionado para o atendimento humanizado ou a fila de espera"""
if novo_ambiente == 'chatbot':
data = {u'usuario': whatsapp,u'atendimento_humanizado': False,u'chatbot': True,
u'fila_espera': False}
if novo_ambiente == 'atendimento_humanizado':
data = {u'usuario': whatsapp,u'atendimento_humanizado': True,u'chatbot': False,
u'fila_espera': False}
if novo_ambiente == 'fila_espera':
data = {u'usuario': whatsapp,u'atendimento_humanizado': False,u'chatbot': False,
u'fila_espera': True}
# conseguir o doc id do usuario no coleção de ambientes
id_documento = db.collection(u'ambiente_usuario').where(u'usuario', u'==', whatsapp).stream()
for documento in id_documento:
id = documento.id
return db.collection(u'ambiente_usuario').document(id).set(data) | [
"def",
"trocar_ambiente",
"(",
"whatsapp",
",",
"novo_ambiente",
")",
":",
"if",
"novo_ambiente",
"==",
"'chatbot'",
":",
"data",
"=",
"{",
"u'usuario'",
":",
"whatsapp",
",",
"u'atendimento_humanizado'",
":",
"False",
",",
"u'chatbot'",
":",
"True",
",",
"u'fila_espera'",
":",
"False",
"}",
"if",
"novo_ambiente",
"==",
"'atendimento_humanizado'",
":",
"data",
"=",
"{",
"u'usuario'",
":",
"whatsapp",
",",
"u'atendimento_humanizado'",
":",
"True",
",",
"u'chatbot'",
":",
"False",
",",
"u'fila_espera'",
":",
"False",
"}",
"if",
"novo_ambiente",
"==",
"'fila_espera'",
":",
"data",
"=",
"{",
"u'usuario'",
":",
"whatsapp",
",",
"u'atendimento_humanizado'",
":",
"False",
",",
"u'chatbot'",
":",
"False",
",",
"u'fila_espera'",
":",
"True",
"}",
"# conseguir o doc id do usuario no coleção de ambientes",
"id_documento",
"=",
"db",
".",
"collection",
"(",
"u'ambiente_usuario'",
")",
".",
"where",
"(",
"u'usuario'",
",",
"u'=='",
",",
"whatsapp",
")",
".",
"stream",
"(",
")",
"for",
"documento",
"in",
"id_documento",
":",
"id",
"=",
"documento",
".",
"id",
"return",
"db",
".",
"collection",
"(",
"u'ambiente_usuario'",
")",
".",
"document",
"(",
"id",
")",
".",
"set",
"(",
"data",
")"
] | [
96,
0
] | [
116,
72
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Thing.show_state | (self) | Exibe o estado interno do agente. Subclasses devem substituir. | Exibe o estado interno do agente. Subclasses devem substituir. | def show_state(self):
"Exibe o estado interno do agente. Subclasses devem substituir."
print("Não sei como mostrar o estado.") | [
"def",
"show_state",
"(",
"self",
")",
":",
"print",
"(",
"\"Não sei como mostrar o estado.\")",
""
] | [
25,
4
] | [
27,
48
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
find_num_all | (num) | Função para encontrar algorismos de 0-9 dentro de iteráveis
Ela continua sua busca mesmo que encontre letras
Não procura por '.'(pontos), podendo alterar os valores de floats
ou números maiores que 999 (1.000)
Esta função retorna integers.
Se não encontrar nenhum número, retornará 0. | Função para encontrar algorismos de 0-9 dentro de iteráveis
Ela continua sua busca mesmo que encontre letras
Não procura por '.'(pontos), podendo alterar os valores de floats
ou números maiores que 999 (1.000)
Esta função retorna integers.
Se não encontrar nenhum número, retornará 0. | def find_num_all(num):
"""Função para encontrar algorismos de 0-9 dentro de iteráveis
Ela continua sua busca mesmo que encontre letras
Não procura por '.'(pontos), podendo alterar os valores de floats
ou números maiores que 999 (1.000)
Esta função retorna integers.
Se não encontrar nenhum número, retornará 0."""
rex = re.compile(r'([0-9])').findall(str(num))
if rex:
return int("".join([*rex]))
else:
return 0 | [
"def",
"find_num_all",
"(",
"num",
")",
":",
"rex",
"=",
"re",
".",
"compile",
"(",
"r'([0-9])'",
")",
".",
"findall",
"(",
"str",
"(",
"num",
")",
")",
"if",
"rex",
":",
"return",
"int",
"(",
"\"\"",
".",
"join",
"(",
"[",
"*",
"rex",
"]",
")",
")",
"else",
":",
"return",
"0"
] | [
17,
0
] | [
28,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_number_rows | (ai_settings, ship_height, alien_height) | return number_rows | Determina o numero de linhas com alienigenas que cabem na tela. | Determina o numero de linhas com alienigenas que cabem na tela. | def get_number_rows(ai_settings, ship_height, alien_height):
"""Determina o numero de linhas com alienigenas que cabem na tela."""
available_space_y = (ai_settings.screen_height -
(3 * alien_height) - ship_height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows | [
"def",
"get_number_rows",
"(",
"ai_settings",
",",
"ship_height",
",",
"alien_height",
")",
":",
"available_space_y",
"=",
"(",
"ai_settings",
".",
"screen_height",
"-",
"(",
"3",
"*",
"alien_height",
")",
"-",
"ship_height",
")",
"number_rows",
"=",
"int",
"(",
"available_space_y",
"/",
"(",
"2",
"*",
"alien_height",
")",
")",
"return",
"number_rows"
] | [
157,
0
] | [
162,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
substitui_secrets | () | No HASS.IO ADD-ON substitui os dados do secrets.ini pelos do options.json | No HASS.IO ADD-ON substitui os dados do secrets.ini pelos do options.json | def substitui_secrets():
"No HASS.IO ADD-ON substitui os dados do secrets.ini pelos do options.json"
global HOYMILES_USER
global HOYMILES_PASSWORD
global HOYMILES_PLANT_ID
global MQTT_HOST
global MQTT_PASSWORD
global MQTT_USERNAME
global DEVELOPERS_MODE
global FILE_COMM
global WEB_SERVER
log().debug ("Loading env data....")
HOYMILES_USER = dl.pegaEnv("HOYMILES_USER")
HOYMILES_PASSWORD = dl.pegaEnv("HOYMILES_PASSWORD")
HOYMILES_PLANT_ID = dl.pegaEnv("HOYMILES_PLANT_ID")
MQTT_HOST = dl.pegaEnv("MQTT_HOST")
MQTT_PASSWORD = dl.pegaEnv("MQTT_PASSWORD")
MQTT_USERNAME = dl.pegaEnv("MQTT_USER")
DEVELOPERS_MODE = dl.pegaEnv("DEVELOPERS_MODE")
DEVELOPERS_MODE = dl.onOff(DEVELOPERS_MODE, True, False)
if dl.IN_HASSIO():
WEB_SERVER = True
FILE_COMM = '/data/' + comum.FILE_COMM
log().debug ("Env data loaded.") | [
"def",
"substitui_secrets",
"(",
")",
":",
"global",
"HOYMILES_USER",
"global",
"HOYMILES_PASSWORD",
"global",
"HOYMILES_PLANT_ID",
"global",
"MQTT_HOST",
"global",
"MQTT_PASSWORD",
"global",
"MQTT_USERNAME",
"global",
"DEVELOPERS_MODE",
"global",
"FILE_COMM",
"global",
"WEB_SERVER",
"log",
"(",
")",
".",
"debug",
"(",
"\"Loading env data....\"",
")",
"HOYMILES_USER",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"HOYMILES_USER\"",
")",
"HOYMILES_PASSWORD",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"HOYMILES_PASSWORD\"",
")",
"HOYMILES_PLANT_ID",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"HOYMILES_PLANT_ID\"",
")",
"MQTT_HOST",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"MQTT_HOST\"",
")",
"MQTT_PASSWORD",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"MQTT_PASSWORD\"",
")",
"MQTT_USERNAME",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"MQTT_USER\"",
")",
"DEVELOPERS_MODE",
"=",
"dl",
".",
"pegaEnv",
"(",
"\"DEVELOPERS_MODE\"",
")",
"DEVELOPERS_MODE",
"=",
"dl",
".",
"onOff",
"(",
"DEVELOPERS_MODE",
",",
"True",
",",
"False",
")",
"if",
"dl",
".",
"IN_HASSIO",
"(",
")",
":",
"WEB_SERVER",
"=",
"True",
"FILE_COMM",
"=",
"'/data/'",
"+",
"comum",
".",
"FILE_COMM",
"log",
"(",
")",
".",
"debug",
"(",
"\"Env data loaded.\"",
")"
] | [
248,
0
] | [
273,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
remover_acentos | (string) | return normalizado.encode('ascii', 'ignore').decode('utf8').lower() | Recebe uma string e retorna a versão dela sem acentos ortográficos e em lowercase. | Recebe uma string e retorna a versão dela sem acentos ortográficos e em lowercase. | def remover_acentos(string):
"""Recebe uma string e retorna a versão dela sem acentos ortográficos e em lowercase."""
normalizado = normalize('NFD', string)
return normalizado.encode('ascii', 'ignore').decode('utf8').lower() | [
"def",
"remover_acentos",
"(",
"string",
")",
":",
"normalizado",
"=",
"normalize",
"(",
"'NFD'",
",",
"string",
")",
"return",
"normalizado",
".",
"encode",
"(",
"'ascii'",
",",
"'ignore'",
")",
".",
"decode",
"(",
"'utf8'",
")",
".",
"lower",
"(",
")"
] | [
4,
0
] | [
7,
71
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoAcessoResource.handle_get | (self, request, user, *args, **kwargs) | Trata as requisições GET para consulta de Informações de Acesso a Equipamentos.
Permite a consulta de Informações de Acesso a Equipamentos existentes.
URL: /equipamentoacesso/
| Trata as requisições GET para consulta de Informações de Acesso a Equipamentos. | def handle_get(self, request, user, *args, **kwargs):
"""Trata as requisições GET para consulta de Informações de Acesso a Equipamentos.
Permite a consulta de Informações de Acesso a Equipamentos existentes.
URL: /equipamentoacesso/
"""
try:
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.READ_OPERATION):
return self.not_authorized()
# Efetua a consulta de todos os tipos de acesso
results = EquipamentoAcesso.search(user.grupos.all())
if results.count() > 0:
# Monta lista com dados retornados
map_list = []
for item in results:
item_map = self.get_equipamento_acesso_map(item)
if item_map not in map_list:
map_list.append(item_map)
# Gera response (XML) com resultados
return self.response(dumps_networkapi({'equipamento_acesso': map_list}))
else:
# Gera response (XML) para resultado vazio
return self.response(dumps_networkapi({}))
except (EquipamentoError, GrupoError):
return self.response_error(1) | [
"def",
"handle_get",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"READ_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"# Efetua a consulta de todos os tipos de acesso",
"results",
"=",
"EquipamentoAcesso",
".",
"search",
"(",
"user",
".",
"grupos",
".",
"all",
"(",
")",
")",
"if",
"results",
".",
"count",
"(",
")",
">",
"0",
":",
"# Monta lista com dados retornados",
"map_list",
"=",
"[",
"]",
"for",
"item",
"in",
"results",
":",
"item_map",
"=",
"self",
".",
"get_equipamento_acesso_map",
"(",
"item",
")",
"if",
"item_map",
"not",
"in",
"map_list",
":",
"map_list",
".",
"append",
"(",
"item_map",
")",
"# Gera response (XML) com resultados",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'equipamento_acesso'",
":",
"map_list",
"}",
")",
")",
"else",
":",
"# Gera response (XML) para resultado vazio",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
48,
4
] | [
78,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
achaLxy | (matrix, L, D, x, y) | return Lxy / D[y] | Encontra o termo Lxy mais detalhes sobre este termo podem ser vistas no relatório | Encontra o termo Lxy mais detalhes sobre este termo podem ser vistas no relatório | def achaLxy(matrix, L, D, x, y):
''''Encontra o termo Lxy mais detalhes sobre este termo podem ser vistas no relatório'''
Lxy = matrix[x, y]
for k in range(x):
Lxy -= D[k] * L[x, k] * L[y, k]
return Lxy / D[y] | [
"def",
"achaLxy",
"(",
"matrix",
",",
"L",
",",
"D",
",",
"x",
",",
"y",
")",
":",
"Lxy",
"=",
"matrix",
"[",
"x",
",",
"y",
"]",
"for",
"k",
"in",
"range",
"(",
"x",
")",
":",
"Lxy",
"-=",
"D",
"[",
"k",
"]",
"*",
"L",
"[",
"x",
",",
"k",
"]",
"*",
"L",
"[",
"y",
",",
"k",
"]",
"return",
"Lxy",
"/",
"D",
"[",
"y",
"]"
] | [
69,
0
] | [
74,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
normalize_ssm_url | (url) | Normaliza a string `url` de acordo com os valores das diretivas de
configuração OPAC_SSM_SCHEME, OPAC_SSM_DOMAIN e OPAC_SSM_PORT.
A normalização busca obter uma URL absoluta em função de uma relativa, ou
uma absoluta em função de uma absoluta, mas com as partes *scheme* e
*authority* trocadas pelas definidas nas diretivas citadas anteriormente.
Este código deve ser removido assim que o valor de Article.xml estiver
consistente, i.e., todos os registros possuirem apenas URLs absolutas.
| Normaliza a string `url` de acordo com os valores das diretivas de
configuração OPAC_SSM_SCHEME, OPAC_SSM_DOMAIN e OPAC_SSM_PORT. | def normalize_ssm_url(url):
"""Normaliza a string `url` de acordo com os valores das diretivas de
configuração OPAC_SSM_SCHEME, OPAC_SSM_DOMAIN e OPAC_SSM_PORT.
A normalização busca obter uma URL absoluta em função de uma relativa, ou
uma absoluta em função de uma absoluta, mas com as partes *scheme* e
*authority* trocadas pelas definidas nas diretivas citadas anteriormente.
Este código deve ser removido assim que o valor de Article.xml estiver
consistente, i.e., todos os registros possuirem apenas URLs absolutas.
"""
if url.startswith("http"):
parsed_url = urlparse(url)
return current_app.config["SSM_BASE_URI"] + parsed_url.path
else:
return current_app.config["SSM_BASE_URI"] + url | [
"def",
"normalize_ssm_url",
"(",
"url",
")",
":",
"if",
"url",
".",
"startswith",
"(",
"\"http\"",
")",
":",
"parsed_url",
"=",
"urlparse",
"(",
"url",
")",
"return",
"current_app",
".",
"config",
"[",
"\"SSM_BASE_URI\"",
"]",
"+",
"parsed_url",
".",
"path",
"else",
":",
"return",
"current_app",
".",
"config",
"[",
"\"SSM_BASE_URI\"",
"]",
"+",
"url"
] | [
1086,
0
] | [
1101,
55
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ListaBemLoka.__iadd__ | (self, val) | Soma todos os ítens da lista com val e manter no obj | Soma todos os ítens da lista com val e manter no obj | def __iadd__(self, val):
"""Soma todos os ítens da lista com val e manter no obj"""
self.l = [x + val for x in self.l] | [
"def",
"__iadd__",
"(",
"self",
",",
"val",
")",
":",
"self",
".",
"l",
"=",
"[",
"x",
"+",
"val",
"for",
"x",
"in",
"self",
".",
"l",
"]"
] | [
19,
4
] | [
21,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CRC16.gen_crc | (self) | return data | Gera o valor de FCS (com complemento de 1). Retorna um objeto
bytes com o os dados seguidos do valor de FCS (LSB e depois MSB) | Gera o valor de FCS (com complemento de 1). Retorna um objeto
bytes com o os dados seguidos do valor de FCS (LSB e depois MSB) | def gen_crc(self):
'''Gera o valor de FCS (com complemento de 1). Retorna um objeto
bytes com o os dados seguidos do valor de FCS (LSB e depois MSB)'''
fcs = self.calculate() ^0xffff
data = bytearray(self.data)
data.append(fcs & 0xff)
data.append((fcs >> 8) & 0xff)
return data | [
"def",
"gen_crc",
"(",
"self",
")",
":",
"fcs",
"=",
"self",
".",
"calculate",
"(",
")",
"^",
"0xffff",
"data",
"=",
"bytearray",
"(",
"self",
".",
"data",
")",
"data",
".",
"append",
"(",
"fcs",
"&",
"0xff",
")",
"data",
".",
"append",
"(",
"(",
"fcs",
">>",
"8",
")",
"&",
"0xff",
")",
"return",
"data"
] | [
76,
2
] | [
83,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
receita | (request, receita_id) | return render(request, 'receitas/receita.html', receita_a_exibir) | Abre uma receita para visualização | Abre uma receita para visualização | def receita(request, receita_id):
"""Abre uma receita para visualização"""
receita = get_object_or_404(Receita, pk=receita_id) # obtendo a receita a partir do index no BD
receita_a_exibir = {'receita': receita}
return render(request, 'receitas/receita.html', receita_a_exibir) | [
"def",
"receita",
"(",
"request",
",",
"receita_id",
")",
":",
"receita",
"=",
"get_object_or_404",
"(",
"Receita",
",",
"pk",
"=",
"receita_id",
")",
"# obtendo a receita a partir do index no BD",
"receita_a_exibir",
"=",
"{",
"'receita'",
":",
"receita",
"}",
"return",
"render",
"(",
"request",
",",
"'receitas/receita.html'",
",",
"receita_a_exibir",
")"
] | [
19,
0
] | [
23,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Scoreboard.show_score | (self) | Desenha a pontuação e o nivel na tela | Desenha a pontuação e o nivel na tela | def show_score(self):
"""Desenha a pontuação e o nivel na tela"""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
# Desenha as espaçonaves
self.ships.draw(self.screen) | [
"def",
"show_score",
"(",
"self",
")",
":",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"score_image",
",",
"self",
".",
"score_rect",
")",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"high_score_image",
",",
"self",
".",
"high_score_rect",
")",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"level_image",
",",
"self",
".",
"level_rect",
")",
"# Desenha as espaçonaves",
"self",
".",
"ships",
".",
"draw",
"(",
"self",
".",
"screen",
")"
] | [
67,
4
] | [
73,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
make_new_folder | (*paths) | return folder_path | Cria diretório caso ele ainda não exista e retorna o path
correspondente. | Cria diretório caso ele ainda não exista e retorna o path
correspondente. | def make_new_folder(*paths):
"""Cria diretório caso ele ainda não exista e retorna o path
correspondente."""
folder_path = os.path.join(*paths)
if not os.path.exists(folder_path):
os.makedirs(folder_path)
return folder_path | [
"def",
"make_new_folder",
"(",
"*",
"paths",
")",
":",
"folder_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"*",
"paths",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"folder_path",
")",
":",
"os",
".",
"makedirs",
"(",
"folder_path",
")",
"return",
"folder_path"
] | [
4,
0
] | [
10,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
save_file | (args, path=path, type_='png') | return fname | Salva o binário no disco como image. | Salva o binário no disco como image. | def save_file(args, path=path, type_='png'):
"""Salva o binário no disco como image."""
name, binary = args
fname = f'{path}/{name}.{type_}'
with open(fname, 'wb') as f:
copyfileobj(binary, f)
return fname | [
"def",
"save_file",
"(",
"args",
",",
"path",
"=",
"path",
",",
"type_",
"=",
"'png'",
")",
":",
"name",
",",
"binary",
"=",
"args",
"fname",
"=",
"f'{path}/{name}.{type_}'",
"with",
"open",
"(",
"fname",
",",
"'wb'",
")",
"as",
"f",
":",
"copyfileobj",
"(",
"binary",
",",
"f",
")",
"return",
"fname"
] | [
23,
0
] | [
29,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
show_sql | (sql=True) | Habilita ou desabilida a exibição das queries no django | Habilita ou desabilida a exibição das queries no django | def show_sql(sql=True):
""" Habilita ou desabilida a exibição das queries no django """
if sql:
logging.getLogger('django.db.backends').level = logging.DEBUG
settings.LOG_SHOW_SQL = True
else:
logging.getLogger('django.db.backends').level = logging.INFO
settings.LOG_SHOW_SQL = False | [
"def",
"show_sql",
"(",
"sql",
"=",
"True",
")",
":",
"if",
"sql",
":",
"logging",
".",
"getLogger",
"(",
"'django.db.backends'",
")",
".",
"level",
"=",
"logging",
".",
"DEBUG",
"settings",
".",
"LOG_SHOW_SQL",
"=",
"True",
"else",
":",
"logging",
".",
"getLogger",
"(",
"'django.db.backends'",
")",
".",
"level",
"=",
"logging",
".",
"INFO",
"settings",
".",
"LOG_SHOW_SQL",
"=",
"False"
] | [
28,
0
] | [
36,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Knowledge.__getitem__ | (self, location) | return self._rooms[y][x] | Obtém a localidade do quarto. | Obtém a localidade do quarto. | def __getitem__(self, location):
"""Obtém a localidade do quarto."""
x, y = location
return self._rooms[y][x] | [
"def",
"__getitem__",
"(",
"self",
",",
"location",
")",
":",
"x",
",",
"y",
"=",
"location",
"return",
"self",
".",
"_rooms",
"[",
"y",
"]",
"[",
"x",
"]"
] | [
251,
2
] | [
256,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Scoreboard.prep_high_score | (self) | Transforma a pontuação máxima em uma imagem renderizada | Transforma a pontuação máxima em uma imagem renderizada | def prep_high_score(self):
"""Transforma a pontuação máxima em uma imagem renderizada"""
high_score = round(self.stats.high_score, -1)
high_score_str = f'High score: {high_score:,}'
self.high_score_image = self.font.render(high_score_str, True, self.text_color, (20, 24, 33))
# Centraliza a pontuação máxima na parte superior da tela
self.high_score_rect = self.high_score_image.get_rect()
self.high_score_rect.centerx = self.screen_rect.centerx
self.high_score_rect.top = 5 | [
"def",
"prep_high_score",
"(",
"self",
")",
":",
"high_score",
"=",
"round",
"(",
"self",
".",
"stats",
".",
"high_score",
",",
"-",
"1",
")",
"high_score_str",
"=",
"f'High score: {high_score:,}'",
"self",
".",
"high_score_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"high_score_str",
",",
"True",
",",
"self",
".",
"text_color",
",",
"(",
"20",
",",
"24",
",",
"33",
")",
")",
"# Centraliza a pontuação máxima na parte superior da tela",
"self",
".",
"high_score_rect",
"=",
"self",
".",
"high_score_image",
".",
"get_rect",
"(",
")",
"self",
".",
"high_score_rect",
".",
"centerx",
"=",
"self",
".",
"screen_rect",
".",
"centerx",
"self",
".",
"high_score_rect",
".",
"top",
"=",
"5"
] | [
37,
4
] | [
46,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
twitter_OAuth | (streamer_type) | return api | Função que faz OAuth na conta correta | Função que faz OAuth na conta correta | def twitter_OAuth(streamer_type):
""" Função que faz OAuth na conta correta"""
CONSUMER_KEY = os.environ["CONSUMER_KEY_C"]
CONSUMER_SECRET = os.environ["CONSUMER_SECRET_C"]
ACCESS_TOKEN = os.environ["ACCESS_TOKEN_C"]
ACCESS_TOKEN_SECRET = os.environ["ACCESS_TOKEN_SECRET_C"]
if streamer_type == "art":
CONSUMER_KEY = os.environ["CONSUMER_KEY_A"]
CONSUMER_SECRET = os.environ["CONSUMER_SECRET_A"]
ACCESS_TOKEN = os.environ["ACCESS_TOKEN_A"]
ACCESS_TOKEN_SECRET = os.environ["ACCESS_TOKEN_SECRET_A"]
try:
auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth.secure = True
auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
api = API(
auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True
)
except BaseException as e:
print("Error in twitter.py", e)
sys.exit(1)
return api | [
"def",
"twitter_OAuth",
"(",
"streamer_type",
")",
":",
"CONSUMER_KEY",
"=",
"os",
".",
"environ",
"[",
"\"CONSUMER_KEY_C\"",
"]",
"CONSUMER_SECRET",
"=",
"os",
".",
"environ",
"[",
"\"CONSUMER_SECRET_C\"",
"]",
"ACCESS_TOKEN",
"=",
"os",
".",
"environ",
"[",
"\"ACCESS_TOKEN_C\"",
"]",
"ACCESS_TOKEN_SECRET",
"=",
"os",
".",
"environ",
"[",
"\"ACCESS_TOKEN_SECRET_C\"",
"]",
"if",
"streamer_type",
"==",
"\"art\"",
":",
"CONSUMER_KEY",
"=",
"os",
".",
"environ",
"[",
"\"CONSUMER_KEY_A\"",
"]",
"CONSUMER_SECRET",
"=",
"os",
".",
"environ",
"[",
"\"CONSUMER_SECRET_A\"",
"]",
"ACCESS_TOKEN",
"=",
"os",
".",
"environ",
"[",
"\"ACCESS_TOKEN_A\"",
"]",
"ACCESS_TOKEN_SECRET",
"=",
"os",
".",
"environ",
"[",
"\"ACCESS_TOKEN_SECRET_A\"",
"]",
"try",
":",
"auth",
"=",
"OAuthHandler",
"(",
"CONSUMER_KEY",
",",
"CONSUMER_SECRET",
")",
"auth",
".",
"secure",
"=",
"True",
"auth",
".",
"set_access_token",
"(",
"ACCESS_TOKEN",
",",
"ACCESS_TOKEN_SECRET",
")",
"api",
"=",
"API",
"(",
"auth",
",",
"wait_on_rate_limit",
"=",
"True",
",",
"wait_on_rate_limit_notify",
"=",
"True",
")",
"except",
"BaseException",
"as",
"e",
":",
"print",
"(",
"\"Error in twitter.py\"",
",",
"e",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"return",
"api"
] | [
13,
0
] | [
39,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
SPS_Package.update_mixed_citations | (self, references: dict, override=False) | return updated | Atualiza a tag `mixed-citation` nas referências do artigo. Também cria
a tag `label` com a ordem/índice da referência.
Params:
references (dict): Dicionário com as referências de um artigo. O
formato esperado é: {"order": "reference-text"}.
override (bool): Força a atualização do mixed-citation para
referências que já possuam o elemento.
Returns:
None
| Atualiza a tag `mixed-citation` nas referências do artigo. Também cria
a tag `label` com a ordem/índice da referência. | def update_mixed_citations(self, references: dict, override=False) -> list:
"""Atualiza a tag `mixed-citation` nas referências do artigo. Também cria
a tag `label` com a ordem/índice da referência.
Params:
references (dict): Dicionário com as referências de um artigo. O
formato esperado é: {"order": "reference-text"}.
override (bool): Força a atualização do mixed-citation para
referências que já possuam o elemento.
Returns:
None
"""
updated = []
for order, reference in enumerate(
self.xmltree.findall(".//back/ref-list/ref"), start=1
):
reference_text = references.get(str(order))
if reference_text is None:
continue
elif not override and reference.find(".//mixed-citation") is not None:
continue
try:
new_mixed_citation = xml.create_mixed_citation_element(reference_text)
except AssertionError:
continue
xml.remove_element(reference, ".//mixed-citation")
reference.insert(0, new_mixed_citation)
extracted_order = xml.extract_reference_order(text=reference_text)
if extracted_order == str(order):
xml.remove_element(reference, ".//label")
reference_label = etree.Element("label")
reference_label.text = extracted_order
reference.insert(0, reference_label)
updated.append(references.get(str(order)))
return updated | [
"def",
"update_mixed_citations",
"(",
"self",
",",
"references",
":",
"dict",
",",
"override",
"=",
"False",
")",
"->",
"list",
":",
"updated",
"=",
"[",
"]",
"for",
"order",
",",
"reference",
"in",
"enumerate",
"(",
"self",
".",
"xmltree",
".",
"findall",
"(",
"\".//back/ref-list/ref\"",
")",
",",
"start",
"=",
"1",
")",
":",
"reference_text",
"=",
"references",
".",
"get",
"(",
"str",
"(",
"order",
")",
")",
"if",
"reference_text",
"is",
"None",
":",
"continue",
"elif",
"not",
"override",
"and",
"reference",
".",
"find",
"(",
"\".//mixed-citation\"",
")",
"is",
"not",
"None",
":",
"continue",
"try",
":",
"new_mixed_citation",
"=",
"xml",
".",
"create_mixed_citation_element",
"(",
"reference_text",
")",
"except",
"AssertionError",
":",
"continue",
"xml",
".",
"remove_element",
"(",
"reference",
",",
"\".//mixed-citation\"",
")",
"reference",
".",
"insert",
"(",
"0",
",",
"new_mixed_citation",
")",
"extracted_order",
"=",
"xml",
".",
"extract_reference_order",
"(",
"text",
"=",
"reference_text",
")",
"if",
"extracted_order",
"==",
"str",
"(",
"order",
")",
":",
"xml",
".",
"remove_element",
"(",
"reference",
",",
"\".//label\"",
")",
"reference_label",
"=",
"etree",
".",
"Element",
"(",
"\"label\"",
")",
"reference_label",
".",
"text",
"=",
"extracted_order",
"reference",
".",
"insert",
"(",
"0",
",",
"reference_label",
")",
"updated",
".",
"append",
"(",
"references",
".",
"get",
"(",
"str",
"(",
"order",
")",
")",
")",
"return",
"updated"
] | [
827,
4
] | [
871,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Quadro.tipo | (self, tipo) | Setter para o tipo do quadro | Setter para o tipo do quadro | def tipo(self, tipo):
''' Setter para o tipo do quadro '''
# if not tipo in (1, 0): raise ValueError('tipo deve ser Quadro.ACK ou Quadro.DATA')
self._ctrl = self._ctrl & 0x7f # 0b01111111
self._ctrl |= (tipo << 7) | [
"def",
"tipo",
"(",
"self",
",",
"tipo",
")",
":",
"# if not tipo in (1, 0): raise ValueError('tipo deve ser Quadro.ACK ou Quadro.DATA')",
"self",
".",
"_ctrl",
"=",
"self",
".",
"_ctrl",
"&",
"0x7f",
"# 0b01111111",
"self",
".",
"_ctrl",
"|=",
"(",
"tipo",
"<<",
"7",
")"
] | [
39,
4
] | [
43,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Secantes.__init__ | (self, f , symbols, x, y, erro) | x e y sao valores iniciais, e os symbols tao na ordem obvia | x e y sao valores iniciais, e os symbols tao na ordem obvia | def __init__(self, f , symbols, x, y, erro):
''''x e y sao valores iniciais, e os symbols tao na ordem obvia'''
self.symbol1 = symbols[0]
self.symbol2 = symbols[1]
symbol1 = self.symbol1
symbol2 = self.symbol2
self.erro = erro
self.f = f
self.x0 = y
self.x1 = x
self.df = pd.DataFrame()
self.phi = symbol1 - (f*(symbol1-symbol2)/(f-f.subs(symbol1,symbol2))) | [
"def",
"__init__",
"(",
"self",
",",
"f",
",",
"symbols",
",",
"x",
",",
"y",
",",
"erro",
")",
":",
"self",
".",
"symbol1",
"=",
"symbols",
"[",
"0",
"]",
"self",
".",
"symbol2",
"=",
"symbols",
"[",
"1",
"]",
"symbol1",
"=",
"self",
".",
"symbol1",
"symbol2",
"=",
"self",
".",
"symbol2",
"self",
".",
"erro",
"=",
"erro",
"self",
".",
"f",
"=",
"f",
"self",
".",
"x0",
"=",
"y",
"self",
".",
"x1",
"=",
"x",
"self",
".",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"self",
".",
"phi",
"=",
"symbol1",
"-",
"(",
"f",
"*",
"(",
"symbol1",
"-",
"symbol2",
")",
"/",
"(",
"f",
"-",
"f",
".",
"subs",
"(",
"symbol1",
",",
"symbol2",
")",
")",
")"
] | [
711,
4
] | [
723,
78
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BaseDoc.generate | (self, mask: bool = False) | Método para gerar um documento válido. | Método para gerar um documento válido. | def generate(self, mask: bool = False) -> str:
"""Método para gerar um documento válido."""
pass | [
"def",
"generate",
"(",
"self",
",",
"mask",
":",
"bool",
"=",
"False",
")",
"->",
"str",
":",
"pass"
] | [
15,
4
] | [
17,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GameStats.__init__ | (self, ai_settings) | Inicia os dados estatísticos. | Inicia os dados estatísticos. | def __init__(self, ai_settings):
"""Inicia os dados estatísticos."""
self.ai_settings = ai_settings
self.reset_stats()
# Inicia a primeira tela do jogo
self.game_start = True
# Inicia o jogo em um estado inativo
self.game_active = False
# Tela de Game-over
self.game_over = False
# A pontuação máxima jamais deverá ser reiniciada
self.high_score = 0 | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
")",
":",
"self",
".",
"ai_settings",
"=",
"ai_settings",
"self",
".",
"reset_stats",
"(",
")",
"# Inicia a primeira tela do jogo",
"self",
".",
"game_start",
"=",
"True",
"# Inicia o jogo em um estado inativo",
"self",
".",
"game_active",
"=",
"False",
"# Tela de Game-over",
"self",
".",
"game_over",
"=",
"False",
"# A pontuação máxima jamais deverá ser reiniciada",
"self",
".",
"high_score",
"=",
"0"
] | [
2,
4
] | [
17,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Problem.goal_test | (self, state) | Retornar verdadeiro se o estado for uma meta. O método padrão compara o
estado para self.goal ou verifica o estado em self.goal se é uma
lista, conforme especificado no construtor. | Retornar verdadeiro se o estado for uma meta. O método padrão compara o
estado para self.goal ou verifica o estado em self.goal se é uma
lista, conforme especificado no construtor. | def goal_test(self, state):
"""Retornar verdadeiro se o estado for uma meta. O método padrão compara o
estado para self.goal ou verifica o estado em self.goal se é uma
lista, conforme especificado no construtor."""
if isinstance(self.goal, list):
return is_in(state, self.goal)
else:
return state == self.goal | [
"def",
"goal_test",
"(",
"self",
",",
"state",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"goal",
",",
"list",
")",
":",
"return",
"is_in",
"(",
"state",
",",
"self",
".",
"goal",
")",
"else",
":",
"return",
"state",
"==",
"self",
".",
"goal"
] | [
45,
4
] | [
52,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
calcula_assinatura | (texto) | return assinatura | IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto. | IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto. | def calcula_assinatura(texto):
'''IMPLEMENTAR. Essa funcao recebe um texto e deve devolver a assinatura do texto.'''
assinatura=[]
lista_palavras=[]
#texto="Então resolveu ir brincar com a Máquina pra ser também imperador dos filhos da mandioca. Mas as três cunhas deram muitas risadas e falaram que isso de deuses era gorda mentira antiga, que não tinha deus não e que com a máquina ninguém não brinca porque ela mata. A máquina não era deus não, nem possuía os distintivos femininos de que o herói gostava tanto. Era feita pelos homens. Se mexia com eletricidade com fogo com água com vento com fumo, os homens aproveitando as forças da natureza. Porém jacaré acreditou? nem o herói! Se levantou na cama e com um gesto, esse sim! bem guaçu de desdém, tó! batendo o antebraço esquerdo dentro do outro dobrado, mexeu com energia a munheca direita pras três cunhas e partiu. Nesse instante, falam, ele inventou o gesto famanado de ofensa: a pacova."
sentencas = separa_sentencas(texto)
for sent in sentencas:
novas_frases = separa_frases(sent)
for fr in novas_frases:
novas_palavras = separa_palavras(fr)
lista_palavras.extend(novas_palavras)
n_frases=[]
sentencas = separa_sentencas(texto)
for sent in sentencas:
novas_frases = separa_frases(sent)
for fr in novas_frases:
n_frases.append(fr)
n_caracteres=[]
for palavra in lista_palavras:
n_caracteres.extend(palavra)
TMP=len(n_caracteres)/len(lista_palavras)
#print("TMP= ",TMP)
assinatura.append(TMP)
MPD=n_palavras_diferentes(lista_palavras)/len(lista_palavras)
#print("MPD= ", MPD)
assinatura.append(MPD)
MPU=n_palavras_unicas(lista_palavras)/len(lista_palavras)
#print("MPU= ",MPU)
assinatura.append(MPU)
n_carac_sent=[]
sentencas = separa_sentencas(texto)
for sent in sentencas:
n_carac_sent.extend(sent)
TMS=len(n_carac_sent)/len(separa_sentencas(texto))
#print(n_carac_sent)
assinatura.append(TMS)
CS=len(n_frases)/len (separa_sentencas(texto))
#print("CS: ",CS)
assinatura.append(CS)
n_caract_frase=[]
sentencas = separa_sentencas(texto)
for sent in sentencas:
novas_frases = separa_frases(sent)
for fr in novas_frases:
n_caract_frase.extend(fr)
TMF=len(n_caract_frase)/len(n_frases)
#print("TMF: ",TMF)
#print(n_caract_frase)
assinatura.append(TMF)
return assinatura | [
"def",
"calcula_assinatura",
"(",
"texto",
")",
":",
"assinatura",
"=",
"[",
"]",
"lista_palavras",
"=",
"[",
"]",
"#texto=\"Então resolveu ir brincar com a Máquina pra ser também imperador dos filhos da mandioca. Mas as três cunhas deram muitas risadas e falaram que isso de deuses era gorda mentira antiga, que não tinha deus não e que com a máquina ninguém não brinca porque ela mata. A máquina não era deus não, nem possuía os distintivos femininos de que o herói gostava tanto. Era feita pelos homens. Se mexia com eletricidade com fogo com água com vento com fumo, os homens aproveitando as forças da natureza. Porém jacaré acreditou? nem o herói! Se levantou na cama e com um gesto, esse sim! bem guaçu de desdém, tó! batendo o antebraço esquerdo dentro do outro dobrado, mexeu com energia a munheca direita pras três cunhas e partiu. Nesse instante, falam, ele inventou o gesto famanado de ofensa: a pacova.\"",
"sentencas",
"=",
"separa_sentencas",
"(",
"texto",
")",
"for",
"sent",
"in",
"sentencas",
":",
"novas_frases",
"=",
"separa_frases",
"(",
"sent",
")",
"for",
"fr",
"in",
"novas_frases",
":",
"novas_palavras",
"=",
"separa_palavras",
"(",
"fr",
")",
"lista_palavras",
".",
"extend",
"(",
"novas_palavras",
")",
"n_frases",
"=",
"[",
"]",
"sentencas",
"=",
"separa_sentencas",
"(",
"texto",
")",
"for",
"sent",
"in",
"sentencas",
":",
"novas_frases",
"=",
"separa_frases",
"(",
"sent",
")",
"for",
"fr",
"in",
"novas_frases",
":",
"n_frases",
".",
"append",
"(",
"fr",
")",
"n_caracteres",
"=",
"[",
"]",
"for",
"palavra",
"in",
"lista_palavras",
":",
"n_caracteres",
".",
"extend",
"(",
"palavra",
")",
"TMP",
"=",
"len",
"(",
"n_caracteres",
")",
"/",
"len",
"(",
"lista_palavras",
")",
"#print(\"TMP= \",TMP)",
"assinatura",
".",
"append",
"(",
"TMP",
")",
"MPD",
"=",
"n_palavras_diferentes",
"(",
"lista_palavras",
")",
"/",
"len",
"(",
"lista_palavras",
")",
"#print(\"MPD= \", MPD)",
"assinatura",
".",
"append",
"(",
"MPD",
")",
"MPU",
"=",
"n_palavras_unicas",
"(",
"lista_palavras",
")",
"/",
"len",
"(",
"lista_palavras",
")",
"#print(\"MPU= \",MPU)",
"assinatura",
".",
"append",
"(",
"MPU",
")",
"n_carac_sent",
"=",
"[",
"]",
"sentencas",
"=",
"separa_sentencas",
"(",
"texto",
")",
"for",
"sent",
"in",
"sentencas",
":",
"n_carac_sent",
".",
"extend",
"(",
"sent",
")",
"TMS",
"=",
"len",
"(",
"n_carac_sent",
")",
"/",
"len",
"(",
"separa_sentencas",
"(",
"texto",
")",
")",
"#print(n_carac_sent)",
"assinatura",
".",
"append",
"(",
"TMS",
")",
"CS",
"=",
"len",
"(",
"n_frases",
")",
"/",
"len",
"(",
"separa_sentencas",
"(",
"texto",
")",
")",
"#print(\"CS: \",CS)",
"assinatura",
".",
"append",
"(",
"CS",
")",
"n_caract_frase",
"=",
"[",
"]",
"sentencas",
"=",
"separa_sentencas",
"(",
"texto",
")",
"for",
"sent",
"in",
"sentencas",
":",
"novas_frases",
"=",
"separa_frases",
"(",
"sent",
")",
"for",
"fr",
"in",
"novas_frases",
":",
"n_caract_frase",
".",
"extend",
"(",
"fr",
")",
"TMF",
"=",
"len",
"(",
"n_caract_frase",
")",
"/",
"len",
"(",
"n_frases",
")",
"#print(\"TMF: \",TMF)",
"#print(n_caract_frase)",
"assinatura",
".",
"append",
"(",
"TMF",
")",
"return",
"assinatura"
] | [
101,
0
] | [
164,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
InsertionSort.__recursiveSwitchBack | (self,array,leftIndex,pivot) | Método auxiliar de recursão
Método responsável por verificar e trocar elementos caso estes sejam menores que o pivô
Parametros:
leftIndex: Índice limite a esquerda
pivot: Pivô usado como referência para comutar elementos
| Método auxiliar de recursão
Método responsável por verificar e trocar elementos caso estes sejam menores que o pivô
Parametros:
leftIndex: Índice limite a esquerda
pivot: Pivô usado como referência para comutar elementos
| def __recursiveSwitchBack(self,array,leftIndex,pivot):
""" Método auxiliar de recursão
Método responsável por verificar e trocar elementos caso estes sejam menores que o pivô
Parametros:
leftIndex: Índice limite a esquerda
pivot: Pivô usado como referência para comutar elementos
"""
if(pivot > leftIndex and array[pivot] < array[pivot -1]):
array[pivot] , array[pivot - 1] = array[pivot -1] , array[pivot]
self.__recursiveSwitchBack(array,leftIndex,pivot - 1) | [
"def",
"__recursiveSwitchBack",
"(",
"self",
",",
"array",
",",
"leftIndex",
",",
"pivot",
")",
":",
"if",
"(",
"pivot",
">",
"leftIndex",
"and",
"array",
"[",
"pivot",
"]",
"<",
"array",
"[",
"pivot",
"-",
"1",
"]",
")",
":",
"array",
"[",
"pivot",
"]",
",",
"array",
"[",
"pivot",
"-",
"1",
"]",
"=",
"array",
"[",
"pivot",
"-",
"1",
"]",
",",
"array",
"[",
"pivot",
"]",
"self",
".",
"__recursiveSwitchBack",
"(",
"array",
",",
"leftIndex",
",",
"pivot",
"-",
"1",
")"
] | [
61,
1
] | [
70,
56
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TituloEleitoral.generate | (self, mask: bool = False) | return document | Método para gerar um título eleitoral válido. | Método para gerar um título eleitoral válido. | def generate(self, mask: bool = False) -> str:
"""Método para gerar um título eleitoral válido."""
document_digits = [sample(self.digits, 1)[0] for _ in range(8)]
state_identifier = self._generate_valid_state_identifier()
document_digits.extend(map(int, state_identifier))
first_check_digit = self._compute_first_check_digit(doc_digits=document_digits)
second_check_digit = self._compute_second_check_digit(doc_digits=document_digits,
first_check_digit=first_check_digit)
document_digits.extend([first_check_digit, second_check_digit])
document = ''.join(map(str, document_digits))
if mask:
return self.mask(doc=document)
return document | [
"def",
"generate",
"(",
"self",
",",
"mask",
":",
"bool",
"=",
"False",
")",
"->",
"str",
":",
"document_digits",
"=",
"[",
"sample",
"(",
"self",
".",
"digits",
",",
"1",
")",
"[",
"0",
"]",
"for",
"_",
"in",
"range",
"(",
"8",
")",
"]",
"state_identifier",
"=",
"self",
".",
"_generate_valid_state_identifier",
"(",
")",
"document_digits",
".",
"extend",
"(",
"map",
"(",
"int",
",",
"state_identifier",
")",
")",
"first_check_digit",
"=",
"self",
".",
"_compute_first_check_digit",
"(",
"doc_digits",
"=",
"document_digits",
")",
"second_check_digit",
"=",
"self",
".",
"_compute_second_check_digit",
"(",
"doc_digits",
"=",
"document_digits",
",",
"first_check_digit",
"=",
"first_check_digit",
")",
"document_digits",
".",
"extend",
"(",
"[",
"first_check_digit",
",",
"second_check_digit",
"]",
")",
"document",
"=",
"''",
".",
"join",
"(",
"map",
"(",
"str",
",",
"document_digits",
")",
")",
"if",
"mask",
":",
"return",
"self",
".",
"mask",
"(",
"doc",
"=",
"document",
")",
"return",
"document"
] | [
30,
4
] | [
47,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Gatinho.comer | (self, geladeira, comida) | Diminui a fome e altera a saúde dependendo dos níveis de saúde da Comida. | Diminui a fome e altera a saúde dependendo dos níveis de saúde da Comida. | def comer(self, geladeira, comida):
"""Diminui a fome e altera a saúde dependendo dos níveis de saúde da Comida."""
geladeira.pegar_comida(comida)
self.fome = self.atualizar_attr(self.fome, comida.saciar)
self.saude = self.atualizar_attr(self.saude, comida.saude) | [
"def",
"comer",
"(",
"self",
",",
"geladeira",
",",
"comida",
")",
":",
"geladeira",
".",
"pegar_comida",
"(",
"comida",
")",
"self",
".",
"fome",
"=",
"self",
".",
"atualizar_attr",
"(",
"self",
".",
"fome",
",",
"comida",
".",
"saciar",
")",
"self",
".",
"saude",
"=",
"self",
".",
"atualizar_attr",
"(",
"self",
".",
"saude",
",",
"comida",
".",
"saude",
")"
] | [
20,
4
] | [
25,
66
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
index_post | () | return """
<h1>Suas informações</h1>
</br>
<h4>{}</h4>
<h4>{}</h4>
""".format(username, password) | Exemplo do metodo POST recebendo os dados do form. | Exemplo do metodo POST recebendo os dados do form. | def index_post():
"""Exemplo do metodo POST recebendo os dados do form."""
username = request.forms.get('username')
password = request.forms.get('password')
return """
<h1>Suas informações</h1>
</br>
<h4>{}</h4>
<h4>{}</h4>
""".format(username, password) | [
"def",
"index_post",
"(",
")",
":",
"username",
"=",
"request",
".",
"forms",
".",
"get",
"(",
"'username'",
")",
"password",
"=",
"request",
".",
"forms",
".",
"get",
"(",
"'password'",
")",
"return",
"\"\"\"\n <h1>Suas informações</h1>\n </br>\n <h4>{}</h4>\n <h4>{}</h4>\n \"\"\"",
".",
"format",
"(",
"username",
",",
"password",
")"
] | [
21,
0
] | [
31,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
variables | (s) | return {x for x in subexpressions(s) if is_variable(x)} | Retorna um conjunto das variáveis na expressão s. | Retorna um conjunto das variáveis na expressão s. | def variables(s):
"""Retorna um conjunto das variáveis na expressão s."""
return {x for x in subexpressions(s) if is_variable(x)} | [
"def",
"variables",
"(",
"s",
")",
":",
"return",
"{",
"x",
"for",
"x",
"in",
"subexpressions",
"(",
"s",
")",
"if",
"is_variable",
"(",
"x",
")",
"}"
] | [
141,
0
] | [
144,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
is_hidden | (var, X, e) | return var != X and var not in e | É var uma variável oculta ao consultar P (X | e)? | É var uma variável oculta ao consultar P (X | e)? | def is_hidden(var, X, e):
"É var uma variável oculta ao consultar P (X | e)?"
return var != X and var not in e | [
"def",
"is_hidden",
"(",
"var",
",",
"X",
",",
"e",
")",
":",
"return",
"var",
"!=",
"X",
"and",
"var",
"not",
"in",
"e"
] | [
321,
0
] | [
323,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
IpResource.handle_put | (self, request, user, *args, **kwargs) | Trata as requisições de PUT para inserir o relacionamento entre IP e Equipamento.
URL: ip/<id_ip>/equipamento/<id_equipamento>/$
| Trata as requisições de PUT para inserir o relacionamento entre IP e Equipamento. | def handle_put(self, request, user, *args, **kwargs):
"""Trata as requisições de PUT para inserir o relacionamento entre IP e Equipamento.
URL: ip/<id_ip>/equipamento/<id_equipamento>/$
"""
try:
ip_id = kwargs.get('id_ip')
equip_id = kwargs.get('id_equipamento')
if not is_valid_int_greater_zero_param(ip_id):
self.log.error(
u'The ip_id parameter is not a valid value: %s.', ip_id)
raise InvalidValueError(None, 'ip_id', ip_id)
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'The equip_id parameter is not a valid value: %s.', equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
Ip.get_by_pk(ip_id)
with distributedlock(LOCK_IP_EQUIPMENT % (ip_id, equip_id)):
ip_equipment = insert_ip_equipment(ip_id, equip_id, user)
ipequipamento_map = dict()
ipequipamento_map['id'] = ip_equipment.id
map = dict()
map['ip_equipamento'] = ipequipamento_map
return self.response(dumps_networkapi(map))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except IpNotFoundError:
return self.response_error(119)
except EquipamentoNotFoundError:
return self.response_error(117, equip_id)
except IpEquipamentoDuplicatedError:
return self.response_error(120)
except UserNotAuthorizedError:
return self.not_authorized()
except (IpError, EquipamentoError, GrupoError):
return self.response_error(1) | [
"def",
"handle_put",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"ip_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_ip'",
")",
"equip_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_equipamento'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"ip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The ip_id parameter is not a valid value: %s.'",
",",
"ip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'ip_id'",
",",
"ip_id",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The equip_id parameter is not a valid value: %s.'",
",",
"equip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equip_id'",
",",
"equip_id",
")",
"Ip",
".",
"get_by_pk",
"(",
"ip_id",
")",
"with",
"distributedlock",
"(",
"LOCK_IP_EQUIPMENT",
"%",
"(",
"ip_id",
",",
"equip_id",
")",
")",
":",
"ip_equipment",
"=",
"insert_ip_equipment",
"(",
"ip_id",
",",
"equip_id",
",",
"user",
")",
"ipequipamento_map",
"=",
"dict",
"(",
")",
"ipequipamento_map",
"[",
"'id'",
"]",
"=",
"ip_equipment",
".",
"id",
"map",
"=",
"dict",
"(",
")",
"map",
"[",
"'ip_equipamento'",
"]",
"=",
"ipequipamento_map",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"map",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"IpNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"119",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equip_id",
")",
"except",
"IpEquipamentoDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"120",
")",
"except",
"UserNotAuthorizedError",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"(",
"IpError",
",",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
189,
4
] | [
232,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.indentar | (self, r = 0) | Calcula a diferença entre o recuo da próxima linha e o recuo da linha atual, caso não exista algum dos dois recuos, retorna o argumento r | Calcula a diferença entre o recuo da próxima linha e o recuo da linha atual, caso não exista algum dos dois recuos, retorna o argumento r | def indentar (self, r = 0):
'''Calcula a diferença entre o recuo da próxima linha e o recuo da linha atual, caso não exista algum dos dois recuos, retorna o argumento r'''
try:
return self.prox.recuo - self.recuo
except AttributeError:
return r | [
"def",
"indentar",
"(",
"self",
",",
"r",
"=",
"0",
")",
":",
"try",
":",
"return",
"self",
".",
"prox",
".",
"recuo",
"-",
"self",
".",
"recuo",
"except",
"AttributeError",
":",
"return",
"r"
] | [
265,
1
] | [
270,
11
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
UndirectedWeightedGraph.add_edge | (self, v, u, weight = None) | Insere um arestas no grafo.
@params <vértice v, vértice w, peso entre (v,w)>
Se os vértices não existem previamente no grafo, então eles são inseridos.
Não permite a inserção de loços, isto é, quando v == w.
Se o parâmetro peso não é definido, é tomado como sendo de valor 1 (um)
| Insere um arestas no grafo.
| def add_edge(self, v, u, weight = None):
'''Insere um arestas no grafo.
@params <vértice v, vértice w, peso entre (v,w)>
Se os vértices não existem previamente no grafo, então eles são inseridos.
Não permite a inserção de loços, isto é, quando v == w.
Se o parâmetro peso não é definido, é tomado como sendo de valor 1 (um)
'''
if weight is None:
raise AttributeError("Weight must be given")
if v != u :
self.__edges[v][u] = weight
self.__edges[u][v] = weight | [
"def",
"add_edge",
"(",
"self",
",",
"v",
",",
"u",
",",
"weight",
"=",
"None",
")",
":",
"if",
"weight",
"is",
"None",
":",
"raise",
"AttributeError",
"(",
"\"Weight must be given\"",
")",
"if",
"v",
"!=",
"u",
":",
"self",
".",
"__edges",
"[",
"v",
"]",
"[",
"u",
"]",
"=",
"weight",
"self",
".",
"__edges",
"[",
"u",
"]",
"[",
"v",
"]",
"=",
"weight"
] | [
167,
4
] | [
181,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
merge | (original, novo) | return original | Merge entre dois dicionários
O primeiro parametro dicionário será sobrescrito pelo valor do segundo parametro dicionário
forçando a conversão do conteúdo de cada indice do segundo dicionário para string.
:param original: dicionario original (possivelmente modulo.default())
:param novo: dicionario alterado (possivelmente uma alteração do odict vindo modulo.default())
:type original: odict
:type novo: odict
:returns: odict original alterado com os valores do novo
:rtype: odict
.. todo:: adicionar recursividade
| Merge entre dois dicionários
O primeiro parametro dicionário será sobrescrito pelo valor do segundo parametro dicionário
forçando a conversão do conteúdo de cada indice do segundo dicionário para string.
:param original: dicionario original (possivelmente modulo.default())
:param novo: dicionario alterado (possivelmente uma alteração do odict vindo modulo.default())
:type original: odict
:type novo: odict
:returns: odict original alterado com os valores do novo
:rtype: odict
.. todo:: adicionar recursividade
| def merge(original, novo):
"""Merge entre dois dicionários
O primeiro parametro dicionário será sobrescrito pelo valor do segundo parametro dicionário
forçando a conversão do conteúdo de cada indice do segundo dicionário para string.
:param original: dicionario original (possivelmente modulo.default())
:param novo: dicionario alterado (possivelmente uma alteração do odict vindo modulo.default())
:type original: odict
:type novo: odict
:returns: odict original alterado com os valores do novo
:rtype: odict
.. todo:: adicionar recursividade
"""
_keys = original.keys()
for _key in _keys:
if(_key in novo):
original[_key] = str(novo[_key])
return original | [
"def",
"merge",
"(",
"original",
",",
"novo",
")",
":",
"_keys",
"=",
"original",
".",
"keys",
"(",
")",
"for",
"_key",
"in",
"_keys",
":",
"if",
"(",
"_key",
"in",
"novo",
")",
":",
"original",
"[",
"_key",
"]",
"=",
"str",
"(",
"novo",
"[",
"_key",
"]",
")",
"return",
"original"
] | [
2,
0
] | [
22,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestLambdas.test_lambda_allany | (self) | Teste usando dois operadores lambda: all e any | Teste usando dois operadores lambda: all e any | def test_lambda_allany(self):
"""Teste usando dois operadores lambda: all e any"""
expected = "customFieldValues/all(x: x/items/any(y: y/customFieldItem eq 'MGSSUSTR6-06R'))"
result = AllAny(
self.properties["customFieldValues"].items.customFieldItem
== "MGSSUSTR6-06R"
)
self.assertEqual(result, expected) | [
"def",
"test_lambda_allany",
"(",
"self",
")",
":",
"expected",
"=",
"\"customFieldValues/all(x: x/items/any(y: y/customFieldItem eq 'MGSSUSTR6-06R'))\"",
"result",
"=",
"AllAny",
"(",
"self",
".",
"properties",
"[",
"\"customFieldValues\"",
"]",
".",
"items",
".",
"customFieldItem",
"==",
"\"MGSSUSTR6-06R\"",
")",
"self",
".",
"assertEqual",
"(",
"result",
",",
"expected",
")"
] | [
72,
4
] | [
79,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_socio | (id) | return socio | Retorna um sócio de acordo com seu id | Retorna um sócio de acordo com seu id | def get_socio(id):
"""Retorna um sócio de acordo com seu id"""
socio = db.query_one('select * from socio where id = %d' % id)
if socio is None:
raise Exception('Não encontrouo socio com o id %d' % id)
return socio | [
"def",
"get_socio",
"(",
"id",
")",
":",
"socio",
"=",
"db",
".",
"query_one",
"(",
"'select * from socio where id = %d'",
"%",
"id",
")",
"if",
"socio",
"is",
"None",
":",
"raise",
"Exception",
"(",
"'Não encontrouo socio com o id %d' ",
" ",
"d)",
"\r",
"return",
"socio"
] | [
32,
0
] | [
39,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
create_us | (plist, N) | return np.array(ulist) | Recebe uma lista de pontos e calcula os vetores U's correspondentes
Recebe tambem o parametro N
Devolve os vetores U dentro de um vetor maior, cada vetor U é um vetor coluna.
| Recebe uma lista de pontos e calcula os vetores U's correspondentes
Recebe tambem o parametro N
Devolve os vetores U dentro de um vetor maior, cada vetor U é um vetor coluna.
| def create_us(plist, N):
''''Recebe uma lista de pontos e calcula os vetores U's correspondentes
Recebe tambem o parametro N
Devolve os vetores U dentro de um vetor maior, cada vetor U é um vetor coluna.
'''
ulist = []
for p in plist:
u = crank_nicolson(N, p).execute()[1:-1] # slicing para retirada das bordas
ulist.append(u)
return np.array(ulist) | [
"def",
"create_us",
"(",
"plist",
",",
"N",
")",
":",
"ulist",
"=",
"[",
"]",
"for",
"p",
"in",
"plist",
":",
"u",
"=",
"crank_nicolson",
"(",
"N",
",",
"p",
")",
".",
"execute",
"(",
")",
"[",
"1",
":",
"-",
"1",
"]",
"# slicing para retirada das bordas\r",
"ulist",
".",
"append",
"(",
"u",
")",
"return",
"np",
".",
"array",
"(",
"ulist",
")"
] | [
10,
0
] | [
19,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Ship.__init__ | (self, ai_setting, screen) | Inicializa a nave e define a posição inicial | Inicializa a nave e define a posição inicial | def __init__(self, ai_setting, screen):
"""Inicializa a nave e define a posição inicial"""
super().__init__()
self.screen = screen
self.ai_setting = ai_setting
# Carrega a imagem da espaçonave e obtém seu rect -> imagens no python são tratadas como retangulos
self.image = pygame.image.load('Assets/ships/ship.bmp')
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.centery = self.screen_rect.centery
self.rect.bottom = self.screen_rect.bottom
# Armazena um valor decimal para o centro da espaçonave
self.center = float(self.rect.centerx)
self.centery = float(self.rect.centery)
# flag de movimento
self.moving_right = False
self.moving_left = False
self.moving_top = False
self.moving_bottom = False | [
"def",
"__init__",
"(",
"self",
",",
"ai_setting",
",",
"screen",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
")",
"self",
".",
"screen",
"=",
"screen",
"self",
".",
"ai_setting",
"=",
"ai_setting",
"# Carrega a imagem da espaçonave e obtém seu rect -> imagens no python são tratadas como retangulos",
"self",
".",
"image",
"=",
"pygame",
".",
"image",
".",
"load",
"(",
"'Assets/ships/ship.bmp'",
")",
"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",
".",
"centery",
"=",
"self",
".",
"screen_rect",
".",
"centery",
"self",
".",
"rect",
".",
"bottom",
"=",
"self",
".",
"screen_rect",
".",
"bottom",
"# Armazena um valor decimal para o centro da espaçonave",
"self",
".",
"center",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"centerx",
")",
"self",
".",
"centery",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"centery",
")",
"# flag de movimento",
"self",
".",
"moving_right",
"=",
"False",
"self",
".",
"moving_left",
"=",
"False",
"self",
".",
"moving_top",
"=",
"False",
"self",
".",
"moving_bottom",
"=",
"False"
] | [
7,
4
] | [
31,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
criar_chamado | (request) | return render(request, "criar_chamado.html", {"form": form}) | Cria formulário do chamado e envia objeto cliente para pegar id.
| Cria formulário do chamado e envia objeto cliente para pegar id.
| def criar_chamado(request):
""" Cria formulário do chamado e envia objeto cliente para pegar id.
"""
usuario = request.user
# é preciso pegar usuario com 'get' para atribuir em cliente de chamado.
# usuario_cli = Cliente.objects.get(usuario_cli=usuario)
#print(usuario_cli)
if request.method == "POST":
form = ChamadoForm(request.POST, request.FILES)
if form.is_valid():
# novo = Chamado(cliente=usuario_cli, **form.cleaned_data)
# titulo = form.cleaned_data['titulo']
# assunto = form.cleaned_data['assunto']
# descricao = form.cleaned_data['descricao']
# arquivo = form.cleaned_data['arquivo']
# funcionario = form.cleaned_data['funcionario']
# #cliente = form.cleaned_data['cliente']
# novo = Chamado(
# titulo=titulo, assunto=assunto, descricao=descricao,
# arquivo=arquivo, funcionario=funcionario, cliente=usuario_cli #aceitar usuario request
# )
# novo.save()
return redirect("chamado_list")
else:
form = ChamadoForm()
return render(request, "criar_chamado.html", {"form": form}) | [
"def",
"criar_chamado",
"(",
"request",
")",
":",
"usuario",
"=",
"request",
".",
"user",
"# é preciso pegar usuario com 'get' para atribuir em cliente de chamado.",
"# usuario_cli = Cliente.objects.get(usuario_cli=usuario)",
"#print(usuario_cli)",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"form",
"=",
"ChamadoForm",
"(",
"request",
".",
"POST",
",",
"request",
".",
"FILES",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"# novo = Chamado(cliente=usuario_cli, **form.cleaned_data)",
"# titulo = form.cleaned_data['titulo']",
"# assunto = form.cleaned_data['assunto']",
"# descricao = form.cleaned_data['descricao']",
"# arquivo = form.cleaned_data['arquivo']",
"# funcionario = form.cleaned_data['funcionario']",
"# #cliente = form.cleaned_data['cliente']",
"# novo = Chamado(",
"# titulo=titulo, assunto=assunto, descricao=descricao,",
"# arquivo=arquivo, funcionario=funcionario, cliente=usuario_cli #aceitar usuario request",
"# )",
"# novo.save()",
"return",
"redirect",
"(",
"\"chamado_list\"",
")",
"else",
":",
"form",
"=",
"ChamadoForm",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"criar_chamado.html\"",
",",
"{",
"\"form\"",
":",
"form",
"}",
")"
] | [
718,
0
] | [
744,
64
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Pesquisador.dfTidy | (self, df, cols_keep, cols_merge, cols_equiv, cols_out, cols_final) | return df | Trabalha as colunas nos dataframes de cada elemento Lattes para ficarem mais amigaveis.
Args:
df (type): dataframe com informações de uma seção `df`.
cols_keep (type): lista de parâmetros para trabalhar `cols_keep`.
cols_merge (type): parâmetros que serão unificados porque aparecem com nomes diferentes `cols_merge`.
cols_equiv (type): mudanças de nome de tabelas como dicionário `cols_equiv`.
cols_out (type): colunas para remover, incluindo substrings `cols_out`.
cols_final (type): colunas para tentar manter `cols_final`.
Returns:
type: dataframe mais ou menos arrumado.
| Trabalha as colunas nos dataframes de cada elemento Lattes para ficarem mais amigaveis. | def dfTidy(self, df, cols_keep, cols_merge, cols_equiv, cols_out, cols_final):
"""Trabalha as colunas nos dataframes de cada elemento Lattes para ficarem mais amigaveis.
Args:
df (type): dataframe com informações de uma seção `df`.
cols_keep (type): lista de parâmetros para trabalhar `cols_keep`.
cols_merge (type): parâmetros que serão unificados porque aparecem com nomes diferentes `cols_merge`.
cols_equiv (type): mudanças de nome de tabelas como dicionário `cols_equiv`.
cols_out (type): colunas para remover, incluindo substrings `cols_out`.
cols_final (type): colunas para tentar manter `cols_final`.
Returns:
type: dataframe mais ou menos arrumado.
"""
#----Validando argumentos
if (not isinstance(df,pd.DataFrame) or df.empty):
return None
#----
cols = df.columns.tolist()
if len(cols_keep)==0:
cols_keep = cols
if len(cols_merge)==0:
cols_merge = None
if len(cols_equiv)==0:
cols_equiv = None
if len(cols_out)==0:
cols_out = None
#-------------------------
#----Sabemos o que manter, garantimos que exista
if cols_keep is not None:
cols = df.columns.tolist()
colG = list(OrderedDict.fromkeys([*cols_keep, *cols]))
for col in colG :
if col not in cols:
df.loc[:,col] = ""
#----Removendo tudo o que parece inútil
if cols_out is not None:
present = {col for col in set(cols) if any(out in col for out in set(cols_out))}
cols = list(set(cols) - present)
df = df[cols]
#----Renomeando algumas colunas
if cols_equiv is not None:
for col in cols_equiv.keys():
if col not in cols:
df = df.copy()
df.loc[:,col] = ""
df = df.rename(columns = cols_equiv)
#----Juntando colunas que representam a mesma coisa com fillna
cols = sorted(df.columns.tolist())
cols_merge = sorted(cols_merge)
if cols_merge is not None:
for agregado in cols_merge:
colmerge = sorted((([col for col in cols if agregado in col]))+[agregado])
colmerge = list(OrderedDict.fromkeys(colmerge))
for col in colmerge:
if col not in cols:
df.loc[:,col]=np.nan
for col in colmerge[1:]:
if not df[col].isnull().all():
df = df.copy()
df.loc[:,colmerge[0]] = df.loc[:,colmerge[0]].fillna(df.loc[:,col])
df = df.drop(col, axis=1)
cols = df.columns.tolist()
if len(cols_final) == 0:
cols_final = cols
colunas = list({col for col in set(cols) if any(out in col for out in set(cols_final))})
df = df[colunas]
return df | [
"def",
"dfTidy",
"(",
"self",
",",
"df",
",",
"cols_keep",
",",
"cols_merge",
",",
"cols_equiv",
",",
"cols_out",
",",
"cols_final",
")",
":",
"#----Validando argumentos",
"if",
"(",
"not",
"isinstance",
"(",
"df",
",",
"pd",
".",
"DataFrame",
")",
"or",
"df",
".",
"empty",
")",
":",
"return",
"None",
"#----",
"cols",
"=",
"df",
".",
"columns",
".",
"tolist",
"(",
")",
"if",
"len",
"(",
"cols_keep",
")",
"==",
"0",
":",
"cols_keep",
"=",
"cols",
"if",
"len",
"(",
"cols_merge",
")",
"==",
"0",
":",
"cols_merge",
"=",
"None",
"if",
"len",
"(",
"cols_equiv",
")",
"==",
"0",
":",
"cols_equiv",
"=",
"None",
"if",
"len",
"(",
"cols_out",
")",
"==",
"0",
":",
"cols_out",
"=",
"None",
"#-------------------------",
"#----Sabemos o que manter, garantimos que exista",
"if",
"cols_keep",
"is",
"not",
"None",
":",
"cols",
"=",
"df",
".",
"columns",
".",
"tolist",
"(",
")",
"colG",
"=",
"list",
"(",
"OrderedDict",
".",
"fromkeys",
"(",
"[",
"*",
"cols_keep",
",",
"*",
"cols",
"]",
")",
")",
"for",
"col",
"in",
"colG",
":",
"if",
"col",
"not",
"in",
"cols",
":",
"df",
".",
"loc",
"[",
":",
",",
"col",
"]",
"=",
"\"\"",
"#----Removendo tudo o que parece inútil",
"if",
"cols_out",
"is",
"not",
"None",
":",
"present",
"=",
"{",
"col",
"for",
"col",
"in",
"set",
"(",
"cols",
")",
"if",
"any",
"(",
"out",
"in",
"col",
"for",
"out",
"in",
"set",
"(",
"cols_out",
")",
")",
"}",
"cols",
"=",
"list",
"(",
"set",
"(",
"cols",
")",
"-",
"present",
")",
"df",
"=",
"df",
"[",
"cols",
"]",
"#----Renomeando algumas colunas",
"if",
"cols_equiv",
"is",
"not",
"None",
":",
"for",
"col",
"in",
"cols_equiv",
".",
"keys",
"(",
")",
":",
"if",
"col",
"not",
"in",
"cols",
":",
"df",
"=",
"df",
".",
"copy",
"(",
")",
"df",
".",
"loc",
"[",
":",
",",
"col",
"]",
"=",
"\"\"",
"df",
"=",
"df",
".",
"rename",
"(",
"columns",
"=",
"cols_equiv",
")",
"#----Juntando colunas que representam a mesma coisa com fillna",
"cols",
"=",
"sorted",
"(",
"df",
".",
"columns",
".",
"tolist",
"(",
")",
")",
"cols_merge",
"=",
"sorted",
"(",
"cols_merge",
")",
"if",
"cols_merge",
"is",
"not",
"None",
":",
"for",
"agregado",
"in",
"cols_merge",
":",
"colmerge",
"=",
"sorted",
"(",
"(",
"(",
"[",
"col",
"for",
"col",
"in",
"cols",
"if",
"agregado",
"in",
"col",
"]",
")",
")",
"+",
"[",
"agregado",
"]",
")",
"colmerge",
"=",
"list",
"(",
"OrderedDict",
".",
"fromkeys",
"(",
"colmerge",
")",
")",
"for",
"col",
"in",
"colmerge",
":",
"if",
"col",
"not",
"in",
"cols",
":",
"df",
".",
"loc",
"[",
":",
",",
"col",
"]",
"=",
"np",
".",
"nan",
"for",
"col",
"in",
"colmerge",
"[",
"1",
":",
"]",
":",
"if",
"not",
"df",
"[",
"col",
"]",
".",
"isnull",
"(",
")",
".",
"all",
"(",
")",
":",
"df",
"=",
"df",
".",
"copy",
"(",
")",
"df",
".",
"loc",
"[",
":",
",",
"colmerge",
"[",
"0",
"]",
"]",
"=",
"df",
".",
"loc",
"[",
":",
",",
"colmerge",
"[",
"0",
"]",
"]",
".",
"fillna",
"(",
"df",
".",
"loc",
"[",
":",
",",
"col",
"]",
")",
"df",
"=",
"df",
".",
"drop",
"(",
"col",
",",
"axis",
"=",
"1",
")",
"cols",
"=",
"df",
".",
"columns",
".",
"tolist",
"(",
")",
"if",
"len",
"(",
"cols_final",
")",
"==",
"0",
":",
"cols_final",
"=",
"cols",
"colunas",
"=",
"list",
"(",
"{",
"col",
"for",
"col",
"in",
"set",
"(",
"cols",
")",
"if",
"any",
"(",
"out",
"in",
"col",
"for",
"out",
"in",
"set",
"(",
"cols_final",
")",
")",
"}",
")",
"df",
"=",
"df",
"[",
"colunas",
"]",
"return",
"df"
] | [
617,
4
] | [
688,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoGrupoResource.handle_delete | (self, request, user, *args, **kwargs) | Trata as requisições de DELETE para remover uma associação entre um Equipamento e um Grupo.
URL: /equipamentogrupo/equipamento/<id_equip>/egrupo/<id_egrupo>/
| Trata as requisições de DELETE para remover uma associação entre um Equipamento e um Grupo. | def handle_delete(self, request, user, *args, **kwargs):
"""Trata as requisições de DELETE para remover uma associação entre um Equipamento e um Grupo.
URL: /equipamentogrupo/equipamento/<id_equip>/egrupo/<id_egrupo>/
"""
try:
equip_id = kwargs.get('id_equip')
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'The equip_id parameter is not a valid value: %s.', equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
egroup_id = kwargs.get('id_egrupo')
if not is_valid_int_greater_zero_param(egroup_id):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.', egroup_id)
raise InvalidValueError(None, 'egroup_id', egroup_id)
Equipamento.get_by_pk(equip_id)
EGrupo.get_by_pk(egroup_id)
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_EQUIPMENT_GROUP % egroup_id):
EquipamentoGrupo.remove(user, equip_id, egroup_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EGrupoNotFoundError:
return self.response_error(102)
except EquipamentoNotFoundError:
return self.response_error(117, equip_id)
except EquipmentDontRemoveError:
return self.response_error(309)
except (EquipamentoError, GrupoError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"equip_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_equip'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The equip_id parameter is not a valid value: %s.'",
",",
"equip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equip_id'",
",",
"equip_id",
")",
"egroup_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_egrupo'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"egroup_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The egroup_id parameter is not a valid value: %s.'",
",",
"egroup_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'egroup_id'",
",",
"egroup_id",
")",
"Equipamento",
".",
"get_by_pk",
"(",
"equip_id",
")",
"EGrupo",
".",
"get_by_pk",
"(",
"egroup_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"equip_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"with",
"distributedlock",
"(",
"LOCK_EQUIPMENT_GROUP",
"%",
"egroup_id",
")",
":",
"EquipamentoGrupo",
".",
"remove",
"(",
"user",
",",
"equip_id",
",",
"egroup_id",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EGrupoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"102",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equip_id",
")",
"except",
"EquipmentDontRemoveError",
":",
"return",
"self",
".",
"response_error",
"(",
"309",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
152,
4
] | [
195,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
import_issues | (json_file: str, session: Session) | Fachada com passo a passo de processamento e carga de fascículo
em formato JSON para a base Kernel | Fachada com passo a passo de processamento e carga de fascículo
em formato JSON para a base Kernel | def import_issues(json_file: str, session: Session):
"""Fachada com passo a passo de processamento e carga de fascículo
em formato JSON para a base Kernel"""
issues_as_json = reading.read_json_file(json_file)
issues_as_xylose = conversion.conversion_issues_to_xylose(issues_as_json)
issues_as_xylose = filter_issues(issues_as_xylose)
manifests = conversion.conversion_issues_to_kernel(issues_as_xylose)
for manifest in manifests:
issue = DocumentsBundle(manifest=manifest)
try:
add_bundle(session, issue)
except AlreadyExists as exc:
logger.info(exc) | [
"def",
"import_issues",
"(",
"json_file",
":",
"str",
",",
"session",
":",
"Session",
")",
":",
"issues_as_json",
"=",
"reading",
".",
"read_json_file",
"(",
"json_file",
")",
"issues_as_xylose",
"=",
"conversion",
".",
"conversion_issues_to_xylose",
"(",
"issues_as_json",
")",
"issues_as_xylose",
"=",
"filter_issues",
"(",
"issues_as_xylose",
")",
"manifests",
"=",
"conversion",
".",
"conversion_issues_to_kernel",
"(",
"issues_as_xylose",
")",
"for",
"manifest",
"in",
"manifests",
":",
"issue",
"=",
"DocumentsBundle",
"(",
"manifest",
"=",
"manifest",
")",
"try",
":",
"add_bundle",
"(",
"session",
",",
"issue",
")",
"except",
"AlreadyExists",
"as",
"exc",
":",
"logger",
".",
"info",
"(",
"exc",
")"
] | [
83,
0
] | [
97,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Ordem_Servico.get_dt_pagamento_os | (self) | return self.dt_pagamento.strftime("%d/%m/%Y %H h : %M min") | Mostra data pagamento formatada da OS. | Mostra data pagamento formatada da OS. | def get_dt_pagamento_os(self):
"""Mostra data pagamento formatada da OS."""
return self.dt_pagamento.strftime("%d/%m/%Y %H h : %M min") | [
"def",
"get_dt_pagamento_os",
"(",
"self",
")",
":",
"return",
"self",
".",
"dt_pagamento",
".",
"strftime",
"(",
"\"%d/%m/%Y %H h : %M min\"",
")"
] | [
290,
4
] | [
292,
67
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Certificado.emissor | (self) | return self._x509.get_issuer().CN | Pega o nome do emissor do certificado | Pega o nome do emissor do certificado | def emissor(self):
"""Pega o nome do emissor do certificado"""
return self._x509.get_issuer().CN | [
"def",
"emissor",
"(",
"self",
")",
":",
"return",
"self",
".",
"_x509",
".",
"get_issuer",
"(",
")",
".",
"CN"
] | [
83,
4
] | [
85,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
fourth_power | (x) | return square(square(x)) | Calcula a quarta potência de um numero.
Args:
x ([int], [float]): Valor fornecido pelo usuário.
Returns:
[[int], [float]]: a quarta potência do numero informado pelo usuário.
>>> fourth_power(2)
16
>>> fourth_power(5)
625
>>> fourth_power(235.4)
3070618301.1856003
| Calcula a quarta potência de um numero. | def fourth_power(x):
"""Calcula a quarta potência de um numero.
Args:
x ([int], [float]): Valor fornecido pelo usuário.
Returns:
[[int], [float]]: a quarta potência do numero informado pelo usuário.
>>> fourth_power(2)
16
>>> fourth_power(5)
625
>>> fourth_power(235.4)
3070618301.1856003
"""
return square(square(x)) | [
"def",
"fourth_power",
"(",
"x",
")",
":",
"return",
"square",
"(",
"square",
"(",
"x",
")",
")"
] | [
28,
0
] | [
44,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Dog.__init__ | (self, name, age) | Inicializa os atributos name e age. | Inicializa os atributos name e age. | def __init__(self, name, age):
"""Inicializa os atributos name e age."""
self.name = name
self.age = age | [
"def",
"__init__",
"(",
"self",
",",
"name",
",",
"age",
")",
":",
"self",
".",
"name",
"=",
"name",
"self",
".",
"age",
"=",
"age"
] | [
3,
4
] | [
6,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
authenticate | (username, password, user_ldap=None) | Busca o usuário com ativo com o login e senha informados.
@raise UsuarioError: Falha ao pesquisar o usuário.
| Busca o usuário com ativo com o login e senha informados. | def authenticate(username, password, user_ldap=None):
"""Busca o usuário com ativo com o login e senha informados.
@raise UsuarioError: Falha ao pesquisar o usuário.
"""
if username is None or password is None:
return None
if user_ldap is None:
return Usuario().get_enabled_user(username, password)
else:
return Usuario().get_by_ldap_user(user_ldap, True) | [
"def",
"authenticate",
"(",
"username",
",",
"password",
",",
"user_ldap",
"=",
"None",
")",
":",
"if",
"username",
"is",
"None",
"or",
"password",
"is",
"None",
":",
"return",
"None",
"if",
"user_ldap",
"is",
"None",
":",
"return",
"Usuario",
"(",
")",
".",
"get_enabled_user",
"(",
"username",
",",
"password",
")",
"else",
":",
"return",
"Usuario",
"(",
")",
".",
"get_by_ldap_user",
"(",
"user_ldap",
",",
"True",
")"
] | [
28,
0
] | [
39,
58
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType63.group_id | (self) | return bin2int(self.data[BYTES_63[17]]) | F17 - O ID do grupo à qual a medida pertence.0 caso não pertença a nenhum grupo. | F17 - O ID do grupo à qual a medida pertence.0 caso não pertença a nenhum grupo. | def group_id(self) -> int:
"""F17 - O ID do grupo à qual a medida pertence.0 caso não pertença a nenhum grupo."""
return bin2int(self.data[BYTES_63[17]]) | [
"def",
"group_id",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_63",
"[",
"17",
"]",
"]",
")"
] | [
1102,
4
] | [
1104,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_expressao | (p) | expressao : expressao_logica
| atribuicao
| expressao : expressao_logica
| atribuicao
| def p_expressao(p):
"""expressao : expressao_logica
| atribuicao
"""
pai = MyNode(name='expressao', type='EXPRESSAO')
p[0] = pai
p[1].parent = pai | [
"def",
"p_expressao",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'expressao'",
",",
"type",
"=",
"'EXPRESSAO'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
740,
0
] | [
746,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Basics.get_script_file | (cls) | return cls.basics_content | Retorna leitura do arquivo de script definido em basics de routers.yaml, no formato list. | Retorna leitura do arquivo de script definido em basics de routers.yaml, no formato list. | def get_script_file(cls):
"""Retorna leitura do arquivo de script definido em basics de routers.yaml, no formato list."""
basics = open('router-config/cisco/basics.ios', 'r')
cls.basics_content = basics.readlines()
return cls.basics_content | [
"def",
"get_script_file",
"(",
"cls",
")",
":",
"basics",
"=",
"open",
"(",
"'router-config/cisco/basics.ios'",
",",
"'r'",
")",
"cls",
".",
"basics_content",
"=",
"basics",
".",
"readlines",
"(",
")",
"return",
"cls",
".",
"basics_content"
] | [
38,
4
] | [
44,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
check_bullet_alien_collisions | (ai_settings, screen, stats, sb, ship, aliens,
bullets) | Responde a colicoes entre projeteis e alienigenas. | Responde a colicoes entre projeteis e alienigenas. | def check_bullet_alien_collisions(ai_settings, screen, stats, sb, ship, aliens,
bullets):
"""Responde a colicoes entre projeteis e alienigenas."""
# Remove qualquer projetil e alienigena que tenham colidido
collisions = pygame.sprite.groupcollide(bullets, aliens, True, True)
if collisions:
for aliens in collisions.values():
stats.score += ai_settings.alien_points * len(aliens)
sb.prep_score()
check_high_score(stats, sb)
if len(aliens) == 0:
# Se a frota for destruida, inicia um novo nivel
bullets.empty()
ai_settings.increase_speed()
# Aumenta o nivel
start_new_level(ai_settings, screen, stats, sb, ship, aliens) | [
"def",
"check_bullet_alien_collisions",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"# Remove qualquer projetil e alienigena que tenham colidido",
"collisions",
"=",
"pygame",
".",
"sprite",
".",
"groupcollide",
"(",
"bullets",
",",
"aliens",
",",
"True",
",",
"True",
")",
"if",
"collisions",
":",
"for",
"aliens",
"in",
"collisions",
".",
"values",
"(",
")",
":",
"stats",
".",
"score",
"+=",
"ai_settings",
".",
"alien_points",
"*",
"len",
"(",
"aliens",
")",
"sb",
".",
"prep_score",
"(",
")",
"check_high_score",
"(",
"stats",
",",
"sb",
")",
"if",
"len",
"(",
"aliens",
")",
"==",
"0",
":",
"# Se a frota for destruida, inicia um novo nivel",
"bullets",
".",
"empty",
"(",
")",
"ai_settings",
".",
"increase_speed",
"(",
")",
"# Aumenta o nivel",
"start_new_level",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
")"
] | [
116,
0
] | [
134,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_all_events_by_group | () | return g | Traga todos os grupos que contenham alguem que possua um agente que possuem eventos do tipo information | Traga todos os grupos que contenham alguem que possua um agente que possuem eventos do tipo information | def get_all_events_by_group() -> Group:
"""Traga todos os grupos que contenham alguem que possua um agente que possuem eventos do tipo information"""
g = []
for grp in Group.objects.all():
for usr in grp.user_set.all():
for agt in usr.agent_set.all():
g.append(agt.objects.filter(level__contains='information'))
return g | [
"def",
"get_all_events_by_group",
"(",
")",
"->",
"Group",
":",
"g",
"=",
"[",
"]",
"for",
"grp",
"in",
"Group",
".",
"objects",
".",
"all",
"(",
")",
":",
"for",
"usr",
"in",
"grp",
".",
"user_set",
".",
"all",
"(",
")",
":",
"for",
"agt",
"in",
"usr",
".",
"agent_set",
".",
"all",
"(",
")",
":",
"g",
".",
"append",
"(",
"agt",
".",
"objects",
".",
"filter",
"(",
"level__contains",
"=",
"'information'",
")",
")",
"return",
"g"
] | [
35,
0
] | [
42,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Battery.describe_battery | (self) | Retorna uma mensagem com a capacidade da bateria. | Retorna uma mensagem com a capacidade da bateria. | def describe_battery(self):
"""Retorna uma mensagem com a capacidade da bateria."""
print('\tThis car has a ' + str(self.battery_size) + ' kwh battery.') | [
"def",
"describe_battery",
"(",
"self",
")",
":",
"print",
"(",
"'\\tThis car has a '",
"+",
"str",
"(",
"self",
".",
"battery_size",
")",
"+",
"' kwh battery.'",
")"
] | [
47,
4
] | [
49,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_number_aliens_x | (ai_settings, alien_width) | return number_aliens_x | Determina o número de aliens que cabem em uma linha | Determina o número de aliens que cabem em uma linha | def get_number_aliens_x(ai_settings, alien_width):
"""Determina o número de aliens que cabem em uma linha"""
available_space_x = ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x | [
"def",
"get_number_aliens_x",
"(",
"ai_settings",
",",
"alien_width",
")",
":",
"available_space_x",
"=",
"ai_settings",
".",
"screen_width",
"-",
"2",
"*",
"alien_width",
"number_aliens_x",
"=",
"int",
"(",
"available_space_x",
"/",
"(",
"2",
"*",
"alien_width",
")",
")",
"return",
"number_aliens_x"
] | [
191,
0
] | [
195,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
GuessTest.test_match_disarray | (self) | Cenário 3: Tentativa tem dígitos corretos, mas fora do lugar | Cenário 3: Tentativa tem dígitos corretos, mas fora do lugar | def test_match_disarray(self):
""" Cenário 3: Tentativa tem dígitos corretos, mas fora do lugar """
self.assertEqual(guess.match('1234', '4321'), '****') | [
"def",
"test_match_disarray",
"(",
"self",
")",
":",
"self",
".",
"assertEqual",
"(",
"guess",
".",
"match",
"(",
"'1234'",
",",
"'4321'",
")",
",",
"'****'",
")"
] | [
12,
4
] | [
14,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
partition | (a_list, start, end) | Divide uma lista | Divide uma lista | def partition(a_list, start, end):
""" Divide uma lista """
pivot = a_list[start]
while True:
while a_list[start] < pivot:
start = start + 1
while a_list[end] > pivot:
end = end - 1
if start >= end:
return end
swap(a_list, start, end)
start = start + 1
end = end - 1 | [
"def",
"partition",
"(",
"a_list",
",",
"start",
",",
"end",
")",
":",
"pivot",
"=",
"a_list",
"[",
"start",
"]",
"while",
"True",
":",
"while",
"a_list",
"[",
"start",
"]",
"<",
"pivot",
":",
"start",
"=",
"start",
"+",
"1",
"while",
"a_list",
"[",
"end",
"]",
">",
"pivot",
":",
"end",
"=",
"end",
"-",
"1",
"if",
"start",
">=",
"end",
":",
"return",
"end",
"swap",
"(",
"a_list",
",",
"start",
",",
"end",
")",
"start",
"=",
"start",
"+",
"1",
"end",
"=",
"end",
"-",
"1"
] | [
10,
0
] | [
26,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
inverse_normal_cdf | (p, mu=0, sigma=1, tolerance=0.00001) | return mid_z | encontra o inverso mais próximo usando a busca binária | encontra o inverso mais próximo usando a busca binária | def inverse_normal_cdf(p, mu=0, sigma=1, tolerance=0.00001):
"""encontra o inverso mais próximo usando a busca binária"""
# se não for padrão, computa o padrão e redimensiona
if mu != 0 or sigma != 1:
return mu + sigma * inverse_normal_cdf(p, tolerance=tolerance)
low_z, low_p = -10.0, 0 # normal_cdf(-10) está (muito perto de) 0
hi_z, hi_p = 10.0, 1 # normal_cdf(10) está (muito perto de) 1
while hi_z - low_z > tolerance:
mid_z = (low_z + hi_z) / 2 # considera o ponto do meio e o valor da
mid_p = normal_cdf(mid_z) # função de distribuição cumulativa lá
if mid_p < p:
# o ponto do meio ainda está baixo, procura acima
low_z, low_p = mid_z, mid_p
elif mid_p > p:
# o ponto do meio ainda está alto, procura abaixo
hi_z, hi_p = mid_z, mid_p
else:
break
return mid_z | [
"def",
"inverse_normal_cdf",
"(",
"p",
",",
"mu",
"=",
"0",
",",
"sigma",
"=",
"1",
",",
"tolerance",
"=",
"0.00001",
")",
":",
"# se não for padrão, computa o padrão e redimensiona",
"if",
"mu",
"!=",
"0",
"or",
"sigma",
"!=",
"1",
":",
"return",
"mu",
"+",
"sigma",
"*",
"inverse_normal_cdf",
"(",
"p",
",",
"tolerance",
"=",
"tolerance",
")",
"low_z",
",",
"low_p",
"=",
"-",
"10.0",
",",
"0",
"# normal_cdf(-10) está (muito perto de) 0",
"hi_z",
",",
"hi_p",
"=",
"10.0",
",",
"1",
"# normal_cdf(10) está (muito perto de) 1",
"while",
"hi_z",
"-",
"low_z",
">",
"tolerance",
":",
"mid_z",
"=",
"(",
"low_z",
"+",
"hi_z",
")",
"/",
"2",
"# considera o ponto do meio e o valor da",
"mid_p",
"=",
"normal_cdf",
"(",
"mid_z",
")",
"# função de distribuição cumulativa lá",
"if",
"mid_p",
"<",
"p",
":",
"# o ponto do meio ainda está baixo, procura acima",
"low_z",
",",
"low_p",
"=",
"mid_z",
",",
"mid_p",
"elif",
"mid_p",
">",
"p",
":",
"# o ponto do meio ainda está alto, procura abaixo",
"hi_z",
",",
"hi_p",
"=",
"mid_z",
",",
"mid_p",
"else",
":",
"break",
"return",
"mid_z"
] | [
7,
0
] | [
25,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
recursive_factorial | (number) | Calcula o fatorial de um número.
Realiza o cálculo do fatorial do número passado por parâmetro e o re-
torna. O fatorial de um número é dado pelo produto de todos os núme-
ros positivos menores ou iguais a esse número, excetuando-se 0, cujo
fatorial tem valor 1. Essa função utiliza uma abordagem recursiva
para a realização do cálculo.
Parameters
----------
number : int
O número cujo fatorial será calculado.
Return
------
factorial : int
O valor do fatorial calulado.
| Calcula o fatorial de um número. | def recursive_factorial(number):
""" Calcula o fatorial de um número.
Realiza o cálculo do fatorial do número passado por parâmetro e o re-
torna. O fatorial de um número é dado pelo produto de todos os núme-
ros positivos menores ou iguais a esse número, excetuando-se 0, cujo
fatorial tem valor 1. Essa função utiliza uma abordagem recursiva
para a realização do cálculo.
Parameters
----------
number : int
O número cujo fatorial será calculado.
Return
------
factorial : int
O valor do fatorial calulado.
"""
assert (number >= 0) # Fatorial só pode ser calculado para não-negativos
if (number == 0):
return 1
else:
return (number * recursive_factorial(number - 1)) | [
"def",
"recursive_factorial",
"(",
"number",
")",
":",
"assert",
"(",
"number",
">=",
"0",
")",
"# Fatorial só pode ser calculado para não-negativos",
"if",
"(",
"number",
"==",
"0",
")",
":",
"return",
"1",
"else",
":",
"return",
"(",
"number",
"*",
"recursive_factorial",
"(",
"number",
"-",
"1",
")",
")"
] | [
29,
0
] | [
53,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
PackPOOII.popularidade | (self, arq_text, palavras) | return Counter(lista) | Retorna quantas vezes uma ou mais palavras aparecem em um arquivo de texto
Parametros
----------
arq_text : str
Nome do arquivo de texto, com a extenção
palavras : str
Palavras que se deseja obter
| Retorna quantas vezes uma ou mais palavras aparecem em um arquivo de texto | def popularidade(self, arq_text, palavras):
""" Retorna quantas vezes uma ou mais palavras aparecem em um arquivo de texto
Parametros
----------
arq_text : str
Nome do arquivo de texto, com a extenção
palavras : str
Palavras que se deseja obter
"""
palavras = palavras.lower().replace(',', '').split() # tirar virgulas
lista = []
with open(arq_text, "r") as f:
lines = f.readlines()
with open(arq_text, "r") as f:
for line in lines:
texto = line.lower().split()
for p in palavras:
for t in texto:
if p == t:
lista.append(t)
return Counter(lista) | [
"def",
"popularidade",
"(",
"self",
",",
"arq_text",
",",
"palavras",
")",
":",
"palavras",
"=",
"palavras",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"','",
",",
"''",
")",
".",
"split",
"(",
")",
"# tirar virgulas",
"lista",
"=",
"[",
"]",
"with",
"open",
"(",
"arq_text",
",",
"\"r\"",
")",
"as",
"f",
":",
"lines",
"=",
"f",
".",
"readlines",
"(",
")",
"with",
"open",
"(",
"arq_text",
",",
"\"r\"",
")",
"as",
"f",
":",
"for",
"line",
"in",
"lines",
":",
"texto",
"=",
"line",
".",
"lower",
"(",
")",
".",
"split",
"(",
")",
"for",
"p",
"in",
"palavras",
":",
"for",
"t",
"in",
"texto",
":",
"if",
"p",
"==",
"t",
":",
"lista",
".",
"append",
"(",
"t",
")",
"return",
"Counter",
"(",
"lista",
")"
] | [
45,
4
] | [
69,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
MainProgram.InitImages | (self) | Inicializa as variáveis de imagem utilizadas ao longo do programa.
O caminho relativo das imagens é passada para a função self.CreateImage.
| Inicializa as variáveis de imagem utilizadas ao longo do programa.
O caminho relativo das imagens é passada para a função self.CreateImage.
| def InitImages(self):
"""Inicializa as variáveis de imagem utilizadas ao longo do programa.
O caminho relativo das imagens é passada para a função self.CreateImage.
"""
# Side Button
self.homeButtonImage = self.CreateImage('img/btn/home.png')
self.tButtonImage = self.CreateImage('img/btn/btn-t.png')
self.LButtonImage = self.CreateImage('img/btn/btn-l.png')
self.uButtonImage = self.CreateImage('img/btn/btn-u.png')
self.cButtonImage = self.CreateImage('img/btn/btn-c.png')
self.iButtonImage = self.CreateImage('img/btn/btn-i.png')
self.hButtonImage = self.CreateImage('img/btn/btn-h.png')
self.infoButtonImage = self.CreateImage('img/btn/info-btn.png')
# Home Image
self.homeImage = self.CreateImage('img/general/img-home.png')
# Shapes Labels
self.tShapeImage = self.CreateImage('img/Shapes/section-t.png')
self.LShapeImage = self.CreateImage('img/Shapes/section-l.png')
self.uShapeImage = self.CreateImage('img/Shapes/section-u.png')
self.cShapeImage = self.CreateImage('img/Shapes/section-c.png')
self.iShapeImage = self.CreateImage('img/Shapes/section-i.png')
self.RomanIShapeImage = self.CreateImage('img/Shapes/section-h.png')
#Menu Buttons
self.CalculateImage = self.CreateImage('img/btn/calculate.png')
self.DiscardImage = self.CreateImage('img/btn/discard.png') | [
"def",
"InitImages",
"(",
"self",
")",
":",
"# Side Button",
"self",
".",
"homeButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/home.png'",
")",
"self",
".",
"tButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-t.png'",
")",
"self",
".",
"LButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-l.png'",
")",
"self",
".",
"uButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-u.png'",
")",
"self",
".",
"cButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-c.png'",
")",
"self",
".",
"iButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-i.png'",
")",
"self",
".",
"hButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/btn-h.png'",
")",
"self",
".",
"infoButtonImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/info-btn.png'",
")",
"# Home Image",
"self",
".",
"homeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/general/img-home.png'",
")",
"# Shapes Labels",
"self",
".",
"tShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-t.png'",
")",
"self",
".",
"LShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-l.png'",
")",
"self",
".",
"uShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-u.png'",
")",
"self",
".",
"cShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-c.png'",
")",
"self",
".",
"iShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-i.png'",
")",
"self",
".",
"RomanIShapeImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/Shapes/section-h.png'",
")",
"#Menu Buttons",
"self",
".",
"CalculateImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/calculate.png'",
")",
"self",
".",
"DiscardImage",
"=",
"self",
".",
"CreateImage",
"(",
"'img/btn/discard.png'",
")"
] | [
159,
4
] | [
188,
67
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Geladeira.add_comida | (self, comida, quantidade=1) | Adiciona uma determinada quantidade da Comida. | Adiciona uma determinada quantidade da Comida. | def add_comida(self, comida, quantidade=1):
"""Adiciona uma determinada quantidade da Comida."""
try:
self.alimentos[comida.nome][1] += quantidade
except KeyError:
self.alimentos[comida.nome] = [comida, quantidade] | [
"def",
"add_comida",
"(",
"self",
",",
"comida",
",",
"quantidade",
"=",
"1",
")",
":",
"try",
":",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]",
"[",
"1",
"]",
"+=",
"quantidade",
"except",
"KeyError",
":",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]",
"=",
"[",
"comida",
",",
"quantidade",
"]"
] | [
28,
4
] | [
33,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.insert | (self, i,*l) | Insere as linhas l antes do índice i dado
Os objetos de l deve ter o método .seguinte, caso algum não tenha, a continuidade da lista é cortada na sua posição
A precisão do corte se um objeto for diferente de None não é garantida
Caso i seja o bool True, insere depois da última linha (na lista circular é a verdadeira self.anterior())
Não há atualização implícita da lista ligada completa | Insere as linhas l antes do índice i dado
Os objetos de l deve ter o método .seguinte, caso algum não tenha, a continuidade da lista é cortada na sua posição
A precisão do corte se um objeto for diferente de None não é garantida
Caso i seja o bool True, insere depois da última linha (na lista circular é a verdadeira self.anterior())
Não há atualização implícita da lista ligada completa | def insert (self, i,*l):
'''Insere as linhas l antes do índice i dado
Os objetos de l deve ter o método .seguinte, caso algum não tenha, a continuidade da lista é cortada na sua posição
A precisão do corte se um objeto for diferente de None não é garantida
Caso i seja o bool True, insere depois da última linha (na lista circular é a verdadeira self.anterior())
Não há atualização implícita da lista ligada completa'''
seguinte = self
anterior = self.anterior()
while i < 0 and anterior != None:
i += 1
seguinte = anterior
anterior = anterior.anterior()
while i > 0 and seguinte != None:
if type(i) != bool:
i -= 1
elif self==seguinte:
break
anterior = seguinte
seguinte = seguinte.seguinte()
for ln in l:
try:
if seguinte != None: #essa redundância garante o corte da lista se ln.seguinte não existir/puder ser executado
seguinte.anterior(ln)
if anterior != None:
anterior.seguinte(ln)
ln.seguinte(seguinte)
except AttributeError:
pass
except:
warnings.warn('Ocorreu algum problema inesperado nas atribuições da sequência;')
anterior = ln
'''
refresh = self.list(refresh)
if i >= len(refresh):
i = len(refresh)
if i >= 0:
if i:
anterior = refresh[i-1]
anterior.seguinte(l)
self.list(refresh).insert(i,l)''' | [
"def",
"insert",
"(",
"self",
",",
"i",
",",
"*",
"l",
")",
":",
"seguinte",
"=",
"self",
"anterior",
"=",
"self",
".",
"anterior",
"(",
")",
"while",
"i",
"<",
"0",
"and",
"anterior",
"!=",
"None",
":",
"i",
"+=",
"1",
"seguinte",
"=",
"anterior",
"anterior",
"=",
"anterior",
".",
"anterior",
"(",
")",
"while",
"i",
">",
"0",
"and",
"seguinte",
"!=",
"None",
":",
"if",
"type",
"(",
"i",
")",
"!=",
"bool",
":",
"i",
"-=",
"1",
"elif",
"self",
"==",
"seguinte",
":",
"break",
"anterior",
"=",
"seguinte",
"seguinte",
"=",
"seguinte",
".",
"seguinte",
"(",
")",
"for",
"ln",
"in",
"l",
":",
"try",
":",
"if",
"seguinte",
"!=",
"None",
":",
"#essa redundância garante o corte da lista se ln.seguinte não existir/puder ser executado",
"seguinte",
".",
"anterior",
"(",
"ln",
")",
"if",
"anterior",
"!=",
"None",
":",
"anterior",
".",
"seguinte",
"(",
"ln",
")",
"ln",
".",
"seguinte",
"(",
"seguinte",
")",
"except",
"AttributeError",
":",
"pass",
"except",
":",
"warnings",
".",
"warn",
"(",
"'Ocorreu algum problema inesperado nas atribuições da sequência;')",
"",
"anterior",
"=",
"ln",
"'''\n\t\trefresh = self.list(refresh)\n\t\tif i >= len(refresh):\n\t\t\ti = len(refresh)\n\t\tif i >= 0:\n\t\t\tif i:\n\t\t\t\tanterior = refresh[i-1]\n\t\t\tanterior.seguinte(l)\n\t\tself.list(refresh).insert(i,l)'''"
] | [
224,
1
] | [
264,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
mount_journals_issues_link | (issues: List[dict]) | return journal_issues | Monta a relação entre os journals e suas issues.
Monta um dicionário na estrutura {"journal_id": ["issue_id"]}. Issues do
tipo ahead ou pressrelease não são consideradas. É utilizado o
campo v35 (issue) para obter o `journal_id` ao qual a issue deve ser relacionada.
:param issues: Lista contendo issues extraídas da base MST | Monta a relação entre os journals e suas issues. | def mount_journals_issues_link(issues: List[dict]) -> dict:
"""Monta a relação entre os journals e suas issues.
Monta um dicionário na estrutura {"journal_id": ["issue_id"]}. Issues do
tipo ahead ou pressrelease não são consideradas. É utilizado o
campo v35 (issue) para obter o `journal_id` ao qual a issue deve ser relacionada.
:param issues: Lista contendo issues extraídas da base MST"""
journal_issues = {}
issues = [Issue({"issue": data}) for data in issues]
issues = filter_issues(issues)
for issue in issues:
issue_to_link = issue_data_to_link(issue)
issue_to_link["order"] = issue.data["issue"]["v36"][0]["_"]
journal_id = issue.data.get("issue").get("v35")[0]["_"]
journal_issues.setdefault(journal_id, [])
if issue_to_link not in journal_issues[journal_id]:
journal_issues[journal_id].append(issue_to_link)
return journal_issues | [
"def",
"mount_journals_issues_link",
"(",
"issues",
":",
"List",
"[",
"dict",
"]",
")",
"->",
"dict",
":",
"journal_issues",
"=",
"{",
"}",
"issues",
"=",
"[",
"Issue",
"(",
"{",
"\"issue\"",
":",
"data",
"}",
")",
"for",
"data",
"in",
"issues",
"]",
"issues",
"=",
"filter_issues",
"(",
"issues",
")",
"for",
"issue",
"in",
"issues",
":",
"issue_to_link",
"=",
"issue_data_to_link",
"(",
"issue",
")",
"issue_to_link",
"[",
"\"order\"",
"]",
"=",
"issue",
".",
"data",
"[",
"\"issue\"",
"]",
"[",
"\"v36\"",
"]",
"[",
"0",
"]",
"[",
"\"_\"",
"]",
"journal_id",
"=",
"issue",
".",
"data",
".",
"get",
"(",
"\"issue\"",
")",
".",
"get",
"(",
"\"v35\"",
")",
"[",
"0",
"]",
"[",
"\"_\"",
"]",
"journal_issues",
".",
"setdefault",
"(",
"journal_id",
",",
"[",
"]",
")",
"if",
"issue_to_link",
"not",
"in",
"journal_issues",
"[",
"journal_id",
"]",
":",
"journal_issues",
"[",
"journal_id",
"]",
".",
"append",
"(",
"issue_to_link",
")",
"return",
"journal_issues"
] | [
370,
0
] | [
392,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
encontrar_repetidos | (jogadas) | return series | Recebe uma lista de jogadas e conta
quantas series de numeros adjacentes iguais
ocorrem nas faces dos dados jogados
list -> int | Recebe uma lista de jogadas e conta
quantas series de numeros adjacentes iguais
ocorrem nas faces dos dados jogados
list -> int | def encontrar_repetidos(jogadas):
""" Recebe uma lista de jogadas e conta
quantas series de numeros adjacentes iguais
ocorrem nas faces dos dados jogados
list -> int """
series = 0
inicio_serie = None
for i in range(len(jogadas)-1):
numero = jogadas[i]
prox_num = jogadas[i + 1]
if numero == prox_num:
if numero != inicio_serie:
inicio_serie = numero
series += 1
if numero != inicio_serie:
inicio_serie = numero
return series | [
"def",
"encontrar_repetidos",
"(",
"jogadas",
")",
":",
"series",
"=",
"0",
"inicio_serie",
"=",
"None",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"jogadas",
")",
"-",
"1",
")",
":",
"numero",
"=",
"jogadas",
"[",
"i",
"]",
"prox_num",
"=",
"jogadas",
"[",
"i",
"+",
"1",
"]",
"if",
"numero",
"==",
"prox_num",
":",
"if",
"numero",
"!=",
"inicio_serie",
":",
"inicio_serie",
"=",
"numero",
"series",
"+=",
"1",
"if",
"numero",
"!=",
"inicio_serie",
":",
"inicio_serie",
"=",
"numero",
"return",
"series"
] | [
31,
0
] | [
51,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TipoRedeResource.handle_post | (self, request, user, *args, **kwargs) | Trata as requisições de POST para criar tipos de rede.
URL: /tiporede/
| Trata as requisições de POST para criar tipos de rede. | def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para criar tipos de rede.
URL: /tiporede/
"""
# Obtém dados do request e verifica acesso
try:
# Verificar a permissão
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
# Obtém os dados do xml do request
xml_map, attrs_map = loads(request.raw_post_data)
# Obtém o mapa correspondente ao root node do mapa do XML
# (networkapi)
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.')
# Verifica a existência do node "tipo_rede"
tipo_rede_map = networkapi_map.get('tipo_rede')
if tipo_rede_map is None:
return self.response_error(3, u'Não existe valor para a tag tipo_rede do XML de requisição.')
# Verifica a existência do valor "fqdn"
nome = tipo_rede_map.get('nome')
if nome is None:
return self.response_error(176)
# Cria acesso ao equipamento conforme dados recebidos no XML
tipo_rede = TipoRede(tipo_rede=nome)
tipo_rede.create(user)
# Monta dict para response
networkapi_map = dict()
tipo_rede_map = dict()
tipo_rede_map['id'] = tipo_rede.id
networkapi_map['tipo_rede'] = tipo_rede_map
return self.response(dumps_networkapi(networkapi_map))
except TipoRedeNameDuplicatedError:
return self.response_error(253, nome)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
except (GrupoError, VlanError):
return self.response_error(1) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Obtém dados do request e verifica acesso",
"try",
":",
"# Verificar a permissão",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"NETWORK_TYPE_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"# Obtém os dados do xml do request",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"# Obtém o mapa correspondente ao root node do mapa do XML",
"# (networkapi)",
"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.')",
"",
"# Verifica a existência do node \"tipo_rede\"",
"tipo_rede_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'tipo_rede'",
")",
"if",
"tipo_rede_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag tipo_rede do XML de requisição.')",
"",
"# Verifica a existência do valor \"fqdn\"",
"nome",
"=",
"tipo_rede_map",
".",
"get",
"(",
"'nome'",
")",
"if",
"nome",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"176",
")",
"# Cria acesso ao equipamento conforme dados recebidos no XML",
"tipo_rede",
"=",
"TipoRede",
"(",
"tipo_rede",
"=",
"nome",
")",
"tipo_rede",
".",
"create",
"(",
"user",
")",
"# Monta dict para response",
"networkapi_map",
"=",
"dict",
"(",
")",
"tipo_rede_map",
"=",
"dict",
"(",
")",
"tipo_rede_map",
"[",
"'id'",
"]",
"=",
"tipo_rede",
".",
"id",
"networkapi_map",
"[",
"'tipo_rede'",
"]",
"=",
"tipo_rede_map",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"networkapi_map",
")",
")",
"except",
"TipoRedeNameDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"253",
",",
"nome",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisição.')",
"",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"except",
"(",
"GrupoError",
",",
"VlanError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
68,
4
] | [
118,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
enumerate_all | (variables, e, bn) | Retorna a soma dessas entradas em P (variáveis | e {outros})
Consistente com e, onde P é a distribuição conjunta representada
Por bn, e e (outros) significa e restrito a outras variáveis de bn
(Os que não sejam variáveis). Os pais devem preceder as crianças em variáveis. | Retorna a soma dessas entradas em P (variáveis | e {outros})
Consistente com e, onde P é a distribuição conjunta representada
Por bn, e e (outros) significa e restrito a outras variáveis de bn
(Os que não sejam variáveis). Os pais devem preceder as crianças em variáveis. | def enumerate_all(variables, e, bn):
"""Retorna a soma dessas entradas em P (variáveis | e {outros})
Consistente com e, onde P é a distribuição conjunta representada
Por bn, e e (outros) significa e restrito a outras variáveis de bn
(Os que não sejam variáveis). Os pais devem preceder as crianças em variáveis."""
if not variables:
return 1.0
Y, rest = variables[0], variables[1:]
Ynode = bn.variable_node(Y)
if Y in e:
return Ynode.p(e[Y], e) * enumerate_all(rest, e, bn)
else:
return sum(
Ynode.p(y, e) * enumerate_all(rest, extend(e, Y, y), bn)
for y in bn.variable_values(Y)
) | [
"def",
"enumerate_all",
"(",
"variables",
",",
"e",
",",
"bn",
")",
":",
"if",
"not",
"variables",
":",
"return",
"1.0",
"Y",
",",
"rest",
"=",
"variables",
"[",
"0",
"]",
",",
"variables",
"[",
"1",
":",
"]",
"Ynode",
"=",
"bn",
".",
"variable_node",
"(",
"Y",
")",
"if",
"Y",
"in",
"e",
":",
"return",
"Ynode",
".",
"p",
"(",
"e",
"[",
"Y",
"]",
",",
"e",
")",
"*",
"enumerate_all",
"(",
"rest",
",",
"e",
",",
"bn",
")",
"else",
":",
"return",
"sum",
"(",
"Ynode",
".",
"p",
"(",
"y",
",",
"e",
")",
"*",
"enumerate_all",
"(",
"rest",
",",
"extend",
"(",
"e",
",",
"Y",
",",
"y",
")",
",",
"bn",
")",
"for",
"y",
"in",
"bn",
".",
"variable_values",
"(",
"Y",
")",
")"
] | [
289,
0
] | [
304,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Bullet.draw_bullet | (self) | Desenho o objeto do projétil na tela | Desenho o objeto do projétil na tela | def draw_bullet(self):
"""Desenho o objeto do projétil na tela"""
pygame.draw.rect(self.screen, self.color, self.rect) | [
"def",
"draw_bullet",
"(",
"self",
")",
":",
"pygame",
".",
"draw",
".",
"rect",
"(",
"self",
".",
"screen",
",",
"self",
".",
"color",
",",
"self",
".",
"rect",
")"
] | [
29,
4
] | [
31,
60
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MinhaUFOP.atestado | (self, **kwargs) | Retorna as matérias do usuário em blocos de 50 minutos.
Kwargs:
url (str): URL para fazer a requisição ao servidor
headers (dict): Headers da requisição ao servidor
Raises:
MinhaUFOPHTTPError: O servidor retornou o código {código HTTP}
| Retorna as matérias do usuário em blocos de 50 minutos. | def atestado(self, **kwargs) -> dict:
"""Retorna as matérias do usuário em blocos de 50 minutos.
Kwargs:
url (str): URL para fazer a requisição ao servidor
headers (dict): Headers da requisição ao servidor
Raises:
MinhaUFOPHTTPError: O servidor retornou o código {código HTTP}
"""
url = kwargs.get('url',
f"https://zeppelin10.ufop.br/api/v1/graduacao/alunos/atestado")
headers = kwargs.get('headers',
{'Authorization': f'Bearer {self.token}'})
response = requests.request("GET", url, headers=headers)
if response.ok:
return response.json()
else:
raise MinhaUFOPHTTPError(response) | [
"def",
"atestado",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
"->",
"dict",
":",
"url",
"=",
"kwargs",
".",
"get",
"(",
"'url'",
",",
"f\"https://zeppelin10.ufop.br/api/v1/graduacao/alunos/atestado\"",
")",
"headers",
"=",
"kwargs",
".",
"get",
"(",
"'headers'",
",",
"{",
"'Authorization'",
":",
"f'Bearer {self.token}'",
"}",
")",
"response",
"=",
"requests",
".",
"request",
"(",
"\"GET\"",
",",
"url",
",",
"headers",
"=",
"headers",
")",
"if",
"response",
".",
"ok",
":",
"return",
"response",
".",
"json",
"(",
")",
"else",
":",
"raise",
"MinhaUFOPHTTPError",
"(",
"response",
")"
] | [
170,
4
] | [
192,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
say_help | (message) | return 'Não entendi o pedido. \n Digite help para uma lista de comandos.' | Se comando não reconhecido | Se comando não reconhecido | def say_help(message):
'''Se comando não reconhecido'''
return 'Não entendi o pedido. \n Digite help para uma lista de comandos.' | [
"def",
"say_help",
"(",
"message",
")",
":",
"return",
"'Não entendi o pedido. \\n Digite help para uma lista de comandos.'"
] | [
41,
0
] | [
43,
78
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DistanceSensor._callback | (self, data) | Função de callback necessária para inicializar o subscriber
Args:
data (sensor_msgs.msg.Range): Dados da leitura do sensor
| Função de callback necessária para inicializar o subscriber | def _callback(self, data):
"""Função de callback necessária para inicializar o subscriber
Args:
data (sensor_msgs.msg.Range): Dados da leitura do sensor
"""
self.range = data.range
self.max_range = data.max_range
self.min_range = data.min_range | [
"def",
"_callback",
"(",
"self",
",",
"data",
")",
":",
"self",
".",
"range",
"=",
"data",
".",
"range",
"self",
".",
"max_range",
"=",
"data",
".",
"max_range",
"self",
".",
"min_range",
"=",
"data",
".",
"min_range"
] | [
21,
4
] | [
29,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Subnet.ip_calculator | (self) | Calcula todos os endereços possiveis no CIDR e adiciona na fila de redes válidas disponiveis. | Calcula todos os endereços possiveis no CIDR e adiciona na fila de redes válidas disponiveis. | def ip_calculator(self):
""" Calcula todos os endereços possiveis no CIDR e adiciona na fila de redes válidas disponiveis."""
host_itter = self.network_obj.hosts()
for host in host_itter:
self.subnet_queue.push(host) | [
"def",
"ip_calculator",
"(",
"self",
")",
":",
"host_itter",
"=",
"self",
".",
"network_obj",
".",
"hosts",
"(",
")",
"for",
"host",
"in",
"host_itter",
":",
"self",
".",
"subnet_queue",
".",
"push",
"(",
"host",
")"
] | [
24,
4
] | [
30,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ScoreBoard.show_score | (self) | Desenha a pontuacao na tela. | Desenha a pontuacao na tela. | def show_score(self):
"""Desenha a pontuacao na tela."""
self.screen.blit(self.score_image, self.score_rect)
self.screen.blit(self.high_score_image, self.high_score_rect)
self.screen.blit(self.level_image, self.level_rect)
# Desenha as espaconaves
self.ships.draw(self.screen) | [
"def",
"show_score",
"(",
"self",
")",
":",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"score_image",
",",
"self",
".",
"score_rect",
")",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"high_score_image",
",",
"self",
".",
"high_score_rect",
")",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"level_image",
",",
"self",
".",
"level_rect",
")",
"# Desenha as espaconaves",
"self",
".",
"ships",
".",
"draw",
"(",
"self",
".",
"screen",
")"
] | [
77,
4
] | [
84,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_amount_users | () | return User.objects.count() | Retorne a quantidade total de usuarios do sistema | Retorne a quantidade total de usuarios do sistema | def get_amount_users() -> User:
"""Retorne a quantidade total de usuarios do sistema """
return User.objects.count() | [
"def",
"get_amount_users",
"(",
")",
"->",
"User",
":",
"return",
"User",
".",
"objects",
".",
"count",
"(",
")"
] | [
15,
0
] | [
17,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
relex | (ctx, extension: str) | Recarrega uma extensão. | Recarrega uma extensão. | async def relex(ctx, extension: str):
"""Recarrega uma extensão."""
try:
client.reload_extension(f"ext.{extension}")
except commands.ExtensionNotLoaded as ex:
await ctx.reply(f"A extensão `{ex.name}` não foi carregada ou não existe.")
return
await ctx.reply("Extensão recarregada :+1:")
| [
"async",
"def",
"relex",
"(",
"ctx",
",",
"extension",
":",
"str",
")",
":",
"try",
":",
"client",
".",
"reload_extension",
"(",
"f\"ext.{extension}\"",
")",
"except",
"commands",
".",
"ExtensionNotLoaded",
"as",
"ex",
":",
"await",
"ctx",
".",
"reply",
"(",
"f\"A extensão `{ex.name}` não foi carregada ou não existe.\")\r",
"",
"return",
"await",
"ctx",
".",
"reply",
"(",
"\"Extensão recarregada :+1:\")",
"\r"
] | [
445,
0
] | [
452,
49
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GrupoEquipamentoAssociaEquipamentoResource.handle_post | (self, request, user, *args, **kwargs) | Trata uma requisicao POST para inserir um associao entre grupo de equipamento e equipamento.
URL: equipmentogrupo/associa
| Trata uma requisicao POST para inserir um associao entre grupo de equipamento e equipamento. | def handle_post(self, request, user, *args, **kwargs):
"""Trata uma requisicao POST para inserir um associao entre grupo de equipamento e equipamento.
URL: equipmentogrupo/associa
"""
try:
# Load XML data
xml_map, attrs_map = loads(request.raw_post_data)
# XML data format
networkapi_map = xml_map.get('networkapi')
if networkapi_map is None:
msg = u'There is no value to the networkapi tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
equip_map = networkapi_map.get('equipamento_grupo')
if equip_map is None:
msg = u'There is no value to the ip tag of XML request.'
self.log.error(msg)
return self.response_error(3, msg)
# Get XML data
equip_id = equip_map.get('id_equipamento')
id_grupo = equip_map.get('id_grupo')
# Valid equip_id
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'Parameter equip_id is invalid. Value: %s.', equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
# Valid id_modelo
if not is_valid_int_greater_zero_param(id_grupo):
self.log.error(
u'Parameter id_grupo is invalid. Value: %s.', id_grupo)
raise InvalidValueError(None, 'id_modelo', id_grupo)
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
id_grupo,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None, u'User does not have permission to perform the operation.')
# Business Rules
# New IP
equip = Equipamento()
equip = equip.get_by_pk(equip_id)
egrupo = EGrupo.get_by_pk(id_grupo)
tipo_equipamento = TipoEquipamento()
try:
if ((int(egrupo.GRUPO_EQUIPAMENTO_ORQUESTRACAO) == int(id_grupo)) and (int(equip.tipo_equipamento.id) != int(tipo_equipamento.TIPO_EQUIPAMENTO_SERVIDOR_VIRTUAL))):
raise EquipamentoError(
None, "Equipamentos que não sejam do tipo 'Servidor Virtual' não podem fazer parte do grupo 'Equipamentos Orquestração'.")
except EquipamentoError, e:
return self.response_error(150, e.message)
equipamento_grupo = EquipamentoGrupo()
equipamento_grupo.egrupo = egrupo
equipamento_grupo.equipamento = equip
equipamento_grupo.create(user)
map = dict()
map['id'] = equipamento_grupo.id
map_return = dict()
lista = []
lista.append(map)
map_return['grupo'] = lista
return self.response(dumps_networkapi(map_return))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except UserNotAuthorizedError:
return self.not_authorized()
except TipoEquipamentoNotFoundError, e:
return self.response_error(150, e.message)
except ModeloNotFoundError, e:
return self.response_error(150, e.message)
except EquipamentoNotFoundError, e:
return self.response_error(117, equip_id)
except EquipamentoNameDuplicatedError, e:
return self.response_error(e.message)
except EquipamentoError, e:
return self.response_error(150, e.message)
except XMLError, x:
self.log.error(u'Error reading the XML request.')
return self.response_error(3, x) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"# Load XML data",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"# XML data format",
"networkapi_map",
"=",
"xml_map",
".",
"get",
"(",
"'networkapi'",
")",
"if",
"networkapi_map",
"is",
"None",
":",
"msg",
"=",
"u'There is no value to the networkapi tag of XML request.'",
"self",
".",
"log",
".",
"error",
"(",
"msg",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"msg",
")",
"equip_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'equipamento_grupo'",
")",
"if",
"equip_map",
"is",
"None",
":",
"msg",
"=",
"u'There is no value to the ip tag of XML request.'",
"self",
".",
"log",
".",
"error",
"(",
"msg",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"msg",
")",
"# Get XML data",
"equip_id",
"=",
"equip_map",
".",
"get",
"(",
"'id_equipamento'",
")",
"id_grupo",
"=",
"equip_map",
".",
"get",
"(",
"'id_grupo'",
")",
"# Valid equip_id",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Parameter equip_id is invalid. Value: %s.'",
",",
"equip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equip_id'",
",",
"equip_id",
")",
"# Valid id_modelo",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"id_grupo",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Parameter id_grupo is invalid. Value: %s.'",
",",
"id_grupo",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'id_modelo'",
",",
"id_grupo",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"id_grupo",
",",
"equip_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"raise",
"UserNotAuthorizedError",
"(",
"None",
",",
"u'User does not have permission to perform the operation.'",
")",
"# Business Rules",
"# New IP",
"equip",
"=",
"Equipamento",
"(",
")",
"equip",
"=",
"equip",
".",
"get_by_pk",
"(",
"equip_id",
")",
"egrupo",
"=",
"EGrupo",
".",
"get_by_pk",
"(",
"id_grupo",
")",
"tipo_equipamento",
"=",
"TipoEquipamento",
"(",
")",
"try",
":",
"if",
"(",
"(",
"int",
"(",
"egrupo",
".",
"GRUPO_EQUIPAMENTO_ORQUESTRACAO",
")",
"==",
"int",
"(",
"id_grupo",
")",
")",
"and",
"(",
"int",
"(",
"equip",
".",
"tipo_equipamento",
".",
"id",
")",
"!=",
"int",
"(",
"tipo_equipamento",
".",
"TIPO_EQUIPAMENTO_SERVIDOR_VIRTUAL",
")",
")",
")",
":",
"raise",
"EquipamentoError",
"(",
"None",
",",
"\"Equipamentos que não sejam do tipo 'Servidor Virtual' não podem fazer parte do grupo 'Equipamentos Orquestração'.\")",
"",
"except",
"EquipamentoError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"150",
",",
"e",
".",
"message",
")",
"equipamento_grupo",
"=",
"EquipamentoGrupo",
"(",
")",
"equipamento_grupo",
".",
"egrupo",
"=",
"egrupo",
"equipamento_grupo",
".",
"equipamento",
"=",
"equip",
"equipamento_grupo",
".",
"create",
"(",
"user",
")",
"map",
"=",
"dict",
"(",
")",
"map",
"[",
"'id'",
"]",
"=",
"equipamento_grupo",
".",
"id",
"map_return",
"=",
"dict",
"(",
")",
"lista",
"=",
"[",
"]",
"lista",
".",
"append",
"(",
"map",
")",
"map_return",
"[",
"'grupo'",
"]",
"=",
"lista",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"map_return",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"UserNotAuthorizedError",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"TipoEquipamentoNotFoundError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"150",
",",
"e",
".",
"message",
")",
"except",
"ModeloNotFoundError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"150",
",",
"e",
".",
"message",
")",
"except",
"EquipamentoNotFoundError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equip_id",
")",
"except",
"EquipamentoNameDuplicatedError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"e",
".",
"message",
")",
"except",
"EquipamentoError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"150",
",",
"e",
".",
"message",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Error reading the XML request.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")"
] | [
38,
4
] | [
130,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
contar_caracteres | (s) | Função que conta os caracteres de uma string
Ex:
>>> contar_caracteres('renzo')
e: 1
n: 1
o: 1
r: 1
z: 1
>>> contar_caracteres('banana')
a: 3
b: 1
n: 2
:param s: string a ser contada
| Função que conta os caracteres de uma string | def contar_caracteres(s):
"""Função que conta os caracteres de uma string
Ex:
>>> contar_caracteres('renzo')
e: 1
n: 1
o: 1
r: 1
z: 1
>>> contar_caracteres('banana')
a: 3
b: 1
n: 2
:param s: string a ser contada
"""
caracteres_ordenados = sorted(s)
caracter_anterior = caracteres_ordenados[0]
contagem = 1
for caracter in caracteres_ordenados[1:]:
if caracter == caracter_anterior:
contagem += 1
else:
print(f"{caracter_anterior}: {contagem}")
caracter_anterior = caracter
contagem = 1
print(f'{caracter_anterior}: {contagem}') | [
"def",
"contar_caracteres",
"(",
"s",
")",
":",
"caracteres_ordenados",
"=",
"sorted",
"(",
"s",
")",
"caracter_anterior",
"=",
"caracteres_ordenados",
"[",
"0",
"]",
"contagem",
"=",
"1",
"for",
"caracter",
"in",
"caracteres_ordenados",
"[",
"1",
":",
"]",
":",
"if",
"caracter",
"==",
"caracter_anterior",
":",
"contagem",
"+=",
"1",
"else",
":",
"print",
"(",
"f\"{caracter_anterior}: {contagem}\"",
")",
"caracter_anterior",
"=",
"caracter",
"contagem",
"=",
"1",
"print",
"(",
"f'{caracter_anterior}: {contagem}'",
")"
] | [
5,
0
] | [
36,
45
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType63.frequencies | (self) | return np.linspace(
self.start_mega, self.stop_mega, num=self.ndata, dtype=np.float32
) | Retorna um numpy array com a faixa de frequências presentes no bloco | Retorna um numpy array com a faixa de frequências presentes no bloco | def frequencies(self) -> np.ndarray:
"""Retorna um numpy array com a faixa de frequências presentes no bloco"""
return np.linspace(
self.start_mega, self.stop_mega, num=self.ndata, dtype=np.float32
) | [
"def",
"frequencies",
"(",
"self",
")",
"->",
"np",
".",
"ndarray",
":",
"return",
"np",
".",
"linspace",
"(",
"self",
".",
"start_mega",
",",
"self",
".",
"stop_mega",
",",
"num",
"=",
"self",
".",
"ndata",
",",
"dtype",
"=",
"np",
".",
"float32",
")"
] | [
1127,
4
] | [
1131,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
NetworkData.get_global_name | (cls) | return _global_name | Retorna somente os itens de nome de um router específico. | Retorna somente os itens de nome de um router específico. | def get_global_name(cls):
""" Retorna somente os itens de nome de um router específico. """
_global_name = []
_globals = NetworkData.get_global_network()
for line in _globals:
_global_name.append(line['scope_name'])
return _global_name | [
"def",
"get_global_name",
"(",
"cls",
")",
":",
"_global_name",
"=",
"[",
"]",
"_globals",
"=",
"NetworkData",
".",
"get_global_network",
"(",
")",
"for",
"line",
"in",
"_globals",
":",
"_global_name",
".",
"append",
"(",
"line",
"[",
"'scope_name'",
"]",
")",
"return",
"_global_name"
] | [
80,
4
] | [
89,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
EquipamentoGrupoResource.handle_post | (self, request, user, *args, **kwargs) | return self.insert_equipment_group(equip_id, group_id, user) | Trata as requisições de POST para inserir um equipamento_grupo.
URL: equipamentogrupo/
| Trata as requisições de POST para inserir um equipamento_grupo. | def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para inserir um equipamento_grupo.
URL: equipamentogrupo/
"""
# verifica parametros
try:
xml_map, attrs_map = loads(request.raw_post_data)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
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_group_map = networkapi_map.get('equipamento_grupo')
if equipment_group_map is None:
return self.response_error(3, u'Não existe valor para a tag equipamento_grupo do XML de requisição.')
self.log.debug('EGROUP_MAP: %s', equipment_group_map)
# equip_id = equipment_group_map.get('id_equipamento')
# if not is_valid_int_greater_zero_param(equip_id):
# self.log.error(u'The equip_id parameter is not a valid value: %s.', equip_id)
# raise InvalidValueError(None, 'equip_id', equip_id)
# try:
# equip_id = int(equip_id)
# except (TypeError, ValueError):
# self.log.error(u'Valor do id_equipamento inválido: %s.', equip_id)
# return self.response_error(117, equip_id)
#
# group_id = equipment_group_map.get('id_grupo')
# if not is_valid_int_greater_zero_param(group_id):
# self.log.error(u'The group_id parameter is not a valid value: %s.', group_id)
# raise InvalidValueError(None, 'group_id', group_id)
# try:
# group_id = int(group_id)
# except (TypeError, ValueError):
# self.log.error(u'Valor do id_grupo inválido: %s.', group_id)
# return self.response_error(102)
# verifica permissao e se o equipamento está cadastrado
try:
equip_id = equipment_group_map.get('id_equipamento')
if not is_valid_int_greater_zero_param(equip_id):
self.log.error(
u'The equip_id parameter is not a valid value: %s.', equip_id)
raise InvalidValueError(None, 'equip_id', equip_id)
else:
equip_id = int(equip_id)
group_id = equipment_group_map.get('id_grupo')
if not is_valid_int_greater_zero_param(group_id):
self.log.error(
u'The group_id parameter is not a valid value: %s.', group_id)
raise InvalidValueError(None, 'group_id', group_id)
else:
equip_id = int(equip_id)
if not has_perm(user,
AdminPermission.EQUIPMENT_MANAGEMENT,
AdminPermission.WRITE_OPERATION,
None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
return self.not_authorized()
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EquipamentoNotFoundError:
return self.response_error(117, equip_id)
except (EquipamentoError, GrupoError):
return self.response_error(1)
return self.insert_equipment_group(equip_id, group_id, user) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# verifica parametros",
"try",
":",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisição.')",
"",
"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_group_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'equipamento_grupo'",
")",
"if",
"equipment_group_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag equipamento_grupo do XML de requisição.')",
"",
"self",
".",
"log",
".",
"debug",
"(",
"'EGROUP_MAP: %s'",
",",
"equipment_group_map",
")",
"# equip_id = equipment_group_map.get('id_equipamento')",
"# if not is_valid_int_greater_zero_param(equip_id):",
"# self.log.error(u'The equip_id parameter is not a valid value: %s.', equip_id)",
"# raise InvalidValueError(None, 'equip_id', equip_id)",
"# try:",
"# equip_id = int(equip_id)",
"# except (TypeError, ValueError):",
"# self.log.error(u'Valor do id_equipamento inválido: %s.', equip_id)",
"# return self.response_error(117, equip_id)",
"#",
"# group_id = equipment_group_map.get('id_grupo')",
"# if not is_valid_int_greater_zero_param(group_id):",
"# self.log.error(u'The group_id parameter is not a valid value: %s.', group_id)",
"# raise InvalidValueError(None, 'group_id', group_id)",
"# try:",
"# group_id = int(group_id)",
"# except (TypeError, ValueError):",
"# self.log.error(u'Valor do id_grupo inválido: %s.', group_id)",
"# return self.response_error(102)",
"# verifica permissao e se o equipamento está cadastrado",
"try",
":",
"equip_id",
"=",
"equipment_group_map",
".",
"get",
"(",
"'id_equipamento'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equip_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The equip_id parameter is not a valid value: %s.'",
",",
"equip_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'equip_id'",
",",
"equip_id",
")",
"else",
":",
"equip_id",
"=",
"int",
"(",
"equip_id",
")",
"group_id",
"=",
"equipment_group_map",
".",
"get",
"(",
"'id_grupo'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"group_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The group_id parameter is not a valid value: %s.'",
",",
"group_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'group_id'",
",",
"group_id",
")",
"else",
":",
"equip_id",
"=",
"int",
"(",
"equip_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"equip_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EquipamentoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"117",
",",
"equip_id",
")",
"except",
"(",
"EquipamentoError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")",
"return",
"self",
".",
"insert_equipment_group",
"(",
"equip_id",
",",
"group_id",
",",
"user",
")"
] | [
47,
4
] | [
125,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_event_id | (event_url) | Extrai número do evento com base em seu URL. | Extrai número do evento com base em seu URL. | def get_event_id(event_url):
"""Extrai número do evento com base em seu URL."""
pass | [
"def",
"get_event_id",
"(",
"event_url",
")",
":",
"pass"
] | [
20,
0
] | [
22,
8
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Car.increment_odometer | (self, miles) | return self.odometer_reading | Atualiza o valor do odômetro do veículo. | Atualiza o valor do odômetro do veículo. | def increment_odometer(self, miles):
"""Atualiza o valor do odômetro do veículo."""
self.odometer_reading += miles
return self.odometer_reading | [
"def",
"increment_odometer",
"(",
"self",
",",
"miles",
")",
":",
"self",
".",
"odometer_reading",
"+=",
"miles",
"return",
"self",
".",
"odometer_reading"
] | [
35,
4
] | [
38,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Bullet.__init__ | (self, ai_settings, screen, ship) | Cria um objeto para o projetil na posição atual da espaçonave | Cria um objeto para o projetil na posição atual da espaçonave | def __init__(self, ai_settings, screen, ship):
"""Cria um objeto para o projetil na posição atual da espaçonave"""
super().__init__()
self.screen = screen
# Cria um retângulo para o projétil em (0, 0) e, em seguida define a posição correta.
self.rect = pygame.Rect(0, 0, ai_settings.bullet_width, ai_settings.bullet_height)
self.rect.centerx = ship.rect.centerx
self.rect.top = ship.rect.top
# Armazena a posição do projétil como um valor decimal
self.y = float(self.rect.y)
self.color = ai_settings.bullet_color
self.speed_factor = ai_settings.bullet_speed_factor | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
",",
"ship",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
")",
"self",
".",
"screen",
"=",
"screen",
"# Cria um retângulo para o projétil em (0, 0) e, em seguida define a posição correta.",
"self",
".",
"rect",
"=",
"pygame",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"ai_settings",
".",
"bullet_width",
",",
"ai_settings",
".",
"bullet_height",
")",
"self",
".",
"rect",
".",
"centerx",
"=",
"ship",
".",
"rect",
".",
"centerx",
"self",
".",
"rect",
".",
"top",
"=",
"ship",
".",
"rect",
".",
"top",
"# Armazena a posição do projétil como um valor decimal",
"self",
".",
"y",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"y",
")",
"self",
".",
"color",
"=",
"ai_settings",
".",
"bullet_color",
"self",
".",
"speed_factor",
"=",
"ai_settings",
".",
"bullet_speed_factor"
] | [
6,
4
] | [
20,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GrupoEquipamentoResource.handle_delete | (self, request, user, *args, **kwargs) | Trata as requisições de DELETE para remover um grupo de equipamento.
URL: egrupo/<id_grupo>/
| Trata as requisições de DELETE para remover um grupo de equipamento. | def handle_delete(self, request, user, *args, **kwargs):
"""Trata as requisições de DELETE para remover um grupo de equipamento.
URL: egrupo/<id_grupo>/
"""
try:
egroup_id = kwargs.get('id_grupo')
if not is_valid_int_greater_zero_param(egroup_id):
self.log.error(
u'The egroup_id parameter is not a valid value: %s.', egroup_id)
raise InvalidValueError(None, 'egroup_id', egroup_id)
egrp = EGrupo.get_by_pk(egroup_id)
if not has_perm(user, AdminPermission.EQUIPMENT_GROUP_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
with distributedlock(LOCK_GROUP_EQUIPMENT % egroup_id):
EGrupo.remove(user, egroup_id)
return self.response(dumps_networkapi({}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except GroupDontRemoveError, e:
return self.response_error(310, e.cause, e.message)
except EGrupoNotFoundError:
return self.response_error(102)
except GrupoError:
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"egroup_id",
"=",
"kwargs",
".",
"get",
"(",
"'id_grupo'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"egroup_id",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'The egroup_id parameter is not a valid value: %s.'",
",",
"egroup_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'egroup_id'",
",",
"egroup_id",
")",
"egrp",
"=",
"EGrupo",
".",
"get_by_pk",
"(",
"egroup_id",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_GROUP_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"with",
"distributedlock",
"(",
"LOCK_GROUP_EQUIPMENT",
"%",
"egroup_id",
")",
":",
"EGrupo",
".",
"remove",
"(",
"user",
",",
"egroup_id",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"GroupDontRemoveError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"310",
",",
"e",
".",
"cause",
",",
"e",
".",
"message",
")",
"except",
"EGrupoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"102",
")",
"except",
"GrupoError",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
163,
4
] | [
192,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
assert_response_success | (response, status_code=200, codigo=0, stdout=None, stderr=None) | Verifica se a resposta da networkapi foi sucesso e com os valores informados | Verifica se a resposta da networkapi foi sucesso e com os valores informados | def assert_response_success(response, status_code=200, codigo=0, stdout=None, stderr=None):
""" Verifica se a resposta da networkapi foi sucesso e com os valores informados """
try:
assert response.status_code == status_code
networkapi_response = xml2dict(response.content)
codigo_resposta = int(networkapi_response['sucesso']['codigo'])
assert codigo_resposta == codigo, u"Código de resposta inválido: %d. Esperado: %d" % (
codigo_resposta, codigo)
if stdout:
assert networkapi_response['sucesso'][
'descricao']['stdout'] == stdout
if stderr:
assert networkapi_response['sucesso'][
'descricao']['stderr'] == stderr
except:
# Se houver algum erro na formação (parsing) da resposta, imprimo qual
# ela era para facilitar a investigação
log.error("Erro fazendo parsing da resposta:\n%s\n",
(response or response.content))
raise | [
"def",
"assert_response_success",
"(",
"response",
",",
"status_code",
"=",
"200",
",",
"codigo",
"=",
"0",
",",
"stdout",
"=",
"None",
",",
"stderr",
"=",
"None",
")",
":",
"try",
":",
"assert",
"response",
".",
"status_code",
"==",
"status_code",
"networkapi_response",
"=",
"xml2dict",
"(",
"response",
".",
"content",
")",
"codigo_resposta",
"=",
"int",
"(",
"networkapi_response",
"[",
"'sucesso'",
"]",
"[",
"'codigo'",
"]",
")",
"assert",
"codigo_resposta",
"==",
"codigo",
",",
"u\"Código de resposta inválido: %d. Esperado: %d\" %",
"(",
"",
"codigo_resposta",
",",
"codigo",
")",
"if",
"stdout",
":",
"assert",
"networkapi_response",
"[",
"'sucesso'",
"]",
"[",
"'descricao'",
"]",
"[",
"'stdout'",
"]",
"==",
"stdout",
"if",
"stderr",
":",
"assert",
"networkapi_response",
"[",
"'sucesso'",
"]",
"[",
"'descricao'",
"]",
"[",
"'stderr'",
"]",
"==",
"stderr",
"except",
":",
"# Se houver algum erro na formação (parsing) da resposta, imprimo qual",
"# ela era para facilitar a investigação",
"log",
".",
"error",
"(",
"\"Erro fazendo parsing da resposta:\\n%s\\n\"",
",",
"(",
"response",
"or",
"response",
".",
"content",
")",
")",
"raise"
] | [
44,
0
] | [
65,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestePesquisaAnonima.test_tres_respostas | (self) | Testa se três respostas individuáis são armazenadas de
forma apropriada. | Testa se três respostas individuáis são armazenadas de
forma apropriada. | def test_tres_respostas(self):
"""Testa se três respostas individuáis são armazenadas de
forma apropriada."""
for resposta in self.respostas:
self.minha_pesquisa.conjunto_respostas(
nova_resposta=resposta
)
for resposta in self.respostas:
self.assertIn(resposta, self.minha_pesquisa.respostas) | [
"def",
"test_tres_respostas",
"(",
"self",
")",
":",
"for",
"resposta",
"in",
"self",
".",
"respostas",
":",
"self",
".",
"minha_pesquisa",
".",
"conjunto_respostas",
"(",
"nova_resposta",
"=",
"resposta",
")",
"for",
"resposta",
"in",
"self",
".",
"respostas",
":",
"self",
".",
"assertIn",
"(",
"resposta",
",",
"self",
".",
"minha_pesquisa",
".",
"respostas",
")"
] | [
26,
4
] | [
34,
66
] | 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.