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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
selection_sort | (values) | Ordena uma lista, em ordem crescente, usando o Selection Sort.
O Selection Sort é, consideravelmente mais intuitivo que o Bubble
Sort, possuindo eficiência muito semelhante. A estratégia utilizada
para a ordenação consiste em selecionar, a cada iteração, o N-ésimo
menor valor e inserí-lo na posição correta da lista. Desse modo, a
lista de tamanho N estará completamente ordenada após N iterações.
Parameters
----------
values : list
A lista que deve ser ordenada
| Ordena uma lista, em ordem crescente, usando o Selection Sort. | def selection_sort(values):
""" Ordena uma lista, em ordem crescente, usando o Selection Sort.
O Selection Sort é, consideravelmente mais intuitivo que o Bubble
Sort, possuindo eficiência muito semelhante. A estratégia utilizada
para a ordenação consiste em selecionar, a cada iteração, o N-ésimo
menor valor e inserí-lo na posição correta da lista. Desse modo, a
lista de tamanho N estará completamente ordenada após N iterações.
Parameters
----------
values : list
A lista que deve ser ordenada
"""
for i in range(len(values)):
n = i
for j in range(i,len(values)):
if values[j] < values[n]:
n = j
values[i], values[n] = values[n], values[i] | [
"def",
"selection_sort",
"(",
"values",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"values",
")",
")",
":",
"n",
"=",
"i",
"for",
"j",
"in",
"range",
"(",
"i",
",",
"len",
"(",
"values",
")",
")",
":",
"if",
"values",
"[",
"j",
"]",
"<",
"values",
"[",
"n",
"]",
":",
"n",
"=",
"j",
"values",
"[",
"i",
"]",
",",
"values",
"[",
"n",
"]",
"=",
"values",
"[",
"n",
"]",
",",
"values",
"[",
"i",
"]"
] | [
30,
0
] | [
49,
51
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurant.increment_number | (self, clientes) | Define o valor atualizado do atributo number_served. | Define o valor atualizado do atributo number_served. | def increment_number(self, clientes):
"""Define o valor atualizado do atributo number_served."""
self.number_served += clientes | [
"def",
"increment_number",
"(",
"self",
",",
"clientes",
")",
":",
"self",
".",
"number_served",
"+=",
"clientes"
] | [
55,
4
] | [
57,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Stack.pop | (self) | Removendo o elemento do topo da pilha | Removendo o elemento do topo da pilha | def pop(self):
""" Removendo o elemento do topo da pilha"""
if self._size > 0:
node = self.top
self.top = self.top.next
self._size = self._size - 1
return node.data
raise IndexError('The stack is empty!') | [
"def",
"pop",
"(",
"self",
")",
":",
"if",
"self",
".",
"_size",
">",
"0",
":",
"node",
"=",
"self",
".",
"top",
"self",
".",
"top",
"=",
"self",
".",
"top",
".",
"next",
"self",
".",
"_size",
"=",
"self",
".",
"_size",
"-",
"1",
"return",
"node",
".",
"data",
"raise",
"IndexError",
"(",
"'The stack is empty!'",
")"
] | [
14,
4
] | [
21,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
UndirectedGraph.has_edge | (self, v, w) | return (w in self.get(v)) and (v in self.get(w)) | Verifica se uma aresta existe no grafo | Verifica se uma aresta existe no grafo | def has_edge(self, v, w):
''' Verifica se uma aresta existe no grafo'''
return (w in self.get(v)) and (v in self.get(w)) | [
"def",
"has_edge",
"(",
"self",
",",
"v",
",",
"w",
")",
":",
"return",
"(",
"w",
"in",
"self",
".",
"get",
"(",
"v",
")",
")",
"and",
"(",
"v",
"in",
"self",
".",
"get",
"(",
"w",
")",
")"
] | [
99,
4
] | [
101,
56
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
journal_as_kernel | (journal: Journal) | return _payload | Gera um dicionário com a estrutura esperada pela API do Kernel a
partir da estrutura gerada pelo isis2json | Gera um dicionário com a estrutura esperada pela API do Kernel a
partir da estrutura gerada pelo isis2json | def journal_as_kernel(journal: Journal) -> dict:
"""Gera um dicionário com a estrutura esperada pela API do Kernel a
partir da estrutura gerada pelo isis2json"""
_payload = {}
_payload["_id"] = journal.scielo_issn
if journal.mission:
_payload["mission"] = [
{"language": lang, "value": value}
for lang, value in journal.mission.items()
]
else:
_payload["mission"] = []
_payload["title"] = journal.title or ""
_payload["title_iso"] = journal.abbreviated_iso_title or ""
_payload["short_title"] = journal.abbreviated_title or ""
_payload["acronym"] = journal.acronym or ""
_payload["scielo_issn"] = journal.scielo_issn or ""
_payload["print_issn"] = journal.print_issn or ""
_payload["electronic_issn"] = journal.electronic_issn or ""
_payload["status"] = {}
if journal.status_history:
_status = journal.status_history[-1]
_payload["status"]["status"] = _status[1]
if _status[2]:
_payload["status"]["reason"] = _status[2]
_payload["subject_areas"] = journal.subject_areas or []
_payload["sponsors"] = []
if journal.sponsors:
_payload["sponsors"] = [{"name": sponsor} for sponsor in journal.sponsors]
_payload["subject_categories"] = journal.wos_subject_areas or []
_payload["online_submission_url"] = journal.submission_url or ""
_payload["next_journal"] = {}
if journal.next_title:
_payload["next_journal"]["name"] = journal.next_title
_payload["previous_journal"] = {}
if journal.previous_title:
_payload["previous_journal"]["name"] = journal.previous_title
_payload["contact"] = {}
if journal.editor_email:
_payload["contact"]["email"] = journal.editor_email
if journal.editor_address:
_payload["contact"]["address"] = journal.editor_address
return _payload | [
"def",
"journal_as_kernel",
"(",
"journal",
":",
"Journal",
")",
"->",
"dict",
":",
"_payload",
"=",
"{",
"}",
"_payload",
"[",
"\"_id\"",
"]",
"=",
"journal",
".",
"scielo_issn",
"if",
"journal",
".",
"mission",
":",
"_payload",
"[",
"\"mission\"",
"]",
"=",
"[",
"{",
"\"language\"",
":",
"lang",
",",
"\"value\"",
":",
"value",
"}",
"for",
"lang",
",",
"value",
"in",
"journal",
".",
"mission",
".",
"items",
"(",
")",
"]",
"else",
":",
"_payload",
"[",
"\"mission\"",
"]",
"=",
"[",
"]",
"_payload",
"[",
"\"title\"",
"]",
"=",
"journal",
".",
"title",
"or",
"\"\"",
"_payload",
"[",
"\"title_iso\"",
"]",
"=",
"journal",
".",
"abbreviated_iso_title",
"or",
"\"\"",
"_payload",
"[",
"\"short_title\"",
"]",
"=",
"journal",
".",
"abbreviated_title",
"or",
"\"\"",
"_payload",
"[",
"\"acronym\"",
"]",
"=",
"journal",
".",
"acronym",
"or",
"\"\"",
"_payload",
"[",
"\"scielo_issn\"",
"]",
"=",
"journal",
".",
"scielo_issn",
"or",
"\"\"",
"_payload",
"[",
"\"print_issn\"",
"]",
"=",
"journal",
".",
"print_issn",
"or",
"\"\"",
"_payload",
"[",
"\"electronic_issn\"",
"]",
"=",
"journal",
".",
"electronic_issn",
"or",
"\"\"",
"_payload",
"[",
"\"status\"",
"]",
"=",
"{",
"}",
"if",
"journal",
".",
"status_history",
":",
"_status",
"=",
"journal",
".",
"status_history",
"[",
"-",
"1",
"]",
"_payload",
"[",
"\"status\"",
"]",
"[",
"\"status\"",
"]",
"=",
"_status",
"[",
"1",
"]",
"if",
"_status",
"[",
"2",
"]",
":",
"_payload",
"[",
"\"status\"",
"]",
"[",
"\"reason\"",
"]",
"=",
"_status",
"[",
"2",
"]",
"_payload",
"[",
"\"subject_areas\"",
"]",
"=",
"journal",
".",
"subject_areas",
"or",
"[",
"]",
"_payload",
"[",
"\"sponsors\"",
"]",
"=",
"[",
"]",
"if",
"journal",
".",
"sponsors",
":",
"_payload",
"[",
"\"sponsors\"",
"]",
"=",
"[",
"{",
"\"name\"",
":",
"sponsor",
"}",
"for",
"sponsor",
"in",
"journal",
".",
"sponsors",
"]",
"_payload",
"[",
"\"subject_categories\"",
"]",
"=",
"journal",
".",
"wos_subject_areas",
"or",
"[",
"]",
"_payload",
"[",
"\"online_submission_url\"",
"]",
"=",
"journal",
".",
"submission_url",
"or",
"\"\"",
"_payload",
"[",
"\"next_journal\"",
"]",
"=",
"{",
"}",
"if",
"journal",
".",
"next_title",
":",
"_payload",
"[",
"\"next_journal\"",
"]",
"[",
"\"name\"",
"]",
"=",
"journal",
".",
"next_title",
"_payload",
"[",
"\"previous_journal\"",
"]",
"=",
"{",
"}",
"if",
"journal",
".",
"previous_title",
":",
"_payload",
"[",
"\"previous_journal\"",
"]",
"[",
"\"name\"",
"]",
"=",
"journal",
".",
"previous_title",
"_payload",
"[",
"\"contact\"",
"]",
"=",
"{",
"}",
"if",
"journal",
".",
"editor_email",
":",
"_payload",
"[",
"\"contact\"",
"]",
"[",
"\"email\"",
"]",
"=",
"journal",
".",
"editor_email",
"if",
"journal",
".",
"editor_address",
":",
"_payload",
"[",
"\"contact\"",
"]",
"[",
"\"address\"",
"]",
"=",
"journal",
".",
"editor_address",
"return",
"_payload"
] | [
84,
0
] | [
139,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Pesquisador.getDadosComplementares | (self) | return result | Extrai informações de DADOS-COMPLEMENTARES do pesquisador do XML do Lattes.
Returns:
type: Dataframe.
| Extrai informações de DADOS-COMPLEMENTARES do pesquisador do XML do Lattes. | def getDadosComplementares(self):
"""Extrai informações de DADOS-COMPLEMENTARES do pesquisador do XML do Lattes.
Returns:
type: Dataframe.
"""
if self.__FLAG:
#----Ajustando informações para o bloco
TAGs = 'DADOS-COMPLEMENTARES'
#----Definindo quais campos são úteis
#--------Colunas com múltiplas equivalências.
cols_merge = ['ANO', 'TITULO','PAIS']
#--------Colunas que tem que mudar de nome
cols_equiv = {}
#--------Juntando todos os dados básicos e complementares.
cols_keep = ['PRODUCAO', 'SEQUENCIA-PRODUCAO', 'NATUREZA', 'TITULO', 'ANO', 'PAIS', 'IDIOMA', 'TIPO-PARTICIPACAO']
#--------Jogue fora toda coluna com estes termos
cols_out = ['INGLES', 'CODIGO', 'FLAG', 'HOME', 'CIDADE','PAGINA']
cols_final = ['SEQUENCIA-PRODUCAO', 'PRODUCAO', 'TIPO','NATUREZA', 'TITULO','ANO', 'PAIS', 'IDIOMA', 'DOI']
#----Parsing
lista = self.xml2dict(tag = TAGs)
df = pd.DataFrame(lista[0])
#----Tidying up
if ((not df.empty) and (df is not None)) :
df = self.dfTidy(df, cols_keep=cols_keep, cols_merge = cols_merge, cols_equiv = cols_equiv, cols_out=cols_out, cols_final=cols_final)
#----Filtrando
df = df[df['ANO'].isin(self.periodo)]
result = df
else:
result = None
else:
result = None
return result | [
"def",
"getDadosComplementares",
"(",
"self",
")",
":",
"if",
"self",
".",
"__FLAG",
":",
"#----Ajustando informações para o bloco",
"TAGs",
"=",
"'DADOS-COMPLEMENTARES'",
"#----Definindo quais campos são úteis",
"#--------Colunas com múltiplas equivalências.",
"cols_merge",
"=",
"[",
"'ANO'",
",",
"'TITULO'",
",",
"'PAIS'",
"]",
"#--------Colunas que tem que mudar de nome",
"cols_equiv",
"=",
"{",
"}",
"#--------Juntando todos os dados básicos e complementares.",
"cols_keep",
"=",
"[",
"'PRODUCAO'",
",",
"'SEQUENCIA-PRODUCAO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'IDIOMA'",
",",
"'TIPO-PARTICIPACAO'",
"]",
"#--------Jogue fora toda coluna com estes termos",
"cols_out",
"=",
"[",
"'INGLES'",
",",
"'CODIGO'",
",",
"'FLAG'",
",",
"'HOME'",
",",
"'CIDADE'",
",",
"'PAGINA'",
"]",
"cols_final",
"=",
"[",
"'SEQUENCIA-PRODUCAO'",
",",
"'PRODUCAO'",
",",
"'TIPO'",
",",
"'NATUREZA'",
",",
"'TITULO'",
",",
"'ANO'",
",",
"'PAIS'",
",",
"'IDIOMA'",
",",
"'DOI'",
"]",
"#----Parsing",
"lista",
"=",
"self",
".",
"xml2dict",
"(",
"tag",
"=",
"TAGs",
")",
"df",
"=",
"pd",
".",
"DataFrame",
"(",
"lista",
"[",
"0",
"]",
")",
"#----Tidying up",
"if",
"(",
"(",
"not",
"df",
".",
"empty",
")",
"and",
"(",
"df",
"is",
"not",
"None",
")",
")",
":",
"df",
"=",
"self",
".",
"dfTidy",
"(",
"df",
",",
"cols_keep",
"=",
"cols_keep",
",",
"cols_merge",
"=",
"cols_merge",
",",
"cols_equiv",
"=",
"cols_equiv",
",",
"cols_out",
"=",
"cols_out",
",",
"cols_final",
"=",
"cols_final",
")",
"#----Filtrando",
"df",
"=",
"df",
"[",
"df",
"[",
"'ANO'",
"]",
".",
"isin",
"(",
"self",
".",
"periodo",
")",
"]",
"result",
"=",
"df",
"else",
":",
"result",
"=",
"None",
"else",
":",
"result",
"=",
"None",
"return",
"result"
] | [
951,
4
] | [
985,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_journal_issns_from_issue | (issue: Issue) | return list(set(issns)) | Busca por todos os issns de periódico disponíveis em uma
issue. Os ISSNs podem estar nos dois campos v35 e v435 com
ou sem repetição | Busca por todos os issns de periódico disponíveis em uma
issue. Os ISSNs podem estar nos dois campos v35 e v435 com
ou sem repetição | def get_journal_issns_from_issue(issue: Issue) -> List[str]:
"""Busca por todos os issns de periódico disponíveis em uma
issue. Os ISSNs podem estar nos dois campos v35 e v435 com
ou sem repetição"""
issns = [get_journal_issn_in_issue(issue)]
if not "v435" in issue.data["issue"]:
return issns
issns.extend([issn["_"] for issn in issue.data["issue"]["v435"]])
return list(set(issns)) | [
"def",
"get_journal_issns_from_issue",
"(",
"issue",
":",
"Issue",
")",
"->",
"List",
"[",
"str",
"]",
":",
"issns",
"=",
"[",
"get_journal_issn_in_issue",
"(",
"issue",
")",
"]",
"if",
"not",
"\"v435\"",
"in",
"issue",
".",
"data",
"[",
"\"issue\"",
"]",
":",
"return",
"issns",
"issns",
".",
"extend",
"(",
"[",
"issn",
"[",
"\"_\"",
"]",
"for",
"issn",
"in",
"issue",
".",
"data",
"[",
"\"issue\"",
"]",
"[",
"\"v435\"",
"]",
"]",
")",
"return",
"list",
"(",
"set",
"(",
"issns",
")",
")"
] | [
265,
0
] | [
277,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Fun.kickrandom | (self, ctx) | Expulsa alguém aleatóriamente. | Expulsa alguém aleatóriamente. | async def kickrandom(self, ctx):
"""Expulsa alguém aleatóriamente."""
client = self.client
msg = await ctx.send("Fique atento de que o bot vai **realmente expulsar alguém**...\nPronto?")
await msg.add_reaction("👎")
await msg.add_reaction("👍")
try:
def react(reaction, user):
return reaction.emoji in ["👍", "👎"] and user.id == ctx.author.id and reaction.message.id == msg.id
reaction, user = await client.wait_for("reaction_add", check=react, timeout=30.0)
except asyncio.TimeoutError:
return
else:
if reaction.emoji == "👎":
await ctx.send("comando cancelado.")
return
invite = random.choice(await ctx.guild.invites())
memb = random.choice(list(filter(lambda member : member.top_role < ctx.me.top_role, ctx.guild.members)))
await ctx.send(f"Eu escolhi {memb} pra ser expulso :smiling_imp:...")
await memb.send(f"Oi, você foi banido do `{ctx.guild.name}`, pelo comando kick, tente entrar no servidor usando esse convite: {invite.url}")
await memb.kick(reason=f"expulso devido ao comando ,banrandom executado por {ctx.author}")
await ctx.send(f"{ctx.author.mention} ele foi expulso.") | [
"async",
"def",
"kickrandom",
"(",
"self",
",",
"ctx",
")",
":",
"client",
"=",
"self",
".",
"client",
"msg",
"=",
"await",
"ctx",
".",
"send",
"(",
"\"Fique atento de que o bot vai **realmente expulsar alguém**...\\nPronto?\")",
"\r",
"await",
"msg",
".",
"add_reaction",
"(",
"\"👎\")\r",
"",
"await",
"msg",
".",
"add_reaction",
"(",
"\"👍\")\r",
"",
"try",
":",
"def",
"react",
"(",
"reaction",
",",
"user",
")",
":",
"return",
"reaction",
".",
"emoji",
"in",
"[",
"\"👍\", \"",
"👎",
"] and ",
"u",
"er.",
"d ==",
" ",
"ct",
".a",
"tho",
"r",
".id an",
"d",
" r",
"act",
"on.messa",
"g",
"e.id ==",
" ",
"ms",
".i",
"\r",
"",
"",
"reaction",
",",
"user",
"=",
"await",
"client",
".",
"wait_for",
"(",
"\"reaction_add\"",
",",
"check",
"=",
"react",
",",
"timeout",
"=",
"30.0",
")",
"except",
"asyncio",
".",
"TimeoutError",
":",
"return",
"else",
":",
"if",
"reaction",
".",
"emoji",
"==",
"\"👎\":\r",
"",
"await",
"ctx",
".",
"send",
"(",
"\"comando cancelado.\"",
")",
"return",
"invite",
"=",
"random",
".",
"choice",
"(",
"await",
"ctx",
".",
"guild",
".",
"invites",
"(",
")",
")",
"memb",
"=",
"random",
".",
"choice",
"(",
"list",
"(",
"filter",
"(",
"lambda",
"member",
":",
"member",
".",
"top_role",
"<",
"ctx",
".",
"me",
".",
"top_role",
",",
"ctx",
".",
"guild",
".",
"members",
")",
")",
")",
"await",
"ctx",
".",
"send",
"(",
"f\"Eu escolhi {memb} pra ser expulso :smiling_imp:...\"",
")",
"await",
"memb",
".",
"send",
"(",
"f\"Oi, você foi banido do `{ctx.guild.name}`, pelo comando kick, tente entrar no servidor usando esse convite: {invite.url}\")",
"\r",
"await",
"memb",
".",
"kick",
"(",
"reason",
"=",
"f\"expulso devido ao comando ,banrandom executado por {ctx.author}\"",
")",
"await",
"ctx",
".",
"send",
"(",
"f\"{ctx.author.mention} ele foi expulso.\"",
")"
] | [
255,
4
] | [
281,
68
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cachorro.rolar | (self) | Simula um cachorro rolando em resposta a um comando. | Simula um cachorro rolando em resposta a um comando. | def rolar(self):
"""Simula um cachorro rolando em resposta a um comando."""
print(self.nome.title() + " está rolando.") | [
"def",
"rolar",
"(",
"self",
")",
":",
"print",
"(",
"self",
".",
"nome",
".",
"title",
"(",
")",
"+",
"\" está rolando.\")",
""
] | [
13,
4
] | [
15,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestePesquisaAnonima.test_resposta_unica | (self) | Testa se uma única resposta é armazenada de
forma apropriada. | Testa se uma única resposta é armazenada de
forma apropriada. | def test_resposta_unica(self):
"""Testa se uma única resposta é armazenada de
forma apropriada."""
self.minha_pesquisa.conjunto_respostas(
nova_resposta=self.respostas[0])
self.assertIn(self.respostas[0], self.minha_pesquisa.respostas) | [
"def",
"test_resposta_unica",
"(",
"self",
")",
":",
"self",
".",
"minha_pesquisa",
".",
"conjunto_respostas",
"(",
"nova_resposta",
"=",
"self",
".",
"respostas",
"[",
"0",
"]",
")",
"self",
".",
"assertIn",
"(",
"self",
".",
"respostas",
"[",
"0",
"]",
",",
"self",
".",
"minha_pesquisa",
".",
"respostas",
")"
] | [
18,
4
] | [
23,
71
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
delete | (rid, tabela) | Função que recebe como parâmetro obrigatório o nome da tabela e o id da linha que deseja deletar | Função que recebe como parâmetro obrigatório o nome da tabela e o id da linha que deseja deletar | def delete(rid, tabela):
""" Função que recebe como parâmetro obrigatório o nome da tabela e o id da linha que deseja deletar """
banco = Banco()
banco.connect()
banco.execute("PRAGMA foreign_keys = ON")
banco.execute(f'DELETE FROM {tabela} WHERE id = {rid}')
banco.persist()
banco.disconnect() | [
"def",
"delete",
"(",
"rid",
",",
"tabela",
")",
":",
"banco",
"=",
"Banco",
"(",
")",
"banco",
".",
"connect",
"(",
")",
"banco",
".",
"execute",
"(",
"\"PRAGMA foreign_keys = ON\"",
")",
"banco",
".",
"execute",
"(",
"f'DELETE FROM {tabela} WHERE id = {rid}'",
")",
"banco",
".",
"persist",
"(",
")",
"banco",
".",
"disconnect",
"(",
")"
] | [
172,
0
] | [
180,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
find_num | (num) | Função para encontrar algarismos de 0-9 dentro de iteráveis
Retornará apenas aa primeira sequência de números encontrados
Esta função não procura por '.'(pontos) podendo alterar os valores
de floats ou números maiores que 999 (1.000)
Esta função retornará float dos valores encontrados ou 0(zero) caso
não encontre nenhum número. | Função para encontrar algarismos de 0-9 dentro de iteráveis
Retornará apenas aa primeira sequência de números encontrados
Esta função não procura por '.'(pontos) podendo alterar os valores
de floats ou números maiores que 999 (1.000)
Esta função retornará float dos valores encontrados ou 0(zero) caso
não encontre nenhum número. | def find_num(num):
"""Função para encontrar algarismos de 0-9 dentro de iteráveis
Retornará apenas aa primeira sequência de números encontrados
Esta função não procura por '.'(pontos) podendo alterar os valores
de floats ou números maiores que 999 (1.000)
Esta função retornará float dos valores encontrados ou 0(zero) caso
não encontre nenhum número."""
rex = re.compile(r'(\d+)').search(str(num))
if rex:
return float(rex.group(1))
else:
return 0 | [
"def",
"find_num",
"(",
"num",
")",
":",
"rex",
"=",
"re",
".",
"compile",
"(",
"r'(\\d+)'",
")",
".",
"search",
"(",
"str",
"(",
"num",
")",
")",
"if",
"rex",
":",
"return",
"float",
"(",
"rex",
".",
"group",
"(",
"1",
")",
")",
"else",
":",
"return",
"0"
] | [
3,
0
] | [
14,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ModeloTransformer.get_tweet_embed | (self, text, method:METHOD, add=True) | Função para gerar embedding do TWEET
Parâmetros:
text: tweet a ser tokenizado
method: conforme enum METHOD
add: Boolean para adição ou não de tokens especiais, como [CLS]
return: média dos tensores de cada token que perfaz o tweet
| Função para gerar embedding do TWEET
Parâmetros:
text: tweet a ser tokenizado
method: conforme enum METHOD
add: Boolean para adição ou não de tokens especiais, como [CLS]
return: média dos tensores de cada token que perfaz o tweet
| def get_tweet_embed(self, text, method:METHOD, add=True):
'''Função para gerar embedding do TWEET
Parâmetros:
text: tweet a ser tokenizado
method: conforme enum METHOD
add: Boolean para adição ou não de tokens especiais, como [CLS]
return: média dos tensores de cada token que perfaz o tweet
'''
self.originalModel.cuda()
# tokenizar texto, transformar num tensor e enviar para a GPU
tokens_tensor = torch.tensor([self.tokenizer.encode(text, add_special_tokens=add)]).cuda()
if (method != ModeloTransformer.METHOD.STATIC_AVG):
with torch.no_grad():
out = self.originalModel(tokens_tensor)
hidden_states = out[2] # selecionando apenas os tensores
if (method == ModeloTransformer.METHOD.CONTEXT_CONCAT):
# get last four layers
last_four_layers = [hidden_states[i] for i in (-1, -2, -3, -4)]
# cast layers to a tuple and concatenate over the last dimension
cat_hidden_states = torch.cat(tuple(last_four_layers), dim= -1)
# take the mean of the concatenated vector over the token dimension
cat_sentence_embedding = torch.mean(cat_hidden_states, dim=1)
return cat_sentence_embedding # gerando o embedding da sentença pela média dos embeddings dos tokens concatenados dos 4 últimos layers
else:
if(method == ModeloTransformer.METHOD.CONTEXT_LAST):
return torch.mean(hidden_states[-1], dim=1) # gerando o embedding da sentença pela média dos embeddings dos tokens
else:
if(method == ModeloTransformer.METHOD.CONTEXT_CLS):
return hidden_states[-1][:,0,:] | [
"def",
"get_tweet_embed",
"(",
"self",
",",
"text",
",",
"method",
":",
"METHOD",
",",
"add",
"=",
"True",
")",
":",
"self",
".",
"originalModel",
".",
"cuda",
"(",
")",
"# tokenizar texto, transformar num tensor e enviar para a GPU",
"tokens_tensor",
"=",
"torch",
".",
"tensor",
"(",
"[",
"self",
".",
"tokenizer",
".",
"encode",
"(",
"text",
",",
"add_special_tokens",
"=",
"add",
")",
"]",
")",
".",
"cuda",
"(",
")",
"if",
"(",
"method",
"!=",
"ModeloTransformer",
".",
"METHOD",
".",
"STATIC_AVG",
")",
":",
"with",
"torch",
".",
"no_grad",
"(",
")",
":",
"out",
"=",
"self",
".",
"originalModel",
"(",
"tokens_tensor",
")",
"hidden_states",
"=",
"out",
"[",
"2",
"]",
"# selecionando apenas os tensores",
"if",
"(",
"method",
"==",
"ModeloTransformer",
".",
"METHOD",
".",
"CONTEXT_CONCAT",
")",
":",
"# get last four layers",
"last_four_layers",
"=",
"[",
"hidden_states",
"[",
"i",
"]",
"for",
"i",
"in",
"(",
"-",
"1",
",",
"-",
"2",
",",
"-",
"3",
",",
"-",
"4",
")",
"]",
"# cast layers to a tuple and concatenate over the last dimension",
"cat_hidden_states",
"=",
"torch",
".",
"cat",
"(",
"tuple",
"(",
"last_four_layers",
")",
",",
"dim",
"=",
"-",
"1",
")",
"# take the mean of the concatenated vector over the token dimension",
"cat_sentence_embedding",
"=",
"torch",
".",
"mean",
"(",
"cat_hidden_states",
",",
"dim",
"=",
"1",
")",
"return",
"cat_sentence_embedding",
"# gerando o embedding da sentença pela média dos embeddings dos tokens concatenados dos 4 últimos layers",
"else",
":",
"if",
"(",
"method",
"==",
"ModeloTransformer",
".",
"METHOD",
".",
"CONTEXT_LAST",
")",
":",
"return",
"torch",
".",
"mean",
"(",
"hidden_states",
"[",
"-",
"1",
"]",
",",
"dim",
"=",
"1",
")",
"# gerando o embedding da sentença pela média dos embeddings dos tokens",
"else",
":",
"if",
"(",
"method",
"==",
"ModeloTransformer",
".",
"METHOD",
".",
"CONTEXT_CLS",
")",
":",
"return",
"hidden_states",
"[",
"-",
"1",
"]",
"[",
":",
",",
"0",
",",
":",
"]"
] | [
64,
4
] | [
93,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Pesquisador.validaDoi | (*args) | return result | Valida código DOI na base de dados crossref
Args:
*args (type): Lista de um nível com números doi `*args`.
Returns:
type: Retorna lista com ISSN se encontrado, NAO-ENCONTRADO ou INVALIDO.
| Valida código DOI na base de dados crossref | def validaDoi(*args):
"""Valida código DOI na base de dados crossref
Args:
*args (type): Lista de um nível com números doi `*args`.
Returns:
type: Retorna lista com ISSN se encontrado, NAO-ENCONTRADO ou INVALIDO.
"""
#----Problemas por aqui. A consulta retorna uma lista.
works = Works()
result = []
args = [*args]
for arg in args:
if len(arg) != 0:
work = Works()
try:
query = work.doi(arg)
ISSN = query['ISSN']
if ISSN is not None:
result.append(query['ISSN'])
else:
result.append('NAO_ENCONTRADO')
except CrossrefAPIError as error:
result.append('INVALIDO')
else:
result.append('INVALIDO')
return result | [
"def",
"validaDoi",
"(",
"*",
"args",
")",
":",
"#----Problemas por aqui. A consulta retorna uma lista.",
"works",
"=",
"Works",
"(",
")",
"result",
"=",
"[",
"]",
"args",
"=",
"[",
"*",
"args",
"]",
"for",
"arg",
"in",
"args",
":",
"if",
"len",
"(",
"arg",
")",
"!=",
"0",
":",
"work",
"=",
"Works",
"(",
")",
"try",
":",
"query",
"=",
"work",
".",
"doi",
"(",
"arg",
")",
"ISSN",
"=",
"query",
"[",
"'ISSN'",
"]",
"if",
"ISSN",
"is",
"not",
"None",
":",
"result",
".",
"append",
"(",
"query",
"[",
"'ISSN'",
"]",
")",
"else",
":",
"result",
".",
"append",
"(",
"'NAO_ENCONTRADO'",
")",
"except",
"CrossrefAPIError",
"as",
"error",
":",
"result",
".",
"append",
"(",
"'INVALIDO'",
")",
"else",
":",
"result",
".",
"append",
"(",
"'INVALIDO'",
")",
"return",
"result"
] | [
323,
4
] | [
351,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Cliente.get_absolute_url | (self) | return reverse('anuncios:cliente_detail', kwargs={'pk': self.id}) | Retorna a url para a página que detalha o cliente | Retorna a url para a página que detalha o cliente | def get_absolute_url(self) -> str:
"""Retorna a url para a página que detalha o cliente"""
return reverse('anuncios:cliente_detail', kwargs={'pk': self.id}) | [
"def",
"get_absolute_url",
"(",
"self",
")",
"->",
"str",
":",
"return",
"reverse",
"(",
"'anuncios:cliente_detail'",
",",
"kwargs",
"=",
"{",
"'pk'",
":",
"self",
".",
"id",
"}",
")"
] | [
31,
4
] | [
33,
73
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
my_reverse | (values) | Inverte a ordenação atual dos elementos em uma lista.
Considerando a lista recebida como parâmetro, inverte a ordenação
atual dos elementos nela contida. Desse modo, o último elemento tor-
na-se o primeiro, o penúltimo torna-se o segundo e, assim, sucessi-
vamente. Essa função modificará diretamente a lista.
Parameters
----------
values : list
A lista cuja ordenação de elementos será invertida
| Inverte a ordenação atual dos elementos em uma lista. | def my_reverse(values):
""" Inverte a ordenação atual dos elementos em uma lista.
Considerando a lista recebida como parâmetro, inverte a ordenação
atual dos elementos nela contida. Desse modo, o último elemento tor-
na-se o primeiro, o penúltimo torna-se o segundo e, assim, sucessi-
vamente. Essa função modificará diretamente a lista.
Parameters
----------
values : list
A lista cuja ordenação de elementos será invertida
"""
for i in range(int(len(values) / 2)):
copy = values[i]
values[i] = values[len(values)-1 - i]
values[len(values)-1 - i] = copy | [
"def",
"my_reverse",
"(",
"values",
")",
":",
"for",
"i",
"in",
"range",
"(",
"int",
"(",
"len",
"(",
"values",
")",
"/",
"2",
")",
")",
":",
"copy",
"=",
"values",
"[",
"i",
"]",
"values",
"[",
"i",
"]",
"=",
"values",
"[",
"len",
"(",
"values",
")",
"-",
"1",
"-",
"i",
"]",
"values",
"[",
"len",
"(",
"values",
")",
"-",
"1",
"-",
"i",
"]",
"=",
"copy"
] | [
89,
0
] | [
105,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Extractor.lbp | (self, img) | return img2 | Função para obter o Local Binary Pattern (LBP)
O algoritmo desta função não trata imagens que tenham sofrido rotação ou espelhamento
| Função para obter o Local Binary Pattern (LBP)
O algoritmo desta função não trata imagens que tenham sofrido rotação ou espelhamento
| def lbp(self, img):
"""Função para obter o Local Binary Pattern (LBP)
O algoritmo desta função não trata imagens que tenham sofrido rotação ou espelhamento
"""
qtdeLinhas, qtdeColunas = img.shape
img2 = np.zeros((qtdeLinhas, qtdeColunas), dtype=int)
for i in range(1, qtdeLinhas-1):
for j in range(1, qtdeColunas-1):
A = img[i-1, j]
B = img[i-1, j+1]
C = img[i, j+1]
D = img[i+1, j+1]
E = img[i+1, j]
F = img[i+1, j-1]
G = img[i, j-1]
H = img[i-1, j-1]
Centro = img[i,j]
soma = 0
soma += 2**7 if A > Centro else 0
soma += 2**6 if B > Centro else 0
soma += 2**5 if C > Centro else 0
soma += 2**4 if D > Centro else 0
soma += 2**3 if E > Centro else 0
soma += 2**2 if F > Centro else 0
soma += 2**1 if G > Centro else 0
soma += 2**0 if H > Centro else 0
img2[i,j] = soma
return img2 | [
"def",
"lbp",
"(",
"self",
",",
"img",
")",
":",
"qtdeLinhas",
",",
"qtdeColunas",
"=",
"img",
".",
"shape",
"img2",
"=",
"np",
".",
"zeros",
"(",
"(",
"qtdeLinhas",
",",
"qtdeColunas",
")",
",",
"dtype",
"=",
"int",
")",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"qtdeLinhas",
"-",
"1",
")",
":",
"for",
"j",
"in",
"range",
"(",
"1",
",",
"qtdeColunas",
"-",
"1",
")",
":",
"A",
"=",
"img",
"[",
"i",
"-",
"1",
",",
"j",
"]",
"B",
"=",
"img",
"[",
"i",
"-",
"1",
",",
"j",
"+",
"1",
"]",
"C",
"=",
"img",
"[",
"i",
",",
"j",
"+",
"1",
"]",
"D",
"=",
"img",
"[",
"i",
"+",
"1",
",",
"j",
"+",
"1",
"]",
"E",
"=",
"img",
"[",
"i",
"+",
"1",
",",
"j",
"]",
"F",
"=",
"img",
"[",
"i",
"+",
"1",
",",
"j",
"-",
"1",
"]",
"G",
"=",
"img",
"[",
"i",
",",
"j",
"-",
"1",
"]",
"H",
"=",
"img",
"[",
"i",
"-",
"1",
",",
"j",
"-",
"1",
"]",
"Centro",
"=",
"img",
"[",
"i",
",",
"j",
"]",
"soma",
"=",
"0",
"soma",
"+=",
"2",
"**",
"7",
"if",
"A",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"6",
"if",
"B",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"5",
"if",
"C",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"4",
"if",
"D",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"3",
"if",
"E",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"2",
"if",
"F",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"1",
"if",
"G",
">",
"Centro",
"else",
"0",
"soma",
"+=",
"2",
"**",
"0",
"if",
"H",
">",
"Centro",
"else",
"0",
"img2",
"[",
"i",
",",
"j",
"]",
"=",
"soma",
"return",
"img2"
] | [
60,
4
] | [
92,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
NetworkAPITestClient.putXML | (self, url, data=None, **extra) | return self.put(url, data=data, content_type=CONTENT_APPLICATION_XML) | Converte o dicionario data para XML e faz um requisição PUT | Converte o dicionario data para XML e faz um requisição PUT | def putXML(self, url, data=None, **extra):
""" Converte o dicionario data para XML e faz um requisição PUT """
if type(data) == dict:
data = dict2xml(data)
return self.put(url, data=data, content_type=CONTENT_APPLICATION_XML) | [
"def",
"putXML",
"(",
"self",
",",
"url",
",",
"data",
"=",
"None",
",",
"*",
"*",
"extra",
")",
":",
"if",
"type",
"(",
"data",
")",
"==",
"dict",
":",
"data",
"=",
"dict2xml",
"(",
"data",
")",
"return",
"self",
".",
"put",
"(",
"url",
",",
"data",
"=",
"data",
",",
"content_type",
"=",
"CONTENT_APPLICATION_XML",
")"
] | [
247,
4
] | [
252,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Button.prep_msg | (self, msg) | Tranforma msg em imagem renderizada e centraliza o texto no
botao. | Tranforma msg em imagem renderizada e centraliza o texto no
botao. | def prep_msg(self, msg):
"""Tranforma msg em imagem renderizada e centraliza o texto no
botao."""
self.msg_image = self.font.render(msg, True, self.text_color,
self.button_color)
self.msg_image_rect = self.msg_image.get_rect()
self.msg_image_rect.center = self.rect.center | [
"def",
"prep_msg",
"(",
"self",
",",
"msg",
")",
":",
"self",
".",
"msg_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"msg",
",",
"True",
",",
"self",
".",
"text_color",
",",
"self",
".",
"button_color",
")",
"self",
".",
"msg_image_rect",
"=",
"self",
".",
"msg_image",
".",
"get_rect",
"(",
")",
"self",
".",
"msg_image_rect",
".",
"center",
"=",
"self",
".",
"rect",
".",
"center"
] | [
23,
4
] | [
29,
53
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ship_hit | (ai_settings, stats, screen, sb, ship, aliens, bullets) | Responde ao fato de a espaconave ter sido atingida por um
alienigena | Responde ao fato de a espaconave ter sido atingida por um
alienigena | def ship_hit(ai_settings, stats, screen, sb, ship, aliens, bullets):
"""Responde ao fato de a espaconave ter sido atingida por um
alienigena"""
if stats.ships_left > 0:
# Decrementa ships_left
stats.ships_left -= 1
# Atualiza o painel de pontuacoes
sb.prep_ships()
# Esvazia a lista de alienigena e de projeteis
aliens.empty()
bullets.empty()
# Cria uma nova frota e centraliza a espaconave
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship()
# Faz uma pausa
sleep(1)
else:
stats.game_active = False
pygame.mouse.set_visible(True) | [
"def",
"ship_hit",
"(",
"ai_settings",
",",
"stats",
",",
"screen",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"if",
"stats",
".",
"ships_left",
">",
"0",
":",
"# Decrementa ships_left",
"stats",
".",
"ships_left",
"-=",
"1",
"# Atualiza o painel de pontuacoes",
"sb",
".",
"prep_ships",
"(",
")",
"# Esvazia a lista de alienigena e de projeteis",
"aliens",
".",
"empty",
"(",
")",
"bullets",
".",
"empty",
"(",
")",
"# Cria uma nova frota e centraliza a espaconave",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
"ship",
".",
"center_ship",
"(",
")",
"# Faz uma pausa",
"sleep",
"(",
"1",
")",
"else",
":",
"stats",
".",
"game_active",
"=",
"False",
"pygame",
".",
"mouse",
".",
"set_visible",
"(",
"True",
")"
] | [
228,
0
] | [
251,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
AtorTestes.teste_valores_padrao | (self) | Testa valores iniciais padrão de um Ator | Testa valores iniciais padrão de um Ator | def teste_valores_padrao(self):
'Testa valores iniciais padrão de um Ator'
ator = Ator()
self.assertEqual(0, ator.x)
self.assertEqual(0, ator.y)
self.assertEqual(ATIVO, ator.status)
self.assertEqual('A', ator.caracter()) | [
"def",
"teste_valores_padrao",
"(",
"self",
")",
":",
"ator",
"=",
"Ator",
"(",
")",
"self",
".",
"assertEqual",
"(",
"0",
",",
"ator",
".",
"x",
")",
"self",
".",
"assertEqual",
"(",
"0",
",",
"ator",
".",
"y",
")",
"self",
".",
"assertEqual",
"(",
"ATIVO",
",",
"ator",
".",
"status",
")",
"self",
".",
"assertEqual",
"(",
"'A'",
",",
"ator",
".",
"caracter",
"(",
")",
")"
] | [
16,
4
] | [
22,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
dfs | (initial, goal_test, successors) | return None | Algoritmo de busca em profundidade. | Algoritmo de busca em profundidade. | def dfs(initial, goal_test, successors):
"""Algoritmo de busca em profundidade."""
# frontier representa os lugares que ainda nao visitamos
frontier = Stack()
frontier.push(Node(initial, None))
# explored representa os lugares que ja foram visitados
explored = {initial}
# continua enquanto houver lugares para explorar
while not frontier.empty:
current_node = frontier.pop()
current_state = current_node.state
# se encontrar o objetivo retorna o no atual
if goal_test(current_state):
return current_node
# verifica para onde podemos ir em seguida
for child in successors(current_state):
# ignora os nos filhos que ja foram visitados
if child in explored:
continue
explored.add(child)
frontier.push(Node(child, current_node))
# passamos por todos os lugares e nao atingimos o objetivo
return None | [
"def",
"dfs",
"(",
"initial",
",",
"goal_test",
",",
"successors",
")",
":",
"# frontier representa os lugares que ainda nao visitamos",
"frontier",
"=",
"Stack",
"(",
")",
"frontier",
".",
"push",
"(",
"Node",
"(",
"initial",
",",
"None",
")",
")",
"# explored representa os lugares que ja foram visitados",
"explored",
"=",
"{",
"initial",
"}",
"# continua enquanto houver lugares para explorar",
"while",
"not",
"frontier",
".",
"empty",
":",
"current_node",
"=",
"frontier",
".",
"pop",
"(",
")",
"current_state",
"=",
"current_node",
".",
"state",
"# se encontrar o objetivo retorna o no atual",
"if",
"goal_test",
"(",
"current_state",
")",
":",
"return",
"current_node",
"# verifica para onde podemos ir em seguida",
"for",
"child",
"in",
"successors",
"(",
"current_state",
")",
":",
"# ignora os nos filhos que ja foram visitados",
"if",
"child",
"in",
"explored",
":",
"continue",
"explored",
".",
"add",
"(",
"child",
")",
"frontier",
".",
"push",
"(",
"Node",
"(",
"child",
",",
"current_node",
")",
")",
"# passamos por todos os lugares e nao atingimos o objetivo",
"return",
"None"
] | [
129,
0
] | [
154,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
sub | (x :int, y: int) | return x - y | Função de subtração. | Função de subtração. | def sub(x :int, y: int) -> int:
"""Função de subtração."""
return x - y | [
"def",
"sub",
"(",
"x",
":",
"int",
",",
"y",
":",
"int",
")",
"->",
"int",
":",
"return",
"x",
"-",
"y"
] | [
6,
0
] | [
8,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Main.tela_inicial | () | return op | `Printa a tela inicial do jogo. | `Printa a tela inicial do jogo. | def tela_inicial():
"""`Printa a tela inicial do jogo."""
fonte = [' /) ',
' |\\---/|(( ',
" | ° ° | )) ",
' \\_T_/_// ',
' ________ _______ _____ _{_}_ {_}____ ______ _______ ________ ',
'|_ _|| _ || | | || _ || ___|| _ ||_ _|',
' | | | |_| || - || |_| || | | |_| | | | ',
' | | | _ || _ _ || _ || |___ | _ | | | ',
' |____| |__| |__||__| |_| |__||__| |__||______||__| |__| |____| ']
botao = ['.-----------------------------.',
'| Aperte ENTER para jogar! |',
"'-----------------------------'"]
janela = cjane.Janela()
for i in range(len(fonte)):
janela.muda_linha(i + 1, fonte[i])
try:
janela.muda_linha(i + 15, botao[i])
except IndexError:
pass
janela.muda_linha(11, 'O MELHOR JOGO DO MUNDO!')
janela.muda_linha(21, '© RaGhu 2021 ', alin='rjust')
print(janela)
input() # para não dar para digitar nada no input além de enter
janela.muda_linha(15, '(1) Novo Jogo ')
janela.muda_linha(16, '(2) Carregar Jogo ')
janela.muda_linha(17, '(3) Sair ')
print(janela)
op = input('Digite a opção desejada: ')
while op not in ['1', '2', '3']:
print(janela)
op = input('Digite uma opção válida: ')
return op | [
"def",
"tela_inicial",
"(",
")",
":",
"fonte",
"=",
"[",
"' /) '",
",",
"' |\\\\---/|(( '",
",",
"\" | ° ° | )) \",",
"",
"' \\\\_T_/_// '",
",",
"' ________ _______ _____ _{_}_ {_}____ ______ _______ ________ '",
",",
"'|_ _|| _ || | | || _ || ___|| _ ||_ _|'",
",",
"' | | | |_| || - || |_| || | | |_| | | | '",
",",
"' | | | _ || _ _ || _ || |___ | _ | | | '",
",",
"' |____| |__| |__||__| |_| |__||__| |__||______||__| |__| |____| '",
"]",
"botao",
"=",
"[",
"'.-----------------------------.'",
",",
"'| Aperte ENTER para jogar! |'",
",",
"\"'-----------------------------'\"",
"]",
"janela",
"=",
"cjane",
".",
"Janela",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"fonte",
")",
")",
":",
"janela",
".",
"muda_linha",
"(",
"i",
"+",
"1",
",",
"fonte",
"[",
"i",
"]",
")",
"try",
":",
"janela",
".",
"muda_linha",
"(",
"i",
"+",
"15",
",",
"botao",
"[",
"i",
"]",
")",
"except",
"IndexError",
":",
"pass",
"janela",
".",
"muda_linha",
"(",
"11",
",",
"'O MELHOR JOGO DO MUNDO!'",
")",
"janela",
".",
"muda_linha",
"(",
"21",
",",
"'© RaGhu 2021 ',",
" ",
"lin=",
"'",
"rjust')",
"",
"print",
"(",
"janela",
")",
"input",
"(",
")",
"# para não dar para digitar nada no input além de enter",
"janela",
".",
"muda_linha",
"(",
"15",
",",
"'(1) Novo Jogo '",
")",
"janela",
".",
"muda_linha",
"(",
"16",
",",
"'(2) Carregar Jogo '",
")",
"janela",
".",
"muda_linha",
"(",
"17",
",",
"'(3) Sair '",
")",
"print",
"(",
"janela",
")",
"op",
"=",
"input",
"(",
"'Digite a opção desejada: ')",
"",
"while",
"op",
"not",
"in",
"[",
"'1'",
",",
"'2'",
",",
"'3'",
"]",
":",
"print",
"(",
"janela",
")",
"op",
"=",
"input",
"(",
"'Digite uma opção válida: ')",
"",
"return",
"op"
] | [
38,
4
] | [
81,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
insert_ip | (ip_map, user) | return 0, ip_map | Insere um IP e o relacionamento entre o IP e o equipamento.
@param ip_map: Map com as chaves: id_equipamento, id_vlan e descricao
@param user: Usuário autenticado na API.
@return Em caso de erro retorna a tupla: (código da mensagem de erro, argumento01, argumento02, ...)
Em caso de sucesso retorna a tupla: (0, <mapa com os dados do IP>)
@raise VlanNotFoundError: VLAN não cadastrada.
@raise VlanError: Falha ao pesquisar a VLAN.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise EquipamentoError: Falha ao pesquisar o Equipamento.
@raise IpNotAvailableError: Não existe um IP disponível para a VLAN.
@raise IpError: Falha ao inserir no banco de dados.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
| Insere um IP e o relacionamento entre o IP e o equipamento. | def insert_ip(ip_map, user):
"""Insere um IP e o relacionamento entre o IP e o equipamento.
@param ip_map: Map com as chaves: id_equipamento, id_vlan e descricao
@param user: Usuário autenticado na API.
@return Em caso de erro retorna a tupla: (código da mensagem de erro, argumento01, argumento02, ...)
Em caso de sucesso retorna a tupla: (0, <mapa com os dados do IP>)
@raise VlanNotFoundError: VLAN não cadastrada.
@raise VlanError: Falha ao pesquisar a VLAN.
@raise EquipamentoNotFoundError: Equipamento não cadastrado.
@raise EquipamentoError: Falha ao pesquisar o Equipamento.
@raise IpNotAvailableError: Não existe um IP disponível para a VLAN.
@raise IpError: Falha ao inserir no banco de dados.
@raise UserNotAuthorizedError: Usuário sem autorização para executar a operação.
"""
log = logging.getLogger('insert_ip')
equip_id = ip_map.get('id_equipamento')
if not is_valid_int_greater_zero_param(equip_id):
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)
if not has_perm(user,
AdminPermission.IPS,
AdminPermission.WRITE_OPERATION,
None,
equip_id,
AdminPermission.EQUIP_WRITE_OPERATION):
raise UserNotAuthorizedError(
None, u'Usuário não tem permissão para executar a operação.')
vlan_id = ip_map.get('id_vlan')
if not is_valid_int_greater_zero_param(vlan_id):
log.error(u'The vlan_id parameter is not a valid value: %s.', vlan_id)
raise InvalidValueError(None, 'vlan_id', vlan_id)
else:
vlan_id = int(vlan_id)
desc_ip = ip_map.get('descricao')
if desc_ip is not None:
if not is_valid_string_maxsize(desc_ip, 100) or not is_valid_string_minsize(desc_ip, 3):
log.error(u'Parameter desc_ip is invalid. Value: %s.', desc_ip)
raise InvalidValueError(None, 'desc_ip', desc_ip)
ip = Ip()
ip.descricao = desc_ip
ip.create(user, equip_id, vlan_id, False)
ip_map = dict()
ip_map['id'] = ip.id
ip_map['id_redeipv4'] = ip.networkipv4.id
ip_map['oct4'] = ip.oct4
ip_map['oct3'] = ip.oct3
ip_map['oct2'] = ip.oct2
ip_map['oct1'] = ip.oct1
ip_map['descricao'] = ip.descricao
return 0, ip_map | [
"def",
"insert_ip",
"(",
"ip_map",
",",
"user",
")",
":",
"log",
"=",
"logging",
".",
"getLogger",
"(",
"'insert_ip'",
")",
"equip_id",
"=",
"ip_map",
".",
"get",
"(",
"'id_equipamento'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"equip_id",
")",
":",
"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",
")",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"IPS",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
",",
"None",
",",
"equip_id",
",",
"AdminPermission",
".",
"EQUIP_WRITE_OPERATION",
")",
":",
"raise",
"UserNotAuthorizedError",
"(",
"None",
",",
"u'Usuário não tem permissão para executar a operação.')",
"",
"vlan_id",
"=",
"ip_map",
".",
"get",
"(",
"'id_vlan'",
")",
"if",
"not",
"is_valid_int_greater_zero_param",
"(",
"vlan_id",
")",
":",
"log",
".",
"error",
"(",
"u'The vlan_id parameter is not a valid value: %s.'",
",",
"vlan_id",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'vlan_id'",
",",
"vlan_id",
")",
"else",
":",
"vlan_id",
"=",
"int",
"(",
"vlan_id",
")",
"desc_ip",
"=",
"ip_map",
".",
"get",
"(",
"'descricao'",
")",
"if",
"desc_ip",
"is",
"not",
"None",
":",
"if",
"not",
"is_valid_string_maxsize",
"(",
"desc_ip",
",",
"100",
")",
"or",
"not",
"is_valid_string_minsize",
"(",
"desc_ip",
",",
"3",
")",
":",
"log",
".",
"error",
"(",
"u'Parameter desc_ip is invalid. Value: %s.'",
",",
"desc_ip",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'desc_ip'",
",",
"desc_ip",
")",
"ip",
"=",
"Ip",
"(",
")",
"ip",
".",
"descricao",
"=",
"desc_ip",
"ip",
".",
"create",
"(",
"user",
",",
"equip_id",
",",
"vlan_id",
",",
"False",
")",
"ip_map",
"=",
"dict",
"(",
")",
"ip_map",
"[",
"'id'",
"]",
"=",
"ip",
".",
"id",
"ip_map",
"[",
"'id_redeipv4'",
"]",
"=",
"ip",
".",
"networkipv4",
".",
"id",
"ip_map",
"[",
"'oct4'",
"]",
"=",
"ip",
".",
"oct4",
"ip_map",
"[",
"'oct3'",
"]",
"=",
"ip",
".",
"oct3",
"ip_map",
"[",
"'oct2'",
"]",
"=",
"ip",
".",
"oct2",
"ip_map",
"[",
"'oct1'",
"]",
"=",
"ip",
".",
"oct1",
"ip_map",
"[",
"'descricao'",
"]",
"=",
"ip",
".",
"descricao",
"return",
"0",
",",
"ip_map"
] | [
60,
0
] | [
124,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestePesquisaAnonima.test_tres_respostas | (self) | Testa se três respostas individuais são armazenadas de
forma apropriada. | Testa se três respostas individuais são armazenadas de
forma apropriada. | def test_tres_respostas(self):
"""Testa se três respostas individuais são armazenadas de
forma apropriada."""
pergunta = "Qual a primeira língua que você aprendeu a falar?"
minha_pesquisa = PesquisaAnonima(
pergunta=pergunta
)
respostas = [
'Inglês', 'Português', 'Francês'
]
for resposta in respostas:
minha_pesquisa.conjunto_respostas(
nova_resposta=resposta
)
for resposta in respostas:
self.assertIn(resposta, minha_pesquisa.respostas) | [
"def",
"test_tres_respostas",
"(",
"self",
")",
":",
"pergunta",
"=",
"\"Qual a primeira língua que você aprendeu a falar?\"",
"minha_pesquisa",
"=",
"PesquisaAnonima",
"(",
"pergunta",
"=",
"pergunta",
")",
"respostas",
"=",
"[",
"'Inglês',",
" ",
"Português', ",
"'",
"rancês'",
"]",
"for",
"resposta",
"in",
"respostas",
":",
"minha_pesquisa",
".",
"conjunto_respostas",
"(",
"nova_resposta",
"=",
"resposta",
")",
"for",
"resposta",
"in",
"respostas",
":",
"self",
".",
"assertIn",
"(",
"resposta",
",",
"minha_pesquisa",
".",
"respostas",
")"
] | [
19,
4
] | [
36,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_document_manifest | (
obj_sps: SPS_Package, document_url: str, assets: list, renditions: List[dict]
) | return _document | Cria um manifesto no formato do Kernel a partir de um
documento xml | Cria um manifesto no formato do Kernel a partir de um
documento xml | def get_document_manifest(
obj_sps: SPS_Package, document_url: str, assets: list, renditions: List[dict]
) -> dict:
"""Cria um manifesto no formato do Kernel a partir de um
documento xml"""
_id = obj_sps.scielo_pid_v3
date = obj_sps.document_pubdate
if not _id:
raise ValueError("Document requires an scielo-pid-v3") from None
if not date:
raise ValueError("A creation date is required") from None
_creation_date = parse_date(
"-".join([date_part for date_part in date])
)
_renditions = []
_version = {
"data": document_url,
"assets": {},
"timestamp": _creation_date,
"renditions": _renditions,
}
_document = {"id": _id, "versions": [_version]}
for asset in assets:
_version["assets"][asset.get("asset_id")] = [
[_creation_date, asset.get("asset_url")]
]
for rendition in renditions:
_renditions.append(
{
"filename": rendition.get("filename"),
"data": [
{
"timestamp": _creation_date,
"url": rendition.get("url"),
"size_bytes": rendition.get("size_bytes"),
}
],
"mimetype": rendition.get("mimetype"),
"lang": rendition.get("lang", obj_sps.languages[0]),
}
)
return _document | [
"def",
"get_document_manifest",
"(",
"obj_sps",
":",
"SPS_Package",
",",
"document_url",
":",
"str",
",",
"assets",
":",
"list",
",",
"renditions",
":",
"List",
"[",
"dict",
"]",
")",
"->",
"dict",
":",
"_id",
"=",
"obj_sps",
".",
"scielo_pid_v3",
"date",
"=",
"obj_sps",
".",
"document_pubdate",
"if",
"not",
"_id",
":",
"raise",
"ValueError",
"(",
"\"Document requires an scielo-pid-v3\"",
")",
"from",
"None",
"if",
"not",
"date",
":",
"raise",
"ValueError",
"(",
"\"A creation date is required\"",
")",
"from",
"None",
"_creation_date",
"=",
"parse_date",
"(",
"\"-\"",
".",
"join",
"(",
"[",
"date_part",
"for",
"date_part",
"in",
"date",
"]",
")",
")",
"_renditions",
"=",
"[",
"]",
"_version",
"=",
"{",
"\"data\"",
":",
"document_url",
",",
"\"assets\"",
":",
"{",
"}",
",",
"\"timestamp\"",
":",
"_creation_date",
",",
"\"renditions\"",
":",
"_renditions",
",",
"}",
"_document",
"=",
"{",
"\"id\"",
":",
"_id",
",",
"\"versions\"",
":",
"[",
"_version",
"]",
"}",
"for",
"asset",
"in",
"assets",
":",
"_version",
"[",
"\"assets\"",
"]",
"[",
"asset",
".",
"get",
"(",
"\"asset_id\"",
")",
"]",
"=",
"[",
"[",
"_creation_date",
",",
"asset",
".",
"get",
"(",
"\"asset_url\"",
")",
"]",
"]",
"for",
"rendition",
"in",
"renditions",
":",
"_renditions",
".",
"append",
"(",
"{",
"\"filename\"",
":",
"rendition",
".",
"get",
"(",
"\"filename\"",
")",
",",
"\"data\"",
":",
"[",
"{",
"\"timestamp\"",
":",
"_creation_date",
",",
"\"url\"",
":",
"rendition",
".",
"get",
"(",
"\"url\"",
")",
",",
"\"size_bytes\"",
":",
"rendition",
".",
"get",
"(",
"\"size_bytes\"",
")",
",",
"}",
"]",
",",
"\"mimetype\"",
":",
"rendition",
".",
"get",
"(",
"\"mimetype\"",
")",
",",
"\"lang\"",
":",
"rendition",
".",
"get",
"(",
"\"lang\"",
",",
"obj_sps",
".",
"languages",
"[",
"0",
"]",
")",
",",
"}",
")",
"return",
"_document"
] | [
7,
0
] | [
56,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
resolveMMQ | (plist, N, uT) | return resp, uarray | Agrupa os metodos anteriores sob uma unica funcao | Agrupa os metodos anteriores sob uma unica funcao | def resolveMMQ(plist, N, uT):
''''Agrupa os metodos anteriores sob uma unica funcao'''
uarray = create_us(plist, N)
matrix = create_matrix_MMQ(uarray)
b = create_right_side_MMQ(uarray, uT)
L, D = LDLt(matrix)
resp = resolve_LDLt(L, D, b)
return resp, uarray | [
"def",
"resolveMMQ",
"(",
"plist",
",",
"N",
",",
"uT",
")",
":",
"uarray",
"=",
"create_us",
"(",
"plist",
",",
"N",
")",
"matrix",
"=",
"create_matrix_MMQ",
"(",
"uarray",
")",
"b",
"=",
"create_right_side_MMQ",
"(",
"uarray",
",",
"uT",
")",
"L",
",",
"D",
"=",
"LDLt",
"(",
"matrix",
")",
"resp",
"=",
"resolve_LDLt",
"(",
"L",
",",
"D",
",",
"b",
")",
"return",
"resp",
",",
"uarray"
] | [
144,
0
] | [
151,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
monthBackup | (bakDir, context, backupFile) | Cria backup mensal no dia 28 do mês | Cria backup mensal no dia 28 do mês | def monthBackup(bakDir, context, backupFile):
'Cria backup mensal no dia 28 do mês'
monthDay = datetime.date.today().day
if monthDay == 28:
try:
from shutil import copy
month = datetime.date.today().month
suffix = '.'.join(backupFile.split('.')[-2:])
monthBackupFile = '%s/%s-mes%0.2d.%s' % (bakDir, context, month, suffix)
if os.path.exists(monthBackupFile):
renameFile(monthBackupFile)
copy(backupFile, monthBackupFile)
except OSError, details:
if details[0] != 1:
print 'Erro[1] ao criar %s: %s' % (monthBackupFile, details)
except Exception, details:
print 'Erro[2] ao criar %s: %s' % (monthBackupFile, details)
print sys.exc_info()[0] | [
"def",
"monthBackup",
"(",
"bakDir",
",",
"context",
",",
"backupFile",
")",
":",
"monthDay",
"=",
"datetime",
".",
"date",
".",
"today",
"(",
")",
".",
"day",
"if",
"monthDay",
"==",
"28",
":",
"try",
":",
"from",
"shutil",
"import",
"copy",
"month",
"=",
"datetime",
".",
"date",
".",
"today",
"(",
")",
".",
"month",
"suffix",
"=",
"'.'",
".",
"join",
"(",
"backupFile",
".",
"split",
"(",
"'.'",
")",
"[",
"-",
"2",
":",
"]",
")",
"monthBackupFile",
"=",
"'%s/%s-mes%0.2d.%s'",
"%",
"(",
"bakDir",
",",
"context",
",",
"month",
",",
"suffix",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"monthBackupFile",
")",
":",
"renameFile",
"(",
"monthBackupFile",
")",
"copy",
"(",
"backupFile",
",",
"monthBackupFile",
")",
"except",
"OSError",
",",
"details",
":",
"if",
"details",
"[",
"0",
"]",
"!=",
"1",
":",
"print",
"'Erro[1] ao criar %s: %s'",
"%",
"(",
"monthBackupFile",
",",
"details",
")",
"except",
"Exception",
",",
"details",
":",
"print",
"'Erro[2] ao criar %s: %s'",
"%",
"(",
"monthBackupFile",
",",
"details",
")",
"print",
"sys",
".",
"exc_info",
"(",
")",
"[",
"0",
"]"
] | [
85,
0
] | [
102,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestLambdas.test_anyany | (self) | Teste usando dois operadores lambda: any e any | Teste usando dois operadores lambda: any e any | def test_anyany(self):
"""Teste usando dois operadores lambda: any e any"""
expected = (
"customFieldValues/any(x: x/items/any"
"(y: y/customFieldItem eq 'MGSSUSTR6-06R'))"
)
result = AnyAny(
self.properties["customFieldValues"].items.customFieldItem
== "MGSSUSTR6-06R"
)
self.assertEqual(result, expected) | [
"def",
"test_anyany",
"(",
"self",
")",
":",
"expected",
"=",
"(",
"\"customFieldValues/any(x: x/items/any\"",
"\"(y: y/customFieldItem eq 'MGSSUSTR6-06R'))\"",
")",
"result",
"=",
"AnyAny",
"(",
"self",
".",
"properties",
"[",
"\"customFieldValues\"",
"]",
".",
"items",
".",
"customFieldItem",
"==",
"\"MGSSUSTR6-06R\"",
")",
"self",
".",
"assertEqual",
"(",
"result",
",",
"expected",
")"
] | [
39,
4
] | [
49,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
make_pizza | (size, *toppings) | Apresenta uma pizza que estamos prestes a preparar. | Apresenta uma pizza que estamos prestes a preparar. | def make_pizza(size, *toppings):
"""Apresenta uma pizza que estamos prestes a preparar."""
print('\nMaking a ' + str(size) + ' -inch pizza with the following topping:')
for topping in toppings:
print('- ' + topping) | [
"def",
"make_pizza",
"(",
"size",
",",
"*",
"toppings",
")",
":",
"print",
"(",
"'\\nMaking a '",
"+",
"str",
"(",
"size",
")",
"+",
"' -inch pizza with the following topping:'",
")",
"for",
"topping",
"in",
"toppings",
":",
"print",
"(",
"'- '",
"+",
"topping",
")"
] | [
10,
0
] | [
14,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
p_declaracao_funcao | (p) | declaracao_funcao : tipo cabecalho
| cabecalho
| declaracao_funcao : tipo cabecalho
| cabecalho
| def p_declaracao_funcao(p):
"""declaracao_funcao : tipo cabecalho
| cabecalho
"""
pai = MyNode(name='declaracao_funcao', type='DECLARACAO_FUNCAO')
p[0] = pai
p[1].parent = pai
if len(p) == 3:
p[2].parent = pai | [
"def",
"p_declaracao_funcao",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'declaracao_funcao'",
",",
"type",
"=",
"'DECLARACAO_FUNCAO'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai",
"if",
"len",
"(",
"p",
")",
"==",
"3",
":",
"p",
"[",
"2",
"]",
".",
"parent",
"=",
"pai"
] | [
301,
0
] | [
310,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Agent.__repr__ | (self) | return str([self.location, self.direction, self.has_gold, self.has_arrow]) | Retorna a representação de string dessa instância. | Retorna a representação de string dessa instância. | def __repr__(self):
"""Retorna a representação de string dessa instância."""
return str([self.location, self.direction, self.has_gold, self.has_arrow]) | [
"def",
"__repr__",
"(",
"self",
")",
":",
"return",
"str",
"(",
"[",
"self",
".",
"location",
",",
"self",
".",
"direction",
",",
"self",
".",
"has_gold",
",",
"self",
".",
"has_arrow",
"]",
")"
] | [
111,
2
] | [
115,
78
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
compara_assinatura | (as_a, as_b) | return grau | IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas. | IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas. | def compara_assinatura(as_a, as_b):
'''IMPLEMENTAR. Essa funcao recebe duas assinaturas de texto e deve devolver o grau de similaridade nas assinaturas.'''
S = 0
for i in range (0, 6):
S = S+ (abs(as_a[i] - as_b[i]))
grau = S/6
if grau < 0:
grau = grau * (-1)
return grau | [
"def",
"compara_assinatura",
"(",
"as_a",
",",
"as_b",
")",
":",
"S",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"6",
")",
":",
"S",
"=",
"S",
"+",
"(",
"abs",
"(",
"as_a",
"[",
"i",
"]",
"-",
"as_b",
"[",
"i",
"]",
")",
")",
"grau",
"=",
"S",
"/",
"6",
"if",
"grau",
"<",
"0",
":",
"grau",
"=",
"grau",
"*",
"(",
"-",
"1",
")",
"return",
"grau"
] | [
71,
0
] | [
79,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
my_insert | (values, element, index = 0) | Insere um elemento num índice específico de uma lista.
Considerando o elemento, o índice e a lista recebidos como parâme-
tros, insere tal elemento no índice especificado da lista sem que
haja sobrescrita do elemento previamente armazenado neste índice.
Por padrão, a inserção será realizada no início da lista.
Parameters
----------
values : list
A lista em que a inserção será realizada
element : ?
O elemento a ser inserido na lista
index : int
O índice em que a inserção será realizada (default 0)
| Insere um elemento num índice específico de uma lista. | def my_insert(values, element, index = 0):
""" Insere um elemento num índice específico de uma lista.
Considerando o elemento, o índice e a lista recebidos como parâme-
tros, insere tal elemento no índice especificado da lista sem que
haja sobrescrita do elemento previamente armazenado neste índice.
Por padrão, a inserção será realizada no início da lista.
Parameters
----------
values : list
A lista em que a inserção será realizada
element : ?
O elemento a ser inserido na lista
index : int
O índice em que a inserção será realizada (default 0)
"""
values.append(element)
for i in range(len(values) - 1, index, -1):
values[i], values[i - 1] = values[i - 1], values[i] | [
"def",
"my_insert",
"(",
"values",
",",
"element",
",",
"index",
"=",
"0",
")",
":",
"values",
".",
"append",
"(",
"element",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"values",
")",
"-",
"1",
",",
"index",
",",
"-",
"1",
")",
":",
"values",
"[",
"i",
"]",
",",
"values",
"[",
"i",
"-",
"1",
"]",
"=",
"values",
"[",
"i",
"-",
"1",
"]",
",",
"values",
"[",
"i",
"]"
] | [
68,
0
] | [
87,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Settings.increase_speed | (self) | Aumenta as configurações de velocidade e os pontos para cada alien | Aumenta as configurações de velocidade e os pontos para cada alien | def increase_speed(self):
"""Aumenta as configurações de velocidade e os pontos para cada alien"""
self.ship_speed_factor *= self.speedup_scale
self.bullet_speed_factor *= self.speedup_scale
self.alien_speed_factor *= self.speedup_scale
self.alien_points = int(self.alien_points * self.score_scale) | [
"def",
"increase_speed",
"(",
"self",
")",
":",
"self",
".",
"ship_speed_factor",
"*=",
"self",
".",
"speedup_scale",
"self",
".",
"bullet_speed_factor",
"*=",
"self",
".",
"speedup_scale",
"self",
".",
"alien_speed_factor",
"*=",
"self",
".",
"speedup_scale",
"self",
".",
"alien_points",
"=",
"int",
"(",
"self",
".",
"alien_points",
"*",
"self",
".",
"score_scale",
")"
] | [
46,
4
] | [
52,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
assert_response_error | (response, codigo, descricao=None) | Verifica se a resposta da networkapi foi como esperada. Quando for passado uma lista de códigos
possiveis, a descrição não poderá ser passada
| Verifica se a resposta da networkapi foi como esperada. Quando for passado uma lista de códigos
possiveis, a descrição não poderá ser passada
| def assert_response_error(response, codigo, descricao=None):
""" Verifica se a resposta da networkapi foi como esperada. Quando for passado uma lista de códigos
possiveis, a descrição não poderá ser passada
"""
# trata o argumento código, quando somente 1 elemento for passado
codigos = codigo if type(codigo) == list else [codigo]
try:
networkapi_response = xml2dict(response.content)
codigo_resposta = int(networkapi_response['erro']['codigo'])
descricao_resposta = networkapi_response['erro']['descricao']
assert codigo_resposta in codigos, u"Código de resposta inválido: %d (descricao: %s). Esperados: %s" % (
codigo_resposta, descricao_resposta, repr(codigos))
assert descricao_resposta is not None
assert len(descricao_resposta) > 0
if descricao:
assert descricao_resposta == descricao
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_error",
"(",
"response",
",",
"codigo",
",",
"descricao",
"=",
"None",
")",
":",
"# trata o argumento código, quando somente 1 elemento for passado",
"codigos",
"=",
"codigo",
"if",
"type",
"(",
"codigo",
")",
"==",
"list",
"else",
"[",
"codigo",
"]",
"try",
":",
"networkapi_response",
"=",
"xml2dict",
"(",
"response",
".",
"content",
")",
"codigo_resposta",
"=",
"int",
"(",
"networkapi_response",
"[",
"'erro'",
"]",
"[",
"'codigo'",
"]",
")",
"descricao_resposta",
"=",
"networkapi_response",
"[",
"'erro'",
"]",
"[",
"'descricao'",
"]",
"assert",
"codigo_resposta",
"in",
"codigos",
",",
"u\"Código de resposta inválido: %d (descricao: %s). Esperados: %s\" %",
"(",
"",
"codigo_resposta",
",",
"descricao_resposta",
",",
"repr",
"(",
"codigos",
")",
")",
"assert",
"descricao_resposta",
"is",
"not",
"None",
"assert",
"len",
"(",
"descricao_resposta",
")",
">",
"0",
"if",
"descricao",
":",
"assert",
"descricao_resposta",
"==",
"descricao",
"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"
] | [
19,
0
] | [
41,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
SistemaLivros.adicionar_livro | (self) | Adiciona um novo livro à lista de livros,
é possivel adicionar um dicionario com a estrutura
padrão ou até criar chaves e valores extras | Adiciona um novo livro à lista de livros,
é possivel adicionar um dicionario com a estrutura
padrão ou até criar chaves e valores extras | def adicionar_livro(self):
""" Adiciona um novo livro à lista de livros,
é possivel adicionar um dicionario com a estrutura
padrão ou até criar chaves e valores extras """
print(""" Adicionando um novo livro ao sistema...
""")
titulos_existentes = []
for livro in self.dados:
titulos_existentes.append(livro["titulo"])
titulo = str(input("Digite o titulo do livro :"))
while titulo in titulos_existentes:
titulo = str(input("Este titulo já existe, tente outro :"))
autor = str(input("Digite o autor do livro :"))
editora = str(input("Digite a editora do livro :"))
livro = {
"titulo":titulo,
"autor":autor,
"editora":editora}
while True:
opcao = input("Quer adicionar mais alguma informação do livro ?[s/n]")
if opcao.lower() == "s":
print("Okay ! então vamos adicionar mais informações !")
chave = input("Qual a informação extra deseja adicionar(Ex: Ano de lançamento) :")
valor = input("Digite agora a informação em sí :")
livro.update({chave.replace(" ","_").lower():valor})
else:
break
self.dados.append(livro)
print("""
Livro Adicionado !! """) | [
"def",
"adicionar_livro",
"(",
"self",
")",
":",
"print",
"(",
"\"\"\" Adicionando um novo livro ao sistema...\n \"\"\"",
")",
"titulos_existentes",
"=",
"[",
"]",
"for",
"livro",
"in",
"self",
".",
"dados",
":",
"titulos_existentes",
".",
"append",
"(",
"livro",
"[",
"\"titulo\"",
"]",
")",
"titulo",
"=",
"str",
"(",
"input",
"(",
"\"Digite o titulo do livro :\"",
")",
")",
"while",
"titulo",
"in",
"titulos_existentes",
":",
"titulo",
"=",
"str",
"(",
"input",
"(",
"\"Este titulo já existe, tente outro :\")",
")",
"",
"autor",
"=",
"str",
"(",
"input",
"(",
"\"Digite o autor do livro :\"",
")",
")",
"editora",
"=",
"str",
"(",
"input",
"(",
"\"Digite a editora do livro :\"",
")",
")",
"livro",
"=",
"{",
"\"titulo\"",
":",
"titulo",
",",
"\"autor\"",
":",
"autor",
",",
"\"editora\"",
":",
"editora",
"}",
"while",
"True",
":",
"opcao",
"=",
"input",
"(",
"\"Quer adicionar mais alguma informação do livro ?[s/n]\")",
"",
"if",
"opcao",
".",
"lower",
"(",
")",
"==",
"\"s\"",
":",
"print",
"(",
"\"Okay ! então vamos adicionar mais informações !\")",
"",
"chave",
"=",
"input",
"(",
"\"Qual a informação extra deseja adicionar(Ex: Ano de lançamento) :\")",
"",
"valor",
"=",
"input",
"(",
"\"Digite agora a informação em sí :\")",
"",
"livro",
".",
"update",
"(",
"{",
"chave",
".",
"replace",
"(",
"\" \"",
",",
"\"_\"",
")",
".",
"lower",
"(",
")",
":",
"valor",
"}",
")",
"else",
":",
"break",
"self",
".",
"dados",
".",
"append",
"(",
"livro",
")",
"print",
"(",
"\"\"\" \n Livro Adicionado !! \"\"\"",
")"
] | [
68,
4
] | [
98,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cadastral.cria_df_cadastral | (self) | Cria o DataFrame com o arquivo csv de cadastro. | Cria o DataFrame com o arquivo csv de cadastro. | def cria_df_cadastral(self):
"""Cria o DataFrame com o arquivo csv de cadastro."""
log.debug("Carregando csv cadastral")
create_dir(CSV_FILES_DIR)
self.download_inf_cadastral()
self.pd_df = pd.read_csv(
self.filename, sep=";", encoding="ISO-8859-1", index_col="CNPJ_FUNDO"
) | [
"def",
"cria_df_cadastral",
"(",
"self",
")",
":",
"log",
".",
"debug",
"(",
"\"Carregando csv cadastral\"",
")",
"create_dir",
"(",
"CSV_FILES_DIR",
")",
"self",
".",
"download_inf_cadastral",
"(",
")",
"self",
".",
"pd_df",
"=",
"pd",
".",
"read_csv",
"(",
"self",
".",
"filename",
",",
"sep",
"=",
"\";\"",
",",
"encoding",
"=",
"\"ISO-8859-1\"",
",",
"index_col",
"=",
"\"CNPJ_FUNDO\"",
")"
] | [
224,
4
] | [
231,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linhas | (prog,prox=None,id=None,ind=recuo,carrega=True) | return prog | Inicializa a lista (e as referências de lista ligada) prog,
referenciando a linha prox ao final, se id != None, atribui-o e conta o recuo inteiro pelo dicionário de indentação ind.
O id é composto pela tupla do valor dado precedido pelo índice da lista, se o referido valor não for None.
Ao final da função, o argumento carrega (verdadeiro por padrão) é fornecido para que a lista ligada completa seja montada (ou não) na primeira linha | Inicializa a lista (e as referências de lista ligada) prog,
referenciando a linha prox ao final, se id != None, atribui-o e conta o recuo inteiro pelo dicionário de indentação ind. | def linhas (prog,prox=None,id=None,ind=recuo,carrega=True):
'''Inicializa a lista (e as referências de lista ligada) prog,
referenciando a linha prox ao final, se id != None, atribui-o e conta o recuo inteiro pelo dicionário de indentação ind.
O id é composto pela tupla do valor dado precedido pelo índice da lista, se o referido valor não for None.
Ao final da função, o argumento carrega (verdadeiro por padrão) é fornecido para que a lista ligada completa seja montada (ou não) na primeira linha'''
if type(prog) == TextIOWrapper:
p = prog.read()
# prog.close()
prog = p
if type(prog) == str:
prog = prog.splitlines()
else:
prog = list(prog)
c = len(prog)
while c > 0:
c += -1
prox = linha(prog[c],prox,ind)
prog[c] = prox
if id != None:
prog[c].__id__((c,id))
if len(prog) > 0:
prog[0].list(carrega)
return prog | [
"def",
"linhas",
"(",
"prog",
",",
"prox",
"=",
"None",
",",
"id",
"=",
"None",
",",
"ind",
"=",
"recuo",
",",
"carrega",
"=",
"True",
")",
":",
"if",
"type",
"(",
"prog",
")",
"==",
"TextIOWrapper",
":",
"p",
"=",
"prog",
".",
"read",
"(",
")",
"#\tprog.close()",
"prog",
"=",
"p",
"if",
"type",
"(",
"prog",
")",
"==",
"str",
":",
"prog",
"=",
"prog",
".",
"splitlines",
"(",
")",
"else",
":",
"prog",
"=",
"list",
"(",
"prog",
")",
"c",
"=",
"len",
"(",
"prog",
")",
"while",
"c",
">",
"0",
":",
"c",
"+=",
"-",
"1",
"prox",
"=",
"linha",
"(",
"prog",
"[",
"c",
"]",
",",
"prox",
",",
"ind",
")",
"prog",
"[",
"c",
"]",
"=",
"prox",
"if",
"id",
"!=",
"None",
":",
"prog",
"[",
"c",
"]",
".",
"__id__",
"(",
"(",
"c",
",",
"id",
")",
")",
"if",
"len",
"(",
"prog",
")",
">",
"0",
":",
"prog",
"[",
"0",
"]",
".",
"list",
"(",
"carrega",
")",
"return",
"prog"
] | [
94,
0
] | [
117,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
soma | (x :int, y: int) | return x + y | Função de soma. | Função de soma. | def soma(x :int, y: int) -> int:
"""Função de soma."""
return x + y | [
"def",
"soma",
"(",
"x",
":",
"int",
",",
"y",
":",
"int",
")",
"->",
"int",
":",
"return",
"x",
"+",
"y"
] | [
1,
0
] | [
3,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Anuncio.__str__ | (self) | return self.nome | Retorna a representação textual do anúncio | Retorna a representação textual do anúncio | def __str__(self) -> str:
"""Retorna a representação textual do anúncio"""
return self.nome | [
"def",
"__str__",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"nome"
] | [
63,
4
] | [
65,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
InterfaceChannelResource.handle_delete | (self, request, user, *args, **kwargs) | Trata uma requisição DELETE para excluir um port channel
URL: /channel/delete/<channel_name>/<interface_id>
| Trata uma requisição DELETE para excluir um port channel
URL: /channel/delete/<channel_name>/<interface_id>
| def handle_delete(self, request, user, *args, **kwargs):
"""Trata uma requisição DELETE para excluir um port channel
URL: /channel/delete/<channel_name>/<interface_id>
"""
try:
self.log.info('Delete Channel')
# User permission
if not has_perm(user, AdminPermission.EQUIPMENT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
self.log.error(
u'User does not have permission to perform the operation.')
raise UserNotAuthorizedError(None)
interface_id = kwargs.get('channel_name')
interface = Interface.get_by_pk(int(interface_id))
equip_list = []
try:
interface.channel.id
channel = interface.channel
except:
channel = interface.ligacao_front.channel
pass
try:
interfaces = Interface.objects.all().filter(channel__id=channel.id)
except:
return self.response(dumps_networkapi({}))
for i in interfaces:
equip_list.append(i.equipamento.id)
equip_list = set(equip_list)
equip_dict = dict()
for e in equip_list:
equip_dict[str(e)] = interfaces.filter(equipamento__id=e)
tipo = TipoInterface()
tipo = tipo.get_by_name('access')
for e in equip_dict:
for i in equip_dict.get(e):
try:
front = i.ligacao_front.id
except:
front = None
pass
try:
back = i.ligacao_back.id
except:
back = None
pass
i.update(user,
i.id,
interface=i.interface,
protegida=i.protegida,
descricao=i.descricao,
ligacao_front_id=front,
ligacao_back_id=back,
tipo=tipo,
vlan_nativa='1')
api_interface_facade.delete_channel(user, e, equip_dict.get(e), channel)
channel.delete(user)
return self.response(dumps_networkapi({}))
except api_interface_exceptions.InterfaceException, e:
return self.response_error(410, e)
except api_interface_exceptions.InvalidKeyException, e:
return self.response_error(410, e)
except var_exceptions.VariableDoesNotExistException, e:
return self.response_error(410, e)
except api_interface_exceptions.InterfaceTemplateException, e:
return self.response_error(410, e)
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"self",
".",
"log",
".",
"info",
"(",
"'Delete Channel'",
")",
"# User permission",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"EQUIPMENT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'User does not have permission to perform the operation.'",
")",
"raise",
"UserNotAuthorizedError",
"(",
"None",
")",
"interface_id",
"=",
"kwargs",
".",
"get",
"(",
"'channel_name'",
")",
"interface",
"=",
"Interface",
".",
"get_by_pk",
"(",
"int",
"(",
"interface_id",
")",
")",
"equip_list",
"=",
"[",
"]",
"try",
":",
"interface",
".",
"channel",
".",
"id",
"channel",
"=",
"interface",
".",
"channel",
"except",
":",
"channel",
"=",
"interface",
".",
"ligacao_front",
".",
"channel",
"pass",
"try",
":",
"interfaces",
"=",
"Interface",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"channel__id",
"=",
"channel",
".",
"id",
")",
"except",
":",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"for",
"i",
"in",
"interfaces",
":",
"equip_list",
".",
"append",
"(",
"i",
".",
"equipamento",
".",
"id",
")",
"equip_list",
"=",
"set",
"(",
"equip_list",
")",
"equip_dict",
"=",
"dict",
"(",
")",
"for",
"e",
"in",
"equip_list",
":",
"equip_dict",
"[",
"str",
"(",
"e",
")",
"]",
"=",
"interfaces",
".",
"filter",
"(",
"equipamento__id",
"=",
"e",
")",
"tipo",
"=",
"TipoInterface",
"(",
")",
"tipo",
"=",
"tipo",
".",
"get_by_name",
"(",
"'access'",
")",
"for",
"e",
"in",
"equip_dict",
":",
"for",
"i",
"in",
"equip_dict",
".",
"get",
"(",
"e",
")",
":",
"try",
":",
"front",
"=",
"i",
".",
"ligacao_front",
".",
"id",
"except",
":",
"front",
"=",
"None",
"pass",
"try",
":",
"back",
"=",
"i",
".",
"ligacao_back",
".",
"id",
"except",
":",
"back",
"=",
"None",
"pass",
"i",
".",
"update",
"(",
"user",
",",
"i",
".",
"id",
",",
"interface",
"=",
"i",
".",
"interface",
",",
"protegida",
"=",
"i",
".",
"protegida",
",",
"descricao",
"=",
"i",
".",
"descricao",
",",
"ligacao_front_id",
"=",
"front",
",",
"ligacao_back_id",
"=",
"back",
",",
"tipo",
"=",
"tipo",
",",
"vlan_nativa",
"=",
"'1'",
")",
"api_interface_facade",
".",
"delete_channel",
"(",
"user",
",",
"e",
",",
"equip_dict",
".",
"get",
"(",
"e",
")",
",",
"channel",
")",
"channel",
".",
"delete",
"(",
"user",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"api_interface_exceptions",
".",
"InterfaceException",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"410",
",",
"e",
")",
"except",
"api_interface_exceptions",
".",
"InvalidKeyException",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"410",
",",
"e",
")",
"except",
"var_exceptions",
".",
"VariableDoesNotExistException",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"410",
",",
"e",
")",
"except",
"api_interface_exceptions",
".",
"InterfaceTemplateException",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"410",
",",
"e",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisição.')",
"",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")"
] | [
278,
4
] | [
356,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
RequisicaoVipsResource.handle_post | (self, request, user, *args, **kwargs) | Trata as requisições de POST para inserir uma requisição de VIP. | Trata as requisições de POST para inserir uma requisição de VIP. | def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para inserir uma requisição de VIP."""
try:
xml_map, attrs_map = loads(
request.raw_post_data, ['transbordo', 'porta', 'real'])
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisição.')
return self.response_error(3, x)
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.')
vip_map = networkapi_map.get('vip')
if vip_map is None:
return self.response_error(3, u'Não existe valor para a tag vip do XML de requisição.')
try:
response = insert_vip_request(vip_map, user)
if (response[0] == 0):
vip_map = dict()
vip_map['id'] = response[1].id
return self.response(dumps_networkapi({'requisicao_vip': vip_map}))
else:
return self.response_error(response[0])
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except EnvironmentVipNotFoundError:
return self.response_error(316, vip_map['finalidade'], vip_map['cliente'], vip_map['ambiente'])
except IpNotFoundError:
return self.response_error(119)
except HealthcheckExpectNotFoundError:
return self.response_error(124)
except InvalidFinalidadeValueError:
return self.response_error(125)
except InvalidClienteValueError:
return self.response_error(126)
except InvalidAmbienteValueError:
return self.response_error(127)
except InvalidCacheValueError:
return self.response_error(128)
except InvalidMetodoBalValueError:
return self.response_error(131)
except InvalidPersistenciaValueError:
return self.response_error(132)
except InvalidHealthcheckTypeValueError:
return self.response_error(133)
except InvalidHealthcheckValueError:
return self.response_error(134)
except InvalidTimeoutValueError:
return self.response_error(135)
except InvalidHostNameError:
return self.response_error(136)
except InvalidMaxConValueError:
return self.response_error(137)
except InvalidBalAtivoValueError:
return self.response_error(129)
except InvalidTransbordoValueError, t:
transbordo = 'nulo'
if t.message is not None:
transbordo = t.message
return self.response_error(130, transbordo)
except InvalidServicePortValueError, s:
porta = 'nulo'
if s.message is not None:
porta = s.message
return self.response_error(138, porta)
except InvalidRealValueError, r:
real = 'nulo'
if r.message is not None:
real = r.message
return self.response_error(151, real)
except UserNotAuthorizedError:
return self.not_authorized()
except (RequisicaoVipsError, EquipamentoError, IpError, HealthcheckExpectError, GrupoError):
return self.response_error(1)
except IpNotFoundByEquipAndVipError, e:
return self.response_error(334, e.message) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
",",
"[",
"'transbordo'",
",",
"'porta'",
",",
"'real'",
"]",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisição.')",
"",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"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.')",
"",
"vip_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'vip'",
")",
"if",
"vip_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag vip do XML de requisição.')",
"",
"try",
":",
"response",
"=",
"insert_vip_request",
"(",
"vip_map",
",",
"user",
")",
"if",
"(",
"response",
"[",
"0",
"]",
"==",
"0",
")",
":",
"vip_map",
"=",
"dict",
"(",
")",
"vip_map",
"[",
"'id'",
"]",
"=",
"response",
"[",
"1",
"]",
".",
"id",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'requisicao_vip'",
":",
"vip_map",
"}",
")",
")",
"else",
":",
"return",
"self",
".",
"response_error",
"(",
"response",
"[",
"0",
"]",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"EnvironmentVipNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"316",
",",
"vip_map",
"[",
"'finalidade'",
"]",
",",
"vip_map",
"[",
"'cliente'",
"]",
",",
"vip_map",
"[",
"'ambiente'",
"]",
")",
"except",
"IpNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"119",
")",
"except",
"HealthcheckExpectNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"124",
")",
"except",
"InvalidFinalidadeValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"125",
")",
"except",
"InvalidClienteValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"126",
")",
"except",
"InvalidAmbienteValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"127",
")",
"except",
"InvalidCacheValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"128",
")",
"except",
"InvalidMetodoBalValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"131",
")",
"except",
"InvalidPersistenciaValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"132",
")",
"except",
"InvalidHealthcheckTypeValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"133",
")",
"except",
"InvalidHealthcheckValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"134",
")",
"except",
"InvalidTimeoutValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"135",
")",
"except",
"InvalidHostNameError",
":",
"return",
"self",
".",
"response_error",
"(",
"136",
")",
"except",
"InvalidMaxConValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"137",
")",
"except",
"InvalidBalAtivoValueError",
":",
"return",
"self",
".",
"response_error",
"(",
"129",
")",
"except",
"InvalidTransbordoValueError",
",",
"t",
":",
"transbordo",
"=",
"'nulo'",
"if",
"t",
".",
"message",
"is",
"not",
"None",
":",
"transbordo",
"=",
"t",
".",
"message",
"return",
"self",
".",
"response_error",
"(",
"130",
",",
"transbordo",
")",
"except",
"InvalidServicePortValueError",
",",
"s",
":",
"porta",
"=",
"'nulo'",
"if",
"s",
".",
"message",
"is",
"not",
"None",
":",
"porta",
"=",
"s",
".",
"message",
"return",
"self",
".",
"response_error",
"(",
"138",
",",
"porta",
")",
"except",
"InvalidRealValueError",
",",
"r",
":",
"real",
"=",
"'nulo'",
"if",
"r",
".",
"message",
"is",
"not",
"None",
":",
"real",
"=",
"r",
".",
"message",
"return",
"self",
".",
"response_error",
"(",
"151",
",",
"real",
")",
"except",
"UserNotAuthorizedError",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"except",
"(",
"RequisicaoVipsError",
",",
"EquipamentoError",
",",
"IpError",
",",
"HealthcheckExpectError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")",
"except",
"IpNotFoundByEquipAndVipError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"334",
",",
"e",
".",
"message",
")"
] | [
294,
4
] | [
375,
54
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DireitoGrupoEquipamentoResource.handle_post | (self, request, user, *args, **kwargs) | Trata as requisições de POST para inserir direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/
| Trata as requisições de POST para inserir direitos de um grupo de usuário em um grupo de equipamento. | def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para inserir direitos de um grupo de usuário em um grupo de equipamento.
URL: direitosgrupoequipamento/
"""
try:
if not has_perm(user, AdminPermission.USER_ADMINISTRATION, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
try:
xml_map, attrs_map = loads(request.raw_post_data)
self.log.debug('XML_MAP: %s', xml_map)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisicao.')
return self.response_error(3, x)
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.')
direito_map = networkapi_map.get('direito_grupo_equipamento')
if direito_map is None:
return self.response_error(3, u'Não existe valor para a tag direito_grupo_equipamento do XML de requisição.')
response = self.__valida_request(direito_map)
if response is not None:
return response
direito = DireitosGrupoEquipamento()
direito.egrupo = EGrupo(id=direito_map.get('id_grupo_equipamento'))
direito.ugrupo = UGrupo(id=direito_map.get('id_grupo_usuario'))
direito.leitura = direito_map.get('leitura')
direito.escrita = direito_map.get('escrita')
direito.alterar_config = direito_map.get('alterar_config')
direito.exclusao = direito_map.get('exclusao')
direito.create(user)
return self.response(dumps_networkapi({'direito_grupo_equipamento': {'id': direito.id}}))
except InvalidValueError, e:
return self.response_error(269, e.param, e.value)
except UGrupo.DoesNotExist:
return self.response_error(180, direito_map.get('id_grupo_usuario'))
except EGrupoNotFoundError:
return self.response_error(102)
except DireitoGrupoEquipamentoDuplicatedError:
return self.response_error(267, direito_map.get('id_grupo_usuario'), direito_map.get('id_grupo_equipamento'))
except (GrupoError):
return self.response_error(1) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"USER_ADMINISTRATION",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"try",
":",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"self",
".",
"log",
".",
"debug",
"(",
"'XML_MAP: %s'",
",",
"xml_map",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisicao.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"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.')",
"",
"direito_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'direito_grupo_equipamento'",
")",
"if",
"direito_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag direito_grupo_equipamento do XML de requisição.')",
"",
"response",
"=",
"self",
".",
"__valida_request",
"(",
"direito_map",
")",
"if",
"response",
"is",
"not",
"None",
":",
"return",
"response",
"direito",
"=",
"DireitosGrupoEquipamento",
"(",
")",
"direito",
".",
"egrupo",
"=",
"EGrupo",
"(",
"id",
"=",
"direito_map",
".",
"get",
"(",
"'id_grupo_equipamento'",
")",
")",
"direito",
".",
"ugrupo",
"=",
"UGrupo",
"(",
"id",
"=",
"direito_map",
".",
"get",
"(",
"'id_grupo_usuario'",
")",
")",
"direito",
".",
"leitura",
"=",
"direito_map",
".",
"get",
"(",
"'leitura'",
")",
"direito",
".",
"escrita",
"=",
"direito_map",
".",
"get",
"(",
"'escrita'",
")",
"direito",
".",
"alterar_config",
"=",
"direito_map",
".",
"get",
"(",
"'alterar_config'",
")",
"direito",
".",
"exclusao",
"=",
"direito_map",
".",
"get",
"(",
"'exclusao'",
")",
"direito",
".",
"create",
"(",
"user",
")",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'direito_grupo_equipamento'",
":",
"{",
"'id'",
":",
"direito",
".",
"id",
"}",
"}",
")",
")",
"except",
"InvalidValueError",
",",
"e",
":",
"return",
"self",
".",
"response_error",
"(",
"269",
",",
"e",
".",
"param",
",",
"e",
".",
"value",
")",
"except",
"UGrupo",
".",
"DoesNotExist",
":",
"return",
"self",
".",
"response_error",
"(",
"180",
",",
"direito_map",
".",
"get",
"(",
"'id_grupo_usuario'",
")",
")",
"except",
"EGrupoNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"102",
")",
"except",
"DireitoGrupoEquipamentoDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"267",
",",
"direito_map",
".",
"get",
"(",
"'id_grupo_usuario'",
")",
",",
"direito_map",
".",
"get",
"(",
"'id_grupo_equipamento'",
")",
")",
"except",
"(",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
352,
4
] | [
400,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
acc_sum | (_list) | return acc_list | Retorna uma lista em que cada elemento é a soma dos anteriores | Retorna uma lista em que cada elemento é a soma dos anteriores | def acc_sum(_list):
"""Retorna uma lista em que cada elemento é a soma dos anteriores"""
acc_list = []
acc = _list.pop(0)
for elm in _list:
acc_list.append(acc)
acc += elm
return acc_list | [
"def",
"acc_sum",
"(",
"_list",
")",
":",
"acc_list",
"=",
"[",
"]",
"acc",
"=",
"_list",
".",
"pop",
"(",
"0",
")",
"for",
"elm",
"in",
"_list",
":",
"acc_list",
".",
"append",
"(",
"acc",
")",
"acc",
"+=",
"elm",
"return",
"acc_list"
] | [
5,
0
] | [
12,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Ship.update | (self) | Atuliza a posição da espaçonave de acordo com a flag de movimento | Atuliza a posição da espaçonave de acordo com a flag de movimento | def update(self):
'''Atuliza a posição da espaçonave de acordo com a flag de movimento'''
# Atualiza o centro da espaçonave, e nao o retangulo
if self.moving_right and self.rect.right < self.screen_rect.right:
self.center += self.ai_settings.ship_speed_factor
if self.moving_left and self.rect.left > 0:
self.center -= self.ai_settings.ship_speed_factor
# Atualiza o objeto rect de acordo com o self.center
self.rect.centerx = self.center | [
"def",
"update",
"(",
"self",
")",
":",
"# Atualiza o centro da espaçonave, e nao o retangulo",
"if",
"self",
".",
"moving_right",
"and",
"self",
".",
"rect",
".",
"right",
"<",
"self",
".",
"screen_rect",
".",
"right",
":",
"self",
".",
"center",
"+=",
"self",
".",
"ai_settings",
".",
"ship_speed_factor",
"if",
"self",
".",
"moving_left",
"and",
"self",
".",
"rect",
".",
"left",
">",
"0",
":",
"self",
".",
"center",
"-=",
"self",
".",
"ai_settings",
".",
"ship_speed_factor",
"# Atualiza o objeto rect de acordo com o self.center",
"self",
".",
"rect",
".",
"centerx",
"=",
"self",
".",
"center"
] | [
25,
4
] | [
34,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
EGrupo.create | (self, authenticated_user) | Insere um novo grupo de equipamento.
@return: Nothing.
@raise EGrupoNameDuplicatedError: Grupo de equipamento com o nome já cadastrado
@raise GrupoError: Falha ao inserir o grupo.
| Insere um novo grupo de equipamento. | def create(self, authenticated_user):
"""Insere um novo grupo de equipamento.
@return: Nothing.
@raise EGrupoNameDuplicatedError: Grupo de equipamento com o nome já cadastrado
@raise GrupoError: Falha ao inserir o grupo.
"""
try:
try:
EGrupo.objects.get(nome__iexact=self.nome)
raise EGrupoNameDuplicatedError(
None, u'Grupo de equipamento com o nome %s já cadastrado' % self.nome)
except EGrupo.DoesNotExist:
pass
self.save()
except EGrupoNameDuplicatedError, e:
raise e
except Exception, e:
self.log.error(u'Falha ao inserir o grupo de equipamento.')
raise GrupoError(e, u'Falha ao inserir o grupo de equipamento.') | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
")",
":",
"try",
":",
"try",
":",
"EGrupo",
".",
"objects",
".",
"get",
"(",
"nome__iexact",
"=",
"self",
".",
"nome",
")",
"raise",
"EGrupoNameDuplicatedError",
"(",
"None",
",",
"u'Grupo de equipamento com o nome %s já cadastrado' ",
" ",
"elf.",
"n",
"ome)",
"",
"except",
"EGrupo",
".",
"DoesNotExist",
":",
"pass",
"self",
".",
"save",
"(",
")",
"except",
"EGrupoNameDuplicatedError",
",",
"e",
":",
"raise",
"e",
"except",
"Exception",
",",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir o grupo de equipamento.'",
")",
"raise",
"GrupoError",
"(",
"e",
",",
"u'Falha ao inserir o grupo de equipamento.'",
")"
] | [
344,
4
] | [
365,
76
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
bfs | (initial, goal_test, successors) | return None | Algoritmo de busca em largura. | Algoritmo de busca em largura. | def bfs(initial, goal_test, successors):
"""Algoritmo de busca em largura."""
# frontier representa os lugares que ainda nao visitamos
frontier = Queue()
frontier.push(Node(initial, None))
# explored representa os lugares que ja foram visitados
explored = {initial}
# continua enquanto houver lugares para explorar
while not frontier.empty:
current_node = frontier.pop()
current_state = current_node.state
# se encontrar o objetivo retorna o no atual
if goal_test(current_state):
return current_node
# verifica para onde podemos ir em seguida
for child in successors(current_state):
# ignora os nos filhos que ja foram visitados
if child in explored:
continue
explored.add(child)
frontier.push(Node(child, current_node))
# passamos por todos os lugares e nao atingimos o objetivo
return None | [
"def",
"bfs",
"(",
"initial",
",",
"goal_test",
",",
"successors",
")",
":",
"# frontier representa os lugares que ainda nao visitamos",
"frontier",
"=",
"Queue",
"(",
")",
"frontier",
".",
"push",
"(",
"Node",
"(",
"initial",
",",
"None",
")",
")",
"# explored representa os lugares que ja foram visitados",
"explored",
"=",
"{",
"initial",
"}",
"# continua enquanto houver lugares para explorar",
"while",
"not",
"frontier",
".",
"empty",
":",
"current_node",
"=",
"frontier",
".",
"pop",
"(",
")",
"current_state",
"=",
"current_node",
".",
"state",
"# se encontrar o objetivo retorna o no atual",
"if",
"goal_test",
"(",
"current_state",
")",
":",
"return",
"current_node",
"# verifica para onde podemos ir em seguida",
"for",
"child",
"in",
"successors",
"(",
"current_state",
")",
":",
"# ignora os nos filhos que ja foram visitados",
"if",
"child",
"in",
"explored",
":",
"continue",
"explored",
".",
"add",
"(",
"child",
")",
"frontier",
".",
"push",
"(",
"Node",
"(",
"child",
",",
"current_node",
")",
")",
"# passamos por todos os lugares e nao atingimos o objetivo",
"return",
"None"
] | [
157,
0
] | [
182,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ler_faces | (qnt_jogadas) | return jogadas | Recebe do usuário a quantidade
de jogadas dadas como parâmetro e
retorna uma lista com as jogadas
int -> list
| Recebe do usuário a quantidade
de jogadas dadas como parâmetro e
retorna uma lista com as jogadas
int -> list
| def ler_faces(qnt_jogadas):
"""Recebe do usuário a quantidade
de jogadas dadas como parâmetro e
retorna uma lista com as jogadas
int -> list
"""
jogadas = []
while len(jogadas) < qnt_jogadas:
jogada = int(input("Digite um numero entre 1 e 6 : "))
if jogada >= 1 and jogada <= 6:
jogadas.append(jogada)
print(f"{len(jogadas)}° face registrada !")
else:
print("Número inválido. ",end="")
return jogadas | [
"def",
"ler_faces",
"(",
"qnt_jogadas",
")",
":",
"jogadas",
"=",
"[",
"]",
"while",
"len",
"(",
"jogadas",
")",
"<",
"qnt_jogadas",
":",
"jogada",
"=",
"int",
"(",
"input",
"(",
"\"Digite um numero entre 1 e 6 : \"",
")",
")",
"if",
"jogada",
">=",
"1",
"and",
"jogada",
"<=",
"6",
":",
"jogadas",
".",
"append",
"(",
"jogada",
")",
"print",
"(",
"f\"{len(jogadas)}° face registrada !\")",
"",
"else",
":",
"print",
"(",
"\"Número inválido. \",e",
"n",
"d=\"",
"\"",
")",
"",
"return",
"jogadas"
] | [
12,
0
] | [
28,
15
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
register_issues | (ds, **kwargs) | return tasks | Registra ou atualiza todos os fascículos a partir do Kernel.
Fascículos de periódicos não encontrados são marcados como órfãos e
armazenados em uma variável persistente para futuras tentativas.
| Registra ou atualiza todos os fascículos a partir do Kernel. | def register_issues(ds, **kwargs):
"""Registra ou atualiza todos os fascículos a partir do Kernel.
Fascículos de periódicos não encontrados são marcados como órfãos e
armazenados em uma variável persistente para futuras tentativas.
"""
tasks = kwargs["ti"].xcom_pull(key="tasks", task_ids="read_changes_task")
known_issues = kwargs["ti"].xcom_pull(
key="known_issues", task_ids="register_journals_task"
)
def _journal_id(issue_id):
"""Obtém o identificador do periódico onde `issue_id` está contido."""
for journal_id, items in known_issues.items():
for item in items:
if issue_id == item["id"]:
return journal_id
def _issue_order(issue_id):
"""A posição em relação aos demais fascículos do periódico.
Pode levantar `ValueError` caso `issue_id` não conste na relação de
fascículos do periódico `journal_id`.
"""
issues = known_issues.get(_journal_id(issue_id), [])
for issue in issues:
if issue_id == issue["id"]:
return issue["order"]
issues_to_get = itertools.chain(
Variable.get("orphan_issues", default_var=[], deserialize_json=True),
(get_id(task["id"]) for task in filter_changes(tasks, "bundles", "get")),
)
orphans, known_documents = try_register_issues(
issues_to_get, _journal_id, _issue_order, fetch_bundles, IssueFactory
)
kwargs["ti"].xcom_push(key="i_documents", value=known_documents)
Variable.set("orphan_issues", orphans, serialize_json=True)
return tasks | [
"def",
"register_issues",
"(",
"ds",
",",
"*",
"*",
"kwargs",
")",
":",
"tasks",
"=",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_pull",
"(",
"key",
"=",
"\"tasks\"",
",",
"task_ids",
"=",
"\"read_changes_task\"",
")",
"known_issues",
"=",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_pull",
"(",
"key",
"=",
"\"known_issues\"",
",",
"task_ids",
"=",
"\"register_journals_task\"",
")",
"def",
"_journal_id",
"(",
"issue_id",
")",
":",
"\"\"\"Obtém o identificador do periódico onde `issue_id` está contido.\"\"\"",
"for",
"journal_id",
",",
"items",
"in",
"known_issues",
".",
"items",
"(",
")",
":",
"for",
"item",
"in",
"items",
":",
"if",
"issue_id",
"==",
"item",
"[",
"\"id\"",
"]",
":",
"return",
"journal_id",
"def",
"_issue_order",
"(",
"issue_id",
")",
":",
"\"\"\"A posição em relação aos demais fascículos do periódico.\n \n Pode levantar `ValueError` caso `issue_id` não conste na relação de \n fascículos do periódico `journal_id`.\n \"\"\"",
"issues",
"=",
"known_issues",
".",
"get",
"(",
"_journal_id",
"(",
"issue_id",
")",
",",
"[",
"]",
")",
"for",
"issue",
"in",
"issues",
":",
"if",
"issue_id",
"==",
"issue",
"[",
"\"id\"",
"]",
":",
"return",
"issue",
"[",
"\"order\"",
"]",
"issues_to_get",
"=",
"itertools",
".",
"chain",
"(",
"Variable",
".",
"get",
"(",
"\"orphan_issues\"",
",",
"default_var",
"=",
"[",
"]",
",",
"deserialize_json",
"=",
"True",
")",
",",
"(",
"get_id",
"(",
"task",
"[",
"\"id\"",
"]",
")",
"for",
"task",
"in",
"filter_changes",
"(",
"tasks",
",",
"\"bundles\"",
",",
"\"get\"",
")",
")",
",",
")",
"orphans",
",",
"known_documents",
"=",
"try_register_issues",
"(",
"issues_to_get",
",",
"_journal_id",
",",
"_issue_order",
",",
"fetch_bundles",
",",
"IssueFactory",
")",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_push",
"(",
"key",
"=",
"\"i_documents\"",
",",
"value",
"=",
"known_documents",
")",
"Variable",
".",
"set",
"(",
"\"orphan_issues\"",
",",
"orphans",
",",
"serialize_json",
"=",
"True",
")",
"return",
"tasks"
] | [
483,
0
] | [
523,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Command.add_arguments | (self, parser) | Configura os parâmetros e opções | Configura os parâmetros e opções | def add_arguments(self, parser):
"Configura os parâmetros e opções"
parser.add_argument('id_campanha', nargs=1, type=int)
parser.add_argument('arquivo', nargs=1, type=str)
parser.add_argument('enderecoremoto', nargs=1, type=str) | [
"def",
"add_arguments",
"(",
"self",
",",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'id_campanha'",
",",
"nargs",
"=",
"1",
",",
"type",
"=",
"int",
")",
"parser",
".",
"add_argument",
"(",
"'arquivo'",
",",
"nargs",
"=",
"1",
",",
"type",
"=",
"str",
")",
"parser",
".",
"add_argument",
"(",
"'enderecoremoto'",
",",
"nargs",
"=",
"1",
",",
"type",
"=",
"str",
")"
] | [
21,
4
] | [
25,
64
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
make_shirt | (mensagem = 'I love Python', tamanho = 'G') | Exibe o tamanho de uma camiseta e uma mensagem | Exibe o tamanho de uma camiseta e uma mensagem | def make_shirt(mensagem = 'I love Python', tamanho = 'G'):
"""Exibe o tamanho de uma camiseta e uma mensagem"""
print(f'Camiseta tamanho {tamanho}!')
print(f'A mensagem da camiseta é {mensagem}\n') | [
"def",
"make_shirt",
"(",
"mensagem",
"=",
"'I love Python'",
",",
"tamanho",
"=",
"'G'",
")",
":",
"print",
"(",
"f'Camiseta tamanho {tamanho}!'",
")",
"print",
"(",
"f'A mensagem da camiseta é {mensagem}\\n')",
""
] | [
4,
0
] | [
7,
52
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType24.group_id | (self) | return bin2int(self.data[BYTES_24[0]]) | F0 - Número identificador do grupo. Zero significa que não faz parte de nenhum grupo | F0 - Número identificador do grupo. Zero significa que não faz parte de nenhum grupo | def group_id(self) -> int:
"""F0 - Número identificador do grupo. Zero significa que não faz parte de nenhum grupo"""
return bin2int(self.data[BYTES_24[0]]) | [
"def",
"group_id",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_24",
"[",
"0",
"]",
"]",
")"
] | [
526,
4
] | [
528,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
cp | (de, para, recursive) | Copia arquivos DE um lugar PARA outro. | Copia arquivos DE um lugar PARA outro. | def cp(de, para, recursive):
"""Copia arquivos DE um lugar PARA outro."""
if recursive:
copytree(abspath(de), abspath(para))
else:
copy(abspath(de), abspath(para)) | [
"def",
"cp",
"(",
"de",
",",
"para",
",",
"recursive",
")",
":",
"if",
"recursive",
":",
"copytree",
"(",
"abspath",
"(",
"de",
")",
",",
"abspath",
"(",
"para",
")",
")",
"else",
":",
"copy",
"(",
"abspath",
"(",
"de",
")",
",",
"abspath",
"(",
"para",
")",
")"
] | [
16,
0
] | [
21,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TipoRedeResource.handle_delete | (self, request, user, *args, **kwargs) | Trata uma requisição DELETE para excluir um tipo de rede
URL: /tiporede/<id_tipo_rede>/
| Trata uma requisição DELETE para excluir um tipo de rede | def handle_delete(self, request, user, *args, **kwargs):
"""Trata uma requisição DELETE para excluir um tipo de rede
URL: /tiporede/<id_tipo_rede>/
"""
# Verifica acesso e obtém dados do request
try:
# Verificar a permissão
if not has_perm(user, AdminPermission.NETWORK_TYPE_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
# Obtém argumentos passados na URL
id_tipo_rede = kwargs.get('id_tipo_rede')
if id_tipo_rede is None:
return self.response_error(256)
# Remove a informação de acesso a equipamento
TipoRede.remove(user, id_tipo_rede)
# Retorna response vazio em caso de sucesso
return self.response(dumps_networkapi({}))
except TipoRedeNotFoundError:
return self.response_error(111)
except TipoRedeUsedByVlanError:
return self.response_error(215, id_tipo_rede)
except (GrupoError, VlanError):
return self.response_error(1) | [
"def",
"handle_delete",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# Verifica acesso e obtém dados do request",
"try",
":",
"# Verificar a permissão",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"NETWORK_TYPE_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"# Obtém argumentos passados na URL",
"id_tipo_rede",
"=",
"kwargs",
".",
"get",
"(",
"'id_tipo_rede'",
")",
"if",
"id_tipo_rede",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"256",
")",
"# Remove a informação de acesso a equipamento",
"TipoRede",
".",
"remove",
"(",
"user",
",",
"id_tipo_rede",
")",
"# Retorna response vazio em caso de sucesso",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"}",
")",
")",
"except",
"TipoRedeNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"111",
")",
"except",
"TipoRedeUsedByVlanError",
":",
"return",
"self",
".",
"response_error",
"(",
"215",
",",
"id_tipo_rede",
")",
"except",
"(",
"GrupoError",
",",
"VlanError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
175,
4
] | [
203,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
update | (id) | return render_template('livro/update.html', livro_content={'editoras': editoras, 'autores': autores, 'livro': livro}, error=error) | Atualiza um livro pelo seu respectivo id. | Atualiza um livro pelo seu respectivo id. | def update(id):
"""Atualiza um livro pelo seu respectivo id."""
livro = get_livro(id)
editoras = db.query_bd('select * from editora')
autores = db.query_bd('select * from autor')
error = ''
if request.method == 'POST':
request_parsed = parse_request(request)
try:
f = ""
if request.files['image']:
file = request.files['image']
f = upload_file(file)
name_image = f.filename if f else livro['caminho_imagem']
sql = 'UPDATE livro set titulo = "%s", entrada = "%s", etq = "%s", ano = "%s", ex = "%s", v = "%s", id_editora = "%s", id_autor = "%s", qtd = "%s" where tombo = %d' % (request_parsed['titulo'], request_parsed['entrada'], request_parsed['etiqueta'], request_parsed['ano'], request_parsed['exemplar'], request_parsed['volume'], request_parsed['id_editora'], request_parsed['id_autor'], request_parsed['quantidade'],request_parsed['tombo'])
db.insert_bd(sql)
return redirect(url_for('livro.index'))
except:
error = 'Não foi possível atualizar esse livro!'
return render_template('livro/update.html', livro_content={'editoras': editoras, 'autores': autores, 'livro': livro}, error=error) | [
"def",
"update",
"(",
"id",
")",
":",
"livro",
"=",
"get_livro",
"(",
"id",
")",
"editoras",
"=",
"db",
".",
"query_bd",
"(",
"'select * from editora'",
")",
"autores",
"=",
"db",
".",
"query_bd",
"(",
"'select * from autor'",
")",
"error",
"=",
"''",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"request_parsed",
"=",
"parse_request",
"(",
"request",
")",
"try",
":",
"f",
"=",
"\"\"",
"if",
"request",
".",
"files",
"[",
"'image'",
"]",
":",
"file",
"=",
"request",
".",
"files",
"[",
"'image'",
"]",
"f",
"=",
"upload_file",
"(",
"file",
")",
"name_image",
"=",
"f",
".",
"filename",
"if",
"f",
"else",
"livro",
"[",
"'caminho_imagem'",
"]",
"sql",
"=",
"'UPDATE livro set titulo = \"%s\", entrada = \"%s\", etq = \"%s\", ano = \"%s\", ex = \"%s\", v = \"%s\", id_editora = \"%s\", id_autor = \"%s\", qtd = \"%s\" where tombo = %d'",
"%",
"(",
"request_parsed",
"[",
"'titulo'",
"]",
",",
"request_parsed",
"[",
"'entrada'",
"]",
",",
"request_parsed",
"[",
"'etiqueta'",
"]",
",",
"request_parsed",
"[",
"'ano'",
"]",
",",
"request_parsed",
"[",
"'exemplar'",
"]",
",",
"request_parsed",
"[",
"'volume'",
"]",
",",
"request_parsed",
"[",
"'id_editora'",
"]",
",",
"request_parsed",
"[",
"'id_autor'",
"]",
",",
"request_parsed",
"[",
"'quantidade'",
"]",
",",
"request_parsed",
"[",
"'tombo'",
"]",
")",
"db",
".",
"insert_bd",
"(",
"sql",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'livro.index'",
")",
")",
"except",
":",
"error",
"=",
"'Não foi possível atualizar esse livro!'",
"return",
"render_template",
"(",
"'livro/update.html'",
",",
"livro_content",
"=",
"{",
"'editoras'",
":",
"editoras",
",",
"'autores'",
":",
"autores",
",",
"'livro'",
":",
"livro",
"}",
",",
"error",
"=",
"error",
")"
] | [
128,
0
] | [
149,
134
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ScoreBoard.prep_high_score | (self) | Transforma a pontuacao maxima em uma imagem renderizada. | Transforma a pontuacao maxima em uma imagem renderizada. | def prep_high_score(self):
"""Transforma a pontuacao maxima em uma imagem renderizada."""
high_score = round(self.stats.high_score, -1)
high_score_str = "{:,}".format(high_score)
self.high_score_image = self.font.render('High score: '+high_score_str, True,
self.text_color,
self.ai_settings.bg_color)
# Centraliza a pontuacao maxima 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 = self.score_rect.top | [
"def",
"prep_high_score",
"(",
"self",
")",
":",
"high_score",
"=",
"round",
"(",
"self",
".",
"stats",
".",
"high_score",
",",
"-",
"1",
")",
"high_score_str",
"=",
"\"{:,}\"",
".",
"format",
"(",
"high_score",
")",
"self",
".",
"high_score_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"'High score: '",
"+",
"high_score_str",
",",
"True",
",",
"self",
".",
"text_color",
",",
"self",
".",
"ai_settings",
".",
"bg_color",
")",
"# Centraliza a pontuacao maxima 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",
"=",
"self",
".",
"score_rect",
".",
"top"
] | [
42,
4
] | [
53,
54
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
rule_match | (state, rules) | Encontre a primeira regra que corresponda ao estado. | Encontre a primeira regra que corresponda ao estado. | def rule_match(state, rules):
"Encontre a primeira regra que corresponda ao estado."
for rule in rules:
if rule.matches(state):
return rule | [
"def",
"rule_match",
"(",
"state",
",",
"rules",
")",
":",
"for",
"rule",
"in",
"rules",
":",
"if",
"rule",
".",
"matches",
"(",
"state",
")",
":",
"return",
"rule"
] | [
116,
0
] | [
120,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
historico_paciente | () | return render_template('historico.html', title='HISTÓRICO', paciente=paciente, idade_mes=idade_mes, vacinas_geral=lista_vacinas_geral, historico=lista_historico, proximas=lista_proximas_vacinas, faixas=lista_vacinas_geral_num_dose, dadosvacina=zip(lista_vacinas_geral,lista_vacinas_geral_num_dose)) | Fornece o histórico de um paciente | Fornece o histórico de um paciente | def historico_paciente():
'''Fornece o histórico de um paciente'''
# Dados do paciente
paciente = db.session.query(Pessoa).filter(Pessoa.id == session['idPaciente']).first()
# Sua idade em mês
d1 = datetime.strptime(str(paciente.nascimento), "%Y-%m-%d")
d2 = datetime.strptime(str(datetime.now().strftime('%Y-%m-%d')), "%Y-%m-%d")
idade_mes = math.floor((abs((d2 - d1).days)/365)*12)
# Buscando alguma Faixa Etaria
faixa_etaria = db.session.query(Faixa_Etaria).filter(Faixa_Etaria.faixa == idade_mes).first()
# Buscando id do ano atual
now = datetime.now()
ano = db.session.query(Ano).filter(Ano.ano == str(now.year)).first()
session['idAnoAtual'] = ano.id
# Vacinas geral
lista_vacinas_geral = []
if not faixa_etaria:
print("> Nenhuma faixa etaria.")
else:
session['faixaEtariaPaciente'] = faixa_etaria.faixa
session['idFaixaEtaria'] = faixa_etaria.id
# Vacinas a serem aplicadas no momento da tabela Vacinacao
vacinas = db.session.query(Vacinacao).filter(Vacinacao.idFaixaEtaria == faixa_etaria.id, Vacinacao.idAno == ano.id).all()
# Vacinas que ja foram aplicadas nessa faixa etaria a partir da Tabela historico
vacinas_ja_aplicadas = db.session.query(Historico).filter(Historico.idPessoa == session['idPaciente'],Historico.idFaixaEtaria == faixa_etaria.id)
# Seleiconando vacinas geral que nao foram aplicadas na faixa etaria
aux = False
for v in vacinas:
vacina_geral = db.session.query(Vacina_Geral).filter(Vacina_Geral.id == v.idVacinaGeral).first()
for vj in vacinas_ja_aplicadas:
if vacina_geral.id == vj.idVacinaGeral:
aux = True
if aux:
print("> Vacina já aplicada para essa faixa etária")
else:
lista_vacinas_geral.append(vacina_geral)
aux = False
# Verificando qual a dose da vacina geral
lista_vacinas_geral_num_dose = []
for i in lista_vacinas_geral:
# Verificando todas as faixas etarias de cada Vacina Geral escolhida
faixas_vacina_escolhida = db.session.query(Faixa_Etaria).join(Vacinacao).filter(Vacinacao.idVacinaGeral == i.id, Vacinacao.idAno == ano.id).order_by(Faixa_Etaria.faixa)
lista_faixas_vacina_escolhida = []
for i in faixas_vacina_escolhida: # Lista com todas as faixas da vacina geral
lista_faixas_vacina_escolhida.append(i.faixa)
numDoseAtual = lista_faixas_vacina_escolhida.index(session['faixaEtariaPaciente']) + 1
lista_vacinas_geral_num_dose.append(numDoseAtual)
# Historico
historico = db.session.query(Historico).filter(Historico.idPessoa == session['idPaciente'])
lista_historico = []
if not historico:
print("> Nenhum histórico")
else:
for h in historico:
item = []
vacina_geral = db.session.query(Vacina_Geral).filter(Vacina_Geral.id == h.idVacinaGeral).first()
local = db.session.query(Unidade_Saude).filter(Unidade_Saude.id == h.idUnidadeSaude).first()
vacina = db.session.query(Vacina).filter(Vacina.id == h.idVacina).first()
item.append(vacina_geral.nome)
item.append(local.nome)
item.append(h.data)
item.append(vacina.nome)
item.append(h.doseAtual)
item.append(vacina.nDose)
lista_historico.append(item)
# Proxima Dose
pd = db.session.query(Proxima_Dose).filter(Proxima_Dose.idPessoa == session['idPaciente'])
# Listando somente datas que ainda nao ocorreram
lista_pd_ativas = []
hoje = date.today()
for i in pd:
if i.data > hoje:
lista_pd_ativas.append(i)
lista_proximas_vacinas = []
for l in lista_pd_ativas:
lista_aux_pd = []
vacinaGeral = db.session.query(Vacina_Geral).filter(Vacina_Geral.id == l.idVacinaGeral).first()
lista_aux_pd.append(vacinaGeral.nome)
lista_aux_pd.append(l.data)
lista_proximas_vacinas.append(lista_aux_pd)
return render_template('historico.html', title='HISTÓRICO', paciente=paciente, idade_mes=idade_mes, vacinas_geral=lista_vacinas_geral, historico=lista_historico, proximas=lista_proximas_vacinas, faixas=lista_vacinas_geral_num_dose, dadosvacina=zip(lista_vacinas_geral,lista_vacinas_geral_num_dose)) | [
"def",
"historico_paciente",
"(",
")",
":",
"# Dados do paciente",
"paciente",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Pessoa",
")",
".",
"filter",
"(",
"Pessoa",
".",
"id",
"==",
"session",
"[",
"'idPaciente'",
"]",
")",
".",
"first",
"(",
")",
"# Sua idade em mês",
"d1",
"=",
"datetime",
".",
"strptime",
"(",
"str",
"(",
"paciente",
".",
"nascimento",
")",
",",
"\"%Y-%m-%d\"",
")",
"d2",
"=",
"datetime",
".",
"strptime",
"(",
"str",
"(",
"datetime",
".",
"now",
"(",
")",
".",
"strftime",
"(",
"'%Y-%m-%d'",
")",
")",
",",
"\"%Y-%m-%d\"",
")",
"idade_mes",
"=",
"math",
".",
"floor",
"(",
"(",
"abs",
"(",
"(",
"d2",
"-",
"d1",
")",
".",
"days",
")",
"/",
"365",
")",
"*",
"12",
")",
"# Buscando alguma Faixa Etaria",
"faixa_etaria",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Faixa_Etaria",
")",
".",
"filter",
"(",
"Faixa_Etaria",
".",
"faixa",
"==",
"idade_mes",
")",
".",
"first",
"(",
")",
"# Buscando id do ano atual",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"ano",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Ano",
")",
".",
"filter",
"(",
"Ano",
".",
"ano",
"==",
"str",
"(",
"now",
".",
"year",
")",
")",
".",
"first",
"(",
")",
"session",
"[",
"'idAnoAtual'",
"]",
"=",
"ano",
".",
"id",
"# Vacinas geral",
"lista_vacinas_geral",
"=",
"[",
"]",
"if",
"not",
"faixa_etaria",
":",
"print",
"(",
"\"> Nenhuma faixa etaria.\"",
")",
"else",
":",
"session",
"[",
"'faixaEtariaPaciente'",
"]",
"=",
"faixa_etaria",
".",
"faixa",
"session",
"[",
"'idFaixaEtaria'",
"]",
"=",
"faixa_etaria",
".",
"id",
"# Vacinas a serem aplicadas no momento da tabela Vacinacao",
"vacinas",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacinacao",
")",
".",
"filter",
"(",
"Vacinacao",
".",
"idFaixaEtaria",
"==",
"faixa_etaria",
".",
"id",
",",
"Vacinacao",
".",
"idAno",
"==",
"ano",
".",
"id",
")",
".",
"all",
"(",
")",
"# Vacinas que ja foram aplicadas nessa faixa etaria a partir da Tabela historico",
"vacinas_ja_aplicadas",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Historico",
")",
".",
"filter",
"(",
"Historico",
".",
"idPessoa",
"==",
"session",
"[",
"'idPaciente'",
"]",
",",
"Historico",
".",
"idFaixaEtaria",
"==",
"faixa_etaria",
".",
"id",
")",
"# Seleiconando vacinas geral que nao foram aplicadas na faixa etaria",
"aux",
"=",
"False",
"for",
"v",
"in",
"vacinas",
":",
"vacina_geral",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacina_Geral",
")",
".",
"filter",
"(",
"Vacina_Geral",
".",
"id",
"==",
"v",
".",
"idVacinaGeral",
")",
".",
"first",
"(",
")",
"for",
"vj",
"in",
"vacinas_ja_aplicadas",
":",
"if",
"vacina_geral",
".",
"id",
"==",
"vj",
".",
"idVacinaGeral",
":",
"aux",
"=",
"True",
"if",
"aux",
":",
"print",
"(",
"\"> Vacina já aplicada para essa faixa etária\")",
"",
"else",
":",
"lista_vacinas_geral",
".",
"append",
"(",
"vacina_geral",
")",
"aux",
"=",
"False",
"# Verificando qual a dose da vacina geral",
"lista_vacinas_geral_num_dose",
"=",
"[",
"]",
"for",
"i",
"in",
"lista_vacinas_geral",
":",
"# Verificando todas as faixas etarias de cada Vacina Geral escolhida",
"faixas_vacina_escolhida",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Faixa_Etaria",
")",
".",
"join",
"(",
"Vacinacao",
")",
".",
"filter",
"(",
"Vacinacao",
".",
"idVacinaGeral",
"==",
"i",
".",
"id",
",",
"Vacinacao",
".",
"idAno",
"==",
"ano",
".",
"id",
")",
".",
"order_by",
"(",
"Faixa_Etaria",
".",
"faixa",
")",
"lista_faixas_vacina_escolhida",
"=",
"[",
"]",
"for",
"i",
"in",
"faixas_vacina_escolhida",
":",
"# Lista com todas as faixas da vacina geral",
"lista_faixas_vacina_escolhida",
".",
"append",
"(",
"i",
".",
"faixa",
")",
"numDoseAtual",
"=",
"lista_faixas_vacina_escolhida",
".",
"index",
"(",
"session",
"[",
"'faixaEtariaPaciente'",
"]",
")",
"+",
"1",
"lista_vacinas_geral_num_dose",
".",
"append",
"(",
"numDoseAtual",
")",
"# Historico",
"historico",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Historico",
")",
".",
"filter",
"(",
"Historico",
".",
"idPessoa",
"==",
"session",
"[",
"'idPaciente'",
"]",
")",
"lista_historico",
"=",
"[",
"]",
"if",
"not",
"historico",
":",
"print",
"(",
"\"> Nenhum histórico\")",
"",
"else",
":",
"for",
"h",
"in",
"historico",
":",
"item",
"=",
"[",
"]",
"vacina_geral",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacina_Geral",
")",
".",
"filter",
"(",
"Vacina_Geral",
".",
"id",
"==",
"h",
".",
"idVacinaGeral",
")",
".",
"first",
"(",
")",
"local",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Unidade_Saude",
")",
".",
"filter",
"(",
"Unidade_Saude",
".",
"id",
"==",
"h",
".",
"idUnidadeSaude",
")",
".",
"first",
"(",
")",
"vacina",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacina",
")",
".",
"filter",
"(",
"Vacina",
".",
"id",
"==",
"h",
".",
"idVacina",
")",
".",
"first",
"(",
")",
"item",
".",
"append",
"(",
"vacina_geral",
".",
"nome",
")",
"item",
".",
"append",
"(",
"local",
".",
"nome",
")",
"item",
".",
"append",
"(",
"h",
".",
"data",
")",
"item",
".",
"append",
"(",
"vacina",
".",
"nome",
")",
"item",
".",
"append",
"(",
"h",
".",
"doseAtual",
")",
"item",
".",
"append",
"(",
"vacina",
".",
"nDose",
")",
"lista_historico",
".",
"append",
"(",
"item",
")",
"# Proxima Dose",
"pd",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Proxima_Dose",
")",
".",
"filter",
"(",
"Proxima_Dose",
".",
"idPessoa",
"==",
"session",
"[",
"'idPaciente'",
"]",
")",
"# Listando somente datas que ainda nao ocorreram",
"lista_pd_ativas",
"=",
"[",
"]",
"hoje",
"=",
"date",
".",
"today",
"(",
")",
"for",
"i",
"in",
"pd",
":",
"if",
"i",
".",
"data",
">",
"hoje",
":",
"lista_pd_ativas",
".",
"append",
"(",
"i",
")",
"lista_proximas_vacinas",
"=",
"[",
"]",
"for",
"l",
"in",
"lista_pd_ativas",
":",
"lista_aux_pd",
"=",
"[",
"]",
"vacinaGeral",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacina_Geral",
")",
".",
"filter",
"(",
"Vacina_Geral",
".",
"id",
"==",
"l",
".",
"idVacinaGeral",
")",
".",
"first",
"(",
")",
"lista_aux_pd",
".",
"append",
"(",
"vacinaGeral",
".",
"nome",
")",
"lista_aux_pd",
".",
"append",
"(",
"l",
".",
"data",
")",
"lista_proximas_vacinas",
".",
"append",
"(",
"lista_aux_pd",
")",
"return",
"render_template",
"(",
"'historico.html'",
",",
"title",
"=",
"'HISTÓRICO',",
" ",
"aciente=",
"p",
"aciente,",
" ",
"dade_mes=",
"i",
"dade_mes,",
" ",
"acinas_geral=",
"l",
"ista_vacinas_geral,",
" ",
"istorico=",
"l",
"ista_historico,",
" ",
"roximas=",
"l",
"ista_proximas_vacinas,",
" ",
"aixas=",
"l",
"ista_vacinas_geral_num_dose,",
" ",
"adosvacina=",
"z",
"ip(",
"l",
"ista_vacinas_geral,",
"l",
"ista_vacinas_geral_num_dose)",
")",
""
] | [
174,
0
] | [
271,
303
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
pesquisar_paciente | () | Realiza a pesquisa por um paciente | Realiza a pesquisa por um paciente | def pesquisar_paciente():
'''Realiza a pesquisa por um paciente'''
form = PesquisarPaciente()
if request.method == 'GET':
return render_template('pesquisar_paciente.html', title='Pesquisar paciente', form=form)
if form.validate_on_submit():
cpf = request.form['cpf']
paciente = db.session.query(Pessoa).filter(Pessoa.cpf == cpf).first()
if paciente is not None:
session['cpf'] = paciente.cpf
session['idPaciente'] = paciente.id
return redirect(url_for('historico_paciente'))
else:
flash('Paciente não encontrado, favor realizar o seu cadastro')
return render_template('index.html', title='SICOVAC') | [
"def",
"pesquisar_paciente",
"(",
")",
":",
"form",
"=",
"PesquisarPaciente",
"(",
")",
"if",
"request",
".",
"method",
"==",
"'GET'",
":",
"return",
"render_template",
"(",
"'pesquisar_paciente.html'",
",",
"title",
"=",
"'Pesquisar paciente'",
",",
"form",
"=",
"form",
")",
"if",
"form",
".",
"validate_on_submit",
"(",
")",
":",
"cpf",
"=",
"request",
".",
"form",
"[",
"'cpf'",
"]",
"paciente",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Pessoa",
")",
".",
"filter",
"(",
"Pessoa",
".",
"cpf",
"==",
"cpf",
")",
".",
"first",
"(",
")",
"if",
"paciente",
"is",
"not",
"None",
":",
"session",
"[",
"'cpf'",
"]",
"=",
"paciente",
".",
"cpf",
"session",
"[",
"'idPaciente'",
"]",
"=",
"paciente",
".",
"id",
"return",
"redirect",
"(",
"url_for",
"(",
"'historico_paciente'",
")",
")",
"else",
":",
"flash",
"(",
"'Paciente não encontrado, favor realizar o seu cadastro')",
"",
"return",
"render_template",
"(",
"'index.html'",
",",
"title",
"=",
"'SICOVAC'",
")"
] | [
74,
0
] | [
92,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
particle_filtering | (e, N, HMM) | return s | Filtragem de partículas considerando duas variáveis de estados. | Filtragem de partículas considerando duas variáveis de estados. | def particle_filtering(e, N, HMM):
"""Filtragem de partículas considerando duas variáveis de estados."""
s = []
dist = [0.5, 0.5]
# Inicialização do estado
s = ["A" if probability(dist[0]) else "B" for i in range(N)]
# Inicialização de peso
w = [0 for i in range(N)]
# PASSO 1 - Propagar um passo usando o modelo de transição dado estado anterior
dist = vector_add(
scalar_vector_product(dist[0], HMM.transition_model[0]),
scalar_vector_product(dist[1], HMM.transition_model[1]),
)
# Atribuir o estado de acordo com a probabilidade
s = ["A" if probability(dist[0]) else "B" for i in range(N)]
w_tot = 0
# Calcular peso de importância dado evidência e
for i in range(N):
if s[i] == "A":
# P(U|A)*P(A)
w_i = HMM.sensor_dist(e)[0] * dist[0]
if s[i] == "B":
# P(U|B)*P(B)
w_i = HMM.sensor_dist(e)[1] * dist[1]
w[i] = w_i
w_tot += w_i
# Normalizar todos os pesos
for i in range(N):
w[i] = w[i] / w_tot
# Limite pesos a 4 dígitos
for i in range(N):
w[i] = float("{0:.4f}".format(w[i]))
# STEP 2
s = weighted_sample_with_replacement(s, w, N)
return s | [
"def",
"particle_filtering",
"(",
"e",
",",
"N",
",",
"HMM",
")",
":",
"s",
"=",
"[",
"]",
"dist",
"=",
"[",
"0.5",
",",
"0.5",
"]",
"# Inicialização do estado",
"s",
"=",
"[",
"\"A\"",
"if",
"probability",
"(",
"dist",
"[",
"0",
"]",
")",
"else",
"\"B\"",
"for",
"i",
"in",
"range",
"(",
"N",
")",
"]",
"# Inicialização de peso",
"w",
"=",
"[",
"0",
"for",
"i",
"in",
"range",
"(",
"N",
")",
"]",
"# PASSO 1 - Propagar um passo usando o modelo de transição dado estado anterior",
"dist",
"=",
"vector_add",
"(",
"scalar_vector_product",
"(",
"dist",
"[",
"0",
"]",
",",
"HMM",
".",
"transition_model",
"[",
"0",
"]",
")",
",",
"scalar_vector_product",
"(",
"dist",
"[",
"1",
"]",
",",
"HMM",
".",
"transition_model",
"[",
"1",
"]",
")",
",",
")",
"# Atribuir o estado de acordo com a probabilidade",
"s",
"=",
"[",
"\"A\"",
"if",
"probability",
"(",
"dist",
"[",
"0",
"]",
")",
"else",
"\"B\"",
"for",
"i",
"in",
"range",
"(",
"N",
")",
"]",
"w_tot",
"=",
"0",
"# Calcular peso de importância dado evidência e",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"if",
"s",
"[",
"i",
"]",
"==",
"\"A\"",
":",
"# P(U|A)*P(A)",
"w_i",
"=",
"HMM",
".",
"sensor_dist",
"(",
"e",
")",
"[",
"0",
"]",
"*",
"dist",
"[",
"0",
"]",
"if",
"s",
"[",
"i",
"]",
"==",
"\"B\"",
":",
"# P(U|B)*P(B)",
"w_i",
"=",
"HMM",
".",
"sensor_dist",
"(",
"e",
")",
"[",
"1",
"]",
"*",
"dist",
"[",
"1",
"]",
"w",
"[",
"i",
"]",
"=",
"w_i",
"w_tot",
"+=",
"w_i",
"# Normalizar todos os pesos",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"w",
"[",
"i",
"]",
"=",
"w",
"[",
"i",
"]",
"/",
"w_tot",
"# Limite pesos a 4 dígitos",
"for",
"i",
"in",
"range",
"(",
"N",
")",
":",
"w",
"[",
"i",
"]",
"=",
"float",
"(",
"\"{0:.4f}\"",
".",
"format",
"(",
"w",
"[",
"i",
"]",
")",
")",
"# STEP 2",
"s",
"=",
"weighted_sample_with_replacement",
"(",
"s",
",",
"w",
",",
"N",
")",
"return",
"s"
] | [
611,
0
] | [
648,
12
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Tarefa.importar_tarefas | (campanha, tarefas) | Importa uma lista de tarefas | Importa uma lista de tarefas | def importar_tarefas(campanha, tarefas):
'Importa uma lista de tarefas'
for item in tarefas:
tarefa = Tarefa()
tarefa.campanha = campanha
tarefa.texto_original = item['original']
tarefa.texto_inteligencia = item['parseado']
tarefa.save() | [
"def",
"importar_tarefas",
"(",
"campanha",
",",
"tarefas",
")",
":",
"for",
"item",
"in",
"tarefas",
":",
"tarefa",
"=",
"Tarefa",
"(",
")",
"tarefa",
".",
"campanha",
"=",
"campanha",
"tarefa",
".",
"texto_original",
"=",
"item",
"[",
"'original'",
"]",
"tarefa",
".",
"texto_inteligencia",
"=",
"item",
"[",
"'parseado'",
"]",
"tarefa",
".",
"save",
"(",
")"
] | [
155,
4
] | [
162,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Bateria.bateria(s | elf): | Exibe uma frase que descreve a capacidade da bateria. | Exibe uma frase que descreve a capacidade da bateria. | def descrição_bateria(self):
"""Exibe uma frase que descreve a capacidade da bateria."""
print("Esse carro tem uma bateria com capacidade total de " +
str(self.capacidade_bateria) + "-KWh.") | [
"def",
"descri",
"ção_",
"bateria(s",
"e",
"lf):",
"",
"",
"print",
"(",
"\"Esse carro tem uma bateria com capacidade total de \"",
"+",
"str",
"(",
"self",
".",
"capacidade_bateria",
")",
"+",
"\"-KWh.\"",
")"
] | [
55,
4
] | [
58,
51
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
delete | (id) | Deleta um livro.
Certifica que o livro existe.
| Deleta um livro. | def delete(id):
"""Deleta um livro.
Certifica que o livro existe.
"""
try:
get_livro(id)
db.insert_bd('DELETE FROM livro WHERE tombo = %d' % id)
return redirect(url_for('livro.index'))
except Exception as e:
print(e)
return render_template('404.html') | [
"def",
"delete",
"(",
"id",
")",
":",
"try",
":",
"get_livro",
"(",
"id",
")",
"db",
".",
"insert_bd",
"(",
"'DELETE FROM livro WHERE tombo = %d'",
"%",
"id",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"'livro.index'",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
154,
0
] | [
167,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
listar_calendario | () | Lista um determinado calendário de vacinas | Lista um determinado calendário de vacinas | def listar_calendario():
'''Lista um determinado calendário de vacinas'''
form = PesquisarCalendario()
anos = db.session.query(Ano).order_by(Ano.ano)
form.calendario.choices = [(a.id, a.ano) for a in anos]
if request.method == 'GET':
return render_template('calendario.html', title='CALENDÁRIO', form=form)
if form.validate_on_submit():
# Vacinas Gerais do calendário
vacinas_calendario = db.session.query(Vacina_Geral).join(Vacinacao).filter(Vacinacao.idAno == request.form['calendario'])
# Doencas de cada Vacina Geral
doencas_vacinas_lista = [] # Lista com doencas de cada Vacina Geral
for vg in vacinas_calendario:
doencas_vacina_geral = db.session.query(Doenca).join(Vacina_Doenca).filter(Vacina_Doenca.idVacinaGeral == vg.id)
doencas = ''
for dvg in doencas_vacina_geral:
doencas = doencas + dvg.nome + ', '
doencas = doencas[:-2]
doencas_vacinas_lista.append(doencas)
# Faixas Etárias de cada Vacina
faixa_vacinas_lista = []
for vg in vacinas_calendario:
faixas = ''
faixas_vacina_geral = db.session.query(Faixa_Etaria).join(Vacinacao).filter(Vacinacao.idVacinaGeral == vg.id).all()
for i in faixas_vacina_geral:
if i.faixa > 24:
faixa_ano = int(math.floor(i.faixa / 12))
frac, full = math.modf((i.faixa/12))
if frac > 0.0:
sobra_mes = int(frac * 12)
faixas = faixas + str(faixa_ano) + ' anos e ' + str(sobra_mes) + ' meses, '
else:
faixas = faixas + str(faixa_ano) + ' anos, '
elif (i.faixa == 0) or (i.faixa == 1):
faixas = faixas + str(i.faixa) + ' mês, '
else:
faixas = faixas + str(i.faixa) + ' meses, '
faixas = faixas[:-2]
faixa_vacinas_lista.append(faixas)
return render_template('calendario.html', title='SICOVAC', form=form, dados=zip(vacinas_calendario,doencas_vacinas_lista,faixa_vacinas_lista)) | [
"def",
"listar_calendario",
"(",
")",
":",
"form",
"=",
"PesquisarCalendario",
"(",
")",
"anos",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Ano",
")",
".",
"order_by",
"(",
"Ano",
".",
"ano",
")",
"form",
".",
"calendario",
".",
"choices",
"=",
"[",
"(",
"a",
".",
"id",
",",
"a",
".",
"ano",
")",
"for",
"a",
"in",
"anos",
"]",
"if",
"request",
".",
"method",
"==",
"'GET'",
":",
"return",
"render_template",
"(",
"'calendario.html'",
",",
"title",
"=",
"'CALENDÁRIO',",
" ",
"orm=",
"f",
"orm)",
"",
"if",
"form",
".",
"validate_on_submit",
"(",
")",
":",
"# Vacinas Gerais do calendário",
"vacinas_calendario",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Vacina_Geral",
")",
".",
"join",
"(",
"Vacinacao",
")",
".",
"filter",
"(",
"Vacinacao",
".",
"idAno",
"==",
"request",
".",
"form",
"[",
"'calendario'",
"]",
")",
"# Doencas de cada Vacina Geral",
"doencas_vacinas_lista",
"=",
"[",
"]",
"# Lista com doencas de cada Vacina Geral",
"for",
"vg",
"in",
"vacinas_calendario",
":",
"doencas_vacina_geral",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Doenca",
")",
".",
"join",
"(",
"Vacina_Doenca",
")",
".",
"filter",
"(",
"Vacina_Doenca",
".",
"idVacinaGeral",
"==",
"vg",
".",
"id",
")",
"doencas",
"=",
"''",
"for",
"dvg",
"in",
"doencas_vacina_geral",
":",
"doencas",
"=",
"doencas",
"+",
"dvg",
".",
"nome",
"+",
"', '",
"doencas",
"=",
"doencas",
"[",
":",
"-",
"2",
"]",
"doencas_vacinas_lista",
".",
"append",
"(",
"doencas",
")",
"# Faixas Etárias de cada Vacina",
"faixa_vacinas_lista",
"=",
"[",
"]",
"for",
"vg",
"in",
"vacinas_calendario",
":",
"faixas",
"=",
"''",
"faixas_vacina_geral",
"=",
"db",
".",
"session",
".",
"query",
"(",
"Faixa_Etaria",
")",
".",
"join",
"(",
"Vacinacao",
")",
".",
"filter",
"(",
"Vacinacao",
".",
"idVacinaGeral",
"==",
"vg",
".",
"id",
")",
".",
"all",
"(",
")",
"for",
"i",
"in",
"faixas_vacina_geral",
":",
"if",
"i",
".",
"faixa",
">",
"24",
":",
"faixa_ano",
"=",
"int",
"(",
"math",
".",
"floor",
"(",
"i",
".",
"faixa",
"/",
"12",
")",
")",
"frac",
",",
"full",
"=",
"math",
".",
"modf",
"(",
"(",
"i",
".",
"faixa",
"/",
"12",
")",
")",
"if",
"frac",
">",
"0.0",
":",
"sobra_mes",
"=",
"int",
"(",
"frac",
"*",
"12",
")",
"faixas",
"=",
"faixas",
"+",
"str",
"(",
"faixa_ano",
")",
"+",
"' anos e '",
"+",
"str",
"(",
"sobra_mes",
")",
"+",
"' meses, '",
"else",
":",
"faixas",
"=",
"faixas",
"+",
"str",
"(",
"faixa_ano",
")",
"+",
"' anos, '",
"elif",
"(",
"i",
".",
"faixa",
"==",
"0",
")",
"or",
"(",
"i",
".",
"faixa",
"==",
"1",
")",
":",
"faixas",
"=",
"faixas",
"+",
"str",
"(",
"i",
".",
"faixa",
")",
"+",
"' mês, '",
"else",
":",
"faixas",
"=",
"faixas",
"+",
"str",
"(",
"i",
".",
"faixa",
")",
"+",
"' meses, '",
"faixas",
"=",
"faixas",
"[",
":",
"-",
"2",
"]",
"faixa_vacinas_lista",
".",
"append",
"(",
"faixas",
")",
"return",
"render_template",
"(",
"'calendario.html'",
",",
"title",
"=",
"'SICOVAC'",
",",
"form",
"=",
"form",
",",
"dados",
"=",
"zip",
"(",
"vacinas_calendario",
",",
"doencas_vacinas_lista",
",",
"faixa_vacinas_lista",
")",
")"
] | [
358,
0
] | [
404,
150
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
p_acao | (p) | acao : expressao
| declaracao_variaveis
| se
| repita
| leia
| escreva
| retorna
| acao : expressao
| declaracao_variaveis
| se
| repita
| leia
| escreva
| retorna
| def p_acao(p):
"""acao : expressao
| declaracao_variaveis
| se
| repita
| leia
| escreva
| retorna
"""
pai = MyNode(name='acao', type='ACAO')
p[0] = pai
p[1].parent = pai | [
"def",
"p_acao",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'acao'",
",",
"type",
"=",
"'ACAO'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
522,
0
] | [
533,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
busca_estado | (property, target, variable, initial_state, delta=200, iters=100, precision=0.99999, dir=1,
proporcionalidade=1) | Dado um estado inicial, variando a pressao ou a temperatura, ele encontra outro estado, baseado numa segunda propriedade | Dado um estado inicial, variando a pressao ou a temperatura, ele encontra outro estado, baseado numa segunda propriedade | def busca_estado(property, target, variable, initial_state, delta=200, iters=100, precision=0.99999, dir=1,
proporcionalidade=1):
'''Dado um estado inicial, variando a pressao ou a temperatura, ele encontra outro estado, baseado numa segunda propriedade'''
if iters < 0:
print('Não achou')
return None
ldict = locals()
try:
p = float(initial_state._p)
except:
p = None
try:
T = float(initial_state._T)
except:
T = None
material = initial_state._material
table = initial_state._table_name
code = 'atual = initial_state.{}'.format(property)
exec(code, ldict)
atual = ldict['atual']
if iters == 100:
if variable == 'T':
T += 5
if variable == 'p':
p += 5
next_state = estado(material, table, p, T)
ldict = locals()
code = 'next = next_state.{}'.format(property)
exec(code, ldict)
next = ldict['next']
proporcionalidade = (next - atual) / abs(next - atual)
real_dir = dir * proporcionalidade
if variable == 'T':
T += delta * real_dir
if variable == 'p':
p += delta * real_dir
try:
next_state = estado(material, table, p, T)
ldict = locals()
code = 'next = next_state.{}'.format(property)
exec(code, ldict)
next = ldict['next']
if (next - target) * proporcionalidade * real_dir > 0:
dir *= -1
delta /= 2
if abs(next - target) < 1 - precision:
return next_state
else:
return busca_estado(property, target, variable, next_state, delta=delta, iters=iters - 1,
precision=precision,
dir=dir, proporcionalidade=proporcionalidade)
except:
return busca_estado(property, target, variable, initial_state, delta=delta / 2, iters=iters - 1,
precision=precision,
dir=dir, proporcionalidade=proporcionalidade) | [
"def",
"busca_estado",
"(",
"property",
",",
"target",
",",
"variable",
",",
"initial_state",
",",
"delta",
"=",
"200",
",",
"iters",
"=",
"100",
",",
"precision",
"=",
"0.99999",
",",
"dir",
"=",
"1",
",",
"proporcionalidade",
"=",
"1",
")",
":",
"if",
"iters",
"<",
"0",
":",
"print",
"(",
"'Não achou')",
"\r",
"return",
"None",
"ldict",
"=",
"locals",
"(",
")",
"try",
":",
"p",
"=",
"float",
"(",
"initial_state",
".",
"_p",
")",
"except",
":",
"p",
"=",
"None",
"try",
":",
"T",
"=",
"float",
"(",
"initial_state",
".",
"_T",
")",
"except",
":",
"T",
"=",
"None",
"material",
"=",
"initial_state",
".",
"_material",
"table",
"=",
"initial_state",
".",
"_table_name",
"code",
"=",
"'atual = initial_state.{}'",
".",
"format",
"(",
"property",
")",
"exec",
"(",
"code",
",",
"ldict",
")",
"atual",
"=",
"ldict",
"[",
"'atual'",
"]",
"if",
"iters",
"==",
"100",
":",
"if",
"variable",
"==",
"'T'",
":",
"T",
"+=",
"5",
"if",
"variable",
"==",
"'p'",
":",
"p",
"+=",
"5",
"next_state",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p",
",",
"T",
")",
"ldict",
"=",
"locals",
"(",
")",
"code",
"=",
"'next = next_state.{}'",
".",
"format",
"(",
"property",
")",
"exec",
"(",
"code",
",",
"ldict",
")",
"next",
"=",
"ldict",
"[",
"'next'",
"]",
"proporcionalidade",
"=",
"(",
"next",
"-",
"atual",
")",
"/",
"abs",
"(",
"next",
"-",
"atual",
")",
"real_dir",
"=",
"dir",
"*",
"proporcionalidade",
"if",
"variable",
"==",
"'T'",
":",
"T",
"+=",
"delta",
"*",
"real_dir",
"if",
"variable",
"==",
"'p'",
":",
"p",
"+=",
"delta",
"*",
"real_dir",
"try",
":",
"next_state",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p",
",",
"T",
")",
"ldict",
"=",
"locals",
"(",
")",
"code",
"=",
"'next = next_state.{}'",
".",
"format",
"(",
"property",
")",
"exec",
"(",
"code",
",",
"ldict",
")",
"next",
"=",
"ldict",
"[",
"'next'",
"]",
"if",
"(",
"next",
"-",
"target",
")",
"*",
"proporcionalidade",
"*",
"real_dir",
">",
"0",
":",
"dir",
"*=",
"-",
"1",
"delta",
"/=",
"2",
"if",
"abs",
"(",
"next",
"-",
"target",
")",
"<",
"1",
"-",
"precision",
":",
"return",
"next_state",
"else",
":",
"return",
"busca_estado",
"(",
"property",
",",
"target",
",",
"variable",
",",
"next_state",
",",
"delta",
"=",
"delta",
",",
"iters",
"=",
"iters",
"-",
"1",
",",
"precision",
"=",
"precision",
",",
"dir",
"=",
"dir",
",",
"proporcionalidade",
"=",
"proporcionalidade",
")",
"except",
":",
"return",
"busca_estado",
"(",
"property",
",",
"target",
",",
"variable",
",",
"initial_state",
",",
"delta",
"=",
"delta",
"/",
"2",
",",
"iters",
"=",
"iters",
"-",
"1",
",",
"precision",
"=",
"precision",
",",
"dir",
"=",
"dir",
",",
"proporcionalidade",
"=",
"proporcionalidade",
")"
] | [
224,
0
] | [
279,
73
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CityHallBid.last_collected_item_date | (cls) | Retorna data para início da coleta.
Dado que as licitações são constantemente atualizadas e nós não temos
um maneira mais simples de verificar os últimos itens atualizados,
vamos assumir que os últimos seis meses é um período razoável para
ter licitações sendo atualizadas.
| Retorna data para início da coleta. | def last_collected_item_date(cls):
"""Retorna data para início da coleta.
Dado que as licitações são constantemente atualizadas e nós não temos
um maneira mais simples de verificar os últimos itens atualizados,
vamos assumir que os últimos seis meses é um período razoável para
ter licitações sendo atualizadas.
"""
try:
# checa se existe algum registro antes
cls.objects.latest()
return date.today() - timedelta(days=180)
except cls.DoesNotExist:
return | [
"def",
"last_collected_item_date",
"(",
"cls",
")",
":",
"try",
":",
"# checa se existe algum registro antes",
"cls",
".",
"objects",
".",
"latest",
"(",
")",
"return",
"date",
".",
"today",
"(",
")",
"-",
"timedelta",
"(",
"days",
"=",
"180",
")",
"except",
"cls",
".",
"DoesNotExist",
":",
"return"
] | [
419,
4
] | [
432,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
linha.__repr__ | (self, link = False) | return self.__class__.__name__ + '(' + self.ln.__repr__() + s + '%d)'%self.recuo | Retorna a representação textual da linha refinada (.ln), se link != 0, inclui as link próximas linhas também (se link < 0, todas as próximas, sem tratamento de listas circulares).
A inicialização pela representação perde o dicionário do recuo .ind original e também perde o id se for exibir a lista ligada. | Retorna a representação textual da linha refinada (.ln), se link != 0, inclui as link próximas linhas também (se link < 0, todas as próximas, sem tratamento de listas circulares).
A inicialização pela representação perde o dicionário do recuo .ind original e também perde o id se for exibir a lista ligada. | def __repr__ (self, link = False):
'''Retorna a representação textual da linha refinada (.ln), se link != 0, inclui as link próximas linhas também (se link < 0, todas as próximas, sem tratamento de listas circulares).
A inicialização pela representação perde o dicionário do recuo .ind original e também perde o id se for exibir a lista ligada.'''
s = virg
if link and self.prox != None:
s += '\n' + ' '*self.recuo + self.prox.__repr__(link - (link > 0)) + virg
else:
if self.id != None:
s += ' id = ' + str(self.id) + virg
s += 'identation='
return self.__class__.__name__ + '(' + self.ln.__repr__() + s + '%d)'%self.recuo | [
"def",
"__repr__",
"(",
"self",
",",
"link",
"=",
"False",
")",
":",
"s",
"=",
"virg",
"if",
"link",
"and",
"self",
".",
"prox",
"!=",
"None",
":",
"s",
"+=",
"'\\n'",
"+",
"' '",
"*",
"self",
".",
"recuo",
"+",
"self",
".",
"prox",
".",
"__repr__",
"(",
"link",
"-",
"(",
"link",
">",
"0",
")",
")",
"+",
"virg",
"else",
":",
"if",
"self",
".",
"id",
"!=",
"None",
":",
"s",
"+=",
"' id = '",
"+",
"str",
"(",
"self",
".",
"id",
")",
"+",
"virg",
"s",
"+=",
"'identation='",
"return",
"self",
".",
"__class__",
".",
"__name__",
"+",
"'('",
"+",
"self",
".",
"ln",
".",
"__repr__",
"(",
")",
"+",
"s",
"+",
"'%d)'",
"%",
"self",
".",
"recuo"
] | [
337,
1
] | [
347,
82
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
greet_user | () | Exibe uma saudação simples. | Exibe uma saudação simples. | def greet_user():
"""Exibe uma saudação simples."""
print('Hello!') | [
"def",
"greet_user",
"(",
")",
":",
"print",
"(",
"'Hello!'",
")"
] | [
4,
0
] | [
6,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
main | (network_name, collection_name, directed, limit, source) | Inicia a geração da rede. | Inicia a geração da rede. | def main(network_name, collection_name, directed, limit, source):
"""Inicia a geração da rede."""
print("---Inputed Data---\n")
print(f"Network name: {network_name} \n"
f"Collection: {collection_name} \n"
f"Directed: {directed} \n"
f"Type: {source}")
print("-----------------")
if directed.lower() == 'true':
directed = True
elif directed.lower() == 'false':
directed = False
else:
raise TypeError("Error, Valid type is True or False."
f"You passed the type: {type(directed)}")
try:
data = SaraData(collection_name, storage_type='mongodb')
if source == 'r':
# Generate Retweets network
projection = {'user.screen_name': 1,
'retweeted_status.user.screen_name': 1}
tweets = data.get_projected_data(projection, limit)
network = get_retweets_network(tweets, directed)
path_to_save = Path(network_path, "retweets/")
path_to_save = path_to_save.joinpath(network_name)
save_network(network, path_to_save)
elif source == 'm':
# Generate mentions network
projection = {'user.screen_name': 1,
'entities.user_mentions.screen_name': 1}
tweets = data.get_projected_data(projection, limit)
network = get_mentions_network(tweets, directed)
path_to_save = Path(network_path, "mention/")
path_to_save = path_to_save.joinpath(network_name)
save_network(network, path_to_save)
else:
raise ValueError("Invalid network type, valid type r or m")
except (IndexError, ValueError) as error:
print(f"Error {error}") | [
"def",
"main",
"(",
"network_name",
",",
"collection_name",
",",
"directed",
",",
"limit",
",",
"source",
")",
":",
"print",
"(",
"\"---Inputed Data---\\n\"",
")",
"print",
"(",
"f\"Network name: {network_name} \\n\"",
"f\"Collection: {collection_name} \\n\"",
"f\"Directed: {directed} \\n\"",
"f\"Type: {source}\"",
")",
"print",
"(",
"\"-----------------\"",
")",
"if",
"directed",
".",
"lower",
"(",
")",
"==",
"'true'",
":",
"directed",
"=",
"True",
"elif",
"directed",
".",
"lower",
"(",
")",
"==",
"'false'",
":",
"directed",
"=",
"False",
"else",
":",
"raise",
"TypeError",
"(",
"\"Error, Valid type is True or False.\"",
"f\"You passed the type: {type(directed)}\"",
")",
"try",
":",
"data",
"=",
"SaraData",
"(",
"collection_name",
",",
"storage_type",
"=",
"'mongodb'",
")",
"if",
"source",
"==",
"'r'",
":",
"# Generate Retweets network",
"projection",
"=",
"{",
"'user.screen_name'",
":",
"1",
",",
"'retweeted_status.user.screen_name'",
":",
"1",
"}",
"tweets",
"=",
"data",
".",
"get_projected_data",
"(",
"projection",
",",
"limit",
")",
"network",
"=",
"get_retweets_network",
"(",
"tweets",
",",
"directed",
")",
"path_to_save",
"=",
"Path",
"(",
"network_path",
",",
"\"retweets/\"",
")",
"path_to_save",
"=",
"path_to_save",
".",
"joinpath",
"(",
"network_name",
")",
"save_network",
"(",
"network",
",",
"path_to_save",
")",
"elif",
"source",
"==",
"'m'",
":",
"# Generate mentions network",
"projection",
"=",
"{",
"'user.screen_name'",
":",
"1",
",",
"'entities.user_mentions.screen_name'",
":",
"1",
"}",
"tweets",
"=",
"data",
".",
"get_projected_data",
"(",
"projection",
",",
"limit",
")",
"network",
"=",
"get_mentions_network",
"(",
"tweets",
",",
"directed",
")",
"path_to_save",
"=",
"Path",
"(",
"network_path",
",",
"\"mention/\"",
")",
"path_to_save",
"=",
"path_to_save",
".",
"joinpath",
"(",
"network_name",
")",
"save_network",
"(",
"network",
",",
"path_to_save",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Invalid network type, valid type r or m\"",
")",
"except",
"(",
"IndexError",
",",
"ValueError",
")",
"as",
"error",
":",
"print",
"(",
"f\"Error {error}\"",
")"
] | [
23,
0
] | [
62,
31
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
achaDz | (matrix, L, D, z) | return Dz | Encontra o termo Dz mais detalhes sobre este termo podem ser vistas no relatório | Encontra o termo Dz mais detalhes sobre este termo podem ser vistas no relatório | def achaDz(matrix, L, D, z):
''''Encontra o termo Dz mais detalhes sobre este termo podem ser vistas no relatório'''
Dz = matrix[z, z]
for k in range(z):
Dz -= D[k] * L[z, k] ** 2
return Dz | [
"def",
"achaDz",
"(",
"matrix",
",",
"L",
",",
"D",
",",
"z",
")",
":",
"Dz",
"=",
"matrix",
"[",
"z",
",",
"z",
"]",
"for",
"k",
"in",
"range",
"(",
"z",
")",
":",
"Dz",
"-=",
"D",
"[",
"k",
"]",
"*",
"L",
"[",
"z",
",",
"k",
"]",
"**",
"2",
"return",
"Dz"
] | [
78,
0
] | [
83,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_fator | (p) | fator : ABRE_PARENTESE expressao FECHA_PARENTESE
| var
| chamada_funcao
| numero
| fator : ABRE_PARENTESE expressao FECHA_PARENTESE
| var
| chamada_funcao
| numero
| def p_fator(p):
"""fator : ABRE_PARENTESE expressao FECHA_PARENTESE
| var
| chamada_funcao
| numero
"""
pai = MyNode(name='fator', type='FATOR')
p[0] = pai
if len(p) > 2:
filho1 = MyNode(name='abre_parentese', type='ABRE_PARENTESE', parent=pai)
filho_sym1 = MyNode(name=p[1], type='SIMBOLO', parent=filho1)
p[1] = filho1
p[2].parent = pai
filho3 = MyNode(name='fecha_parentese', type='FECHA_PARENTESE', parent=pai)
filho_sym3 = MyNode(name=p[3], type='SIMBOLO', parent=filho3)
p[3] = filho3
else:
p[1].parent = pai | [
"def",
"p_fator",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'fator'",
",",
"type",
"=",
"'FATOR'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"if",
"len",
"(",
"p",
")",
">",
"2",
":",
"filho1",
"=",
"MyNode",
"(",
"name",
"=",
"'abre_parentese'",
",",
"type",
"=",
"'ABRE_PARENTESE'",
",",
"parent",
"=",
"pai",
")",
"filho_sym1",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"1",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho1",
")",
"p",
"[",
"1",
"]",
"=",
"filho1",
"p",
"[",
"2",
"]",
".",
"parent",
"=",
"pai",
"filho3",
"=",
"MyNode",
"(",
"name",
"=",
"'fecha_parentese'",
",",
"type",
"=",
"'FECHA_PARENTESE'",
",",
"parent",
"=",
"pai",
")",
"filho_sym3",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"3",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho3",
")",
"p",
"[",
"3",
"]",
"=",
"filho3",
"else",
":",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
910,
0
] | [
929,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
EquipamentoRoteiro.remove | (cls, authenticated_user, equip_id, script_id) | Pesquisa e remove uma associação entre um Equipamento e um Roteiro.
@return: Nothing
@raise EquipamentoRoteiroNotFoundError: Não existe associação entre o equipamento e o roteiro.
@raise EquipamentoError: Falha ao remover uma associação entre um Equipamento e um Roteiro.
| Pesquisa e remove uma associação entre um Equipamento e um Roteiro. | def remove(cls, authenticated_user, equip_id, script_id):
"""Pesquisa e remove uma associação entre um Equipamento e um Roteiro.
@return: Nothing
@raise EquipamentoRoteiroNotFoundError: Não existe associação entre o equipamento e o roteiro.
@raise EquipamentoError: Falha ao remover uma associação entre um Equipamento e um Roteiro.
"""
try:
equip_script = EquipamentoRoteiro.objects.get(
equipamento__id=equip_id, roteiro__id=script_id)
equip_script.delete()
except EquipamentoRoteiro.DoesNotExist, n:
cls.log.debug(u'Não existe um equipamento_roteiro com o equipamento = %s e o roteiro = %s.' % (
equip_id, script_id))
raise EquipamentoRoteiroNotFoundError(
n, u'Não existe um equipamento_roteiro com o equipamento = %s e o roteiro = %s.' % (equip_id, script_id))
except Exception as e:
cls.log.error(
u'Falha ao remover uma associação entre um Equipamento e um Roteiro.')
raise EquipamentoError(
e, u'Falha ao remover uma associação entre um Equipamento e um Roteiro.') | [
"def",
"remove",
"(",
"cls",
",",
"authenticated_user",
",",
"equip_id",
",",
"script_id",
")",
":",
"try",
":",
"equip_script",
"=",
"EquipamentoRoteiro",
".",
"objects",
".",
"get",
"(",
"equipamento__id",
"=",
"equip_id",
",",
"roteiro__id",
"=",
"script_id",
")",
"equip_script",
".",
"delete",
"(",
")",
"except",
"EquipamentoRoteiro",
".",
"DoesNotExist",
",",
"n",
":",
"cls",
".",
"log",
".",
"debug",
"(",
"u'Não existe um equipamento_roteiro com o equipamento = %s e o roteiro = %s.' ",
" ",
"",
"equip_id",
",",
"script_id",
")",
")",
"raise",
"EquipamentoRoteiroNotFoundError",
"(",
"n",
",",
"u'Não existe um equipamento_roteiro com o equipamento = %s e o roteiro = %s.' ",
" ",
"e",
"quip_id,",
" ",
"cript_id)",
")",
"",
"except",
"Exception",
"as",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao remover uma associação entre um Equipamento e um Roteiro.')",
"",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao remover uma associação entre um Equipamento e um Roteiro.')",
""
] | [
1883,
4
] | [
1906,
91
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
obter_palavra | () | return lista_de_palavras[sorteio] | Abre um arquivo com as palavras, armazena em uma lista; obtém um número aleatório de 0 a x, onde x é o número
de itens da lista; e usa esse número para escolher e retornar uma palavra aleatória da lista. | Abre um arquivo com as palavras, armazena em uma lista; obtém um número aleatório de 0 a x, onde x é o número
de itens da lista; e usa esse número para escolher e retornar uma palavra aleatória da lista. | def obter_palavra():
"""Abre um arquivo com as palavras, armazena em uma lista; obtém um número aleatório de 0 a x, onde x é o número
de itens da lista; e usa esse número para escolher e retornar uma palavra aleatória da lista."""
arquivo = open('palavras_faceis.txt', 'r', encoding='UTF-8')
lista_de_palavras = arquivo.read().split('\n')
arquivo.close()
sorteio = randint(0, len(lista_de_palavras))
return lista_de_palavras[sorteio] | [
"def",
"obter_palavra",
"(",
")",
":",
"arquivo",
"=",
"open",
"(",
"'palavras_faceis.txt'",
",",
"'r'",
",",
"encoding",
"=",
"'UTF-8'",
")",
"lista_de_palavras",
"=",
"arquivo",
".",
"read",
"(",
")",
".",
"split",
"(",
"'\\n'",
")",
"arquivo",
".",
"close",
"(",
")",
"sorteio",
"=",
"randint",
"(",
"0",
",",
"len",
"(",
"lista_de_palavras",
")",
")",
"return",
"lista_de_palavras",
"[",
"sorteio",
"]"
] | [
15,
0
] | [
22,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
MainWP.abre_conversa | (self, contato) | Abre a conversa com um contato especifico | Abre a conversa com um contato especifico | def abre_conversa(self, contato):
""" Abre a conversa com um contato especifico """
"""
labels = driver.find_elements_by_tag_name('label')
labels[0].click()
self.send_keys_anywhere(contato)
"""
# procura inicial
driver = self.driver
conversa = driver.find_element_by_xpath(f"//span[@title = '{contato}']")
self.click_ac_elementors(conversa)
driver.implicitly_wait(2.5) | [
"def",
"abre_conversa",
"(",
"self",
",",
"contato",
")",
":",
"\"\"\"\n labels = driver.find_elements_by_tag_name('label')\n labels[0].click()\n self.send_keys_anywhere(contato)\n \"\"\"",
"# procura inicial",
"driver",
"=",
"self",
".",
"driver",
"conversa",
"=",
"driver",
".",
"find_element_by_xpath",
"(",
"f\"//span[@title = '{contato}']\"",
")",
"self",
".",
"click_ac_elementors",
"(",
"conversa",
")",
"driver",
".",
"implicitly_wait",
"(",
"2.5",
")"
] | [
115,
4
] | [
126,
35
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
fetch_documents_renditions | (document_id: str) | return fetch_data("/documents/%s/renditions" % (document_id)) | Obtém o uma lista contendo as representações de um documento
Args:
document_id (str): Identificador único de um documento
Returns:
renditions (List[Dict])
| Obtém o uma lista contendo as representações de um documento | def fetch_documents_renditions(document_id: str) -> List[Dict]:
"""Obtém o uma lista contendo as representações de um documento
Args:
document_id (str): Identificador único de um documento
Returns:
renditions (List[Dict])
"""
return fetch_data("/documents/%s/renditions" % (document_id)) | [
"def",
"fetch_documents_renditions",
"(",
"document_id",
":",
"str",
")",
"->",
"List",
"[",
"Dict",
"]",
":",
"return",
"fetch_data",
"(",
"\"/documents/%s/renditions\"",
"%",
"(",
"document_id",
")",
")"
] | [
153,
0
] | [
162,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RoteiroResource.handle_post | (self, request, user, *args, **kwargs) | Trata as requisições de POST para inserir um Roteiro.
URL: roteiro/
| Trata as requisições de POST para inserir um Roteiro. | def handle_post(self, request, user, *args, **kwargs):
"""Trata as requisições de POST para inserir um Roteiro.
URL: roteiro/
"""
try:
if not has_perm(user, AdminPermission.SCRIPT_MANAGEMENT, AdminPermission.WRITE_OPERATION):
return self.not_authorized()
xml_map, attrs_map = loads(request.raw_post_data)
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.')
script_map = networkapi_map.get('roteiro')
if script_map is None:
return self.response_error(3, u'Não existe valor para a tag roteiro do XML de requisição.')
script_type_id = script_map.get('id_tipo_roteiro')
if script_type_id is None:
return self.response_error(194)
script_name = script_map.get('nome')
if script_name is None:
return self.response_error(195)
script = Roteiro()
script.tipo_roteiro = TipoRoteiro()
try:
script.tipo_roteiro.id = int(script_type_id)
except (TypeError, ValueError):
self.log.error(
u'Valor do id_tipo_roteiro inválido: %s.', script_type_id)
return self.response_error(158, script_type_id)
script.roteiro = script_name
script.descricao = script_map.get('descricao')
script.create(user)
script_map = dict()
script_map['id'] = script.id
networkapi_map = dict()
networkapi_map['roteiro'] = script_map
return self.response(dumps_networkapi(networkapi_map))
except TipoRoteiroNotFoundError:
return self.response_error(158, script_type_id)
except RoteiroNameDuplicatedError:
return self.response_error(250, script_name)
except XMLError, x:
self.log.error(u'Erro ao ler o XML da requisicao.')
return self.response_error(3, x)
except (RoteiroError, GrupoError):
return self.response_error(1) | [
"def",
"handle_post",
"(",
"self",
",",
"request",
",",
"user",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"if",
"not",
"has_perm",
"(",
"user",
",",
"AdminPermission",
".",
"SCRIPT_MANAGEMENT",
",",
"AdminPermission",
".",
"WRITE_OPERATION",
")",
":",
"return",
"self",
".",
"not_authorized",
"(",
")",
"xml_map",
",",
"attrs_map",
"=",
"loads",
"(",
"request",
".",
"raw_post_data",
")",
"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.')",
"",
"script_map",
"=",
"networkapi_map",
".",
"get",
"(",
"'roteiro'",
")",
"if",
"script_map",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"u'Não existe valor para a tag roteiro do XML de requisição.')",
"",
"script_type_id",
"=",
"script_map",
".",
"get",
"(",
"'id_tipo_roteiro'",
")",
"if",
"script_type_id",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"194",
")",
"script_name",
"=",
"script_map",
".",
"get",
"(",
"'nome'",
")",
"if",
"script_name",
"is",
"None",
":",
"return",
"self",
".",
"response_error",
"(",
"195",
")",
"script",
"=",
"Roteiro",
"(",
")",
"script",
".",
"tipo_roteiro",
"=",
"TipoRoteiro",
"(",
")",
"try",
":",
"script",
".",
"tipo_roteiro",
".",
"id",
"=",
"int",
"(",
"script_type_id",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Valor do id_tipo_roteiro inválido: %s.',",
" ",
"cript_type_id)",
"",
"return",
"self",
".",
"response_error",
"(",
"158",
",",
"script_type_id",
")",
"script",
".",
"roteiro",
"=",
"script_name",
"script",
".",
"descricao",
"=",
"script_map",
".",
"get",
"(",
"'descricao'",
")",
"script",
".",
"create",
"(",
"user",
")",
"script_map",
"=",
"dict",
"(",
")",
"script_map",
"[",
"'id'",
"]",
"=",
"script",
".",
"id",
"networkapi_map",
"=",
"dict",
"(",
")",
"networkapi_map",
"[",
"'roteiro'",
"]",
"=",
"script_map",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"networkapi_map",
")",
")",
"except",
"TipoRoteiroNotFoundError",
":",
"return",
"self",
".",
"response_error",
"(",
"158",
",",
"script_type_id",
")",
"except",
"RoteiroNameDuplicatedError",
":",
"return",
"self",
".",
"response_error",
"(",
"250",
",",
"script_name",
")",
"except",
"XMLError",
",",
"x",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Erro ao ler o XML da requisicao.'",
")",
"return",
"self",
".",
"response_error",
"(",
"3",
",",
"x",
")",
"except",
"(",
"RoteiroError",
",",
"GrupoError",
")",
":",
"return",
"self",
".",
"response_error",
"(",
"1",
")"
] | [
96,
4
] | [
155,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
EquipamentoGrupo.create | (self, authenticated_user=None) | Insere uma nova associação entre um Equipamento e um Grupo.
@return: Nothing
@raise EGrupoNotFoundError: Grupo não cadastrado.
@raise GrupoError: Falha ao pesquisar o grupo do equipamento.
@raise EquipamentoGrupoDuplicatedError: Equipamento já está cadastrado no grupo
@raise EquipamentoError: Falha ao inserir o equipamento no grupo.
| Insere uma nova associação entre um Equipamento e um Grupo. | def create(self, authenticated_user=None):
"""Insere uma nova associação entre um Equipamento e um Grupo.
@return: Nothing
@raise EGrupoNotFoundError: Grupo não cadastrado.
@raise GrupoError: Falha ao pesquisar o grupo do equipamento.
@raise EquipamentoGrupoDuplicatedError: Equipamento já está cadastrado no grupo
@raise EquipamentoError: Falha ao inserir o equipamento no grupo.
"""
self.egrupo = EGrupo.get_by_pk(self.egrupo.id)
self.equipamento = Equipamento().get_by_pk(self.equipamento.id)
try:
self.get_by_equipment_group(self.equipamento.id, self.egrupo.id)
raise EquipamentoGrupoDuplicatedError(
None, u'Equipamento já está cadastrado no grupo.')
except EquipamentoGrupoNotFoundError:
pass
try:
self.save()
except Exception as e:
self.log.error(u'Falha ao inserir a associação equipamento/grupo: %d/%d.' %
(self.equipamento.id, self.egrupo.id))
raise EquipamentoError(
e, u'Falha ao inserir a associação equipamento/grupo: %d/%d.' % (self.equipamento.id, self.egrupo.id)) | [
"def",
"create",
"(",
"self",
",",
"authenticated_user",
"=",
"None",
")",
":",
"self",
".",
"egrupo",
"=",
"EGrupo",
".",
"get_by_pk",
"(",
"self",
".",
"egrupo",
".",
"id",
")",
"self",
".",
"equipamento",
"=",
"Equipamento",
"(",
")",
".",
"get_by_pk",
"(",
"self",
".",
"equipamento",
".",
"id",
")",
"try",
":",
"self",
".",
"get_by_equipment_group",
"(",
"self",
".",
"equipamento",
".",
"id",
",",
"self",
".",
"egrupo",
".",
"id",
")",
"raise",
"EquipamentoGrupoDuplicatedError",
"(",
"None",
",",
"u'Equipamento já está cadastrado no grupo.')",
"",
"except",
"EquipamentoGrupoNotFoundError",
":",
"pass",
"try",
":",
"self",
".",
"save",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"log",
".",
"error",
"(",
"u'Falha ao inserir a associação equipamento/grupo: %d/%d.' %",
"",
"(",
"self",
".",
"equipamento",
".",
"id",
",",
"self",
".",
"egrupo",
".",
"id",
")",
")",
"raise",
"EquipamentoError",
"(",
"e",
",",
"u'Falha ao inserir a associação equipamento/grupo: %d/%d.' %",
"(",
"e",
"lf.e",
"q",
"uipamento.i",
"d",
", ",
"s",
"lf.e",
"g",
"rupo.i",
"d",
"))",
"",
""
] | [
1569,
4
] | [
1599,
120
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Historico._estado( | self, indice: int): | return self.__estados_salvos[indice] | Consulta o historico dos contratatos em uma list atreves de um indice.
Returns:
class Contrato: Objeto class Contrato especifico.
| Consulta o historico dos contratatos em uma list atreves de um indice. | def obtém_estado(self, indice: int):
"""Consulta o historico dos contratatos em uma list atreves de um indice.
Returns:
class Contrato: Objeto class Contrato especifico.
"""
return self.__estados_salvos[indice] | [
"def",
"obt",
"ém",
"_estado(",
"s",
"elf,",
" ",
"ndice:",
" ",
"nt)",
":",
"",
"return",
"self",
".",
"__estados_salvos",
"[",
"indice",
"]"
] | [
106,
4
] | [
112,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
enumerate_joint_ask | (X, e, P) | return Q.normalize() | Retornar uma distribuição de probabilidade sobre os valores da variável X,
Dadas as observações {var: val} e, no método JointProbDist P. | Retornar uma distribuição de probabilidade sobre os valores da variável X,
Dadas as observações {var: val} e, no método JointProbDist P. | def enumerate_joint_ask(X, e, P):
"""Retornar uma distribuição de probabilidade sobre os valores da variável X,
Dadas as observações {var: val} e, no método JointProbDist P."""
assert X not in e, "Query variable must be distinct from evidence"
Q = ProbDist(X) # Distribuição de probabilidade para X, inicialmente vazia
Y = [v for v in P.variables if v != X and v not in e] # Variáveis ocultas.
for xi in P.values(X):
Q[xi] = enumerate_joint(Y, extend(e, X, xi), P)
return Q.normalize() | [
"def",
"enumerate_joint_ask",
"(",
"X",
",",
"e",
",",
"P",
")",
":",
"assert",
"X",
"not",
"in",
"e",
",",
"\"Query variable must be distinct from evidence\"",
"Q",
"=",
"ProbDist",
"(",
"X",
")",
"# Distribuição de probabilidade para X, inicialmente vazia",
"Y",
"=",
"[",
"v",
"for",
"v",
"in",
"P",
".",
"variables",
"if",
"v",
"!=",
"X",
"and",
"v",
"not",
"in",
"e",
"]",
"# Variáveis ocultas.",
"for",
"xi",
"in",
"P",
".",
"values",
"(",
"X",
")",
":",
"Q",
"[",
"xi",
"]",
"=",
"enumerate_joint",
"(",
"Y",
",",
"extend",
"(",
"e",
",",
"X",
",",
"xi",
")",
",",
"P",
")",
"return",
"Q",
".",
"normalize",
"(",
")"
] | [
134,
0
] | [
142,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ListaDuplamenteEncadeada.mostrar | (self) | Mostra todos os dados da lista. | Mostra todos os dados da lista. | def mostrar(self):
""" Mostra todos os dados da lista. """
print("Lista Duplamente Encadeada:")
# O no atual eh o primeiro no da lista
no_atual = self.cabeca
no = ""
# Para cada no valido da lista
while no_atual is not None:
if no_atual.anterior is None:
no += "None "
no += "<---> | " + str(no_atual.dado) + " | "
if no_atual.proximo is None:
no += "<---> None"
no_atual = no_atual.proximo
print(no)
print("=" * 80) | [
"def",
"mostrar",
"(",
"self",
")",
":",
"print",
"(",
"\"Lista Duplamente Encadeada:\"",
")",
"# O no atual eh o primeiro no da lista",
"no_atual",
"=",
"self",
".",
"cabeca",
"no",
"=",
"\"\"",
"# Para cada no valido da lista",
"while",
"no_atual",
"is",
"not",
"None",
":",
"if",
"no_atual",
".",
"anterior",
"is",
"None",
":",
"no",
"+=",
"\"None \"",
"no",
"+=",
"\"<---> | \"",
"+",
"str",
"(",
"no_atual",
".",
"dado",
")",
"+",
"\" | \"",
"if",
"no_atual",
".",
"proximo",
"is",
"None",
":",
"no",
"+=",
"\"<---> None\"",
"no_atual",
"=",
"no_atual",
".",
"proximo",
"print",
"(",
"no",
")",
"print",
"(",
"\"=\"",
"*",
"80",
")"
] | [
77,
4
] | [
95,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
embaralhar | (*programas) | return embaralhado | Embaralhamento simples: recebe listas para serem mescladas numa só.
Não observa níveis de exclusão entre itens, somente a unidade deles.
Classes, funções, try-except e if-else não-blocados podem ter sintaxe da indentação prejudicada! | Embaralhamento simples: recebe listas para serem mescladas numa só.
Não observa níveis de exclusão entre itens, somente a unidade deles. | def embaralhar (*programas):
''' Embaralhamento simples: recebe listas para serem mescladas numa só.
Não observa níveis de exclusão entre itens, somente a unidade deles.
Classes, funções, try-except e if-else não-blocados podem ter sintaxe da indentação prejudicada!'''
programas = [list(p) for p in programas] # lista de listas (estas últimas que podem ser encadeadas) que serão utilizadas
embaralhado = [] # programa de resultado
while len(programas) > 0:
s = random.randint(0,len(programas)-1)
s = programas.pop(s)
try:
if type(s) == list:
embaralhado.append(s.pop(0))
else:
embaralhado.append(s)
s = s.seguinte()
except AttributeError:
pass # caso a linha não tenha uma próxima,
else: # ela não é mantida no rol de sorteio
if s != None and len(s):
programas.append(s)
return embaralhado | [
"def",
"embaralhar",
"(",
"*",
"programas",
")",
":",
"programas",
"=",
"[",
"list",
"(",
"p",
")",
"for",
"p",
"in",
"programas",
"]",
"# lista de listas (estas últimas que podem ser encadeadas) que serão utilizadas",
"embaralhado",
"=",
"[",
"]",
"# programa de resultado",
"while",
"len",
"(",
"programas",
")",
">",
"0",
":",
"s",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"len",
"(",
"programas",
")",
"-",
"1",
")",
"s",
"=",
"programas",
".",
"pop",
"(",
"s",
")",
"try",
":",
"if",
"type",
"(",
"s",
")",
"==",
"list",
":",
"embaralhado",
".",
"append",
"(",
"s",
".",
"pop",
"(",
"0",
")",
")",
"else",
":",
"embaralhado",
".",
"append",
"(",
"s",
")",
"s",
"=",
"s",
".",
"seguinte",
"(",
")",
"except",
"AttributeError",
":",
"pass",
"# caso a linha não tenha uma próxima, ",
"else",
":",
"# ela não é mantida no rol de sorteio",
"if",
"s",
"!=",
"None",
"and",
"len",
"(",
"s",
")",
":",
"programas",
".",
"append",
"(",
"s",
")",
"return",
"embaralhado"
] | [
426,
0
] | [
448,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
InterfaceResource.search_interface_by_name_and_equipment | (self, equipment_id, interface_name, is_new) | Obtém a interface do equipamento e retorna todas as interfaces ligadas no front e no back. | Obtém a interface do equipamento e retorna todas as interfaces ligadas no front e no back. | def search_interface_by_name_and_equipment(self, equipment_id, interface_name, is_new):
"""Obtém a interface do equipamento e retorna todas as interfaces ligadas no front e no back. """
interface = Interface.get_by_interface_equipment(
interface_name, equipment_id)
interfaces = interface.search_front_back_interfaces()
map_list = []
for interface in interfaces:
if is_new:
map_list.append(self.get_new_interface_map(interface))
else:
map_list.append(self.get_interface_map(interface))
if is_new:
return self.response(dumps_networkapi({'interfaces': map_list}))
else:
return self.response(dumps_networkapi({'interface': map_list})) | [
"def",
"search_interface_by_name_and_equipment",
"(",
"self",
",",
"equipment_id",
",",
"interface_name",
",",
"is_new",
")",
":",
"interface",
"=",
"Interface",
".",
"get_by_interface_equipment",
"(",
"interface_name",
",",
"equipment_id",
")",
"interfaces",
"=",
"interface",
".",
"search_front_back_interfaces",
"(",
")",
"map_list",
"=",
"[",
"]",
"for",
"interface",
"in",
"interfaces",
":",
"if",
"is_new",
":",
"map_list",
".",
"append",
"(",
"self",
".",
"get_new_interface_map",
"(",
"interface",
")",
")",
"else",
":",
"map_list",
".",
"append",
"(",
"self",
".",
"get_interface_map",
"(",
"interface",
")",
")",
"if",
"is_new",
":",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'interfaces'",
":",
"map_list",
"}",
")",
")",
"else",
":",
"return",
"self",
".",
"response",
"(",
"dumps_networkapi",
"(",
"{",
"'interface'",
":",
"map_list",
"}",
")",
")"
] | [
434,
4
] | [
451,
75
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
start_game | (ai_settings, screen, stats, sb, ship, aliens, bullets) | Inicia um novo jogo quando o jogador clicar em play ou quando o jogador teclar p | Inicia um novo jogo quando o jogador clicar em play ou quando o jogador teclar p | def start_game(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Inicia um novo jogo quando o jogador clicar em play ou quando o jogador teclar p"""
# Oculta o cursor do mouse
# pygame.mouse.set_visible(False)
# Reinicia os dados estatisticcos e apresenta a tela do jogo
stats.reset_stats()
stats.game_active = True
stats.game_start = False
# Reinicia as imagens do painel de pontuação
sb.prep_score()
sb.prep_high_score()
sb.prep_level()
sb.prep_ships()
# Esvazia a lista de alienigenas e de projéteis
aliens.empty()
bullets.empty()
# Cria uma nova frota e centraliza a espaçonave
create_fleet(ai_settings, screen, ship, aliens)
ship.center_ship() | [
"def",
"start_game",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"# Oculta o cursor do mouse",
"# pygame.mouse.set_visible(False)",
"# Reinicia os dados estatisticcos e apresenta a tela do jogo",
"stats",
".",
"reset_stats",
"(",
")",
"stats",
".",
"game_active",
"=",
"True",
"stats",
".",
"game_start",
"=",
"False",
"# Reinicia as imagens do painel de pontuação",
"sb",
".",
"prep_score",
"(",
")",
"sb",
".",
"prep_high_score",
"(",
")",
"sb",
".",
"prep_level",
"(",
")",
"sb",
".",
"prep_ships",
"(",
")",
"# Esvazia a lista de alienigenas e de projéteis",
"aliens",
".",
"empty",
"(",
")",
"bullets",
".",
"empty",
"(",
")",
"# Cria uma nova frota e centraliza a espaçonave",
"create_fleet",
"(",
"ai_settings",
",",
"screen",
",",
"ship",
",",
"aliens",
")",
"ship",
".",
"center_ship",
"(",
")"
] | [
74,
0
] | [
96,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
GameSats.__init__ | (self, ai_settings) | Inicializa os dados estatisticos. | Inicializa os dados estatisticos. | def __init__(self, ai_settings):
"""Inicializa os dados estatisticos."""
self.ai_settings = ai_settings
self.reset_stats()
# Inicia a Invasao Alienigena em um estado ativo
self.game_active = False
# A pontuacao maxima jamais devera ser reiniciada
self.high_score = 0 | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
")",
":",
"self",
".",
"ai_settings",
"=",
"ai_settings",
"self",
".",
"reset_stats",
"(",
")",
"# Inicia a Invasao Alienigena em um estado ativo",
"self",
".",
"game_active",
"=",
"False",
"# A pontuacao maxima jamais devera ser reiniciada",
"self",
".",
"high_score",
"=",
"0"
] | [
3,
4
] | [
13,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TraductorFiscal.dailyClose | (self, type) | return ret | Comando X o Z | Comando X o Z | def dailyClose(self, type):
"Comando X o Z"
# cancelar y volver a un estado conocido
self.comando.cancelAnyDocument()
self.comando.start()
ret = self.comando.dailyClose(type)
self.comando.close()
return ret | [
"def",
"dailyClose",
"(",
"self",
",",
"type",
")",
":",
"# cancelar y volver a un estado conocido",
"self",
".",
"comando",
".",
"cancelAnyDocument",
"(",
")",
"self",
".",
"comando",
".",
"start",
"(",
")",
"ret",
"=",
"self",
".",
"comando",
".",
"dailyClose",
"(",
"type",
")",
"self",
".",
"comando",
".",
"close",
"(",
")",
"return",
"ret"
] | [
6,
4
] | [
14,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
AtorBaseTest.assert_ator_caracteres | (self, ator, caracter_status_ativo, caracter_status_destruido) | Confere status e caracteres ativos e destruidos de um ator | Confere status e caracteres ativos e destruidos de um ator | def assert_ator_caracteres(self, ator, caracter_status_ativo, caracter_status_destruido):
'Confere status e caracteres ativos e destruidos de um ator'
# Conferencia de caracter de ator ativo
self.assertEqual(ATIVO, ator.status(0))
self.assertEqual(caracter_status_ativo, ator.caracter(0))
# Colidindo ator com ele mesmo para alterar seu status para destruido
ator.colidir(ator, 3.2)
self.assertEqual(caracter_status_ativo, ator.caracter(3.1),
'Status ativo, logo o caracter deveria ser %s' % caracter_status_ativo)
self.assertEqual(caracter_status_destruido, ator.caracter(3.2),
'Status destruido, logo o caracter deveria ser %s' % caracter_status_destruido)
self.assertEqual(caracter_status_destruido, ator.caracter(4),
'Status destruido, logo o caracter deveria ser %s' % caracter_status_destruido) | [
"def",
"assert_ator_caracteres",
"(",
"self",
",",
"ator",
",",
"caracter_status_ativo",
",",
"caracter_status_destruido",
")",
":",
"# Conferencia de caracter de ator ativo",
"self",
".",
"assertEqual",
"(",
"ATIVO",
",",
"ator",
".",
"status",
"(",
"0",
")",
")",
"self",
".",
"assertEqual",
"(",
"caracter_status_ativo",
",",
"ator",
".",
"caracter",
"(",
"0",
")",
")",
"# Colidindo ator com ele mesmo para alterar seu status para destruido",
"ator",
".",
"colidir",
"(",
"ator",
",",
"3.2",
")",
"self",
".",
"assertEqual",
"(",
"caracter_status_ativo",
",",
"ator",
".",
"caracter",
"(",
"3.1",
")",
",",
"'Status ativo, logo o caracter deveria ser %s'",
"%",
"caracter_status_ativo",
")",
"self",
".",
"assertEqual",
"(",
"caracter_status_destruido",
",",
"ator",
".",
"caracter",
"(",
"3.2",
")",
",",
"'Status destruido, logo o caracter deveria ser %s'",
"%",
"caracter_status_destruido",
")",
"self",
".",
"assertEqual",
"(",
"caracter_status_destruido",
",",
"ator",
".",
"caracter",
"(",
"4",
")",
",",
"'Status destruido, logo o caracter deveria ser %s'",
"%",
"caracter_status_destruido",
")"
] | [
8,
4
] | [
22,
104
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType63.ntun | (self) | return bin2int(self.data[BYTES_63[18]]) | F18 - 0 ou igual à quantidade de valores de AGC usados na amostra | F18 - 0 ou igual à quantidade de valores de AGC usados na amostra | def ntun(self) -> int:
"""F18 - 0 ou igual à quantidade de valores de AGC usados na amostra"""
return bin2int(self.data[BYTES_63[18]]) | [
"def",
"ntun",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_63",
"[",
"18",
"]",
"]",
")"
] | [
1107,
4
] | [
1109,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
NumeroGrego.show_npi | (self) | return numero_pi | Chama a função com o número pi com 10 dígitos | Chama a função com o número pi com 10 dígitos | def show_npi(self):
"""Chama a função com o número pi com 10 dígitos"""
numero_pi = self.npi
return numero_pi | [
"def",
"show_npi",
"(",
"self",
")",
":",
"numero_pi",
"=",
"self",
".",
"npi",
"return",
"numero_pi"
] | [
5,
4
] | [
8,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
dados.name | (self) | return "validate_option_form" | Identifica o form na estória do Rasa. | Identifica o form na estória do Rasa. | def name(self) -> Text:
"""Identifica o form na estória do Rasa."""
return "validate_option_form" | [
"def",
"name",
"(",
"self",
")",
"->",
"Text",
":",
"return",
"\"validate_option_form\""
] | [
137,
4
] | [
139,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
LoggerAnalyzer.dump | (self, lines) | Escreve resultado do parser em um arquivo caminho determinado.
A sequência de caracteres de dados deve implementar a interface TextIOWrapper
Args:
lines: Lista de linhas contento sequência de caracteres.
Retornos:
Não há retorno
Exceções:
Não lança exceções.
| Escreve resultado do parser em um arquivo caminho determinado.
A sequência de caracteres de dados deve implementar a interface TextIOWrapper | def dump(self, lines) -> None:
"""Escreve resultado do parser em um arquivo caminho determinado.
A sequência de caracteres de dados deve implementar a interface TextIOWrapper
Args:
lines: Lista de linhas contento sequência de caracteres.
Retornos:
Não há retorno
Exceções:
Não lança exceções.
"""
for line in lines:
self.out_file.write(line)
self.out_file.write("\n") | [
"def",
"dump",
"(",
"self",
",",
"lines",
")",
"->",
"None",
":",
"for",
"line",
"in",
"lines",
":",
"self",
".",
"out_file",
".",
"write",
"(",
"line",
")",
"self",
".",
"out_file",
".",
"write",
"(",
"\"\\n\"",
")"
] | [
252,
4
] | [
267,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cadastral.busca_fundo_cnpj | (self, cnpj) | return fundo_df.iloc[0, :] | Retorna dataframe de um fundo. | Retorna dataframe de um fundo. | def busca_fundo_cnpj(self, cnpj):
"""Retorna dataframe de um fundo."""
if not isinstance(self.pd_df, pd.DataFrame):
self.cria_df_cadastral()
# No arquivo cadastral alguns fundos tem o mesmo cnpj.
# Retorna o primeiro encontrado
fundo_df = self.pd_df.loc[[cnpj], :]
return fundo_df.iloc[0, :] | [
"def",
"busca_fundo_cnpj",
"(",
"self",
",",
"cnpj",
")",
":",
"if",
"not",
"isinstance",
"(",
"self",
".",
"pd_df",
",",
"pd",
".",
"DataFrame",
")",
":",
"self",
".",
"cria_df_cadastral",
"(",
")",
"# No arquivo cadastral alguns fundos tem o mesmo cnpj.",
"# Retorna o primeiro encontrado",
"fundo_df",
"=",
"self",
".",
"pd_df",
".",
"loc",
"[",
"[",
"cnpj",
"]",
",",
":",
"]",
"return",
"fundo_df",
".",
"iloc",
"[",
"0",
",",
":",
"]"
] | [
271,
4
] | [
279,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
download_file | (name, url, *, path=path, type_='png') | return fname | Faz o download de um arquivo. | Faz o download de um arquivo. | def download_file(name, url, *, path=path, type_='png'):
"""Faz o download de um arquivo."""
response = get(url, stream=True)
fname = f'{path}/{name}.{type_}'
with open(fname, 'wb') as f:
copyfileobj(response.raw, f)
return fname | [
"def",
"download_file",
"(",
"name",
",",
"url",
",",
"*",
",",
"path",
"=",
"path",
",",
"type_",
"=",
"'png'",
")",
":",
"response",
"=",
"get",
"(",
"url",
",",
"stream",
"=",
"True",
")",
"fname",
"=",
"f'{path}/{name}.{type_}'",
"with",
"open",
"(",
"fname",
",",
"'wb'",
")",
"as",
"f",
":",
"copyfileobj",
"(",
"response",
".",
"raw",
",",
"f",
")",
"return",
"fname"
] | [
37,
0
] | [
43,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
update_journals_and_issues_link | (journal_issues: dict) | Atualiza o relacionamento entre Journal e Issues.
Para cada Journal é verificado se há mudanças entre a lista de Issues
obtida via API e a lista de issues recém montada durante o espelhamento. Caso
alguma mudança seja detectada o Journal será atualizado com a nova lista de
issues.
:param journal_issues: Dicionário contendo journals e issues. As chaves do
dicionário serão os identificadores dos journals e os valores serão listas contendo
os indificadores das issues. | Atualiza o relacionamento entre Journal e Issues. | def update_journals_and_issues_link(journal_issues: dict):
"""Atualiza o relacionamento entre Journal e Issues.
Para cada Journal é verificado se há mudanças entre a lista de Issues
obtida via API e a lista de issues recém montada durante o espelhamento. Caso
alguma mudança seja detectada o Journal será atualizado com a nova lista de
issues.
:param journal_issues: Dicionário contendo journals e issues. As chaves do
dicionário serão os identificadores dos journals e os valores serão listas contendo
os indificadores das issues."""
for journal_id, issues in journal_issues.items():
try:
api_hook = HttpHook(http_conn_id="kernel_conn", method="GET")
response = api_hook.run(endpoint="{}{}".format(KERNEL_API_JOURNAL_ENDPOINT, journal_id))
journal_items = response.json()["items"]
if DeepDiff(journal_items, issues):
BUNDLE_URL = KERNEL_API_JOURNAL_BUNDLES_ENDPOINT.format(
journal_id=journal_id
)
api_hook = HttpHook(http_conn_id="kernel_conn", method="PUT")
response = api_hook.run(endpoint=BUNDLE_URL, data=json.dumps(issues))
logging.info("updating bundles of journal %s" % journal_id)
except (AirflowException):
logging.warning("journal %s cannot be found" % journal_id) | [
"def",
"update_journals_and_issues_link",
"(",
"journal_issues",
":",
"dict",
")",
":",
"for",
"journal_id",
",",
"issues",
"in",
"journal_issues",
".",
"items",
"(",
")",
":",
"try",
":",
"api_hook",
"=",
"HttpHook",
"(",
"http_conn_id",
"=",
"\"kernel_conn\"",
",",
"method",
"=",
"\"GET\"",
")",
"response",
"=",
"api_hook",
".",
"run",
"(",
"endpoint",
"=",
"\"{}{}\"",
".",
"format",
"(",
"KERNEL_API_JOURNAL_ENDPOINT",
",",
"journal_id",
")",
")",
"journal_items",
"=",
"response",
".",
"json",
"(",
")",
"[",
"\"items\"",
"]",
"if",
"DeepDiff",
"(",
"journal_items",
",",
"issues",
")",
":",
"BUNDLE_URL",
"=",
"KERNEL_API_JOURNAL_BUNDLES_ENDPOINT",
".",
"format",
"(",
"journal_id",
"=",
"journal_id",
")",
"api_hook",
"=",
"HttpHook",
"(",
"http_conn_id",
"=",
"\"kernel_conn\"",
",",
"method",
"=",
"\"PUT\"",
")",
"response",
"=",
"api_hook",
".",
"run",
"(",
"endpoint",
"=",
"BUNDLE_URL",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"issues",
")",
")",
"logging",
".",
"info",
"(",
"\"updating bundles of journal %s\"",
"%",
"journal_id",
")",
"except",
"(",
"AirflowException",
")",
":",
"logging",
".",
"warning",
"(",
"\"journal %s cannot be found\"",
"%",
"journal_id",
")"
] | [
395,
0
] | [
422,
70
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
create | () | return render_template('socio/create.html', success=success, error=error) | Cria um novo socio. | Cria um novo socio. | def create():
"""Cria um novo socio."""
success = False
error = False
if request.method == 'POST':
try:
request_parsed = parse_request(request)
f = ""
if request.files['image']:
file = request.files['image']
f = upload_file(file)
name_image = f.filename if f else 'who.png'
sql = 'INSERT INTO socio values (default, "%s", "%s", "%s", "%s", default, "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", "%s", default)' % (request_parsed['nome'],
request_parsed['rg'], request_parsed['nasc'], request_parsed[
'email'], request_parsed['nome_pai'],
request_parsed['nome_mae'], request_parsed['cidade'], request_parsed[
'bairro'], request_parsed['logradouro'],
request_parsed['num'], request_parsed['tel_res'], request_parsed['cel_1'], request_parsed['cel_2'], name_image)
db.insert_bd(sql)
success = True
except Exception as e:
print(e)
error = 'Campos inválidos.'
return render_template('socio/create.html', success=success, error=error) | [
"def",
"create",
"(",
")",
":",
"success",
"=",
"False",
"error",
"=",
"False",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"try",
":",
"request_parsed",
"=",
"parse_request",
"(",
"request",
")",
"f",
"=",
"\"\"",
"if",
"request",
".",
"files",
"[",
"'image'",
"]",
":",
"file",
"=",
"request",
".",
"files",
"[",
"'image'",
"]",
"f",
"=",
"upload_file",
"(",
"file",
")",
"name_image",
"=",
"f",
".",
"filename",
"if",
"f",
"else",
"'who.png'",
"sql",
"=",
"'INSERT INTO socio values (default, \"%s\", \"%s\", \"%s\", \"%s\", default, \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", default)'",
"%",
"(",
"request_parsed",
"[",
"'nome'",
"]",
",",
"request_parsed",
"[",
"'rg'",
"]",
",",
"request_parsed",
"[",
"'nasc'",
"]",
",",
"request_parsed",
"[",
"'email'",
"]",
",",
"request_parsed",
"[",
"'nome_pai'",
"]",
",",
"request_parsed",
"[",
"'nome_mae'",
"]",
",",
"request_parsed",
"[",
"'cidade'",
"]",
",",
"request_parsed",
"[",
"'bairro'",
"]",
",",
"request_parsed",
"[",
"'logradouro'",
"]",
",",
"request_parsed",
"[",
"'num'",
"]",
",",
"request_parsed",
"[",
"'tel_res'",
"]",
",",
"request_parsed",
"[",
"'cel_1'",
"]",
",",
"request_parsed",
"[",
"'cel_2'",
"]",
",",
"name_image",
")",
"db",
".",
"insert_bd",
"(",
"sql",
")",
"success",
"=",
"True",
"except",
"Exception",
"as",
"e",
":",
"print",
"(",
"e",
")",
"error",
"=",
"'Campos inválidos.'\r",
"return",
"render_template",
"(",
"'socio/create.html'",
",",
"success",
"=",
"success",
",",
"error",
"=",
"error",
")"
] | [
141,
0
] | [
166,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
TestePesquisaAnonima.setUp | (self) | Cria uma pesquisa e um conjunto de respostas que poderão ser
usados em todos os métodos de teste. | Cria uma pesquisa e um conjunto de respostas que poderão ser
usados em todos os métodos de teste. | def setUp(self):
"""Cria uma pesquisa e um conjunto de respostas que poderão ser
usados em todos os métodos de teste."""
pergunta = "Qual foi a primeira língua que você aprendeu a falar?"
self.minha_pesquisa = PesquisaAnonima(
pergunta=pergunta
)
self.respostas = [
'Inglês', 'Português', 'Francês'
] | [
"def",
"setUp",
"(",
"self",
")",
":",
"pergunta",
"=",
"\"Qual foi a primeira língua que você aprendeu a falar?\"",
"self",
".",
"minha_pesquisa",
"=",
"PesquisaAnonima",
"(",
"pergunta",
"=",
"pergunta",
")",
"self",
".",
"respostas",
"=",
"[",
"'Inglês',",
" ",
"Português', ",
"'",
"rancês'",
"]"
] | [
6,
4
] | [
15,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
_gerar_id_carrinho | () | return id_carrinho | função para gerar ID de carrinhos aleatórios | função para gerar ID de carrinhos aleatórios | def _gerar_id_carrinho():
""" função para gerar ID de carrinhos aleatórios """
id_carrinho = ''
caracteres = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'
id_carrinho_length = 50
for y in range(id_carrinho_length):
id_carrinho += caracteres[random.randint(0, len(caracteres)-1)]
return id_carrinho | [
"def",
"_gerar_id_carrinho",
"(",
")",
":",
"id_carrinho",
"=",
"''",
"caracteres",
"=",
"'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()'",
"id_carrinho_length",
"=",
"50",
"for",
"y",
"in",
"range",
"(",
"id_carrinho_length",
")",
":",
"id_carrinho",
"+=",
"caracteres",
"[",
"random",
".",
"randint",
"(",
"0",
",",
"len",
"(",
"caracteres",
")",
"-",
"1",
")",
"]",
"return",
"id_carrinho"
] | [
19,
0
] | [
26,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Router.read_script | (self) | return script.readlines() | Retorna lista com todos os comandos do arquivo de script. | Retorna lista com todos os comandos do arquivo de script. | def read_script(self):
"""Retorna lista com todos os comandos do arquivo de script."""
script = open(f'{self.script}','r')
return script.readlines() | [
"def",
"read_script",
"(",
"self",
")",
":",
"script",
"=",
"open",
"(",
"f'{self.script}'",
",",
"'r'",
")",
"return",
"script",
".",
"readlines",
"(",
")"
] | [
22,
4
] | [
27,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.