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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
copy_mst_files_to_work_folder | (**kwargs) | Copia as bases MST para a área de trabalho da execução corrente.
O resultado desta função gera cópias das bases title e issue para paths correspondentes aos:
title: /airflow_home/work_folder_path/{{ run_id }}/isis/title.*
issue: /airflow_home/work_folder_path/{{ run_id }}/isis/issue.*
| Copia as bases MST para a área de trabalho da execução corrente. | def copy_mst_files_to_work_folder(**kwargs):
"""Copia as bases MST para a área de trabalho da execução corrente.
O resultado desta função gera cópias das bases title e issue para paths correspondentes aos:
title: /airflow_home/work_folder_path/{{ run_id }}/isis/title.*
issue: /airflow_home/work_folder_path/{{ run_id }}/isis/issue.*
"""
WORK_PATH = Variable.get("WORK_FOLDER_PATH")
CURRENT_EXECUTION_FOLDER = os.path.join(WORK_PATH, kwargs["run_id"])
WORK_ISIS_FILES = os.path.join(CURRENT_EXECUTION_FOLDER, "isis")
WORK_JSON_FILES = os.path.join(CURRENT_EXECUTION_FOLDER, "json")
BASE_TITLE_FOLDER_PATH = Variable.get("BASE_TITLE_FOLDER_PATH")
BASE_ISSUE_FOLDER_PATH = Variable.get("BASE_ISSUE_FOLDER_PATH")
copying_paths = []
for path in [BASE_TITLE_FOLDER_PATH, BASE_ISSUE_FOLDER_PATH]:
files = [
f for f in os.listdir(path) if f.endswith(".xrf") or f.endswith(".mst")
]
for file in files:
origin_path = os.path.join(path, file)
desatination_path = os.path.join(WORK_ISIS_FILES, file)
copying_paths.append([origin_path, desatination_path])
for origin, destination in copying_paths:
logging.info("copying file from %s to %s." % (origin, destination))
shutil.copy(origin, destination)
if "title.mst" in destination:
kwargs["ti"].xcom_push("title_mst_path", destination)
kwargs["ti"].xcom_push(
"title_json_path", os.path.join(WORK_JSON_FILES, "title.json")
)
if "issue.mst" in destination:
kwargs["ti"].xcom_push("issue_mst_path", destination)
kwargs["ti"].xcom_push(
"issue_json_path", os.path.join(WORK_JSON_FILES, "issue.json")
) | [
"def",
"copy_mst_files_to_work_folder",
"(",
"*",
"*",
"kwargs",
")",
":",
"WORK_PATH",
"=",
"Variable",
".",
"get",
"(",
"\"WORK_FOLDER_PATH\"",
")",
"CURRENT_EXECUTION_FOLDER",
"=",
"os",
".",
"path",
".",
"join",
"(",
"WORK_PATH",
",",
"kwargs",
"[",
"\"run_id\"",
"]",
")",
"WORK_ISIS_FILES",
"=",
"os",
".",
"path",
".",
"join",
"(",
"CURRENT_EXECUTION_FOLDER",
",",
"\"isis\"",
")",
"WORK_JSON_FILES",
"=",
"os",
".",
"path",
".",
"join",
"(",
"CURRENT_EXECUTION_FOLDER",
",",
"\"json\"",
")",
"BASE_TITLE_FOLDER_PATH",
"=",
"Variable",
".",
"get",
"(",
"\"BASE_TITLE_FOLDER_PATH\"",
")",
"BASE_ISSUE_FOLDER_PATH",
"=",
"Variable",
".",
"get",
"(",
"\"BASE_ISSUE_FOLDER_PATH\"",
")",
"copying_paths",
"=",
"[",
"]",
"for",
"path",
"in",
"[",
"BASE_TITLE_FOLDER_PATH",
",",
"BASE_ISSUE_FOLDER_PATH",
"]",
":",
"files",
"=",
"[",
"f",
"for",
"f",
"in",
"os",
".",
"listdir",
"(",
"path",
")",
"if",
"f",
".",
"endswith",
"(",
"\".xrf\"",
")",
"or",
"f",
".",
"endswith",
"(",
"\".mst\"",
")",
"]",
"for",
"file",
"in",
"files",
":",
"origin_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"file",
")",
"desatination_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"WORK_ISIS_FILES",
",",
"file",
")",
"copying_paths",
".",
"append",
"(",
"[",
"origin_path",
",",
"desatination_path",
"]",
")",
"for",
"origin",
",",
"destination",
"in",
"copying_paths",
":",
"logging",
".",
"info",
"(",
"\"copying file from %s to %s.\"",
"%",
"(",
"origin",
",",
"destination",
")",
")",
"shutil",
".",
"copy",
"(",
"origin",
",",
"destination",
")",
"if",
"\"title.mst\"",
"in",
"destination",
":",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_push",
"(",
"\"title_mst_path\"",
",",
"destination",
")",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_push",
"(",
"\"title_json_path\"",
",",
"os",
".",
"path",
".",
"join",
"(",
"WORK_JSON_FILES",
",",
"\"title.json\"",
")",
")",
"if",
"\"issue.mst\"",
"in",
"destination",
":",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_push",
"(",
"\"issue_mst_path\"",
",",
"destination",
")",
"kwargs",
"[",
"\"ti\"",
"]",
".",
"xcom_push",
"(",
"\"issue_json_path\"",
",",
"os",
".",
"path",
".",
"join",
"(",
"WORK_JSON_FILES",
",",
"\"issue.json\"",
")",
")"
] | [
325,
0
] | [
367,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
print_tela | (n) | Printa a tela do jogo. | Printa a tela do jogo. | def print_tela(n):
"""Printa a tela do jogo."""
# coordenadas centrais da bolinha
meio_x = randint(2, 20)
meio_y = randint(3, 76)
bolinha = criar_bola(n)
janela = bfunc.cjane.Janela()
janela.muda_slice(meio_x-1, meio_y - 2, meio_y + 3, bolinha[0])
janela.muda_slice(meio_x, meio_y - 2, meio_y + 3, bolinha[1])
janela.muda_slice(meio_x + 1, meio_y - 2, meio_y + 3, bolinha[2])
# coloca os algarismos de 0 a 9 no miolo, diferentes do algarismo dentro da bolinha
k = 0
while k != 10:
if k != n:
# coordenadas do algarismo
xn, yn = randint(2, 20), randint(3, 76)
# não deixa o algarismo aparecer dentro da bolinha ou em um caractere que não esteja em branco
while (meio_x - 1 <= xn <= meio_x + 1 and meio_y - 2 <= yn <= meio_y + 2) or janela[xn][yn] != ' ':
xn, yn = randint(2, 20), randint(3, 76)
janela.muda_slice(xn, yn, yn+1, str(k))
k += 1
print(janela) | [
"def",
"print_tela",
"(",
"n",
")",
":",
"# coordenadas centrais da bolinha",
"meio_x",
"=",
"randint",
"(",
"2",
",",
"20",
")",
"meio_y",
"=",
"randint",
"(",
"3",
",",
"76",
")",
"bolinha",
"=",
"criar_bola",
"(",
"n",
")",
"janela",
"=",
"bfunc",
".",
"cjane",
".",
"Janela",
"(",
")",
"janela",
".",
"muda_slice",
"(",
"meio_x",
"-",
"1",
",",
"meio_y",
"-",
"2",
",",
"meio_y",
"+",
"3",
",",
"bolinha",
"[",
"0",
"]",
")",
"janela",
".",
"muda_slice",
"(",
"meio_x",
",",
"meio_y",
"-",
"2",
",",
"meio_y",
"+",
"3",
",",
"bolinha",
"[",
"1",
"]",
")",
"janela",
".",
"muda_slice",
"(",
"meio_x",
"+",
"1",
",",
"meio_y",
"-",
"2",
",",
"meio_y",
"+",
"3",
",",
"bolinha",
"[",
"2",
"]",
")",
"# coloca os algarismos de 0 a 9 no miolo, diferentes do algarismo dentro da bolinha",
"k",
"=",
"0",
"while",
"k",
"!=",
"10",
":",
"if",
"k",
"!=",
"n",
":",
"# coordenadas do algarismo",
"xn",
",",
"yn",
"=",
"randint",
"(",
"2",
",",
"20",
")",
",",
"randint",
"(",
"3",
",",
"76",
")",
"# não deixa o algarismo aparecer dentro da bolinha ou em um caractere que não esteja em branco",
"while",
"(",
"meio_x",
"-",
"1",
"<=",
"xn",
"<=",
"meio_x",
"+",
"1",
"and",
"meio_y",
"-",
"2",
"<=",
"yn",
"<=",
"meio_y",
"+",
"2",
")",
"or",
"janela",
"[",
"xn",
"]",
"[",
"yn",
"]",
"!=",
"' '",
":",
"xn",
",",
"yn",
"=",
"randint",
"(",
"2",
",",
"20",
")",
",",
"randint",
"(",
"3",
",",
"76",
")",
"janela",
".",
"muda_slice",
"(",
"xn",
",",
"yn",
",",
"yn",
"+",
"1",
",",
"str",
"(",
"k",
")",
")",
"k",
"+=",
"1",
"print",
"(",
"janela",
")"
] | [
14,
0
] | [
45,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
PessoasDb.gen_cidade | (self) | return q.fetchone()[0] | conta quantas cidades estão cadastradas e escolhe uma delas pelo id. | conta quantas cidades estão cadastradas e escolhe uma delas pelo id. | def gen_cidade(self):
''' conta quantas cidades estão cadastradas e escolhe uma delas pelo id. '''
sql = 'SELECT COUNT(*) FROM cidades'
q = self.db.cursor.execute(sql)
return q.fetchone()[0] | [
"def",
"gen_cidade",
"(",
"self",
")",
":",
"sql",
"=",
"'SELECT COUNT(*) FROM cidades'",
"q",
"=",
"self",
".",
"db",
".",
"cursor",
".",
"execute",
"(",
"sql",
")",
"return",
"q",
".",
"fetchone",
"(",
")",
"[",
"0",
"]"
] | [
468,
4
] | [
472,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
separa_sentencas | (texto) | return sentencas | A funcao recebe um texto e devolve uma lista das sentencas dentro do texto | A funcao recebe um texto e devolve uma lista das sentencas dentro do texto | def separa_sentencas(texto):
'''A funcao recebe um texto e devolve uma lista das sentencas dentro do texto'''
sentencas = re.split(r'[.!?]+', texto)
if sentencas[-1] == '':
del sentencas[-1]
return sentencas | [
"def",
"separa_sentencas",
"(",
"texto",
")",
":",
"sentencas",
"=",
"re",
".",
"split",
"(",
"r'[.!?]+'",
",",
"texto",
")",
"if",
"sentencas",
"[",
"-",
"1",
"]",
"==",
"''",
":",
"del",
"sentencas",
"[",
"-",
"1",
"]",
"return",
"sentencas"
] | [
28,
0
] | [
33,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
prepare_document | (self, code) | Modifica o XML que será enviado para o Crossref com dados do depositante.
Os únicos tipos de erros passíveis de novas tentativas são os de comunicação
com o banco de dados.
| Modifica o XML que será enviado para o Crossref com dados do depositante. | def prepare_document(self, code):
"""Modifica o XML que será enviado para o Crossref com dados do depositante.
Os únicos tipos de erros passíveis de novas tentativas são os de comunicação
com o banco de dados.
"""
with transactional_session() as session:
deposit = session.query(Deposit).filter_by(code=code).first()
def setup_depositor(xml):
registrant = xml.find('//{http://www.crossref.org/schema/4.4.0}registrant')
registrant.text = CROSSREF_DEPOSITOR_NAME
depositor_name = xml.find('//{http://www.crossref.org/schema/4.4.0}depositor_name')
depositor_name.text = CROSSREF_DEPOSITOR_NAME
depositor_email = xml.find('//{http://www.crossref.org/schema/4.4.0}email_address')
depositor_email.text = CROSSREF_DEPOSITOR_EMAIL
doi = xml.find('//{http://www.crossref.org/schema/4.4.0}doi_data/{http://www.crossref.org/schema/4.4.0}doi')
doi.text = deposit.doi
return xml
def xml_is_valid(xml, only_front=False):
xml = BytesIO(xml.encode('utf-8'))
try:
xml_doc = etree.parse(xml)
logger.debug('XML is well formed')
except Exception as e:
logger.exception(e)
logger.error('Fail to parse XML')
return (False, '', str(e))
xml_doc = setup_depositor(xml_doc)
if only_front:
citation_list = xml_doc.find(
'//{http://www.crossref.org/schema/4.4.0}citation_list')
if citation_list:
citation_list.getparent().remove(citation_list)
xml_doc_pprint = etree.tostring(xml_doc, pretty_print=True)
xml_doc = etree.parse(BytesIO(xml_doc_pprint))
try:
result = PARSED_SCHEMA.assertValid(xml_doc)
logger.debug('XML is valid')
return (True, xml_doc, '')
except etree.DocumentInvalid as e:
logger.exception(e)
logger.error('Fail to parse XML')
return (False, xml_doc, str(e))
is_valid, parsed_xml, exc = xml_is_valid(deposit.submission_xml)
deposit.submission_xml = etree.tostring(parsed_xml, encoding='utf-8', pretty_print=True, xml_declaration=True).decode('utf-8')
if is_valid is True:
log_title = 'XML is valid, it will be submitted to Crossref'
now = datetime.now()
logger.info(log_title)
deposit.is_xml_valid = True
deposit.has_submission_xml_valid_references = True
deposit.submission_status = 'waiting'
deposit.submission_updated_at = now
deposit.doi_batch_id = parsed_xml.find(
'//{http://www.crossref.org/schema/4.4.0}doi_batch_id').text
log_event(session, {'title': log_title, 'type': 'submission', 'status': 'success', 'deposit_code': code})
return code
log_title = 'XML with references is invalid, fail to parse xml for document (%s)' % code
now = datetime.now()
logger.warning(log_title)
deposit.is_xml_valid = False
deposit.submission_status = 'error'
deposit.submission_updated_at = now
deposit.updated_at = now
log_event(session, {'title': log_title, 'body': str(exc), 'type': 'submission', 'status': 'error', 'deposit_code': code})
log_title = 'Trying to send XML without references'
now = datetime.now()
logger.debug(log_title)
log_event(session, {'title': log_title, 'type': 'submission', 'status': 'info', 'deposit_code': code})
is_valid, parsed_xml, exc = xml_is_valid(
deposit.submission_xml, only_front=True
)
deposit.submission_xml = etree.tostring(parsed_xml, encoding='utf-8', pretty_print=True, xml_declaration=True).decode('utf-8')
if is_valid is True:
log_title = 'XML only with front metadata is valid, it will be submitted to Crossref'
now = datetime.now()
logger.info(log_title)
deposit.is_xml_valid = True
deposit.submission_status = 'waiting'
deposit.submission_updated_at = now
deposit.doi_batch_id = parsed_xml.find(
'//{http://www.crossref.org/schema/4.4.0}doi_batch_id').text
log_event(session, {'title': log_title, 'type': 'submission', 'status': 'success', 'deposit_code': code})
return code
log_title = 'XML only with front metadata is also invalid, fail to parse xml for document (%s)' % code
now = datetime.now()
logger.error(log_title)
deposit.is_xml_valid = False
deposit.submission_status = 'error'
deposit.submission_updated_at = now
deposit.updated_at = now
log_event(session, {'title': log_title, 'body': str(exc), 'type': 'submission', 'status': 'error', 'deposit_code': code})
raise ChainAborted(log_title) | [
"def",
"prepare_document",
"(",
"self",
",",
"code",
")",
":",
"with",
"transactional_session",
"(",
")",
"as",
"session",
":",
"deposit",
"=",
"session",
".",
"query",
"(",
"Deposit",
")",
".",
"filter_by",
"(",
"code",
"=",
"code",
")",
".",
"first",
"(",
")",
"def",
"setup_depositor",
"(",
"xml",
")",
":",
"registrant",
"=",
"xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}registrant'",
")",
"registrant",
".",
"text",
"=",
"CROSSREF_DEPOSITOR_NAME",
"depositor_name",
"=",
"xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}depositor_name'",
")",
"depositor_name",
".",
"text",
"=",
"CROSSREF_DEPOSITOR_NAME",
"depositor_email",
"=",
"xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}email_address'",
")",
"depositor_email",
".",
"text",
"=",
"CROSSREF_DEPOSITOR_EMAIL",
"doi",
"=",
"xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}doi_data/{http://www.crossref.org/schema/4.4.0}doi'",
")",
"doi",
".",
"text",
"=",
"deposit",
".",
"doi",
"return",
"xml",
"def",
"xml_is_valid",
"(",
"xml",
",",
"only_front",
"=",
"False",
")",
":",
"xml",
"=",
"BytesIO",
"(",
"xml",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"try",
":",
"xml_doc",
"=",
"etree",
".",
"parse",
"(",
"xml",
")",
"logger",
".",
"debug",
"(",
"'XML is well formed'",
")",
"except",
"Exception",
"as",
"e",
":",
"logger",
".",
"exception",
"(",
"e",
")",
"logger",
".",
"error",
"(",
"'Fail to parse XML'",
")",
"return",
"(",
"False",
",",
"''",
",",
"str",
"(",
"e",
")",
")",
"xml_doc",
"=",
"setup_depositor",
"(",
"xml_doc",
")",
"if",
"only_front",
":",
"citation_list",
"=",
"xml_doc",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}citation_list'",
")",
"if",
"citation_list",
":",
"citation_list",
".",
"getparent",
"(",
")",
".",
"remove",
"(",
"citation_list",
")",
"xml_doc_pprint",
"=",
"etree",
".",
"tostring",
"(",
"xml_doc",
",",
"pretty_print",
"=",
"True",
")",
"xml_doc",
"=",
"etree",
".",
"parse",
"(",
"BytesIO",
"(",
"xml_doc_pprint",
")",
")",
"try",
":",
"result",
"=",
"PARSED_SCHEMA",
".",
"assertValid",
"(",
"xml_doc",
")",
"logger",
".",
"debug",
"(",
"'XML is valid'",
")",
"return",
"(",
"True",
",",
"xml_doc",
",",
"''",
")",
"except",
"etree",
".",
"DocumentInvalid",
"as",
"e",
":",
"logger",
".",
"exception",
"(",
"e",
")",
"logger",
".",
"error",
"(",
"'Fail to parse XML'",
")",
"return",
"(",
"False",
",",
"xml_doc",
",",
"str",
"(",
"e",
")",
")",
"is_valid",
",",
"parsed_xml",
",",
"exc",
"=",
"xml_is_valid",
"(",
"deposit",
".",
"submission_xml",
")",
"deposit",
".",
"submission_xml",
"=",
"etree",
".",
"tostring",
"(",
"parsed_xml",
",",
"encoding",
"=",
"'utf-8'",
",",
"pretty_print",
"=",
"True",
",",
"xml_declaration",
"=",
"True",
")",
".",
"decode",
"(",
"'utf-8'",
")",
"if",
"is_valid",
"is",
"True",
":",
"log_title",
"=",
"'XML is valid, it will be submitted to Crossref'",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"logger",
".",
"info",
"(",
"log_title",
")",
"deposit",
".",
"is_xml_valid",
"=",
"True",
"deposit",
".",
"has_submission_xml_valid_references",
"=",
"True",
"deposit",
".",
"submission_status",
"=",
"'waiting'",
"deposit",
".",
"submission_updated_at",
"=",
"now",
"deposit",
".",
"doi_batch_id",
"=",
"parsed_xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}doi_batch_id'",
")",
".",
"text",
"log_event",
"(",
"session",
",",
"{",
"'title'",
":",
"log_title",
",",
"'type'",
":",
"'submission'",
",",
"'status'",
":",
"'success'",
",",
"'deposit_code'",
":",
"code",
"}",
")",
"return",
"code",
"log_title",
"=",
"'XML with references is invalid, fail to parse xml for document (%s)'",
"%",
"code",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"logger",
".",
"warning",
"(",
"log_title",
")",
"deposit",
".",
"is_xml_valid",
"=",
"False",
"deposit",
".",
"submission_status",
"=",
"'error'",
"deposit",
".",
"submission_updated_at",
"=",
"now",
"deposit",
".",
"updated_at",
"=",
"now",
"log_event",
"(",
"session",
",",
"{",
"'title'",
":",
"log_title",
",",
"'body'",
":",
"str",
"(",
"exc",
")",
",",
"'type'",
":",
"'submission'",
",",
"'status'",
":",
"'error'",
",",
"'deposit_code'",
":",
"code",
"}",
")",
"log_title",
"=",
"'Trying to send XML without references'",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"logger",
".",
"debug",
"(",
"log_title",
")",
"log_event",
"(",
"session",
",",
"{",
"'title'",
":",
"log_title",
",",
"'type'",
":",
"'submission'",
",",
"'status'",
":",
"'info'",
",",
"'deposit_code'",
":",
"code",
"}",
")",
"is_valid",
",",
"parsed_xml",
",",
"exc",
"=",
"xml_is_valid",
"(",
"deposit",
".",
"submission_xml",
",",
"only_front",
"=",
"True",
")",
"deposit",
".",
"submission_xml",
"=",
"etree",
".",
"tostring",
"(",
"parsed_xml",
",",
"encoding",
"=",
"'utf-8'",
",",
"pretty_print",
"=",
"True",
",",
"xml_declaration",
"=",
"True",
")",
".",
"decode",
"(",
"'utf-8'",
")",
"if",
"is_valid",
"is",
"True",
":",
"log_title",
"=",
"'XML only with front metadata is valid, it will be submitted to Crossref'",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"logger",
".",
"info",
"(",
"log_title",
")",
"deposit",
".",
"is_xml_valid",
"=",
"True",
"deposit",
".",
"submission_status",
"=",
"'waiting'",
"deposit",
".",
"submission_updated_at",
"=",
"now",
"deposit",
".",
"doi_batch_id",
"=",
"parsed_xml",
".",
"find",
"(",
"'//{http://www.crossref.org/schema/4.4.0}doi_batch_id'",
")",
".",
"text",
"log_event",
"(",
"session",
",",
"{",
"'title'",
":",
"log_title",
",",
"'type'",
":",
"'submission'",
",",
"'status'",
":",
"'success'",
",",
"'deposit_code'",
":",
"code",
"}",
")",
"return",
"code",
"log_title",
"=",
"'XML only with front metadata is also invalid, fail to parse xml for document (%s)'",
"%",
"code",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"logger",
".",
"error",
"(",
"log_title",
")",
"deposit",
".",
"is_xml_valid",
"=",
"False",
"deposit",
".",
"submission_status",
"=",
"'error'",
"deposit",
".",
"submission_updated_at",
"=",
"now",
"deposit",
".",
"updated_at",
"=",
"now",
"log_event",
"(",
"session",
",",
"{",
"'title'",
":",
"log_title",
",",
"'body'",
":",
"str",
"(",
"exc",
")",
",",
"'type'",
":",
"'submission'",
",",
"'status'",
":",
"'error'",
",",
"'deposit_code'",
":",
"code",
"}",
")",
"raise",
"ChainAborted",
"(",
"log_title",
")"
] | [
180,
0
] | [
293,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
neighbor | (location, direction, size=(4, 4)) | Obter o vizinho de acordo com a localização e direção. | Obter o vizinho de acordo com a localização e direção. | def neighbor(location, direction, size=(4, 4)):
"""Obter o vizinho de acordo com a localização e direção."""
x, y = location
width, height = size
dx, dy = DELTA[direction]
# Verifica se o vizinho está dentro da caverna
if 0 <= x + dx < width and 0 <= y + dy < height:
return x + dx, y + dy | [
"def",
"neighbor",
"(",
"location",
",",
"direction",
",",
"size",
"=",
"(",
"4",
",",
"4",
")",
")",
":",
"x",
",",
"y",
"=",
"location",
"width",
",",
"height",
"=",
"size",
"dx",
",",
"dy",
"=",
"DELTA",
"[",
"direction",
"]",
"# Verifica se o vizinho está dentro da caverna",
"if",
"0",
"<=",
"x",
"+",
"dx",
"<",
"width",
"and",
"0",
"<=",
"y",
"+",
"dy",
"<",
"height",
":",
"return",
"x",
"+",
"dx",
",",
"y",
"+",
"dy"
] | [
33,
0
] | [
43,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
remove_element | (root: etree.Element, query: str) | return False | Encontra um elemento a partir de uma string de consulta (LXML) e o
remove. A busca e a remoção são feitas no elemento ``root``. | Encontra um elemento a partir de uma string de consulta (LXML) e o
remove. A busca e a remoção são feitas no elemento ``root``. | def remove_element(root: etree.Element, query: str) -> bool:
"""Encontra um elemento a partir de uma string de consulta (LXML) e o
remove. A busca e a remoção são feitas no elemento ``root``."""
if root is None or root.find(query) is None:
return False
el = root.find(query)
if root.remove(el) is None and el.getparent() is None:
return True
return False | [
"def",
"remove_element",
"(",
"root",
":",
"etree",
".",
"Element",
",",
"query",
":",
"str",
")",
"->",
"bool",
":",
"if",
"root",
"is",
"None",
"or",
"root",
".",
"find",
"(",
"query",
")",
"is",
"None",
":",
"return",
"False",
"el",
"=",
"root",
".",
"find",
"(",
"query",
")",
"if",
"root",
".",
"remove",
"(",
"el",
")",
"is",
"None",
"and",
"el",
".",
"getparent",
"(",
")",
"is",
"None",
":",
"return",
"True",
"return",
"False"
] | [
232,
0
] | [
243,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Bullet.__init__ | (self, ai_settings, screen, ship) | Cria um objecto para o projetil na posicao actual
da espaconave | Cria um objecto para o projetil na posicao actual
da espaconave | def __init__(self, ai_settings, screen, ship):
"""Cria um objecto para o projetil na posicao actual
da espaconave"""
super(Bullet, self).__init__()
self.screen = screen
# Cria um rectangulo para o projectil em (0, 0) e, em seguida,
# define a posicao correta
self.rect = pygame.Rect(0, 0, ai_settings.bullet_width,
ai_settings.bullet_height)
self.rect.centerx = ship.rect.centerx
self.rect.top = ship.rect.top
# Armazena a posicao do projetil como um valor decimal
self.y = float(self.rect.y)
self.color = ai_settings.bullet_color
self.speed_factor = ai_settings.bullet_speed_factor | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
",",
"ship",
")",
":",
"super",
"(",
"Bullet",
",",
"self",
")",
".",
"__init__",
"(",
")",
"self",
".",
"screen",
"=",
"screen",
"# Cria um rectangulo para o projectil em (0, 0) e, em seguida,",
"# define a posicao correta",
"self",
".",
"rect",
"=",
"pygame",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"ai_settings",
".",
"bullet_width",
",",
"ai_settings",
".",
"bullet_height",
")",
"self",
".",
"rect",
".",
"centerx",
"=",
"ship",
".",
"rect",
".",
"centerx",
"self",
".",
"rect",
".",
"top",
"=",
"ship",
".",
"rect",
".",
"top",
"# Armazena a posicao do projetil como um valor decimal",
"self",
".",
"y",
"=",
"float",
"(",
"self",
".",
"rect",
".",
"y",
")",
"self",
".",
"color",
"=",
"ai_settings",
".",
"bullet_color",
"self",
".",
"speed_factor",
"=",
"ai_settings",
".",
"bullet_speed_factor"
] | [
7,
4
] | [
24,
59
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
min_max_array | (vetor) | Busca os valores máximo e mínimo em vetor | Busca os valores máximo e mínimo em vetor | def min_max_array(vetor):
""" Busca os valores máximo e mínimo em vetor """
minimo = vetor[0]
maximo = vetor[0]
for i in range(1, len(vetor)):
if vetor[i] < minimo:
minimo = vetor[i]
elif vetor[i] > maximo:
maximo = vetor[i]
print('Minimo : ' + str(minimo))
print('Maximo : ' + str(maximo)) | [
"def",
"min_max_array",
"(",
"vetor",
")",
":",
"minimo",
"=",
"vetor",
"[",
"0",
"]",
"maximo",
"=",
"vetor",
"[",
"0",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"vetor",
")",
")",
":",
"if",
"vetor",
"[",
"i",
"]",
"<",
"minimo",
":",
"minimo",
"=",
"vetor",
"[",
"i",
"]",
"elif",
"vetor",
"[",
"i",
"]",
">",
"maximo",
":",
"maximo",
"=",
"vetor",
"[",
"i",
"]",
"print",
"(",
"'Minimo : '",
"+",
"str",
"(",
"minimo",
")",
")",
"print",
"(",
"'Maximo : '",
"+",
"str",
"(",
"maximo",
")",
")"
] | [
6,
0
] | [
18,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Item.valor | (self) | return self.__valor | Dar acesso a variavel privada __valor como propriedade.
Ex: orçamento_a = Orçamento(500)
orçamento_a.valor
Returns:
[int, float]: Leitura de valor no formato int ou float
| Dar acesso a variavel privada __valor como propriedade.
Ex: orçamento_a = Orçamento(500)
orçamento_a.valor | def valor(self) -> Union[int, float]:
"""Dar acesso a variavel privada __valor como propriedade.
Ex: orçamento_a = Orçamento(500)
orçamento_a.valor
Returns:
[int, float]: Leitura de valor no formato int ou float
"""
return self.__valor | [
"def",
"valor",
"(",
"self",
")",
"->",
"Union",
"[",
"int",
",",
"float",
"]",
":",
"return",
"self",
".",
"__valor"
] | [
20,
4
] | [
28,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ArticleFactory | (
document_id: str,
data: dict,
issue_id: str,
document_order: int,
document_xml_url: str,
) | return article | Cria uma instância de artigo a partir dos dados de entrada.
Os dados do parâmetro `data` são adaptados ao formato exigido pelo
modelo Article do OPAC Schema.
Args:
document_id (str): Identificador do documento
data (dict): Estrutura contendo o `front` do documento.
issue_id (str): Identificador de issue.
document_order (int): Posição do artigo.
document_xml_url (str): URL do XML do artigo
Returns:
models.Article: Instância de um artigo próprio do modelo de dados do
OPAC.
| Cria uma instância de artigo a partir dos dados de entrada. | def ArticleFactory(
document_id: str,
data: dict,
issue_id: str,
document_order: int,
document_xml_url: str,
) -> models.Article:
"""Cria uma instância de artigo a partir dos dados de entrada.
Os dados do parâmetro `data` são adaptados ao formato exigido pelo
modelo Article do OPAC Schema.
Args:
document_id (str): Identificador do documento
data (dict): Estrutura contendo o `front` do documento.
issue_id (str): Identificador de issue.
document_order (int): Posição do artigo.
document_xml_url (str): URL do XML do artigo
Returns:
models.Article: Instância de um artigo próprio do modelo de dados do
OPAC.
"""
def _nestget(data, *path, default=""):
"""Obtém valores de list ou dicionários."""
for key_or_index in path:
try:
data = data[key_or_index]
except (KeyError, IndexError):
return default
return data
AUTHOR_CONTRIB_TYPES = (
"author",
"editor",
"organizer",
"translator",
"autor",
"compiler",
)
try:
article = models.Article.objects.get(_id=document_id)
except models.Article.DoesNotExist:
article = models.Article()
# Dados principais
article.title = _nestget(data, "article_meta", 0, "article_title", 0)
article.section = _nestget(data, "article_meta", 0, "pub_subject", 0)
article.abstract = _nestget(data, "article_meta", 0, "abstract", 0)
# Identificadores
article._id = _nestget(data, "article_meta", 0, "article_publisher_id", 0)
article.aid = _nestget(data, "article_meta", 0, "article_publisher_id", 0)
article.pid = _nestget(data, "article_meta", 0, "article_publisher_id", 1)
article.doi = _nestget(data, "article_meta", 0, "article_doi", 0)
def _get_article_authors(data) -> Generator:
"""Recupera a lista de autores do artigo"""
for contrib in _nestget(data, "contrib"):
if _nestget(contrib, "contrib_type", 0) in AUTHOR_CONTRIB_TYPES:
yield (
"%s, %s"
% (
_nestget(contrib, "contrib_surname", 0),
_nestget(contrib, "contrib_given_names", 0),
)
)
def _get_original_language(data: dict) -> str:
return _nestget(data, "article", 0, "lang", 0)
def _get_languages(data: dict) -> List[str]:
"""Recupera a lista de idiomas em que o artigo foi publicado"""
languages = [_get_original_language(data)]
for sub_article in _nestget(data, "sub_article"):
languages.append(_nestget(sub_article, "article", 0, "lang", 0))
return languages
def _get_translated_titles(data: dict) -> Generator:
"""Recupera a lista de títulos do artigo"""
for sub_article in _nestget(data, "sub_article"):
yield models.TranslatedTitle(
**{
"name": _nestget(
sub_article, "article_meta", 0, "article_title", 0
),
"language": _nestget(sub_article, "article", 0, "lang", 0),
}
)
def _get_translated_sections(data: dict) -> List[models.TranslatedSection]:
"""Recupera a lista de seções traduzidas a partir do document front"""
sections = [
models.TranslatedSection(
**{
"name": _nestget(data, "article_meta", 0, "pub_subject", 0),
"language": _get_original_language(data),
}
)
]
for sub_article in _nestget(data, "sub_article"):
sections.append(
models.TranslatedSection(
**{
"name": _nestget(
sub_article, "article_meta", 0, "pub_subject", 0
),
"language": _nestget(sub_article, "article", 0, "lang", 0),
}
)
)
return sections
def _get_abstracts(data: dict) -> List[models.Abstract]:
"""Recupera todos os abstracts do artigo"""
abstracts = [
models.Abstract(
**{
"text": _nestget(data, "article_meta", 0, "abstract", 0),
"language": _get_original_language(data),
}
)
]
for trans_abstract in data.get("trans_abstract", []):
abstracts.append(
models.Abstract(
**{
"text": _nestget(trans_abstract, "text", 0),
"language": _nestget(trans_abstract, "lang", 0),
}
)
)
for sub_article in _nestget(data, "sub_article"):
abstracts.append(
models.Abstract(
**{
"text": _nestget(sub_article, "article_meta", 0, "abstract", 0),
"language": _nestget(sub_article, "article", 0, "lang", 0),
}
)
)
return abstracts
def _get_keywords(data: dict) -> List[models.ArticleKeyword]:
"""Retorna a lista de palavras chaves do artigo e dos
seus sub articles"""
keywords = [
models.ArticleKeyword(
**{
"keywords": _nestget(kwd_group, "kwd", default=[]),
"language": _nestget(kwd_group, "lang", 0),
}
)
for kwd_group in _nestget(data, "kwd_group", default=[])
]
for sub_article in _nestget(data, "sub_article"):
[
keywords.append(
models.ArticleKeyword(
**{
"keywords": _nestget(kwd_group, "kwd", default=[]),
"language": _nestget(kwd_group, "lang", 0),
}
)
)
for kwd_group in _nestget(sub_article, "kwd_group", default=[])
]
return keywords
article.authors = list(_get_article_authors(data))
article.languages = list(_get_languages(data))
article.translated_titles = list(_get_translated_titles(data))
article.trans_sections = list(_get_translated_sections(data))
article.abstracts = list(_get_abstracts(data))
article.keywords = list(_get_keywords(data))
article.abstract_languages = [
abstract["language"] for abstract in article.abstracts
]
article.original_language = _get_original_language(data)
article.publication_date = _nestget(data, "pub_date", 0, "text", 0)
article.type = _nestget(data, "article", 0, "type", 0)
# Dados de localização
article.elocation = _nestget(data, "article_meta", 0, "pub_elocation", 0)
article.fpage = _nestget(data, "article_meta", 0, "pub_fpage", 0)
article.fpage_sequence = _nestget(data, "article_meta", 0, "pub_fpage_seq", 0)
article.lpage = _nestget(data, "article_meta", 0, "pub_lpage", 0)
# Issue vinculada
if issue_id:
issue = models.Issue.objects.get(_id=issue_id)
article.issue = issue
article.journal = issue.journal
if document_order:
article.order = int(document_order)
article.xml = document_xml_url
# Campo de compatibilidade do OPAC
article.htmls = [{"lang": lang} for lang in _get_languages(data)]
return article | [
"def",
"ArticleFactory",
"(",
"document_id",
":",
"str",
",",
"data",
":",
"dict",
",",
"issue_id",
":",
"str",
",",
"document_order",
":",
"int",
",",
"document_xml_url",
":",
"str",
",",
")",
"->",
"models",
".",
"Article",
":",
"def",
"_nestget",
"(",
"data",
",",
"*",
"path",
",",
"default",
"=",
"\"\"",
")",
":",
"\"\"\"Obtém valores de list ou dicionários.\"\"\"",
"for",
"key_or_index",
"in",
"path",
":",
"try",
":",
"data",
"=",
"data",
"[",
"key_or_index",
"]",
"except",
"(",
"KeyError",
",",
"IndexError",
")",
":",
"return",
"default",
"return",
"data",
"AUTHOR_CONTRIB_TYPES",
"=",
"(",
"\"author\"",
",",
"\"editor\"",
",",
"\"organizer\"",
",",
"\"translator\"",
",",
"\"autor\"",
",",
"\"compiler\"",
",",
")",
"try",
":",
"article",
"=",
"models",
".",
"Article",
".",
"objects",
".",
"get",
"(",
"_id",
"=",
"document_id",
")",
"except",
"models",
".",
"Article",
".",
"DoesNotExist",
":",
"article",
"=",
"models",
".",
"Article",
"(",
")",
"# Dados principais",
"article",
".",
"title",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_title\"",
",",
"0",
")",
"article",
".",
"section",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_subject\"",
",",
"0",
")",
"article",
".",
"abstract",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"abstract\"",
",",
"0",
")",
"# Identificadores",
"article",
".",
"_id",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_publisher_id\"",
",",
"0",
")",
"article",
".",
"aid",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_publisher_id\"",
",",
"0",
")",
"article",
".",
"pid",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_publisher_id\"",
",",
"1",
")",
"article",
".",
"doi",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_doi\"",
",",
"0",
")",
"def",
"_get_article_authors",
"(",
"data",
")",
"->",
"Generator",
":",
"\"\"\"Recupera a lista de autores do artigo\"\"\"",
"for",
"contrib",
"in",
"_nestget",
"(",
"data",
",",
"\"contrib\"",
")",
":",
"if",
"_nestget",
"(",
"contrib",
",",
"\"contrib_type\"",
",",
"0",
")",
"in",
"AUTHOR_CONTRIB_TYPES",
":",
"yield",
"(",
"\"%s, %s\"",
"%",
"(",
"_nestget",
"(",
"contrib",
",",
"\"contrib_surname\"",
",",
"0",
")",
",",
"_nestget",
"(",
"contrib",
",",
"\"contrib_given_names\"",
",",
"0",
")",
",",
")",
")",
"def",
"_get_original_language",
"(",
"data",
":",
"dict",
")",
"->",
"str",
":",
"return",
"_nestget",
"(",
"data",
",",
"\"article\"",
",",
"0",
",",
"\"lang\"",
",",
"0",
")",
"def",
"_get_languages",
"(",
"data",
":",
"dict",
")",
"->",
"List",
"[",
"str",
"]",
":",
"\"\"\"Recupera a lista de idiomas em que o artigo foi publicado\"\"\"",
"languages",
"=",
"[",
"_get_original_language",
"(",
"data",
")",
"]",
"for",
"sub_article",
"in",
"_nestget",
"(",
"data",
",",
"\"sub_article\"",
")",
":",
"languages",
".",
"append",
"(",
"_nestget",
"(",
"sub_article",
",",
"\"article\"",
",",
"0",
",",
"\"lang\"",
",",
"0",
")",
")",
"return",
"languages",
"def",
"_get_translated_titles",
"(",
"data",
":",
"dict",
")",
"->",
"Generator",
":",
"\"\"\"Recupera a lista de títulos do artigo\"\"\"",
"for",
"sub_article",
"in",
"_nestget",
"(",
"data",
",",
"\"sub_article\"",
")",
":",
"yield",
"models",
".",
"TranslatedTitle",
"(",
"*",
"*",
"{",
"\"name\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article_meta\"",
",",
"0",
",",
"\"article_title\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article\"",
",",
"0",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
"def",
"_get_translated_sections",
"(",
"data",
":",
"dict",
")",
"->",
"List",
"[",
"models",
".",
"TranslatedSection",
"]",
":",
"\"\"\"Recupera a lista de seções traduzidas a partir do document front\"\"\"",
"sections",
"=",
"[",
"models",
".",
"TranslatedSection",
"(",
"*",
"*",
"{",
"\"name\"",
":",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_subject\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_get_original_language",
"(",
"data",
")",
",",
"}",
")",
"]",
"for",
"sub_article",
"in",
"_nestget",
"(",
"data",
",",
"\"sub_article\"",
")",
":",
"sections",
".",
"append",
"(",
"models",
".",
"TranslatedSection",
"(",
"*",
"*",
"{",
"\"name\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_subject\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article\"",
",",
"0",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
")",
"return",
"sections",
"def",
"_get_abstracts",
"(",
"data",
":",
"dict",
")",
"->",
"List",
"[",
"models",
".",
"Abstract",
"]",
":",
"\"\"\"Recupera todos os abstracts do artigo\"\"\"",
"abstracts",
"=",
"[",
"models",
".",
"Abstract",
"(",
"*",
"*",
"{",
"\"text\"",
":",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"abstract\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_get_original_language",
"(",
"data",
")",
",",
"}",
")",
"]",
"for",
"trans_abstract",
"in",
"data",
".",
"get",
"(",
"\"trans_abstract\"",
",",
"[",
"]",
")",
":",
"abstracts",
".",
"append",
"(",
"models",
".",
"Abstract",
"(",
"*",
"*",
"{",
"\"text\"",
":",
"_nestget",
"(",
"trans_abstract",
",",
"\"text\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"trans_abstract",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
")",
"for",
"sub_article",
"in",
"_nestget",
"(",
"data",
",",
"\"sub_article\"",
")",
":",
"abstracts",
".",
"append",
"(",
"models",
".",
"Abstract",
"(",
"*",
"*",
"{",
"\"text\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article_meta\"",
",",
"0",
",",
"\"abstract\"",
",",
"0",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"sub_article",
",",
"\"article\"",
",",
"0",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
")",
"return",
"abstracts",
"def",
"_get_keywords",
"(",
"data",
":",
"dict",
")",
"->",
"List",
"[",
"models",
".",
"ArticleKeyword",
"]",
":",
"\"\"\"Retorna a lista de palavras chaves do artigo e dos\n seus sub articles\"\"\"",
"keywords",
"=",
"[",
"models",
".",
"ArticleKeyword",
"(",
"*",
"*",
"{",
"\"keywords\"",
":",
"_nestget",
"(",
"kwd_group",
",",
"\"kwd\"",
",",
"default",
"=",
"[",
"]",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"kwd_group",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
"for",
"kwd_group",
"in",
"_nestget",
"(",
"data",
",",
"\"kwd_group\"",
",",
"default",
"=",
"[",
"]",
")",
"]",
"for",
"sub_article",
"in",
"_nestget",
"(",
"data",
",",
"\"sub_article\"",
")",
":",
"[",
"keywords",
".",
"append",
"(",
"models",
".",
"ArticleKeyword",
"(",
"*",
"*",
"{",
"\"keywords\"",
":",
"_nestget",
"(",
"kwd_group",
",",
"\"kwd\"",
",",
"default",
"=",
"[",
"]",
")",
",",
"\"language\"",
":",
"_nestget",
"(",
"kwd_group",
",",
"\"lang\"",
",",
"0",
")",
",",
"}",
")",
")",
"for",
"kwd_group",
"in",
"_nestget",
"(",
"sub_article",
",",
"\"kwd_group\"",
",",
"default",
"=",
"[",
"]",
")",
"]",
"return",
"keywords",
"article",
".",
"authors",
"=",
"list",
"(",
"_get_article_authors",
"(",
"data",
")",
")",
"article",
".",
"languages",
"=",
"list",
"(",
"_get_languages",
"(",
"data",
")",
")",
"article",
".",
"translated_titles",
"=",
"list",
"(",
"_get_translated_titles",
"(",
"data",
")",
")",
"article",
".",
"trans_sections",
"=",
"list",
"(",
"_get_translated_sections",
"(",
"data",
")",
")",
"article",
".",
"abstracts",
"=",
"list",
"(",
"_get_abstracts",
"(",
"data",
")",
")",
"article",
".",
"keywords",
"=",
"list",
"(",
"_get_keywords",
"(",
"data",
")",
")",
"article",
".",
"abstract_languages",
"=",
"[",
"abstract",
"[",
"\"language\"",
"]",
"for",
"abstract",
"in",
"article",
".",
"abstracts",
"]",
"article",
".",
"original_language",
"=",
"_get_original_language",
"(",
"data",
")",
"article",
".",
"publication_date",
"=",
"_nestget",
"(",
"data",
",",
"\"pub_date\"",
",",
"0",
",",
"\"text\"",
",",
"0",
")",
"article",
".",
"type",
"=",
"_nestget",
"(",
"data",
",",
"\"article\"",
",",
"0",
",",
"\"type\"",
",",
"0",
")",
"# Dados de localização",
"article",
".",
"elocation",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_elocation\"",
",",
"0",
")",
"article",
".",
"fpage",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_fpage\"",
",",
"0",
")",
"article",
".",
"fpage_sequence",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_fpage_seq\"",
",",
"0",
")",
"article",
".",
"lpage",
"=",
"_nestget",
"(",
"data",
",",
"\"article_meta\"",
",",
"0",
",",
"\"pub_lpage\"",
",",
"0",
")",
"# Issue vinculada",
"if",
"issue_id",
":",
"issue",
"=",
"models",
".",
"Issue",
".",
"objects",
".",
"get",
"(",
"_id",
"=",
"issue_id",
")",
"article",
".",
"issue",
"=",
"issue",
"article",
".",
"journal",
"=",
"issue",
".",
"journal",
"if",
"document_order",
":",
"article",
".",
"order",
"=",
"int",
"(",
"document_order",
")",
"article",
".",
"xml",
"=",
"document_xml_url",
"# Campo de compatibilidade do OPAC",
"article",
".",
"htmls",
"=",
"[",
"{",
"\"lang\"",
":",
"lang",
"}",
"for",
"lang",
"in",
"_get_languages",
"(",
"data",
")",
"]",
"return",
"article"
] | [
8,
0
] | [
230,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
fixed_lag_smoothing | (e_t, HMM, d, ev, t) | Algoritmo de suavização com um intervalo de tempo fixo de passos 'd'.
Algoritmo online que produz a nova estimativa suavizada se a observação
Para novo passo de tempo é dado. | Algoritmo de suavização com um intervalo de tempo fixo de passos 'd'.
Algoritmo online que produz a nova estimativa suavizada se a observação
Para novo passo de tempo é dado. | def fixed_lag_smoothing(e_t, HMM, d, ev, t):
"""Algoritmo de suavização com um intervalo de tempo fixo de passos 'd'.
Algoritmo online que produz a nova estimativa suavizada se a observação
Para novo passo de tempo é dado."""
ev.insert(0, None)
T_model = HMM.transition_model
f = HMM.prior
B = [[1, 0], [0, 1]]
evidence = []
evidence.append(e_t)
O_t = vector_to_diagonal(HMM.sensor_dist(e_t))
if t > d:
f = forward(HMM, f, e_t)
O_tmd = vector_to_diagonal(HMM.sensor_dist(ev[t - d]))
B = matrix_multiplication(
inverse_matrix(O_tmd), inverse_matrix(T_model), B, T_model, O_t
)
else:
B = matrix_multiplication(B, T_model, O_t)
t = t + 1
if t > d:
return [normalize(i) for i in matrix_multiplication([f], B)][0]
else:
return None | [
"def",
"fixed_lag_smoothing",
"(",
"e_t",
",",
"HMM",
",",
"d",
",",
"ev",
",",
"t",
")",
":",
"ev",
".",
"insert",
"(",
"0",
",",
"None",
")",
"T_model",
"=",
"HMM",
".",
"transition_model",
"f",
"=",
"HMM",
".",
"prior",
"B",
"=",
"[",
"[",
"1",
",",
"0",
"]",
",",
"[",
"0",
",",
"1",
"]",
"]",
"evidence",
"=",
"[",
"]",
"evidence",
".",
"append",
"(",
"e_t",
")",
"O_t",
"=",
"vector_to_diagonal",
"(",
"HMM",
".",
"sensor_dist",
"(",
"e_t",
")",
")",
"if",
"t",
">",
"d",
":",
"f",
"=",
"forward",
"(",
"HMM",
",",
"f",
",",
"e_t",
")",
"O_tmd",
"=",
"vector_to_diagonal",
"(",
"HMM",
".",
"sensor_dist",
"(",
"ev",
"[",
"t",
"-",
"d",
"]",
")",
")",
"B",
"=",
"matrix_multiplication",
"(",
"inverse_matrix",
"(",
"O_tmd",
")",
",",
"inverse_matrix",
"(",
"T_model",
")",
",",
"B",
",",
"T_model",
",",
"O_t",
")",
"else",
":",
"B",
"=",
"matrix_multiplication",
"(",
"B",
",",
"T_model",
",",
"O_t",
")",
"t",
"=",
"t",
"+",
"1",
"if",
"t",
">",
"d",
":",
"return",
"[",
"normalize",
"(",
"i",
")",
"for",
"i",
"in",
"matrix_multiplication",
"(",
"[",
"f",
"]",
",",
"B",
")",
"]",
"[",
"0",
"]",
"else",
":",
"return",
"None"
] | [
579,
0
] | [
605,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
classify_temp | () | Classificaça o input do usuario | Classificaça o input do usuario | def classify_temp():
'''Classificaça o input do usuario'''
ask = True
while ask:
#input de temperatura
temp = input("Insira a temparatura(graus celsius): ")
#Transformar para numpy array
temp = np.array(float(temp)).reshape(-1,1)
#Realizar classificação
class_temp = clf.predict(temp)
#Transformação inversa para retorna string original
class_temp = le.inverse_transform(class_temp)
#Classificação
print(f'A classificação da temperatura {temp.ravel()[0]} é:', class_temp[0])
#Perguntar
ask = input('Nova classificação(y/n): ') == 'y' | [
"def",
"classify_temp",
"(",
")",
":",
"ask",
"=",
"True",
"while",
"ask",
":",
"#input de temperatura",
"temp",
"=",
"input",
"(",
"\"Insira a temparatura(graus celsius): \"",
")",
"#Transformar para numpy array",
"temp",
"=",
"np",
".",
"array",
"(",
"float",
"(",
"temp",
")",
")",
".",
"reshape",
"(",
"-",
"1",
",",
"1",
")",
"#Realizar classificação",
"class_temp",
"=",
"clf",
".",
"predict",
"(",
"temp",
")",
"#Transformação inversa para retorna string original",
"class_temp",
"=",
"le",
".",
"inverse_transform",
"(",
"class_temp",
")",
"#Classificação",
"print",
"(",
"f'A classificação da temperatura {temp.ravel()[0]} é:', c",
"l",
"ss_temp[0]",
")",
"",
"",
"",
"#Perguntar",
"ask",
"=",
"input",
"(",
"'Nova classificação(y/n): ') ",
"=",
" '",
"'"
] | [
63,
0
] | [
78,
57
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MeuJogador.pensa_cacar | (self, reputacoes, razao, reputacao) | return 'c' if (np.random.rand() >= razao) == self.estrategia else 'd' | funcao interna, de decisao de cacada | funcao interna, de decisao de cacada | def pensa_cacar(self, reputacoes, razao, reputacao):
""" funcao interna, de decisao de cacada """
""" analisa a variacao da curva de comida recente """
if self.historico[-3] - self.historico[-2] > self.historico[-2] - self.historico[-1]:
self.estrategia = not self.estrategia
return 'c' if (np.random.rand() >= razao) == self.estrategia else 'd' | [
"def",
"pensa_cacar",
"(",
"self",
",",
"reputacoes",
",",
"razao",
",",
"reputacao",
")",
":",
"\"\"\" analisa a variacao da curva de comida recente \"\"\"",
"if",
"self",
".",
"historico",
"[",
"-",
"3",
"]",
"-",
"self",
".",
"historico",
"[",
"-",
"2",
"]",
">",
"self",
".",
"historico",
"[",
"-",
"2",
"]",
"-",
"self",
".",
"historico",
"[",
"-",
"1",
"]",
":",
"self",
".",
"estrategia",
"=",
"not",
"self",
".",
"estrategia",
"return",
"'c'",
"if",
"(",
"np",
".",
"random",
".",
"rand",
"(",
")",
">=",
"razao",
")",
"==",
"self",
".",
"estrategia",
"else",
"'d'"
] | [
26,
4
] | [
33,
77
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ViewTestCase.test_api_can_create_a_sala | (self) | Testando a criacao da sala via post | Testando a criacao da sala via post | def test_api_can_create_a_sala(self):
"""Testando a criacao da sala via post"""
self.assertEqual(self.response.status_code, status.HTTP_201_CREATED) | [
"def",
"test_api_can_create_a_sala",
"(",
"self",
")",
":",
"self",
".",
"assertEqual",
"(",
"self",
".",
"response",
".",
"status_code",
",",
"status",
".",
"HTTP_201_CREATED",
")"
] | [
40,
4
] | [
42,
76
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Ship.blitme | (self) | Desenha a espaçonave em sua posição atual. | Desenha a espaçonave em sua posição atual. | def blitme(self):
'''Desenha a espaçonave em sua posição atual.'''
self.screen.blit(self.image, self.rect) | [
"def",
"blitme",
"(",
"self",
")",
":",
"self",
".",
"screen",
".",
"blit",
"(",
"self",
".",
"image",
",",
"self",
".",
"rect",
")"
] | [
38,
1
] | [
40,
41
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Bateria.obter_alcance | (self) | Exibe uma frase sobre a distância que o carro é capaz de
percorrer com essa bateria. | Exibe uma frase sobre a distância que o carro é capaz de
percorrer com essa bateria. | def obter_alcance(self):
"""Exibe uma frase sobre a distância que o carro é capaz de
percorrer com essa bateria."""
if self.capacidade_bateria == 70:
range = 240
elif self.capacidade_bateria == 85:
range = 270
mensagem = "Esse carro pode percorrer, aproximadamente, "
mensagem += str(range) + " quilometros."
print(mensagem) | [
"def",
"obter_alcance",
"(",
"self",
")",
":",
"if",
"self",
".",
"capacidade_bateria",
"==",
"70",
":",
"range",
"=",
"240",
"elif",
"self",
".",
"capacidade_bateria",
"==",
"85",
":",
"range",
"=",
"270",
"mensagem",
"=",
"\"Esse carro pode percorrer, aproximadamente, \"",
"mensagem",
"+=",
"str",
"(",
"range",
")",
"+",
"\" quilometros.\"",
"print",
"(",
"mensagem",
")"
] | [
69,
4
] | [
79,
23
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestCns.setUp | (self) | Inicia novo objeto em todo os testes. | Inicia novo objeto em todo os testes. | def setUp(self):
"""Inicia novo objeto em todo os testes."""
self.cns = docbr.CNS() | [
"def",
"setUp",
"(",
"self",
")",
":",
"self",
".",
"cns",
"=",
"docbr",
".",
"CNS",
"(",
")"
] | [
7,
4
] | [
9,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestPlayer.test_create_player_obj_with_more_than_max_pokemons | (self) | Testa instancia de classe usando uma lista com mais Pokemons do que ela esta definida para ter. | Testa instancia de classe usando uma lista com mais Pokemons do que ela esta definida para ter. | def test_create_player_obj_with_more_than_max_pokemons(self):
"""Testa instancia de classe usando uma lista com mais Pokemons do que ela esta definida para ter."""
from poke_api_handler import PokeAPIHandler
# Teste usando a url do Pokemon Butterfree
pokemon_url = "https://pokeapi.co/api/v2/pokemon/butterfree/"
poke_api_handler = PokeAPIHandler() # A classe precisa ser instanciada antes da chamada de um metodo
base_experience = poke_api_handler.get_pokemon_base_experience(pokemon_url)
self.assertRaises(ValueError, lambda: Player([Pokemon("Pichu", base_experience), Pokemon("Pikachu", base_experience)], max_limit_pokemons=1)) | [
"def",
"test_create_player_obj_with_more_than_max_pokemons",
"(",
"self",
")",
":",
"from",
"poke_api_handler",
"import",
"PokeAPIHandler",
"# Teste usando a url do Pokemon Butterfree",
"pokemon_url",
"=",
"\"https://pokeapi.co/api/v2/pokemon/butterfree/\"",
"poke_api_handler",
"=",
"PokeAPIHandler",
"(",
")",
"# A classe precisa ser instanciada antes da chamada de um metodo",
"base_experience",
"=",
"poke_api_handler",
".",
"get_pokemon_base_experience",
"(",
"pokemon_url",
")",
"self",
".",
"assertRaises",
"(",
"ValueError",
",",
"lambda",
":",
"Player",
"(",
"[",
"Pokemon",
"(",
"\"Pichu\"",
",",
"base_experience",
")",
",",
"Pokemon",
"(",
"\"Pikachu\"",
",",
"base_experience",
")",
"]",
",",
"max_limit_pokemons",
"=",
"1",
")",
")"
] | [
16,
4
] | [
25,
149
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
TestTradeCalculator.test_player_total_base_experience_passing_wrong_type | (self) | Teste passando argumento diferente de Player
>>> _total_base_experience(Player(...))
sum(Player(Pokemon.base_experience, ...))
>>> _total_base_experience(wrong_type)
Error
| Teste passando argumento diferente de Player
>>> _total_base_experience(Player(...))
sum(Player(Pokemon.base_experience, ...)) | def test_player_total_base_experience_passing_wrong_type(self):
"""Teste passando argumento diferente de Player
>>> _total_base_experience(Player(...))
sum(Player(Pokemon.base_experience, ...))
>>> _total_base_experience(wrong_type)
Error
"""
p1 = Player([Pokemon("Pichu", 42), Pokemon("Pikachu", 145)])
p2 = Player([Pokemon("Dito", 30), Pokemon("Charizard", 260)])
tc = TradeCalculator(p1, p2)
self.assertRaises(TypeError, lambda: tc._total_base_experience(42)) | [
"def",
"test_player_total_base_experience_passing_wrong_type",
"(",
"self",
")",
":",
"p1",
"=",
"Player",
"(",
"[",
"Pokemon",
"(",
"\"Pichu\"",
",",
"42",
")",
",",
"Pokemon",
"(",
"\"Pikachu\"",
",",
"145",
")",
"]",
")",
"p2",
"=",
"Player",
"(",
"[",
"Pokemon",
"(",
"\"Dito\"",
",",
"30",
")",
",",
"Pokemon",
"(",
"\"Charizard\"",
",",
"260",
")",
"]",
")",
"tc",
"=",
"TradeCalculator",
"(",
"p1",
",",
"p2",
")",
"self",
".",
"assertRaises",
"(",
"TypeError",
",",
"lambda",
":",
"tc",
".",
"_total_base_experience",
"(",
"42",
")",
")"
] | [
8,
4
] | [
21,
75
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_pool | (n_th: int) | return [Worker(target=target, queue=fila, name=f'Worker{n}')
for n in range(n_th)] | Retorna um número n de Threads. | Retorna um número n de Threads. | def get_pool(n_th: int):
"""Retorna um número n de Threads."""
return [Worker(target=target, queue=fila, name=f'Worker{n}')
for n in range(n_th)] | [
"def",
"get_pool",
"(",
"n_th",
":",
"int",
")",
":",
"return",
"[",
"Worker",
"(",
"target",
"=",
"target",
",",
"queue",
"=",
"fila",
",",
"name",
"=",
"f'Worker{n}'",
")",
"for",
"n",
"in",
"range",
"(",
"n_th",
")",
"]"
] | [
44,
0
] | [
47,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ScoreBoard.__init__ | (self, ai_settings, screen, stats) | Inicializa os atributos da pontuacao. | Inicializa os atributos da pontuacao. | def __init__(self, ai_settings, screen, stats):
"""Inicializa os atributos da pontuacao."""
self.screen = screen
self.screen_rect = screen.get_rect()
self.ai_settings = ai_settings
self.stats = stats
# Configuracoes de fonte para as informacoes de pontuacao
self.text_color = (30, 30, 30)
self.font = pygame.font.SysFont(None, 40)
# Prepara a imagem das pontuacoes inciais
self.prep_images() | [
"def",
"__init__",
"(",
"self",
",",
"ai_settings",
",",
"screen",
",",
"stats",
")",
":",
"self",
".",
"screen",
"=",
"screen",
"self",
".",
"screen_rect",
"=",
"screen",
".",
"get_rect",
"(",
")",
"self",
".",
"ai_settings",
"=",
"ai_settings",
"self",
".",
"stats",
"=",
"stats",
"# Configuracoes de fonte para as informacoes de pontuacao",
"self",
".",
"text_color",
"=",
"(",
"30",
",",
"30",
",",
"30",
")",
"self",
".",
"font",
"=",
"pygame",
".",
"font",
".",
"SysFont",
"(",
"None",
",",
"40",
")",
"# Prepara a imagem das pontuacoes inciais",
"self",
".",
"prep_images",
"(",
")"
] | [
8,
4
] | [
20,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
bol_clientes | (request) | return render(request, "upload_boletos_clientes.html", dados) | Lista clientes. Usado para mostrar 'Lançar Boletos' pelo funcionário.
Pegar id do cliente específico para mostrar o boleto no cliente - Função uploadb.
Mostrar id e pegar mesmo id no uploadb. | Lista clientes. Usado para mostrar 'Lançar Boletos' pelo funcionário.
Pegar id do cliente específico para mostrar o boleto no cliente - Função uploadb.
Mostrar id e pegar mesmo id no uploadb. | def bol_clientes(request):
""" Lista clientes. Usado para mostrar 'Lançar Boletos' pelo funcionário.
Pegar id do cliente específico para mostrar o boleto no cliente - Função uploadb.
Mostrar id e pegar mesmo id no uploadb."""
usuario = request.user
try:
# Pegar foreingkey usuario_cli
funcionario = Funcionario.objects.get(usuario_fun=usuario)
except Exception:
raise Http404()
if funcionario:
#id pesquisa
termo_pesquisa = request.GET.get('pesquisa', None)
# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO
if termo_pesquisa:
bols = Bol.objects.all()
#__icontains sem case sensitive
bols = bols.filter(titulo__icontains=termo_pesquisa)
cliente = Cliente.objects.all()
else:
bols = Bol.objects.all()
cliente = Cliente.objects.all()
dados = {"bols": bols, "cliente": cliente}
else:
raise Http404()
return render(request, "upload_boletos_clientes.html", dados) | [
"def",
"bol_clientes",
"(",
"request",
")",
":",
"usuario",
"=",
"request",
".",
"user",
"try",
":",
"# Pegar foreingkey usuario_cli",
"funcionario",
"=",
"Funcionario",
".",
"objects",
".",
"get",
"(",
"usuario_fun",
"=",
"usuario",
")",
"except",
"Exception",
":",
"raise",
"Http404",
"(",
")",
"if",
"funcionario",
":",
"#id pesquisa",
"termo_pesquisa",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'pesquisa'",
",",
"None",
")",
"# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO",
"if",
"termo_pesquisa",
":",
"bols",
"=",
"Bol",
".",
"objects",
".",
"all",
"(",
")",
"#__icontains sem case sensitive",
"bols",
"=",
"bols",
".",
"filter",
"(",
"titulo__icontains",
"=",
"termo_pesquisa",
")",
"cliente",
"=",
"Cliente",
".",
"objects",
".",
"all",
"(",
")",
"else",
":",
"bols",
"=",
"Bol",
".",
"objects",
".",
"all",
"(",
")",
"cliente",
"=",
"Cliente",
".",
"objects",
".",
"all",
"(",
")",
"dados",
"=",
"{",
"\"bols\"",
":",
"bols",
",",
"\"cliente\"",
":",
"cliente",
"}",
"else",
":",
"raise",
"Http404",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"upload_boletos_clientes.html\"",
",",
"dados",
")"
] | [
512,
0
] | [
540,
65
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
try_register_issues | (
issues, get_journal_id, get_issue_order, fetch_data, issue_factory
) | return list(set(orphans)), known_documents | Registra uma coleção de fascículos.
Retorna a dupla: lista dos fascículos que não foram registrados por
serem órfãos, e dicionário com os documentos conhecidos.
:param issues: lista de identificadores dos fascículos a serem registrados.
:param get_journal_id: função que recebe o identificador de um fascículo no
Kernel e retorna o identificador do periódico que o contém.
:param get_issue_order: função que recebe o identificador de um fascículo e
retorna um número inteiro referente a posição do fascículo em relação
aos demais.
:param fetch_data: função que recebe o identificador de um fascículo e
retorna seus dados, em estruturas do Python, conforme retornado pelo
endpoint do Kernel.
:param issue_factory: função que recebe os dados retornados da função
`fetch_data` e retorna uma instância da classe `Issue`, do `opac_schema`.
| Registra uma coleção de fascículos. | def try_register_issues(
issues, get_journal_id, get_issue_order, fetch_data, issue_factory
):
"""Registra uma coleção de fascículos.
Retorna a dupla: lista dos fascículos que não foram registrados por
serem órfãos, e dicionário com os documentos conhecidos.
:param issues: lista de identificadores dos fascículos a serem registrados.
:param get_journal_id: função que recebe o identificador de um fascículo no
Kernel e retorna o identificador do periódico que o contém.
:param get_issue_order: função que recebe o identificador de um fascículo e
retorna um número inteiro referente a posição do fascículo em relação
aos demais.
:param fetch_data: função que recebe o identificador de um fascículo e
retorna seus dados, em estruturas do Python, conforme retornado pelo
endpoint do Kernel.
:param issue_factory: função que recebe os dados retornados da função
`fetch_data` e retorna uma instância da classe `Issue`, do `opac_schema`.
"""
known_documents = {}
orphans = []
for issue_id in issues:
journal_id = get_journal_id(issue_id)
logging.info('Registering issue "%s" to journal "%s"', issue_id, journal_id)
if journal_id is not None:
data = fetch_data(issue_id)
try:
issue = issue_factory(
data, journal_id, get_issue_order(issue_id)
)
issue.save()
except models.Journal.DoesNotExist:
orphans.append(issue_id)
else:
known_documents[issue_id] = data.get("items", [])
else:
orphans.append(issue_id)
return list(set(orphans)), known_documents | [
"def",
"try_register_issues",
"(",
"issues",
",",
"get_journal_id",
",",
"get_issue_order",
",",
"fetch_data",
",",
"issue_factory",
")",
":",
"known_documents",
"=",
"{",
"}",
"orphans",
"=",
"[",
"]",
"for",
"issue_id",
"in",
"issues",
":",
"journal_id",
"=",
"get_journal_id",
"(",
"issue_id",
")",
"logging",
".",
"info",
"(",
"'Registering issue \"%s\" to journal \"%s\"'",
",",
"issue_id",
",",
"journal_id",
")",
"if",
"journal_id",
"is",
"not",
"None",
":",
"data",
"=",
"fetch_data",
"(",
"issue_id",
")",
"try",
":",
"issue",
"=",
"issue_factory",
"(",
"data",
",",
"journal_id",
",",
"get_issue_order",
"(",
"issue_id",
")",
")",
"issue",
".",
"save",
"(",
")",
"except",
"models",
".",
"Journal",
".",
"DoesNotExist",
":",
"orphans",
".",
"append",
"(",
"issue_id",
")",
"else",
":",
"known_documents",
"[",
"issue_id",
"]",
"=",
"data",
".",
"get",
"(",
"\"items\"",
",",
"[",
"]",
")",
"else",
":",
"orphans",
".",
"append",
"(",
"issue_id",
")",
"return",
"list",
"(",
"set",
"(",
"orphans",
")",
")",
",",
"known_documents"
] | [
440,
0
] | [
480,
46
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
CNS._sum_algorithm | (self, cns: list, n: int = 15) | return sum | Realiza o processo de soma necessária para o CNS. | Realiza o processo de soma necessária para o CNS. | def _sum_algorithm(self, cns: list, n: int = 15) -> int:
"""Realiza o processo de soma necessária para o CNS."""
sum = 0
for i in range(n):
sum += int(cns[i]) * (15 - i)
return sum | [
"def",
"_sum_algorithm",
"(",
"self",
",",
"cns",
":",
"list",
",",
"n",
":",
"int",
"=",
"15",
")",
"->",
"int",
":",
"sum",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"sum",
"+=",
"int",
"(",
"cns",
"[",
"i",
"]",
")",
"*",
"(",
"15",
"-",
"i",
")",
"return",
"sum"
] | [
120,
4
] | [
126,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DType63.gflags | (self) | return bin2int(self.data[BYTES_63[16]]) | F16 - Códigos de alertas globais ou de processamento do radio. | F16 - Códigos de alertas globais ou de processamento do radio. | def gflags(self) -> int:
"""F16 - Códigos de alertas globais ou de processamento do radio."""
return bin2int(self.data[BYTES_63[16]]) | [
"def",
"gflags",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_63",
"[",
"16",
"]",
"]",
")"
] | [
1097,
4
] | [
1099,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PropKB.ask_generator | (self, query) | Valida a substituição vazia {} se KB envolve consulta; Senão não há resultados. | Valida a substituição vazia {} se KB envolve consulta; Senão não há resultados. | def ask_generator(self, query):
"Valida a substituição vazia {} se KB envolve consulta; Senão não há resultados."
if tt_entails(Expr('&', *self.clauses), query):
yield {} | [
"def",
"ask_generator",
"(",
"self",
",",
"query",
")",
":",
"if",
"tt_entails",
"(",
"Expr",
"(",
"'&'",
",",
"*",
"self",
".",
"clauses",
")",
",",
"query",
")",
":",
"yield",
"{",
"}"
] | [
83,
4
] | [
86,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
_eval_or_exec | (src: str, is_exec=False) | return result | Função utilizada internamente por eval/module/run. | Função utilizada internamente por eval/module/run. | def _eval_or_exec(src: str, is_exec=False) -> Any:
"""Função utilizada internamente por eval/module/run."""
if is_exec:
grammar = grammar_mod
else:
grammar = grammar_expr
try:
tree = grammar.parse(src)
except LarkError:
print(f"Erro avaliando a expressão: \n{src}")
print("\nImprimindo tokens")
for i, tk in enumerate(grammar.lex(src), start=1):
print(f" - {i}) {tk} ({tk.type})")
raise
transformer = RuspyTransformer()
result = transformer.transform(tree)
if isinstance(result, Tree):
print(tree.pretty())
bads = [*tree.find_pred(lambda x: not hasattr(transformer, x.data))]
bad = bads[0] if bads else tree
raise NotImplementedError(
f"""
não implementou regra para lidar com: {tree.data!r}.
Crie um método como abaixo na classe do transformer.
def {bad.data}(self, ...):
return ...
"""
)
return result | [
"def",
"_eval_or_exec",
"(",
"src",
":",
"str",
",",
"is_exec",
"=",
"False",
")",
"->",
"Any",
":",
"if",
"is_exec",
":",
"grammar",
"=",
"grammar_mod",
"else",
":",
"grammar",
"=",
"grammar_expr",
"try",
":",
"tree",
"=",
"grammar",
".",
"parse",
"(",
"src",
")",
"except",
"LarkError",
":",
"print",
"(",
"f\"Erro avaliando a expressão: \\n{src}\")",
"",
"print",
"(",
"\"\\nImprimindo tokens\"",
")",
"for",
"i",
",",
"tk",
"in",
"enumerate",
"(",
"grammar",
".",
"lex",
"(",
"src",
")",
",",
"start",
"=",
"1",
")",
":",
"print",
"(",
"f\" - {i}) {tk} ({tk.type})\"",
")",
"raise",
"transformer",
"=",
"RuspyTransformer",
"(",
")",
"result",
"=",
"transformer",
".",
"transform",
"(",
"tree",
")",
"if",
"isinstance",
"(",
"result",
",",
"Tree",
")",
":",
"print",
"(",
"tree",
".",
"pretty",
"(",
")",
")",
"bads",
"=",
"[",
"*",
"tree",
".",
"find_pred",
"(",
"lambda",
"x",
":",
"not",
"hasattr",
"(",
"transformer",
",",
"x",
".",
"data",
")",
")",
"]",
"bad",
"=",
"bads",
"[",
"0",
"]",
"if",
"bads",
"else",
"tree",
"raise",
"NotImplementedError",
"(",
"f\"\"\"\nnão implementou regra para lidar com: {tree.data!r}.\nCrie um método como abaixo na classe do transformer.\n def {bad.data}(self, ...): \n return ... \n\"\"\"",
")",
"return",
"result"
] | [
185,
0
] | [
215,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RequisicaoVips.update | (cls, authenticated_user, pk, variables_map, **kwargs) | Atualiza os dados de uma requisição de VIP.
Após atualizar os dados o campo "validado" receberá o valor 0(zero).
Se o campo "vip_criado" da requisição de VIP tem o valor 1 então
o VIP não poderá ser alterado.
@return: Nothing.
@raise RequisicaoVipsNotFoundError: Requisição de VIP não cadastrada.
@raise RequisicaoVipsError: Falha ao atualizar a requisição de VIP.
@raise RequisicaoVipsAlreadyCreatedError: Requisição de VIP já foi criada e não poderá ser alterada.
@raise HealthcheckExpectNotFoundError: HealthcheckExpect não cadastrado.
@raise HealthcheckExpectError: Falha ao pesquisar o HealthcheckExpect.
@raise IpError: Falha ao pesquisar o IP.
@raise IpNotFoundError: IP nao cadastrado.
@raise InvalidHealthcheckTypeValueError: Healthcheck_Type com valor inválido ou inconsistente em relação ao valor do healthcheck_expect.
| Atualiza os dados de uma requisição de VIP. | def update(cls, authenticated_user, pk, variables_map, **kwargs):
"""Atualiza os dados de uma requisição de VIP.
Após atualizar os dados o campo "validado" receberá o valor 0(zero).
Se o campo "vip_criado" da requisição de VIP tem o valor 1 então
o VIP não poderá ser alterado.
@return: Nothing.
@raise RequisicaoVipsNotFoundError: Requisição de VIP não cadastrada.
@raise RequisicaoVipsError: Falha ao atualizar a requisição de VIP.
@raise RequisicaoVipsAlreadyCreatedError: Requisição de VIP já foi criada e não poderá ser alterada.
@raise HealthcheckExpectNotFoundError: HealthcheckExpect não cadastrado.
@raise HealthcheckExpectError: Falha ao pesquisar o HealthcheckExpect.
@raise IpError: Falha ao pesquisar o IP.
@raise IpNotFoundError: IP nao cadastrado.
@raise InvalidHealthcheckTypeValueError: Healthcheck_Type com valor inválido ou inconsistente em relação ao valor do healthcheck_expect.
"""
vip = RequisicaoVips.get_by_pk(pk)
with distributedlock(LOCK_VIP % pk):
try:
ip_id = kwargs['ip_id']
if vip.ip_id != ip_id:
if vip.vip_criado:
raise RequisicaoVipsAlreadyCreatedError(
None,
u'O IP da requisição de VIP %d não pode ser alterado porque o VIP já está criado.' % vip.id)
vip.ip = Ip().get_by_pk(ip_id)
except KeyError:
pass
# Valid ports
variables_map, code = vip.valid_values_ports(variables_map)
if code is not None:
return code
finalidade = variables_map.get('finalidade')
cliente = variables_map.get('cliente')
ambiente = variables_map.get('ambiente')
if not is_valid_string_minsize(finalidade, 3) or not is_valid_string_maxsize(finalidade, 50):
cls.log.error(u'Finality value is invalid: %s.', finalidade)
raise InvalidValueError(None, 'finalidade', finalidade)
if not is_valid_string_minsize(cliente, 3) or not is_valid_string_maxsize(cliente, 50):
cls.log.error(u'Client value is invalid: %s.', cliente)
raise InvalidValueError(None, 'cliente', cliente)
if not is_valid_string_minsize(ambiente, 3) or not is_valid_string_maxsize(ambiente, 50):
cls.log.error(u'Environment value is invalid: %s.', ambiente)
raise InvalidValueError(None, 'ambiente', ambiente)
# get environmentVip dor validation dynamic heathcheck
environment_vip = EnvironmentVip.get_by_values(
finalidade, cliente, ambiente)
# Valid HealthcheckExpect
variables_map, vip, code = vip.valid_values_healthcheck(
variables_map, vip, environment_vip)
if code is not None:
return code
vip_variables = vip.variables_to_map()
# Valid list reals_prioritys
if variables_map.get('reals_prioritys') is None:
if vip_variables.get('reals_prioritys') is None:
priority_map = []
for __reals in variables_map.get('reals').get('real'):
priority_map.append('0')
variables_map['reals_prioritys'] = {
'reals_priority': priority_map}
else:
if vip_variables.get('reals_prioritys').get('reals_priority') is None:
priority_map = []
for __reals in variables_map.get('reals').get('real'):
priority_map.append('0')
variables_map['reals_prioritys'] = {
'reals_priority': priority_map}
else:
variables_map['reals_prioritys'] = vip_variables.get(
'reals_prioritys')
# Valid list reals_weights
if variables_map.get('reals_weights') is None:
if vip_variables.get('reals_weights') is None:
weight_map = []
for __reals in variables_map.get('reals').get('real'):
weight_map.append('0')
variables_map['reals_weights'] = {'reals_weight': weight_map}
else:
if vip_variables.get('reals_weights').get('reals_weight') is None:
priority_map = []
for __reals in variables_map.get('reals').get('real'):
priority_map.append('0')
variables_map['reals_weights'] = {
'reals_weight': priority_map}
else:
variables_map['reals_weights'] = vip_variables.get(
'reals_weights')
# Valid l7_filter
if vip.l7_filter is None:
vip.l7_filter = None
# Valid transbordos
if vip_variables.get('transbordos') is None:
variables_map['transbordos'] = None
else:
variables_map['transbordos'] = vip_variables.get('transbordos')
# Valid bal_ativo
if vip_variables.get('bal_ativo') is None:
variables_map['bal_ativo'] = None
else:
variables_map['bal_ativo'] = vip_variables.get('bal_ativo')
vip.__dict__.update(kwargs)
vip.set_variables(variables_map)
try:
vip.save(authenticated_user)
except Exception, e:
cls.log.error(u'Falha ao atualizar a requisição de vip.')
raise RequisicaoVipsError(
e, u'Falha ao atualizar a requisição de vip.') | [
"def",
"update",
"(",
"cls",
",",
"authenticated_user",
",",
"pk",
",",
"variables_map",
",",
"*",
"*",
"kwargs",
")",
":",
"vip",
"=",
"RequisicaoVips",
".",
"get_by_pk",
"(",
"pk",
")",
"with",
"distributedlock",
"(",
"LOCK_VIP",
"%",
"pk",
")",
":",
"try",
":",
"ip_id",
"=",
"kwargs",
"[",
"'ip_id'",
"]",
"if",
"vip",
".",
"ip_id",
"!=",
"ip_id",
":",
"if",
"vip",
".",
"vip_criado",
":",
"raise",
"RequisicaoVipsAlreadyCreatedError",
"(",
"None",
",",
"u'O IP da requisição de VIP %d não pode ser alterado porque o VIP já está criado.' % vi",
".",
"d)",
"",
"",
"",
"vip",
".",
"ip",
"=",
"Ip",
"(",
")",
".",
"get_by_pk",
"(",
"ip_id",
")",
"except",
"KeyError",
":",
"pass",
"# Valid ports",
"variables_map",
",",
"code",
"=",
"vip",
".",
"valid_values_ports",
"(",
"variables_map",
")",
"if",
"code",
"is",
"not",
"None",
":",
"return",
"code",
"finalidade",
"=",
"variables_map",
".",
"get",
"(",
"'finalidade'",
")",
"cliente",
"=",
"variables_map",
".",
"get",
"(",
"'cliente'",
")",
"ambiente",
"=",
"variables_map",
".",
"get",
"(",
"'ambiente'",
")",
"if",
"not",
"is_valid_string_minsize",
"(",
"finalidade",
",",
"3",
")",
"or",
"not",
"is_valid_string_maxsize",
"(",
"finalidade",
",",
"50",
")",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Finality value is invalid: %s.'",
",",
"finalidade",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'finalidade'",
",",
"finalidade",
")",
"if",
"not",
"is_valid_string_minsize",
"(",
"cliente",
",",
"3",
")",
"or",
"not",
"is_valid_string_maxsize",
"(",
"cliente",
",",
"50",
")",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Client value is invalid: %s.'",
",",
"cliente",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'cliente'",
",",
"cliente",
")",
"if",
"not",
"is_valid_string_minsize",
"(",
"ambiente",
",",
"3",
")",
"or",
"not",
"is_valid_string_maxsize",
"(",
"ambiente",
",",
"50",
")",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Environment value is invalid: %s.'",
",",
"ambiente",
")",
"raise",
"InvalidValueError",
"(",
"None",
",",
"'ambiente'",
",",
"ambiente",
")",
"# get environmentVip dor validation dynamic heathcheck",
"environment_vip",
"=",
"EnvironmentVip",
".",
"get_by_values",
"(",
"finalidade",
",",
"cliente",
",",
"ambiente",
")",
"# Valid HealthcheckExpect",
"variables_map",
",",
"vip",
",",
"code",
"=",
"vip",
".",
"valid_values_healthcheck",
"(",
"variables_map",
",",
"vip",
",",
"environment_vip",
")",
"if",
"code",
"is",
"not",
"None",
":",
"return",
"code",
"vip_variables",
"=",
"vip",
".",
"variables_to_map",
"(",
")",
"# Valid list reals_prioritys",
"if",
"variables_map",
".",
"get",
"(",
"'reals_prioritys'",
")",
"is",
"None",
":",
"if",
"vip_variables",
".",
"get",
"(",
"'reals_prioritys'",
")",
"is",
"None",
":",
"priority_map",
"=",
"[",
"]",
"for",
"__reals",
"in",
"variables_map",
".",
"get",
"(",
"'reals'",
")",
".",
"get",
"(",
"'real'",
")",
":",
"priority_map",
".",
"append",
"(",
"'0'",
")",
"variables_map",
"[",
"'reals_prioritys'",
"]",
"=",
"{",
"'reals_priority'",
":",
"priority_map",
"}",
"else",
":",
"if",
"vip_variables",
".",
"get",
"(",
"'reals_prioritys'",
")",
".",
"get",
"(",
"'reals_priority'",
")",
"is",
"None",
":",
"priority_map",
"=",
"[",
"]",
"for",
"__reals",
"in",
"variables_map",
".",
"get",
"(",
"'reals'",
")",
".",
"get",
"(",
"'real'",
")",
":",
"priority_map",
".",
"append",
"(",
"'0'",
")",
"variables_map",
"[",
"'reals_prioritys'",
"]",
"=",
"{",
"'reals_priority'",
":",
"priority_map",
"}",
"else",
":",
"variables_map",
"[",
"'reals_prioritys'",
"]",
"=",
"vip_variables",
".",
"get",
"(",
"'reals_prioritys'",
")",
"# Valid list reals_weights",
"if",
"variables_map",
".",
"get",
"(",
"'reals_weights'",
")",
"is",
"None",
":",
"if",
"vip_variables",
".",
"get",
"(",
"'reals_weights'",
")",
"is",
"None",
":",
"weight_map",
"=",
"[",
"]",
"for",
"__reals",
"in",
"variables_map",
".",
"get",
"(",
"'reals'",
")",
".",
"get",
"(",
"'real'",
")",
":",
"weight_map",
".",
"append",
"(",
"'0'",
")",
"variables_map",
"[",
"'reals_weights'",
"]",
"=",
"{",
"'reals_weight'",
":",
"weight_map",
"}",
"else",
":",
"if",
"vip_variables",
".",
"get",
"(",
"'reals_weights'",
")",
".",
"get",
"(",
"'reals_weight'",
")",
"is",
"None",
":",
"priority_map",
"=",
"[",
"]",
"for",
"__reals",
"in",
"variables_map",
".",
"get",
"(",
"'reals'",
")",
".",
"get",
"(",
"'real'",
")",
":",
"priority_map",
".",
"append",
"(",
"'0'",
")",
"variables_map",
"[",
"'reals_weights'",
"]",
"=",
"{",
"'reals_weight'",
":",
"priority_map",
"}",
"else",
":",
"variables_map",
"[",
"'reals_weights'",
"]",
"=",
"vip_variables",
".",
"get",
"(",
"'reals_weights'",
")",
"# Valid l7_filter",
"if",
"vip",
".",
"l7_filter",
"is",
"None",
":",
"vip",
".",
"l7_filter",
"=",
"None",
"# Valid transbordos",
"if",
"vip_variables",
".",
"get",
"(",
"'transbordos'",
")",
"is",
"None",
":",
"variables_map",
"[",
"'transbordos'",
"]",
"=",
"None",
"else",
":",
"variables_map",
"[",
"'transbordos'",
"]",
"=",
"vip_variables",
".",
"get",
"(",
"'transbordos'",
")",
"# Valid bal_ativo",
"if",
"vip_variables",
".",
"get",
"(",
"'bal_ativo'",
")",
"is",
"None",
":",
"variables_map",
"[",
"'bal_ativo'",
"]",
"=",
"None",
"else",
":",
"variables_map",
"[",
"'bal_ativo'",
"]",
"=",
"vip_variables",
".",
"get",
"(",
"'bal_ativo'",
")",
"vip",
".",
"__dict__",
".",
"update",
"(",
"kwargs",
")",
"vip",
".",
"set_variables",
"(",
"variables_map",
")",
"try",
":",
"vip",
".",
"save",
"(",
"authenticated_user",
")",
"except",
"Exception",
",",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao atualizar a requisição de vip.')",
"",
"raise",
"RequisicaoVipsError",
"(",
"e",
",",
"u'Falha ao atualizar a requisição de vip.')",
""
] | [
1245,
4
] | [
1380,
64
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Ambiente.get_by_pk | (cls, id) | Efetua a consulta de Ambiente pelo seu id.
@return: Um Ambiente.
@raise AmbienteError: Falha ao pesquisar o Ambiente.
@raise AmbienteNotFoundError: Não existe um Ambiente para o id pesquisado.
| Efetua a consulta de Ambiente pelo seu id. | def get_by_pk(cls, id):
"""Efetua a consulta de Ambiente pelo seu id.
@return: Um Ambiente.
@raise AmbienteError: Falha ao pesquisar o Ambiente.
@raise AmbienteNotFoundError: Não existe um Ambiente para o id pesquisado.
"""
try:
return Ambiente.objects.filter(id=id).uniqueResult()
except ObjectDoesNotExist, e:
raise AmbienteNotFoundError(
e, u'There is no environment with id = %s.' % id)
except OperationalError, e:
cls.log.error(u'Lock wait timeout exceeded.')
raise OperationalError(
e, u'Lock wait timeout exceeded; try restarting transaction')
except Exception, e:
cls.log.error(u'Falha ao pesquisar o ambiente.')
raise AmbienteError(e, u'Falha ao pesquisar o ambiente.') | [
"def",
"get_by_pk",
"(",
"cls",
",",
"id",
")",
":",
"try",
":",
"return",
"Ambiente",
".",
"objects",
".",
"filter",
"(",
"id",
"=",
"id",
")",
".",
"uniqueResult",
"(",
")",
"except",
"ObjectDoesNotExist",
",",
"e",
":",
"raise",
"AmbienteNotFoundError",
"(",
"e",
",",
"u'There is no environment with id = %s.'",
"%",
"id",
")",
"except",
"OperationalError",
",",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Lock wait timeout exceeded.'",
")",
"raise",
"OperationalError",
"(",
"e",
",",
"u'Lock wait timeout exceeded; try restarting transaction'",
")",
"except",
"Exception",
",",
"e",
":",
"cls",
".",
"log",
".",
"error",
"(",
"u'Falha ao pesquisar o ambiente.'",
")",
"raise",
"AmbienteError",
"(",
"e",
",",
"u'Falha ao pesquisar o ambiente.'",
")"
] | [
1083,
4
] | [
1103,
69
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Topic.__str__ | (self) | return self.text | Devolve uma representação em string do modelo. | Devolve uma representação em string do modelo. | def __str__(self):
"""Devolve uma representação em string do modelo."""
return self.text | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"self",
".",
"text"
] | [
10,
4
] | [
12,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
GameSats.reset_stats | (self) | Inicializa os dados estatisticos que podem mudar durante o
jogo. | Inicializa os dados estatisticos que podem mudar durante o
jogo. | def reset_stats(self):
"""Inicializa os dados estatisticos que podem mudar durante o
jogo."""
self.ships_left = self.ai_settings.ship_limit
self.score = 0
self.level = 1 | [
"def",
"reset_stats",
"(",
"self",
")",
":",
"self",
".",
"ships_left",
"=",
"self",
".",
"ai_settings",
".",
"ship_limit",
"self",
".",
"score",
"=",
"0",
"self",
".",
"level",
"=",
"1"
] | [
15,
4
] | [
21,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
origem_destino_iguais | (origem, destino, lista_de_erros) | Verifica se origem e destino são iguais | Verifica se origem e destino são iguais | def origem_destino_iguais(origem, destino, lista_de_erros):
"""Verifica se origem e destino são iguais"""
if origem == destino:
lista_de_erros['destino'] = "Origem e destino não podem ser iguais" | [
"def",
"origem_destino_iguais",
"(",
"origem",
",",
"destino",
",",
"lista_de_erros",
")",
":",
"if",
"origem",
"==",
"destino",
":",
"lista_de_erros",
"[",
"'destino'",
"]",
"=",
"\"Origem e destino não podem ser iguais\""
] | [
2,
0
] | [
5,
76
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
renameFile | (backupFile) | Renomeia o arquivo de backup existente adicionando a extensão .old | Renomeia o arquivo de backup existente adicionando a extensão .old | def renameFile(backupFile):
'Renomeia o arquivo de backup existente adicionando a extensão .old'
try:
os.rename(backupFile, '%s.old' % backupFile)
except OSError, details:
if details[0] != 2:
print 'Erro renomeando %s para %s.old: %s' % (backupFile, backupFile, details)
except Exception, details:
print 'Erro renomeando %s para %s.old: %s' % (backupFile, backupFile, details) | [
"def",
"renameFile",
"(",
"backupFile",
")",
":",
"try",
":",
"os",
".",
"rename",
"(",
"backupFile",
",",
"'%s.old'",
"%",
"backupFile",
")",
"except",
"OSError",
",",
"details",
":",
"if",
"details",
"[",
"0",
"]",
"!=",
"2",
":",
"print",
"'Erro renomeando %s para %s.old: %s'",
"%",
"(",
"backupFile",
",",
"backupFile",
",",
"details",
")",
"except",
"Exception",
",",
"details",
":",
"print",
"'Erro renomeando %s para %s.old: %s'",
"%",
"(",
"backupFile",
",",
"backupFile",
",",
"details",
")"
] | [
66,
0
] | [
74,
86
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
criarArquivo | (nome,palavra) | [Cria um arquivo de texto.]
Args:
nome ([str]): [nome do arquivo a ser criado.]
palavra([str]): [primeira palavra]
Criado por:
Murilo-Henrique060
| [Cria um arquivo de texto.] | def criarArquivo(nome,palavra):
"""[Cria um arquivo de texto.]
Args:
nome ([str]): [nome do arquivo a ser criado.]
palavra([str]): [primeira palavra]
Criado por:
Murilo-Henrique060
"""
try:
a = open(nome,'wt+')
a.close()
except:
print(f'Erro ao criar o arquivo {nome}.')
else:
print(f'Arquivo {nome} criado com sucesso.')
try:
a = open(nome,'at')
except:
print('Erro ao adicionar a primeira palavra.')
else:
try:
a.write(f'{palavra}')
except:
print('Erro ao escrever a palavra.')
else:
print('Nova palavra adicionada com sucesso.')
a.close() | [
"def",
"criarArquivo",
"(",
"nome",
",",
"palavra",
")",
":",
"try",
":",
"a",
"=",
"open",
"(",
"nome",
",",
"'wt+'",
")",
"a",
".",
"close",
"(",
")",
"except",
":",
"print",
"(",
"f'Erro ao criar o arquivo {nome}.'",
")",
"else",
":",
"print",
"(",
"f'Arquivo {nome} criado com sucesso.'",
")",
"try",
":",
"a",
"=",
"open",
"(",
"nome",
",",
"'at'",
")",
"except",
":",
"print",
"(",
"'Erro ao adicionar a primeira palavra.'",
")",
"else",
":",
"try",
":",
"a",
".",
"write",
"(",
"f'{palavra}'",
")",
"except",
":",
"print",
"(",
"'Erro ao escrever a palavra.'",
")",
"else",
":",
"print",
"(",
"'Nova palavra adicionada com sucesso.'",
")",
"a",
".",
"close",
"(",
")"
] | [
18,
0
] | [
45,
21
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Gatinho.brincar | (self, bau, brinquedo) | Realiza as ações resultantes da brincadeira no objeto gatinho, no baú e no próprio brinquedo. | Realiza as ações resultantes da brincadeira no objeto gatinho, no baú e no próprio brinquedo. | def brincar(self, bau, brinquedo):
"""Realiza as ações resultantes da brincadeira no objeto gatinho, no baú e no próprio brinquedo."""
# resultado da brincadeira (se ganhou ou perdeu)
res = brinquedo.brincadeira(self)
if res:
self.feliz = self.atualizar_attr(self.feliz, brinquedo.feliz)
brinquedo.usar()
if brinquedo.quebrou():
bau.remover_brinquedo(brinquedo) | [
"def",
"brincar",
"(",
"self",
",",
"bau",
",",
"brinquedo",
")",
":",
"# resultado da brincadeira (se ganhou ou perdeu)",
"res",
"=",
"brinquedo",
".",
"brincadeira",
"(",
"self",
")",
"if",
"res",
":",
"self",
".",
"feliz",
"=",
"self",
".",
"atualizar_attr",
"(",
"self",
".",
"feliz",
",",
"brinquedo",
".",
"feliz",
")",
"brinquedo",
".",
"usar",
"(",
")",
"if",
"brinquedo",
".",
"quebrou",
"(",
")",
":",
"bau",
".",
"remover_brinquedo",
"(",
"brinquedo",
")"
] | [
27,
4
] | [
38,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ProbDist.normalize | (self) | return self | Verifique se as probabilidades de todos os valores somam 1.
Retorna a distribuição normalizada.
Aumenta um ZeroDivisionError se a soma dos valores for 0. | Verifique se as probabilidades de todos os valores somam 1.
Retorna a distribuição normalizada.
Aumenta um ZeroDivisionError se a soma dos valores for 0. | def normalize(self):
"""Verifique se as probabilidades de todos os valores somam 1.
Retorna a distribuição normalizada.
Aumenta um ZeroDivisionError se a soma dos valores for 0."""
total = sum(self.prob.values())
if not isclose(total, 1.0):
for val in self.prob:
self.prob[val] /= total
return self | [
"def",
"normalize",
"(",
"self",
")",
":",
"total",
"=",
"sum",
"(",
"self",
".",
"prob",
".",
"values",
"(",
")",
")",
"if",
"not",
"isclose",
"(",
"total",
",",
"1.0",
")",
":",
"for",
"val",
"in",
"self",
".",
"prob",
":",
"self",
".",
"prob",
"[",
"val",
"]",
"/=",
"total",
"return",
"self"
] | [
71,
4
] | [
79,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
PropKB.retract | (self, sentence) | Remove as cláusulas da sentença da KB. | Remove as cláusulas da sentença da KB. | def retract(self, sentence):
"Remove as cláusulas da sentença da KB."
for c in conjuncts(to_cnf(sentence)):
if c in self.clauses:
self.clauses.remove(c) | [
"def",
"retract",
"(",
"self",
",",
"sentence",
")",
":",
"for",
"c",
"in",
"conjuncts",
"(",
"to_cnf",
"(",
"sentence",
")",
")",
":",
"if",
"c",
"in",
"self",
".",
"clauses",
":",
"self",
".",
"clauses",
".",
"remove",
"(",
"c",
")"
] | [
94,
4
] | [
98,
38
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
update_bullets | (bullets) | Atualiza a posição dos projeteis e se livra dos projeteis antigos | Atualiza a posição dos projeteis e se livra dos projeteis antigos | def update_bullets(bullets):
"""Atualiza a posição dos projeteis e se livra dos projeteis antigos"""
#Atualiza a posição dos projeteis
bullets.update()
#Livra se dos projeteis que desaparecem
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet) | [
"def",
"update_bullets",
"(",
"bullets",
")",
":",
"#Atualiza a posição dos projeteis",
"bullets",
".",
"update",
"(",
")",
"#Livra se dos projeteis que desaparecem",
"for",
"bullet",
"in",
"bullets",
".",
"copy",
"(",
")",
":",
"if",
"bullet",
".",
"rect",
".",
"bottom",
"<=",
"0",
":",
"bullets",
".",
"remove",
"(",
"bullet",
")"
] | [
58,
0
] | [
66,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Restaurant.open_served | (self) | return time_function | Retorna o horário de funcionamento do restaurante. | Retorna o horário de funcionamento do restaurante. | def open_served(self):
"""Retorna o horário de funcionamento do restaurante."""
time_function = self.restaurant_name + ' está aberto das 11h30min às 22h00min.'
return time_function | [
"def",
"open_served",
"(",
"self",
")",
":",
"time_function",
"=",
"self",
".",
"restaurant_name",
"+",
"' está aberto das 11h30min às 22h00min.'",
"return",
"time_function"
] | [
38,
4
] | [
41,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
backup_and_extract_content | (sender, instance, **kwargs) | Faz backup e extrai conteúdo de um arquivo após sua criação. | Faz backup e extrai conteúdo de um arquivo após sua criação. | def backup_and_extract_content(sender, instance, **kwargs):
"""Faz backup e extrai conteúdo de um arquivo após sua criação."""
if bool(os.getenv("ENABLE_SIGNAL_FOR_FILE_TASKS", False)):
from .tasks import backup_file, content_from_file
if instance.s3_url is None or instance.content is None:
backup_file.apply_async(
(instance.pk,),
link=content_from_file.s(
instance.pk,
),
) | [
"def",
"backup_and_extract_content",
"(",
"sender",
",",
"instance",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"bool",
"(",
"os",
".",
"getenv",
"(",
"\"ENABLE_SIGNAL_FOR_FILE_TASKS\"",
",",
"False",
")",
")",
":",
"from",
".",
"tasks",
"import",
"backup_file",
",",
"content_from_file",
"if",
"instance",
".",
"s3_url",
"is",
"None",
"or",
"instance",
".",
"content",
"is",
"None",
":",
"backup_file",
".",
"apply_async",
"(",
"(",
"instance",
".",
"pk",
",",
")",
",",
"link",
"=",
"content_from_file",
".",
"s",
"(",
"instance",
".",
"pk",
",",
")",
",",
")"
] | [
9,
0
] | [
20,
13
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
CRC16.check_crc | (self) | return fcs == self.GOODFCS | Verifica o valor de FCS contido nos dados armazenados no buffer interno | Verifica o valor de FCS contido nos dados armazenados no buffer interno | def check_crc(self):
'''Verifica o valor de FCS contido nos dados armazenados no buffer interno'''
fcs = self.calculate()
return fcs == self.GOODFCS | [
"def",
"check_crc",
"(",
"self",
")",
":",
"fcs",
"=",
"self",
".",
"calculate",
"(",
")",
"return",
"fcs",
"==",
"self",
".",
"GOODFCS"
] | [
85,
2
] | [
88,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
DiarioGC.cadastro | (self) | funcao para cadastramento | funcao para cadastramento | def cadastro(self):
"""funcao para cadastramento"""
def guardar():
if not path.exists(f'DIARIOGC-{self.nome.text()}/debug'):
mkdir(f"DIARIOGC-{self.nome.text()}/debug")
basicConfig(filename=f'DIARIOGC-{self.nome.text()}/debug/{datetime.datetime.today()}.gc-log', level=INFO, format='%(asctime)s - %(levelname)s - %(message)s')
if senha.text() != confirmarSenha.text():
QMessageBox.critical(self.ferramentas, "Falha", f"Lamento {self.nome.text()} as senhas não correspondem..")
critical('senhas nao correspondem!')
pass
elif isEmpty(self.nome.text()) and isEmpty(senha.text()) and isEmpty(respostaEspecial.text()):
QMessageBox.critical(self.ferramentas, "Falha", "Lamento, mas você precisa prencher devidamente os seus dados antes de iniciar..")
critical('dados nao preenchidos!')
pass
else:
try:
if not path.exists(f'DIARIOGC-{self.nome.text()}'):
mkdir(f'DIARIOGC-{self.nome.text()}')
with open(f'DIARIOGC-{self.nome.text()}/utilizador.log', 'w+') as salvarDados:
salvarDados.write(f"""*** Bem-Vindo ***
Nome: {self.nome.text()}
Senha: {senha.text()}
Resposta: {respostaEspecial.text()}""")
QMessageBox.information(self.ferramentas, "Bem-Vindo", "Cadastro Concluido..\nAgora inicie sessao para confirmar os seus dados!")
self.tab.removeTab(0)
return self.iniciar()
except Exception as e:
QMessageBox.warning(self.ferramentas, "Falha", f"Lamento ocorreu um erro inesperado:\n\t{e}\n\nTente verificar e preencher propriamente os seus dados..")
warning(f'{e}')
pass
janela2 = QWidget()
self.ferramentas.setPalette(QPalette(QColor('blue')))
layout = QFormLayout()
layout.setSpacing(20)
labelImagem = QLabel()
labelImagem.setPixmap(QPixmap("img/01.png"))
labelImagem.setAlignment(Qt.AlignCenter)
layout.addWidget(labelImagem)
self.nome = QLineEdit()
self.nome.setToolTip('*: OBRIGATORIO!')
layout.addRow('&Nome: *', self.nome)
senha = QLineEdit()
senha.setToolTip('*: OBRIGATORIO!')
senha.setEchoMode(senha.PasswordEchoOnEdit)
layout.addRow('&Senha: *', senha)
confirmarSenha = QLineEdit()
confirmarSenha.setToolTip('*: OBRIGATORIO!')
confirmarSenha.setEchoMode(confirmarSenha.PasswordEchoOnEdit)
layout.addRow('Redigite a &Senha: *', confirmarSenha)
respostaEspecial = QLineEdit()
respostaEspecial.setToolTip('*: OBRIGATORIO!\nResposta especial que usaremos para recuperar o seu login..')
respostaEspecial.returnPressed.connect(guardar)
layout.addRow('Qual seu bem mais precioso? *', respostaEspecial)
botaoCadastrar = QPushButton('Cadastrar')
botaoCadastrar.clicked.connect(guardar)
botaoCadastrar.setDefault(True)
layout.addWidget(botaoCadastrar)
janela2.setLayout(layout)
self.tab.addTab(janela2, "Cadastro")
self.tab.setCurrentWidget(janela2) | [
"def",
"cadastro",
"(",
"self",
")",
":",
"def",
"guardar",
"(",
")",
":",
"if",
"not",
"path",
".",
"exists",
"(",
"f'DIARIOGC-{self.nome.text()}/debug'",
")",
":",
"mkdir",
"(",
"f\"DIARIOGC-{self.nome.text()}/debug\"",
")",
"basicConfig",
"(",
"filename",
"=",
"f'DIARIOGC-{self.nome.text()}/debug/{datetime.datetime.today()}.gc-log'",
",",
"level",
"=",
"INFO",
",",
"format",
"=",
"'%(asctime)s - %(levelname)s - %(message)s'",
")",
"if",
"senha",
".",
"text",
"(",
")",
"!=",
"confirmarSenha",
".",
"text",
"(",
")",
":",
"QMessageBox",
".",
"critical",
"(",
"self",
".",
"ferramentas",
",",
"\"Falha\"",
",",
"f\"Lamento {self.nome.text()} as senhas não correspondem..\")",
"",
"critical",
"(",
"'senhas nao correspondem!'",
")",
"pass",
"elif",
"isEmpty",
"(",
"self",
".",
"nome",
".",
"text",
"(",
")",
")",
"and",
"isEmpty",
"(",
"senha",
".",
"text",
"(",
")",
")",
"and",
"isEmpty",
"(",
"respostaEspecial",
".",
"text",
"(",
")",
")",
":",
"QMessageBox",
".",
"critical",
"(",
"self",
".",
"ferramentas",
",",
"\"Falha\"",
",",
"\"Lamento, mas você precisa prencher devidamente os seus dados antes de iniciar..\")",
"",
"critical",
"(",
"'dados nao preenchidos!'",
")",
"pass",
"else",
":",
"try",
":",
"if",
"not",
"path",
".",
"exists",
"(",
"f'DIARIOGC-{self.nome.text()}'",
")",
":",
"mkdir",
"(",
"f'DIARIOGC-{self.nome.text()}'",
")",
"with",
"open",
"(",
"f'DIARIOGC-{self.nome.text()}/utilizador.log'",
",",
"'w+'",
")",
"as",
"salvarDados",
":",
"salvarDados",
".",
"write",
"(",
"f\"\"\"*** Bem-Vindo ***\nNome: {self.nome.text()}\nSenha: {senha.text()}\nResposta: {respostaEspecial.text()}\"\"\"",
")",
"QMessageBox",
".",
"information",
"(",
"self",
".",
"ferramentas",
",",
"\"Bem-Vindo\"",
",",
"\"Cadastro Concluido..\\nAgora inicie sessao para confirmar os seus dados!\"",
")",
"self",
".",
"tab",
".",
"removeTab",
"(",
"0",
")",
"return",
"self",
".",
"iniciar",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"QMessageBox",
".",
"warning",
"(",
"self",
".",
"ferramentas",
",",
"\"Falha\"",
",",
"f\"Lamento ocorreu um erro inesperado:\\n\\t{e}\\n\\nTente verificar e preencher propriamente os seus dados..\"",
")",
"warning",
"(",
"f'{e}'",
")",
"pass",
"janela2",
"=",
"QWidget",
"(",
")",
"self",
".",
"ferramentas",
".",
"setPalette",
"(",
"QPalette",
"(",
"QColor",
"(",
"'blue'",
")",
")",
")",
"layout",
"=",
"QFormLayout",
"(",
")",
"layout",
".",
"setSpacing",
"(",
"20",
")",
"labelImagem",
"=",
"QLabel",
"(",
")",
"labelImagem",
".",
"setPixmap",
"(",
"QPixmap",
"(",
"\"img/01.png\"",
")",
")",
"labelImagem",
".",
"setAlignment",
"(",
"Qt",
".",
"AlignCenter",
")",
"layout",
".",
"addWidget",
"(",
"labelImagem",
")",
"self",
".",
"nome",
"=",
"QLineEdit",
"(",
")",
"self",
".",
"nome",
".",
"setToolTip",
"(",
"'*: OBRIGATORIO!'",
")",
"layout",
".",
"addRow",
"(",
"'&Nome: *'",
",",
"self",
".",
"nome",
")",
"senha",
"=",
"QLineEdit",
"(",
")",
"senha",
".",
"setToolTip",
"(",
"'*: OBRIGATORIO!'",
")",
"senha",
".",
"setEchoMode",
"(",
"senha",
".",
"PasswordEchoOnEdit",
")",
"layout",
".",
"addRow",
"(",
"'&Senha: *'",
",",
"senha",
")",
"confirmarSenha",
"=",
"QLineEdit",
"(",
")",
"confirmarSenha",
".",
"setToolTip",
"(",
"'*: OBRIGATORIO!'",
")",
"confirmarSenha",
".",
"setEchoMode",
"(",
"confirmarSenha",
".",
"PasswordEchoOnEdit",
")",
"layout",
".",
"addRow",
"(",
"'Redigite a &Senha: *'",
",",
"confirmarSenha",
")",
"respostaEspecial",
"=",
"QLineEdit",
"(",
")",
"respostaEspecial",
".",
"setToolTip",
"(",
"'*: OBRIGATORIO!\\nResposta especial que usaremos para recuperar o seu login..'",
")",
"respostaEspecial",
".",
"returnPressed",
".",
"connect",
"(",
"guardar",
")",
"layout",
".",
"addRow",
"(",
"'Qual seu bem mais precioso? *'",
",",
"respostaEspecial",
")",
"botaoCadastrar",
"=",
"QPushButton",
"(",
"'Cadastrar'",
")",
"botaoCadastrar",
".",
"clicked",
".",
"connect",
"(",
"guardar",
")",
"botaoCadastrar",
".",
"setDefault",
"(",
"True",
")",
"layout",
".",
"addWidget",
"(",
"botaoCadastrar",
")",
"janela2",
".",
"setLayout",
"(",
"layout",
")",
"self",
".",
"tab",
".",
"addTab",
"(",
"janela2",
",",
"\"Cadastro\"",
")",
"self",
".",
"tab",
".",
"setCurrentWidget",
"(",
"janela2",
")"
] | [
122,
4
] | [
190,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
AppSettings.__init__ | (self) | O init será chamado todas as vezes | O init será chamado todas as vezes | def __init__(self) -> None:
""" O init será chamado todas as vezes """
self.tema = 'O tema escuro'
self.font = '18px' | [
"def",
"__init__",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"tema",
"=",
"'O tema escuro'",
"self",
".",
"font",
"=",
"'18px'"
] | [
21,
4
] | [
24,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ChangesStore.rollback | (self, id: str) | Deleta todos os registros de mudança registrados para o ID informado. | Deleta todos os registros de mudança registrados para o ID informado. | def rollback(self, id: str) -> None:
"""Deleta todos os registros de mudança registrados para o ID informado."""
self.delete_many({"id": id}) | [
"def",
"rollback",
"(",
"self",
",",
"id",
":",
"str",
")",
"->",
"None",
":",
"self",
".",
"delete_many",
"(",
"{",
"\"id\"",
":",
"id",
"}",
")"
] | [
57,
4
] | [
59,
36
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
verifica | (id) | Retorna um único sócio para verificação de todos os dados | Retorna um único sócio para verificação de todos os dados | def verifica(id):
"""Retorna um único sócio para verificação de todos os dados"""
try:
socio = get_socio(id)
return render_template('socio/verifica.html', socio=socio)
except Exception as e:
return render_template('404.html') | [
"def",
"verifica",
"(",
"id",
")",
":",
"try",
":",
"socio",
"=",
"get_socio",
"(",
"id",
")",
"return",
"render_template",
"(",
"'socio/verifica.html'",
",",
"socio",
"=",
"socio",
")",
"except",
"Exception",
"as",
"e",
":",
"return",
"render_template",
"(",
"'404.html'",
")"
] | [
171,
0
] | [
177,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Grafo.isBipartido | (self, rotulo) | return 1 | Verifica se um grafo é bipartido a partir de um dfs | Verifica se um grafo é bipartido a partir de um dfs | def isBipartido(self, rotulo):
"""Verifica se um grafo é bipartido a partir de um dfs"""
inicio = self.localizaRotulo(rotulo)
# Setou a raiz como vertice visitado
self.listaVertices[inicio].regVisitado()
self.listaVertices[inicio].regCor(1) # coloriu raiz do grafo
self.pilha.append(inicio) # Empilhou o vertice Visitado
while(len(self.pilha) > 0):
# pega o vertice que está no topo da pilha
verticeAnalisar = self.pilha[len(self.pilha) - 1]
# Pega um vertice que não foi visitado adjacente ao vertice que está no topo da pilha
v = self.obtemAdjacenteNaoVisitado(verticeAnalisar)
if(v == -1):
# se não existir vertice adjacente não visitado, desempilha
self.pilha.pop()
else:
# existe vertice adjacente não visitado
# registra que foi visitado
self.listaVertices[v].regVisitado()
self.pilha.append(v) # coloca no topo da pilha
bipartido = self.coloracao(v) # define a cor
if(bipartido == -1 ):
return -1
for item in self.listaVertices:
if item.consultaCor() == 0:
return -1
return 1 | [
"def",
"isBipartido",
"(",
"self",
",",
"rotulo",
")",
":",
"inicio",
"=",
"self",
".",
"localizaRotulo",
"(",
"rotulo",
")",
"# Setou a raiz como vertice visitado",
"self",
".",
"listaVertices",
"[",
"inicio",
"]",
".",
"regVisitado",
"(",
")",
"self",
".",
"listaVertices",
"[",
"inicio",
"]",
".",
"regCor",
"(",
"1",
")",
"# coloriu raiz do grafo",
"self",
".",
"pilha",
".",
"append",
"(",
"inicio",
")",
"# Empilhou o vertice Visitado",
"while",
"(",
"len",
"(",
"self",
".",
"pilha",
")",
">",
"0",
")",
":",
"# pega o vertice que está no topo da pilha",
"verticeAnalisar",
"=",
"self",
".",
"pilha",
"[",
"len",
"(",
"self",
".",
"pilha",
")",
"-",
"1",
"]",
"# Pega um vertice que não foi visitado adjacente ao vertice que está no topo da pilha",
"v",
"=",
"self",
".",
"obtemAdjacenteNaoVisitado",
"(",
"verticeAnalisar",
")",
"if",
"(",
"v",
"==",
"-",
"1",
")",
":",
"# se não existir vertice adjacente não visitado, desempilha",
"self",
".",
"pilha",
".",
"pop",
"(",
")",
"else",
":",
"# existe vertice adjacente não visitado",
"# registra que foi visitado",
"self",
".",
"listaVertices",
"[",
"v",
"]",
".",
"regVisitado",
"(",
")",
"self",
".",
"pilha",
".",
"append",
"(",
"v",
")",
"# coloca no topo da pilha",
"bipartido",
"=",
"self",
".",
"coloracao",
"(",
"v",
")",
"# define a cor",
"if",
"(",
"bipartido",
"==",
"-",
"1",
")",
":",
"return",
"-",
"1",
"for",
"item",
"in",
"self",
".",
"listaVertices",
":",
"if",
"item",
".",
"consultaCor",
"(",
")",
"==",
"0",
":",
"return",
"-",
"1",
"return",
"1"
] | [
223,
4
] | [
252,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Grafo.adiciona_arestas | (self, arestas: list) | Adiciona todas as arestas ao grafo
Args:
arestas (list): a lista contendo todas as definições de arestas do grafo
| Adiciona todas as arestas ao grafo
Args:
arestas (list): a lista contendo todas as definições de arestas do grafo
| def adiciona_arestas(self, arestas: list) -> None:
"""Adiciona todas as arestas ao grafo
Args:
arestas (list): a lista contendo todas as definições de arestas do grafo
"""
for i in range(len(arestas)):
for j in range(len(arestas[i])):
self.__adiciona_aresta(i, arestas[i][j]) | [
"def",
"adiciona_arestas",
"(",
"self",
",",
"arestas",
":",
"list",
")",
"->",
"None",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"arestas",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"arestas",
"[",
"i",
"]",
")",
")",
":",
"self",
".",
"__adiciona_aresta",
"(",
"i",
",",
"arestas",
"[",
"i",
"]",
"[",
"j",
"]",
")"
] | [
20,
4
] | [
28,
56
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
import_documents_to_kernel | (session_db, pid_database_engine, storage, folder, output_path) | Armazena os arquivos do pacote SPS em um object storage, registra o documento
no banco de dados do Kernel e por fim associa-o ao seu `document bundle` | Armazena os arquivos do pacote SPS em um object storage, registra o documento
no banco de dados do Kernel e por fim associa-o ao seu `document bundle` | def import_documents_to_kernel(session_db, pid_database_engine, storage, folder, output_path) -> None:
"""Armazena os arquivos do pacote SPS em um object storage, registra o documento
no banco de dados do Kernel e por fim associa-o ao seu `document bundle`"""
jobs = [
{"folder": package_folder, "session": session_db, "storage": storage, "pid_database_engine": pid_database_engine}
for package_folder, _, files in os.walk(folder)
if files is not None and len(files) > 0
]
with tqdm(total=len(jobs)) as pbar:
def update_bar(pbar=pbar):
pbar.update(1)
def write_result_to_file(result, path=output_path):
with open(path, "a") as f:
f.write(json.dumps(result) + "\n")
def exception_callback(exception, job, logger=logger):
logger.error(
"Could not import package '%s'. The following exception "
"was raised: '%s'.",
job["folder"],
exception,
)
# O param executor por padrão é concurrent.futures.ThreadPoolExecutor.
# É possível e ganhamos velocidade quando utilizamos concurrent.futures.Executor,
# porém é necessário saber dos por menores que envolve essa alteração, é possível
# verificar isso em: https://docs.python.org/3/library/concurrent.futures.html#processpoolexecutor
DoJobsConcurrently(
register_document,
jobs=jobs,
max_workers=int(config.get("PROCESSPOOL_MAX_WORKERS")),
success_callback=write_result_to_file,
exception_callback=exception_callback,
update_bar=update_bar,
) | [
"def",
"import_documents_to_kernel",
"(",
"session_db",
",",
"pid_database_engine",
",",
"storage",
",",
"folder",
",",
"output_path",
")",
"->",
"None",
":",
"jobs",
"=",
"[",
"{",
"\"folder\"",
":",
"package_folder",
",",
"\"session\"",
":",
"session_db",
",",
"\"storage\"",
":",
"storage",
",",
"\"pid_database_engine\"",
":",
"pid_database_engine",
"}",
"for",
"package_folder",
",",
"_",
",",
"files",
"in",
"os",
".",
"walk",
"(",
"folder",
")",
"if",
"files",
"is",
"not",
"None",
"and",
"len",
"(",
"files",
")",
">",
"0",
"]",
"with",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"jobs",
")",
")",
"as",
"pbar",
":",
"def",
"update_bar",
"(",
"pbar",
"=",
"pbar",
")",
":",
"pbar",
".",
"update",
"(",
"1",
")",
"def",
"write_result_to_file",
"(",
"result",
",",
"path",
"=",
"output_path",
")",
":",
"with",
"open",
"(",
"path",
",",
"\"a\"",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"json",
".",
"dumps",
"(",
"result",
")",
"+",
"\"\\n\"",
")",
"def",
"exception_callback",
"(",
"exception",
",",
"job",
",",
"logger",
"=",
"logger",
")",
":",
"logger",
".",
"error",
"(",
"\"Could not import package '%s'. The following exception \"",
"\"was raised: '%s'.\"",
",",
"job",
"[",
"\"folder\"",
"]",
",",
"exception",
",",
")",
"# O param executor por padrão é concurrent.futures.ThreadPoolExecutor.",
"# É possível e ganhamos velocidade quando utilizamos concurrent.futures.Executor,",
"# porém é necessário saber dos por menores que envolve essa alteração, é possível",
"# verificar isso em: https://docs.python.org/3/library/concurrent.futures.html#processpoolexecutor",
"DoJobsConcurrently",
"(",
"register_document",
",",
"jobs",
"=",
"jobs",
",",
"max_workers",
"=",
"int",
"(",
"config",
".",
"get",
"(",
"\"PROCESSPOOL_MAX_WORKERS\"",
")",
")",
",",
"success_callback",
"=",
"write_result_to_file",
",",
"exception_callback",
"=",
"exception_callback",
",",
"update_bar",
"=",
"update_bar",
",",
")"
] | [
285,
0
] | [
323,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
get_DOC | (aCDOM_300, S_275_to_295) | return DOC | Função que retorna DOC (μmol L−1) com base nos valores de aCDOM(300) e S(275-295).
A variabilidade (R2) desta função varia entre 0.92 e 0.94.
A função foi otimizada para um range de DOC variando entre [73–953 μmol L−1]
Referência do cálculo :
CAO, F. et al. Remote sensing retrievals of colored
dissolved organic matter and dissolved organic carbon
dynamics in North American estuaries and their margins.
Remote Sensing of Environment, v. 205, n. April 2017,
p. 151–165, 2018.
| Função que retorna DOC (μmol L−1) com base nos valores de aCDOM(300) e S(275-295). | def get_DOC(aCDOM_300, S_275_to_295):
""" Função que retorna DOC (μmol L−1) com base nos valores de aCDOM(300) e S(275-295).
A variabilidade (R2) desta função varia entre 0.92 e 0.94.
A função foi otimizada para um range de DOC variando entre [73–953 μmol L−1]
Referência do cálculo :
CAO, F. et al. Remote sensing retrievals of colored
dissolved organic matter and dissolved organic carbon
dynamics in North American estuaries and their margins.
Remote Sensing of Environment, v. 205, n. April 2017,
p. 151–165, 2018.
"""
DOC = aCDOM_300 / (exp(-15.05 - (33,95 * S_275_to_295))
+ exp(-1,502 - (104,3 * S_275_to_295)))
print("\n\nDOC: ", DOC, " μmol L−1")
return DOC | [
"def",
"get_DOC",
"(",
"aCDOM_300",
",",
"S_275_to_295",
")",
":",
"DOC",
"=",
"aCDOM_300",
"/",
"(",
"exp",
"(",
"-",
"15.05",
"-",
"(",
"33",
",",
"95",
"*",
"S_275_to_295",
")",
")",
"+",
"exp",
"(",
"-",
"1",
",",
"502",
"-",
"(",
"104",
",",
"3",
"*",
"S_275_to_295",
")",
")",
")",
"print",
"(",
"\"\\n\\nDOC: \"",
",",
"DOC",
",",
"\" μmol L−1\")",
"",
"return",
"DOC"
] | [
2,
0
] | [
23,
11
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
interpolador_h_s_liq | (h, s, estado_inicial, iters=100, precision=0.99999, delta=100) | return estado_new._T | Mesma coisa que o do gas, mas para liquidos | Mesma coisa que o do gas, mas para liquidos | def interpolador_h_s_liq(h, s, estado_inicial, iters=100, precision=0.99999, delta=100):
'''Mesma coisa que o do gas, mas para liquidos'''
material = estado_inicial._material
table = estado_inicial._table_name
p_atual = float(estado_inicial._p)
T_atual = float(estado_inicial._T)
estado00 = estado_inicial
estado10 = estado(material, table, p_atual, T_atual + delta)
estado11 = estado(material, table, p_atual + delta, T_atual + delta)
estado01 = estado(material, table, p_atual + delta, T_atual)
arr = array([[T_atual, '', T_atual + delta],
[estado00.specific_enthalpy, h, estado10.specific_enthalpy]])
T_new = interpolacao(arr)
# arr = array([[estado00.specific_entropy,'',estado10.specific_entropy],
# [T_atual, T_new,T_atual + delta]])
# S0 = interpolacao(arr)
#
# arr = array([[estado01.specific_entropy,'',estado11.specific_entropy],
# [T_atual, T_new,T_atual + delta]])
# S1 = interpolacao(arr)
#
# arr = array([[p_atual,'',p_atual + delta],
# [S0, s, S1]])
# p_new = interpolacao(arr)
estado_new = estado(material, table, p_atual, T_new)
print('Temperatura agua comprimida')
return estado_new._T | [
"def",
"interpolador_h_s_liq",
"(",
"h",
",",
"s",
",",
"estado_inicial",
",",
"iters",
"=",
"100",
",",
"precision",
"=",
"0.99999",
",",
"delta",
"=",
"100",
")",
":",
"material",
"=",
"estado_inicial",
".",
"_material",
"table",
"=",
"estado_inicial",
".",
"_table_name",
"p_atual",
"=",
"float",
"(",
"estado_inicial",
".",
"_p",
")",
"T_atual",
"=",
"float",
"(",
"estado_inicial",
".",
"_T",
")",
"estado00",
"=",
"estado_inicial",
"estado10",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
",",
"T_atual",
"+",
"delta",
")",
"estado11",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
"+",
"delta",
",",
"T_atual",
"+",
"delta",
")",
"estado01",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
"+",
"delta",
",",
"T_atual",
")",
"arr",
"=",
"array",
"(",
"[",
"[",
"T_atual",
",",
"''",
",",
"T_atual",
"+",
"delta",
"]",
",",
"[",
"estado00",
".",
"specific_enthalpy",
",",
"h",
",",
"estado10",
".",
"specific_enthalpy",
"]",
"]",
")",
"T_new",
"=",
"interpolacao",
"(",
"arr",
")",
"# arr = array([[estado00.specific_entropy,'',estado10.specific_entropy],\r",
"# [T_atual, T_new,T_atual + delta]])\r",
"# S0 = interpolacao(arr)\r",
"#\r",
"# arr = array([[estado01.specific_entropy,'',estado11.specific_entropy],\r",
"# [T_atual, T_new,T_atual + delta]])\r",
"# S1 = interpolacao(arr)\r",
"#\r",
"# arr = array([[p_atual,'',p_atual + delta],\r",
"# [S0, s, S1]])\r",
"# p_new = interpolacao(arr)\r",
"estado_new",
"=",
"estado",
"(",
"material",
",",
"table",
",",
"p_atual",
",",
"T_new",
")",
"print",
"(",
"'Temperatura agua comprimida'",
")",
"return",
"estado_new",
".",
"_T"
] | [
348,
0
] | [
377,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Problem.path_cost | (self, c, state1, action, state2) | return c + 1 | Retorna o custo de um caminho de solução que chega ao estado2 a partir
do estado1 via ação, assumindo o custo c para chegar até estado1. Se o problema
é tal que o caminho não importa, esta função só vai olhar para
estado2. Se o caminho não importa, ele considerará c e talvez estado1
e ação. O método padrão custa 1 para cada etapa do caminho. | Retorna o custo de um caminho de solução que chega ao estado2 a partir
do estado1 via ação, assumindo o custo c para chegar até estado1. Se o problema
é tal que o caminho não importa, esta função só vai olhar para
estado2. Se o caminho não importa, ele considerará c e talvez estado1
e ação. O método padrão custa 1 para cada etapa do caminho. | def path_cost(self, c, state1, action, state2):
"""Retorna o custo de um caminho de solução que chega ao estado2 a partir
do estado1 via ação, assumindo o custo c para chegar até estado1. Se o problema
é tal que o caminho não importa, esta função só vai olhar para
estado2. Se o caminho não importa, ele considerará c e talvez estado1
e ação. O método padrão custa 1 para cada etapa do caminho."""
return c + 1 | [
"def",
"path_cost",
"(",
"self",
",",
"c",
",",
"state1",
",",
"action",
",",
"state2",
")",
":",
"return",
"c",
"+",
"1"
] | [
54,
4
] | [
60,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Factor.sum_out | (self, var, bn) | return Factor(variables, cpt) | Faça um fator eliminando var por soma sobre seus valores. | Faça um fator eliminando var por soma sobre seus valores. | def sum_out(self, var, bn):
"Faça um fator eliminando var por soma sobre seus valores."
variables = [X for X in self.variables if X != var]
cpt = {
event_values(e, variables): sum(
self.p(extend(e, var, val)) for val in bn.variable_values(var)
)
for e in all_events(variables, bn, {})
}
return Factor(variables, cpt) | [
"def",
"sum_out",
"(",
"self",
",",
"var",
",",
"bn",
")",
":",
"variables",
"=",
"[",
"X",
"for",
"X",
"in",
"self",
".",
"variables",
"if",
"X",
"!=",
"var",
"]",
"cpt",
"=",
"{",
"event_values",
"(",
"e",
",",
"variables",
")",
":",
"sum",
"(",
"self",
".",
"p",
"(",
"extend",
"(",
"e",
",",
"var",
",",
"val",
")",
")",
"for",
"val",
"in",
"bn",
".",
"variable_values",
"(",
"var",
")",
")",
"for",
"e",
"in",
"all_events",
"(",
"variables",
",",
"bn",
",",
"{",
"}",
")",
"}",
"return",
"Factor",
"(",
"variables",
",",
"cpt",
")"
] | [
369,
4
] | [
378,
37
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
OptimalControl._backward | (self, t, x, u, lambda_, params,h) | return lambda_ | A função realiza o processo backward que integra a equação de lambda' = -H_x
dadj: função (t,x,u) com a derivada de lambda.
x: estado calculado. Vetor de tamanho N + 1.
u: controle do último passo. Vetor de tamanho N + 1.
lambda_: função adjunta do último passo. Vetor de tamanho N + 1.
h: passo a ser dado pelo método de Runge-Kutta.
| A função realiza o processo backward que integra a equação de lambda' = -H_x
dadj: função (t,x,u) com a derivada de lambda.
x: estado calculado. Vetor de tamanho N + 1.
u: controle do último passo. Vetor de tamanho N + 1.
lambda_: função adjunta do último passo. Vetor de tamanho N + 1.
h: passo a ser dado pelo método de Runge-Kutta.
| def _backward(self, t, x, u, lambda_, params,h):
'''A função realiza o processo backward que integra a equação de lambda' = -H_x
dadj: função (t,x,u) com a derivada de lambda.
x: estado calculado. Vetor de tamanho N + 1.
u: controle do último passo. Vetor de tamanho N + 1.
lambda_: função adjunta do último passo. Vetor de tamanho N + 1.
h: passo a ser dado pelo método de Runge-Kutta.
'''
for i in range(len(t)-1,0,-1):
k1 = self.dadj(t[i],x[i],u[i],lambda_[i], params)
k2 = self.dadj(t[i]-h/2,0.5*(x[i] + x[i-1]), 0.5*(u[i] + u[i-1]),lambda_[i] - 0.5*h*k1, params)
k3 = self.dadj(t[i]-h/2,0.5*(x[i] + x[i-1]), 0.5*(u[i] + u[i-1]),lambda_[i] - 0.5*h*k2, params)
k4 = self.dadj(t[i]-h,x[i-1], u[i-1], lambda_[i] - h*k3, params)
lambda_[i-1] = lambda_[i] - (h/6)*(k1 + 2*k2 + 2*k3 + k4)
return lambda_ | [
"def",
"_backward",
"(",
"self",
",",
"t",
",",
"x",
",",
"u",
",",
"lambda_",
",",
"params",
",",
"h",
")",
":",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"t",
")",
"-",
"1",
",",
"0",
",",
"-",
"1",
")",
":",
"k1",
"=",
"self",
".",
"dadj",
"(",
"t",
"[",
"i",
"]",
",",
"x",
"[",
"i",
"]",
",",
"u",
"[",
"i",
"]",
",",
"lambda_",
"[",
"i",
"]",
",",
"params",
")",
"k2",
"=",
"self",
".",
"dadj",
"(",
"t",
"[",
"i",
"]",
"-",
"h",
"/",
"2",
",",
"0.5",
"*",
"(",
"x",
"[",
"i",
"]",
"+",
"x",
"[",
"i",
"-",
"1",
"]",
")",
",",
"0.5",
"*",
"(",
"u",
"[",
"i",
"]",
"+",
"u",
"[",
"i",
"-",
"1",
"]",
")",
",",
"lambda_",
"[",
"i",
"]",
"-",
"0.5",
"*",
"h",
"*",
"k1",
",",
"params",
")",
"k3",
"=",
"self",
".",
"dadj",
"(",
"t",
"[",
"i",
"]",
"-",
"h",
"/",
"2",
",",
"0.5",
"*",
"(",
"x",
"[",
"i",
"]",
"+",
"x",
"[",
"i",
"-",
"1",
"]",
")",
",",
"0.5",
"*",
"(",
"u",
"[",
"i",
"]",
"+",
"u",
"[",
"i",
"-",
"1",
"]",
")",
",",
"lambda_",
"[",
"i",
"]",
"-",
"0.5",
"*",
"h",
"*",
"k2",
",",
"params",
")",
"k4",
"=",
"self",
".",
"dadj",
"(",
"t",
"[",
"i",
"]",
"-",
"h",
",",
"x",
"[",
"i",
"-",
"1",
"]",
",",
"u",
"[",
"i",
"-",
"1",
"]",
",",
"lambda_",
"[",
"i",
"]",
"-",
"h",
"*",
"k3",
",",
"params",
")",
"lambda_",
"[",
"i",
"-",
"1",
"]",
"=",
"lambda_",
"[",
"i",
"]",
"-",
"(",
"h",
"/",
"6",
")",
"*",
"(",
"k1",
"+",
"2",
"*",
"k2",
"+",
"2",
"*",
"k3",
"+",
"k4",
")",
"return",
"lambda_"
] | [
60,
4
] | [
74,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
p_lista_argumentos | (p) | lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
| lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
| def p_lista_argumentos(p):
"""lista_argumentos : lista_argumentos VIRGULA expressao
| expressao
| vazio
"""
pai = MyNode(name='lista_argumentos', type='LISTA_ARGUMENTOS')
p[0] = pai
if len(p) > 2:
p[1].parent = pai
filho2 = MyNode(name='VIRGULA', type='VIRGULA', parent=pai)
filho_sym = MyNode(name=p[2], type='SIMBOLO', parent=filho2)
p[2] = filho2
p[3].parent = pai
else:
p[1].parent = pai | [
"def",
"p_lista_argumentos",
"(",
"p",
")",
":",
"pai",
"=",
"MyNode",
"(",
"name",
"=",
"'lista_argumentos'",
",",
"type",
"=",
"'LISTA_ARGUMENTOS'",
")",
"p",
"[",
"0",
"]",
"=",
"pai",
"if",
"len",
"(",
"p",
")",
">",
"2",
":",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai",
"filho2",
"=",
"MyNode",
"(",
"name",
"=",
"'VIRGULA'",
",",
"type",
"=",
"'VIRGULA'",
",",
"parent",
"=",
"pai",
")",
"filho_sym",
"=",
"MyNode",
"(",
"name",
"=",
"p",
"[",
"2",
"]",
",",
"type",
"=",
"'SIMBOLO'",
",",
"parent",
"=",
"filho2",
")",
"p",
"[",
"2",
"]",
"=",
"filho2",
"p",
"[",
"3",
"]",
".",
"parent",
"=",
"pai",
"else",
":",
"p",
"[",
"1",
"]",
".",
"parent",
"=",
"pai"
] | [
999,
0
] | [
1016,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
register | (request) | return render(request, 'users/register.html', context) | Faz o cadastro de um novo usuário. | Faz o cadastro de um novo usuário. | def register(request):
"""Faz o cadastro de um novo usuário."""
if request.method != 'POST':
# Exibe o formulário de cadastro em branco
form = UserCreationForm()
else:
# Processa o formulario preenchido
form = UserCreationForm(data=request.POST)
if form.is_valid():
new_user = form.save()
# Faz login do usuário e o redireciona para a página inicial
authenticated_user =authenticate(username=new_user.username, password=request.POST['password1'])
login(request, authenticated_user)
return HttpResponseRedirect(reverse('learning_logs:index'))
context = {'form': form}
return render(request, 'users/register.html', context) | [
"def",
"register",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"!=",
"'POST'",
":",
"# Exibe o formulário de cadastro em branco",
"form",
"=",
"UserCreationForm",
"(",
")",
"else",
":",
"# Processa o formulario preenchido",
"form",
"=",
"UserCreationForm",
"(",
"data",
"=",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"new_user",
"=",
"form",
".",
"save",
"(",
")",
"# Faz login do usuário e o redireciona para a página inicial",
"authenticated_user",
"=",
"authenticate",
"(",
"username",
"=",
"new_user",
".",
"username",
",",
"password",
"=",
"request",
".",
"POST",
"[",
"'password1'",
"]",
")",
"login",
"(",
"request",
",",
"authenticated_user",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'learning_logs:index'",
")",
")",
"context",
"=",
"{",
"'form'",
":",
"form",
"}",
"return",
"render",
"(",
"request",
",",
"'users/register.html'",
",",
"context",
")"
] | [
14,
0
] | [
29,
58
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
lista_ordem_servicos | (request) | return render(request, "devsys-ordem-servicos.html", dados) | Lista das Ordens de Serviços. | Lista das Ordens de Serviços. | def lista_ordem_servicos(request):
""" Lista das Ordens de Serviços."""
usuario = request.user
try:
# Mesmo objeto em html
# verificar se é um funcionário.
funcionario = Funcionario.objects.filter(usuario_fun=usuario)
except Exception:
raise Http404()
if funcionario:
#id pesquisa
termo_pesquisa = request.GET.get('pesquisa', None)
# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO
if termo_pesquisa:
# Com essa função de mostrar somente maiores ou menores da para esconder os registros
# PARA APARECER AS ORDENS DE SERVIÇOS SOMENTE MAIORES -> (__gt) QUE A DATA ATUAL
data_atual = datetime.now() - timedelta(
days=365
) # para retornar com atrasados há 1 ano
ordem_servico = Ordem_Servico.objects.filter(
usuario_os=usuario, dt_agenda__gt=data_atual
) # __gt só Maior, __lt só Menor
#__icontains sem case sensitive
ordem_servico = ordem_servico.filter(responsavel__icontains=termo_pesquisa)
else:
data_atual = datetime.now() - timedelta(
days=365
)
ordem_servico_list = Ordem_Servico.objects.filter(
usuario_os=usuario, dt_agenda__gt=data_atual
).order_by('-dt_atualizada')
paginator = Paginator(ordem_servico_list, 10)
page = request.GET.get('page')
ordem_servico = paginator.get_page(page)
dados = {"ordem_servicos": ordem_servico}
else:
raise Http404()
return render(request, "devsys-ordem-servicos.html", dados) | [
"def",
"lista_ordem_servicos",
"(",
"request",
")",
":",
"usuario",
"=",
"request",
".",
"user",
"try",
":",
"# Mesmo objeto em html",
"# verificar se é um funcionário.",
"funcionario",
"=",
"Funcionario",
".",
"objects",
".",
"filter",
"(",
"usuario_fun",
"=",
"usuario",
")",
"except",
"Exception",
":",
"raise",
"Http404",
"(",
")",
"if",
"funcionario",
":",
"#id pesquisa",
"termo_pesquisa",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'pesquisa'",
",",
"None",
")",
"# PESQUISAS DEVEM ESTAR DIRETO EM MODEL PESQUISANDO",
"if",
"termo_pesquisa",
":",
"# Com essa função de mostrar somente maiores ou menores da para esconder os registros",
"# PARA APARECER AS ORDENS DE SERVIÇOS SOMENTE MAIORES -> (__gt) QUE A DATA ATUAL",
"data_atual",
"=",
"datetime",
".",
"now",
"(",
")",
"-",
"timedelta",
"(",
"days",
"=",
"365",
")",
"# para retornar com atrasados há 1 ano",
"ordem_servico",
"=",
"Ordem_Servico",
".",
"objects",
".",
"filter",
"(",
"usuario_os",
"=",
"usuario",
",",
"dt_agenda__gt",
"=",
"data_atual",
")",
"# __gt só Maior, __lt só Menor",
"#__icontains sem case sensitive",
"ordem_servico",
"=",
"ordem_servico",
".",
"filter",
"(",
"responsavel__icontains",
"=",
"termo_pesquisa",
")",
"else",
":",
"data_atual",
"=",
"datetime",
".",
"now",
"(",
")",
"-",
"timedelta",
"(",
"days",
"=",
"365",
")",
"ordem_servico_list",
"=",
"Ordem_Servico",
".",
"objects",
".",
"filter",
"(",
"usuario_os",
"=",
"usuario",
",",
"dt_agenda__gt",
"=",
"data_atual",
")",
".",
"order_by",
"(",
"'-dt_atualizada'",
")",
"paginator",
"=",
"Paginator",
"(",
"ordem_servico_list",
",",
"10",
")",
"page",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'page'",
")",
"ordem_servico",
"=",
"paginator",
".",
"get_page",
"(",
"page",
")",
"dados",
"=",
"{",
"\"ordem_servicos\"",
":",
"ordem_servico",
"}",
"else",
":",
"raise",
"Http404",
"(",
")",
"return",
"render",
"(",
"request",
",",
"\"devsys-ordem-servicos.html\"",
",",
"dados",
")"
] | [
188,
0
] | [
231,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
login | (request) | return render(request, 'usuarios/login.html') | Faz o login do usuário no sistema | Faz o login do usuário no sistema | def login(request):
"""Faz o login do usuário no sistema"""
if request.method == 'POST':
email = request.POST['email']
senha = request.POST['senha']
if campo_vazio(email) or campo_vazio(senha):
messages.error(request, 'Os campos devem ser preenchidos')
return redirect('login')
if User.objects.filter(email=email).exists():
# filtrando o username a partir do e-mail
nome = User.objects.filter(email=email).values_list('username', flat=True).get()
user = auth.authenticate(request, username=nome, password=senha)
# fazendo a autenticação do usuário e senha
if user is not None:
auth.login(request, user)
print('Login realizado com sucesso')
return redirect('dashboard')
return render(request, 'usuarios/login.html') | [
"def",
"login",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"'POST'",
":",
"email",
"=",
"request",
".",
"POST",
"[",
"'email'",
"]",
"senha",
"=",
"request",
".",
"POST",
"[",
"'senha'",
"]",
"if",
"campo_vazio",
"(",
"email",
")",
"or",
"campo_vazio",
"(",
"senha",
")",
":",
"messages",
".",
"error",
"(",
"request",
",",
"'Os campos devem ser preenchidos'",
")",
"return",
"redirect",
"(",
"'login'",
")",
"if",
"User",
".",
"objects",
".",
"filter",
"(",
"email",
"=",
"email",
")",
".",
"exists",
"(",
")",
":",
"# filtrando o username a partir do e-mail",
"nome",
"=",
"User",
".",
"objects",
".",
"filter",
"(",
"email",
"=",
"email",
")",
".",
"values_list",
"(",
"'username'",
",",
"flat",
"=",
"True",
")",
".",
"get",
"(",
")",
"user",
"=",
"auth",
".",
"authenticate",
"(",
"request",
",",
"username",
"=",
"nome",
",",
"password",
"=",
"senha",
")",
"# fazendo a autenticação do usuário e senha",
"if",
"user",
"is",
"not",
"None",
":",
"auth",
".",
"login",
"(",
"request",
",",
"user",
")",
"print",
"(",
"'Login realizado com sucesso'",
")",
"return",
"redirect",
"(",
"'dashboard'",
")",
"return",
"render",
"(",
"request",
",",
"'usuarios/login.html'",
")"
] | [
37,
0
] | [
54,
49
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
distribute_city_council_objects_to_sync | (payload) | Recebe o payload e dispara uma task para cada registro.
O webservice da Câmara retorna uma lista de ações (inserção,
atualização e deleção) e os registros que sofreram cada uma
delas. Essa task executa cada uma de maneira separada para que,
caso tenham algum erro, possam ser tratados de maneira separada.
| Recebe o payload e dispara uma task para cada registro. | def distribute_city_council_objects_to_sync(payload):
"""Recebe o payload e dispara uma task para cada registro.
O webservice da Câmara retorna uma lista de ações (inserção,
atualização e deleção) e os registros que sofreram cada uma
delas. Essa task executa cada uma de maneira separada para que,
caso tenham algum erro, possam ser tratados de maneira separada.
"""
action_methods = {
"inclusoesContrato": add_citycouncil_contract,
"alteracoesContrato": update_citycouncil_contract,
"exclusoesContrato": remove_citycouncil_contract,
"inclusoesLicitacao": add_citycouncil_bid,
"alteracoesLicitacao": update_citycouncil_bid,
"exclusoesLicitacao": remove_citycouncil_bid,
"inclusoesReceita": add_citycouncil_revenue,
"alteracoesReceita": update_citycouncil_revenue,
"exclusoesReceita": remove_citycouncil_revenue,
"inclusoesDespesa": add_citycouncil_expense,
"alteracoesDespesa": update_citycouncil_expense,
"exclusoesDespesa": remove_citycouncil_expense,
}
for action_name, records in payload.items():
info(f"{action_name}: {len(records)} registros")
task = action_methods.get(action_name)
if action_name.startswith("exclusoes"):
task.delay(records)
else:
for record in records:
task.delay(record) | [
"def",
"distribute_city_council_objects_to_sync",
"(",
"payload",
")",
":",
"action_methods",
"=",
"{",
"\"inclusoesContrato\"",
":",
"add_citycouncil_contract",
",",
"\"alteracoesContrato\"",
":",
"update_citycouncil_contract",
",",
"\"exclusoesContrato\"",
":",
"remove_citycouncil_contract",
",",
"\"inclusoesLicitacao\"",
":",
"add_citycouncil_bid",
",",
"\"alteracoesLicitacao\"",
":",
"update_citycouncil_bid",
",",
"\"exclusoesLicitacao\"",
":",
"remove_citycouncil_bid",
",",
"\"inclusoesReceita\"",
":",
"add_citycouncil_revenue",
",",
"\"alteracoesReceita\"",
":",
"update_citycouncil_revenue",
",",
"\"exclusoesReceita\"",
":",
"remove_citycouncil_revenue",
",",
"\"inclusoesDespesa\"",
":",
"add_citycouncil_expense",
",",
"\"alteracoesDespesa\"",
":",
"update_citycouncil_expense",
",",
"\"exclusoesDespesa\"",
":",
"remove_citycouncil_expense",
",",
"}",
"for",
"action_name",
",",
"records",
"in",
"payload",
".",
"items",
"(",
")",
":",
"info",
"(",
"f\"{action_name}: {len(records)} registros\"",
")",
"task",
"=",
"action_methods",
".",
"get",
"(",
"action_name",
")",
"if",
"action_name",
".",
"startswith",
"(",
"\"exclusoes\"",
")",
":",
"task",
".",
"delay",
"(",
"records",
")",
"else",
":",
"for",
"record",
"in",
"records",
":",
"task",
".",
"delay",
"(",
"record",
")"
] | [
126,
0
] | [
155,
34
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
MeuJogador.faz_previsao | (self, data) | return self.accuracy[centro_min] | Funcao recebe os dados e, com base no cluster de centroid mais proximo, devolve o cluster a qual aquele dado povavelemte esta e, utilizando dessa informacao, retorna a probabilidade de aquele cluster possuir "c", que depois sera usado como parametro para decisao de jogada. | Funcao recebe os dados e, com base no cluster de centroid mais proximo, devolve o cluster a qual aquele dado povavelemte esta e, utilizando dessa informacao, retorna a probabilidade de aquele cluster possuir "c", que depois sera usado como parametro para decisao de jogada. | def faz_previsao(self, data):
"""Funcao recebe os dados e, com base no cluster de centroid mais proximo, devolve o cluster a qual aquele dado povavelemte esta e, utilizando dessa informacao, retorna a probabilidade de aquele cluster possuir "c", que depois sera usado como parametro para decisao de jogada."""
distancia = 10000000000000000000000
centro_min = 0
#procura o cluster de centroide a menor distancia
for centro in range(len(self.centros)):
erro = self.centros[centro] - data
if erro.dot(erro) < distancia:
distancia = erro.dot(erro)
centro_min = centro
#retorna a probabilidade estimada de aqueles valores especificos de input retornarem "c"
return self.accuracy[centro_min] | [
"def",
"faz_previsao",
"(",
"self",
",",
"data",
")",
":",
"distancia",
"=",
"10000000000000000000000",
"centro_min",
"=",
"0",
"#procura o cluster de centroide a menor distancia",
"for",
"centro",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"centros",
")",
")",
":",
"erro",
"=",
"self",
".",
"centros",
"[",
"centro",
"]",
"-",
"data",
"if",
"erro",
".",
"dot",
"(",
"erro",
")",
"<",
"distancia",
":",
"distancia",
"=",
"erro",
".",
"dot",
"(",
"erro",
")",
"centro_min",
"=",
"centro",
"#retorna a probabilidade estimada de aqueles valores especificos de input retornarem \"c\"",
"return",
"self",
".",
"accuracy",
"[",
"centro_min",
"]"
] | [
2128,
4
] | [
2139,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
ship_hit | (ai_settings, screen, stats, sb, ship, aliens, bullets) | Responde ao fato de a espaçonave ter sido atingida por um alienigena | Responde ao fato de a espaçonave ter sido atingida por um alienigena | def ship_hit(ai_settings, screen, stats, sb, ship, aliens, bullets):
"""Responde ao fato de a espaçonave ter sido atingida por um alienigena"""
if stats.ships_left > 1:
# Decrementa ships_left
stats.ships_left -= 1
# Atualiza o painel de pontuações
sb.prep_ships()
stats.score -= ai_settings.alien_points * (36 - len(aliens))
sb.prep_score()
# Esvazia a lista de aliens 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()
# Toca o som de explosão da nave
explotion_sound = pygame.mixer.Sound('Sounds/explosion.wav')
pygame.mixer.Sound.set_volume(explotion_sound, 0.1)
explotion_sound.play()
# Faz uma pausa
sleep(0.5)
else:
stats.game_active = False
stats.game_over = True | [
"def",
"ship_hit",
"(",
"ai_settings",
",",
"screen",
",",
"stats",
",",
"sb",
",",
"ship",
",",
"aliens",
",",
"bullets",
")",
":",
"if",
"stats",
".",
"ships_left",
">",
"1",
":",
"# Decrementa ships_left",
"stats",
".",
"ships_left",
"-=",
"1",
"# Atualiza o painel de pontuações",
"sb",
".",
"prep_ships",
"(",
")",
"stats",
".",
"score",
"-=",
"ai_settings",
".",
"alien_points",
"*",
"(",
"36",
"-",
"len",
"(",
"aliens",
")",
")",
"sb",
".",
"prep_score",
"(",
")",
"# Esvazia a lista de aliens 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",
"(",
")",
"# Toca o som de explosão da nave",
"explotion_sound",
"=",
"pygame",
".",
"mixer",
".",
"Sound",
"(",
"'Sounds/explosion.wav'",
")",
"pygame",
".",
"mixer",
".",
"Sound",
".",
"set_volume",
"(",
"explotion_sound",
",",
"0.1",
")",
"explotion_sound",
".",
"play",
"(",
")",
"# Faz uma pausa",
"sleep",
"(",
"0.5",
")",
"else",
":",
"stats",
".",
"game_active",
"=",
"False",
"stats",
".",
"game_over",
"=",
"True"
] | [
262,
0
] | [
291,
30
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
OverlapCommunity.salvar_compartilhados | (self, lista) | Salva comunidades compartilhadas | Salva comunidades compartilhadas | def salvar_compartilhados(self, lista):
"""Salva comunidades compartilhadas"""
arq = open(
"elementos_compartilhados_"
+ self.nome_arq_sementes
+ "_"
+ self.nome_rede.split(".")[0]
+ ".txt",
'w',
)
arq.write(str(lista) + ";")
print("elementos compartilhados salvos!!")
arq.close() | [
"def",
"salvar_compartilhados",
"(",
"self",
",",
"lista",
")",
":",
"arq",
"=",
"open",
"(",
"\"elementos_compartilhados_\"",
"+",
"self",
".",
"nome_arq_sementes",
"+",
"\"_\"",
"+",
"self",
".",
"nome_rede",
".",
"split",
"(",
"\".\"",
")",
"[",
"0",
"]",
"+",
"\".txt\"",
",",
"'w'",
",",
")",
"arq",
".",
"write",
"(",
"str",
"(",
"lista",
")",
"+",
"\";\"",
")",
"print",
"(",
"\"elementos compartilhados salvos!!\"",
")",
"arq",
".",
"close",
"(",
")"
] | [
329,
4
] | [
341,
19
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Utilitario.ser_util | (self) | Método da classe utilitária
`Returns`: proprieade
| Método da classe utilitária | def ser_util(self):
'''Método da classe utilitária
`Returns`: proprieade
'''
print(self.__propriedade) | [
"def",
"ser_util",
"(",
"self",
")",
":",
"print",
"(",
"self",
".",
"__propriedade",
")"
] | [
8,
4
] | [
13,
33
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
faz_grafico | (nome_arquivo, tipo_componente=None) | Faz o gráfico com os componentes obrigatórios ou eletivos. | Faz o gráfico com os componentes obrigatórios ou eletivos. | def faz_grafico(nome_arquivo, tipo_componente=None):
"""Faz o gráfico com os componentes obrigatórios ou eletivos."""
integralizacao = Digraph(name=OPTIONS['digraph_name'],
comment=OPTIONS['comment'],
filename=nome_arquivo,
directory=OPTIONS['directory'],
format=OPTIONS['format'],
engine=OPTIONS['engine'],
encoding=OPTIONS['encoding'],
graph_attr=OPTIONS['graph_attr'],
node_attr=OPTIONS['node_attr'],
edge_attr=OPTIONS['edge_attr'],
body=OPTIONS['body'],
strict=OPTIONS['strict'])
componentes_todos = load("./_data/componentes-curriculares")
componentes_selecionados = seleciona_componentes(componentes_todos,
tipo_componente)
# calcula o maior semestre do curso para fazer a clusterização do gráfico.
max_semestres = 0
for componente in componentes_selecionados:
max_semestres = max(max_semestres,
componente['curso'].get('semestre', -1))
# semestre['i'] guarda as componentes do i-esimo semestre.
semestre = {}
for x in range(1, max_semestres + 1):
semestre[str(x) + "º Semestre"] = [
componente for componente in componentes_selecionados
if componente['curso'].get('semestre') == x
]
semestre['Nenhum'] = [
componente for componente in componentes_selecionados
if componente['curso'].get('semestre') == None
]
# adiciona os nós das componentes de cada semestre.
for nome, componentes in semestre.items():
with integralizacao.subgraph(name='cluster_' + str(nome)) as c:
c.attr(pencolor='black', style='rounded', label=nome, tooltip=nome)
for componente in componentes:
c.node(componente['codigo'],
label=componente['codigo'],
href='../../curso/componentes/' +
componente['codigo'].lower() + '.html',
tooltip=componente['nome'])
# adiciona as arestas entre os pre-requisitos e seus componentes.
pre_requisitos = pares_prerequisitos(componentes_selecionados)
edges = []
for prereq, componente in pre_requisitos:
edges.append((prereq['codigo'], componente['codigo']))
integralizacao.edges(edges)
integralizacao.render() | [
"def",
"faz_grafico",
"(",
"nome_arquivo",
",",
"tipo_componente",
"=",
"None",
")",
":",
"integralizacao",
"=",
"Digraph",
"(",
"name",
"=",
"OPTIONS",
"[",
"'digraph_name'",
"]",
",",
"comment",
"=",
"OPTIONS",
"[",
"'comment'",
"]",
",",
"filename",
"=",
"nome_arquivo",
",",
"directory",
"=",
"OPTIONS",
"[",
"'directory'",
"]",
",",
"format",
"=",
"OPTIONS",
"[",
"'format'",
"]",
",",
"engine",
"=",
"OPTIONS",
"[",
"'engine'",
"]",
",",
"encoding",
"=",
"OPTIONS",
"[",
"'encoding'",
"]",
",",
"graph_attr",
"=",
"OPTIONS",
"[",
"'graph_attr'",
"]",
",",
"node_attr",
"=",
"OPTIONS",
"[",
"'node_attr'",
"]",
",",
"edge_attr",
"=",
"OPTIONS",
"[",
"'edge_attr'",
"]",
",",
"body",
"=",
"OPTIONS",
"[",
"'body'",
"]",
",",
"strict",
"=",
"OPTIONS",
"[",
"'strict'",
"]",
")",
"componentes_todos",
"=",
"load",
"(",
"\"./_data/componentes-curriculares\"",
")",
"componentes_selecionados",
"=",
"seleciona_componentes",
"(",
"componentes_todos",
",",
"tipo_componente",
")",
"# calcula o maior semestre do curso para fazer a clusterização do gráfico.",
"max_semestres",
"=",
"0",
"for",
"componente",
"in",
"componentes_selecionados",
":",
"max_semestres",
"=",
"max",
"(",
"max_semestres",
",",
"componente",
"[",
"'curso'",
"]",
".",
"get",
"(",
"'semestre'",
",",
"-",
"1",
")",
")",
"# semestre['i'] guarda as componentes do i-esimo semestre.",
"semestre",
"=",
"{",
"}",
"for",
"x",
"in",
"range",
"(",
"1",
",",
"max_semestres",
"+",
"1",
")",
":",
"semestre",
"[",
"str",
"(",
"x",
")",
"+",
"\"º Semestre\"]",
" ",
" ",
"",
"componente",
"for",
"componente",
"in",
"componentes_selecionados",
"if",
"componente",
"[",
"'curso'",
"]",
".",
"get",
"(",
"'semestre'",
")",
"==",
"x",
"]",
"semestre",
"[",
"'Nenhum'",
"]",
"=",
"[",
"componente",
"for",
"componente",
"in",
"componentes_selecionados",
"if",
"componente",
"[",
"'curso'",
"]",
".",
"get",
"(",
"'semestre'",
")",
"==",
"None",
"]",
"# adiciona os nós das componentes de cada semestre.",
"for",
"nome",
",",
"componentes",
"in",
"semestre",
".",
"items",
"(",
")",
":",
"with",
"integralizacao",
".",
"subgraph",
"(",
"name",
"=",
"'cluster_'",
"+",
"str",
"(",
"nome",
")",
")",
"as",
"c",
":",
"c",
".",
"attr",
"(",
"pencolor",
"=",
"'black'",
",",
"style",
"=",
"'rounded'",
",",
"label",
"=",
"nome",
",",
"tooltip",
"=",
"nome",
")",
"for",
"componente",
"in",
"componentes",
":",
"c",
".",
"node",
"(",
"componente",
"[",
"'codigo'",
"]",
",",
"label",
"=",
"componente",
"[",
"'codigo'",
"]",
",",
"href",
"=",
"'../../curso/componentes/'",
"+",
"componente",
"[",
"'codigo'",
"]",
".",
"lower",
"(",
")",
"+",
"'.html'",
",",
"tooltip",
"=",
"componente",
"[",
"'nome'",
"]",
")",
"# adiciona as arestas entre os pre-requisitos e seus componentes.",
"pre_requisitos",
"=",
"pares_prerequisitos",
"(",
"componentes_selecionados",
")",
"edges",
"=",
"[",
"]",
"for",
"prereq",
",",
"componente",
"in",
"pre_requisitos",
":",
"edges",
".",
"append",
"(",
"(",
"prereq",
"[",
"'codigo'",
"]",
",",
"componente",
"[",
"'codigo'",
"]",
")",
")",
"integralizacao",
".",
"edges",
"(",
"edges",
")",
"integralizacao",
".",
"render",
"(",
")"
] | [
80,
0
] | [
133,
27
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
set_proc_cpu | (*args) | Define em qual CPU o processo deve ser executado.
Parâmetros:
cpus: list com os índices das cpus nas quais se deseja que o processo
seja executado.
Exceptions:
NoSuchProcess: quando o processo referente ao pid não é
encontrado. | Define em qual CPU o processo deve ser executado. | def set_proc_cpu(*args):
""" Define em qual CPU o processo deve ser executado.
Parâmetros:
cpus: list com os índices das cpus nas quais se deseja que o processo
seja executado.
Exceptions:
NoSuchProcess: quando o processo referente ao pid não é
encontrado. """
cpus = [int(i) - 1 for i in cpu_list.get().split(',')]
print(cpus)
pid = get_current_process()
p = psutil.Process(pid)
p.cpu_affinity(cpus) | [
"def",
"set_proc_cpu",
"(",
"*",
"args",
")",
":",
"cpus",
"=",
"[",
"int",
"(",
"i",
")",
"-",
"1",
"for",
"i",
"in",
"cpu_list",
".",
"get",
"(",
")",
".",
"split",
"(",
"','",
")",
"]",
"print",
"(",
"cpus",
")",
"pid",
"=",
"get_current_process",
"(",
")",
"p",
"=",
"psutil",
".",
"Process",
"(",
"pid",
")",
"p",
".",
"cpu_affinity",
"(",
"cpus",
")"
] | [
89,
0
] | [
105,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Cliente.__str__ | (self) | return self.nome | Retorna a representação textual do cliente | Retorna a representação textual do cliente | def __str__(self) -> str:
"""Retorna a representação textual do cliente"""
return self.nome | [
"def",
"__str__",
"(",
"self",
")",
"->",
"str",
":",
"return",
"self",
".",
"nome"
] | [
27,
4
] | [
29,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Callback.enable | (self) | Reativa o monitoramento do descritor neste callback | Reativa o monitoramento do descritor neste callback | def enable(self):
'Reativa o monitoramento do descritor neste callback'
self._enabled = True | [
"def",
"enable",
"(",
"self",
")",
":",
"self",
".",
"_enabled",
"=",
"True"
] | [
62,
4
] | [
64,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
main | () | Classe principal, que reconhece as ações de movimentação
e interação do jogador
| Classe principal, que reconhece as ações de movimentação
e interação do jogador
| def main():
''' Classe principal, que reconhece as ações de movimentação
e interação do jogador
'''
inventory, inventory2, scenario = init()
# list all available actions
available_actions = {
'sair': 'Sai do jogo',
'ajuda': 'Mostra os comandos possíveis',
'inventario ou inv': 'Abre inventario',
'direita ou dir': 'Vai para a sala da direita',
'esquerda ou esq': 'Vai para a sala da esquerda',
'interagir ou int': 'Interage com moveis da sala',
'olhar': 'Dá descrição de itens e móveis'
}
room = scenario.head
print(room)
while True:
# pede ação ao jogador
action = input("\nInsira uma ação: \n>>>").lower()
# sai do jogo
if action == 'sair':
break
# mostra a ajuda
elif action == 'ajuda':
for key, value in available_actions.items():
print("%s: %s" % (key, value))
elif action == 'inventario' or action == "inv":
print(inventory)
#elif action == 'inventario2':
#print(inventory2)
## Ações de movimentação
elif action == 'direita' or action == "dir":
room = room.gonext()
elif action == 'esquerda' or action == "esq":
room = room.goprev()
# interação com os elementos
elif 'interagir' in action or 'int' in action:
try:
print(room)
# get the desired furniture
movel = action.split()[1]
resp = room.data.get_furniture(movel).play(inventory, inventory2)
if movel == 'bote' and resp:
print("Parabens, você conseguiu sair do navio!!")
print('Fim de jogo, muito obrigado por jogar!')
break
if resp:
# add item to the player inventory
inventory.add(resp)
except:
print('Comando invalido')
# ação de olhar
elif 'olhar' in action:
print(room)
objeto_para_olhar = action.split()
if len(objeto_para_olhar) == 2:
try:
objeto_para_olhar = objeto_para_olhar[1]
# se o objeto para olhar é o ambiente
ambiente_atual = room.data.name.lower()
if objeto_para_olhar == ambiente_atual:
print(room.data.descricao)
# se o objeto para olhar é um item do inventário
elif inventory.check(objeto_para_olhar):
for item in inventory.itens:
if item.name == objeto_para_olhar:
print(item.message)
# se o objeto para olhar é um móvel
else:
movel = room.data.get_furniture(objeto_para_olhar)
movel.olhar()
except:
print('Objeto inválido')
else:
print("Comando inválido")
else:
print('Interação inválida\n') | [
"def",
"main",
"(",
")",
":",
"inventory",
",",
"inventory2",
",",
"scenario",
"=",
"init",
"(",
")",
"# list all available actions",
"available_actions",
"=",
"{",
"'sair'",
":",
"'Sai do jogo'",
",",
"'ajuda'",
":",
"'Mostra os comandos possíveis',",
"",
"'inventario ou inv'",
":",
"'Abre inventario'",
",",
"'direita ou dir'",
":",
"'Vai para a sala da direita'",
",",
"'esquerda ou esq'",
":",
"'Vai para a sala da esquerda'",
",",
"'interagir ou int'",
":",
"'Interage com moveis da sala'",
",",
"'olhar'",
":",
"'Dá descrição de itens e móveis'",
"}",
"room",
"=",
"scenario",
".",
"head",
"print",
"(",
"room",
")",
"while",
"True",
":",
"# pede ação ao jogador",
"action",
"=",
"input",
"(",
"\"\\nInsira uma ação: \\n>>>\").",
"l",
"o",
"wer()",
"",
"",
"# sai do jogo",
"if",
"action",
"==",
"'sair'",
":",
"break",
"# mostra a ajuda",
"elif",
"action",
"==",
"'ajuda'",
":",
"for",
"key",
",",
"value",
"in",
"available_actions",
".",
"items",
"(",
")",
":",
"print",
"(",
"\"%s: %s\"",
"%",
"(",
"key",
",",
"value",
")",
")",
"elif",
"action",
"==",
"'inventario'",
"or",
"action",
"==",
"\"inv\"",
":",
"print",
"(",
"inventory",
")",
"#elif action == 'inventario2': ",
"#print(inventory2)",
"## Ações de movimentação",
"elif",
"action",
"==",
"'direita'",
"or",
"action",
"==",
"\"dir\"",
":",
"room",
"=",
"room",
".",
"gonext",
"(",
")",
"elif",
"action",
"==",
"'esquerda'",
"or",
"action",
"==",
"\"esq\"",
":",
"room",
"=",
"room",
".",
"goprev",
"(",
")",
"# interação com os elementos",
"elif",
"'interagir'",
"in",
"action",
"or",
"'int'",
"in",
"action",
":",
"try",
":",
"print",
"(",
"room",
")",
"# get the desired furniture",
"movel",
"=",
"action",
".",
"split",
"(",
")",
"[",
"1",
"]",
"resp",
"=",
"room",
".",
"data",
".",
"get_furniture",
"(",
"movel",
")",
".",
"play",
"(",
"inventory",
",",
"inventory2",
")",
"if",
"movel",
"==",
"'bote'",
"and",
"resp",
":",
"print",
"(",
"\"Parabens, você conseguiu sair do navio!!\")",
"",
"print",
"(",
"'Fim de jogo, muito obrigado por jogar!'",
")",
"break",
"if",
"resp",
":",
"# add item to the player inventory",
"inventory",
".",
"add",
"(",
"resp",
")",
"except",
":",
"print",
"(",
"'Comando invalido'",
")",
"# ação de olhar",
"elif",
"'olhar'",
"in",
"action",
":",
"print",
"(",
"room",
")",
"objeto_para_olhar",
"=",
"action",
".",
"split",
"(",
")",
"if",
"len",
"(",
"objeto_para_olhar",
")",
"==",
"2",
":",
"try",
":",
"objeto_para_olhar",
"=",
"objeto_para_olhar",
"[",
"1",
"]",
"# se o objeto para olhar é o ambiente",
"ambiente_atual",
"=",
"room",
".",
"data",
".",
"name",
".",
"lower",
"(",
")",
"if",
"objeto_para_olhar",
"==",
"ambiente_atual",
":",
"print",
"(",
"room",
".",
"data",
".",
"descricao",
")",
"# se o objeto para olhar é um item do inventário",
"elif",
"inventory",
".",
"check",
"(",
"objeto_para_olhar",
")",
":",
"for",
"item",
"in",
"inventory",
".",
"itens",
":",
"if",
"item",
".",
"name",
"==",
"objeto_para_olhar",
":",
"print",
"(",
"item",
".",
"message",
")",
"# se o objeto para olhar é um móvel",
"else",
":",
"movel",
"=",
"room",
".",
"data",
".",
"get_furniture",
"(",
"objeto_para_olhar",
")",
"movel",
".",
"olhar",
"(",
")",
"except",
":",
"print",
"(",
"'Objeto inválido')",
"",
"else",
":",
"print",
"(",
"\"Comando inválido\")",
"",
"else",
":",
"print",
"(",
"'Interação inválida\\n')",
""
] | [
5,
0
] | [
101,
44
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
AtorTestes.assert_colisao_atores_ativos | (self, ator, ator2, intervalo=1) | Se certifica que há colisão entre atores ativos | Se certifica que há colisão entre atores ativos | def assert_colisao_atores_ativos(self, ator, ator2, intervalo=1):
'Se certifica que há colisão entre atores ativos'
tempo_da_colisao = 2
# Conferindo status dos dois atores antes da colisão
self.assertEqual(ator.status(tempo_da_colisao), ATIVO, 'Status deveria ser ativo antes da colisão')
self.assertEqual(ator2.status(tempo_da_colisao), ATIVO, 'Status deveria ser ativo antes da colisão')
ator.colidir(ator2, tempo_da_colisao, intervalo)
# Conferindo status dos dois atores depois da colisão
self.assertEqual(ator2.status(tempo_da_colisao), DESTRUIDO, 'Status deveria ser destruido depois da colisão')
self.assertEqual(ator.status(tempo_da_colisao), DESTRUIDO, 'Status deveria ser destruido depois da colisão') | [
"def",
"assert_colisao_atores_ativos",
"(",
"self",
",",
"ator",
",",
"ator2",
",",
"intervalo",
"=",
"1",
")",
":",
"tempo_da_colisao",
"=",
"2",
"# Conferindo status dos dois atores antes da colisão",
"self",
".",
"assertEqual",
"(",
"ator",
".",
"status",
"(",
"tempo_da_colisao",
")",
",",
"ATIVO",
",",
"'Status deveria ser ativo antes da colisão')",
"",
"self",
".",
"assertEqual",
"(",
"ator2",
".",
"status",
"(",
"tempo_da_colisao",
")",
",",
"ATIVO",
",",
"'Status deveria ser ativo antes da colisão')",
"",
"ator",
".",
"colidir",
"(",
"ator2",
",",
"tempo_da_colisao",
",",
"intervalo",
")",
"# Conferindo status dos dois atores depois da colisão",
"self",
".",
"assertEqual",
"(",
"ator2",
".",
"status",
"(",
"tempo_da_colisao",
")",
",",
"DESTRUIDO",
",",
"'Status deveria ser destruido depois da colisão')",
"",
"self",
".",
"assertEqual",
"(",
"ator",
".",
"status",
"(",
"tempo_da_colisao",
")",
",",
"DESTRUIDO",
",",
"'Status deveria ser destruido depois da colisão')",
""
] | [
113,
4
] | [
122,
117
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Fun.text | self, ctx): | Faz um textão do tamanho do pinto do João. | Faz um textão do tamanho do pinto do João. | async def textão(self, ctx):
"""Faz um textão do tamanho do pinto do João."""
with ctx.typing():
await asyncio.sleep(120)
await ctx.channel.send("lacrei manas")
try:
await ctx.message.delete()
except discord.NotFound:
pass | [
"async",
"def",
"text",
"ão",
"(",
"s",
"elf,",
" ",
"tx)",
":",
"\r",
"with",
"ctx",
".",
"typing",
"(",
")",
":",
"await",
"asyncio",
".",
"sleep",
"(",
"120",
")",
"await",
"ctx",
".",
"channel",
".",
"send",
"(",
"\"lacrei manas\"",
")",
"try",
":",
"await",
"ctx",
".",
"message",
".",
"delete",
"(",
")",
"except",
"discord",
".",
"NotFound",
":",
"pass"
] | [
285,
4
] | [
293,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
DType63.ndata | (self) | return bin2int(self.data[BYTES_63[21]]) | F21 - O número de canais (ou "steps") que dividem igualmente a largura de banda | F21 - O número de canais (ou "steps") que dividem igualmente a largura de banda | def ndata(self) -> int:
"""F21 - O número de canais (ou "steps") que dividem igualmente a largura de banda"""
return bin2int(self.data[BYTES_63[21]]) | [
"def",
"ndata",
"(",
"self",
")",
"->",
"int",
":",
"return",
"bin2int",
"(",
"self",
".",
"data",
"[",
"BYTES_63",
"[",
"21",
"]",
"]",
")"
] | [
1122,
4
] | [
1124,
47
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Classroom.plot_tree | (self, Cenario, Estagios, Aberturas, Nome_Arq) | Gera um pdf com estágios e aberturas.
Keyword arguments:
Cenario -- Especifique o cenario de afluencia a ser utilizado no primeiro estagio
Estagios -- Especifique a profundidade da árvore, ou seja, quantas camadas terá a árvore
Aberturas -- Especifique o número aberturas para cada nó
Nome_Arq -- Especifique o Nome do arquivo de saída
| Gera um pdf com estágios e aberturas. | def plot_tree(self, Cenario, Estagios, Aberturas, Nome_Arq):
"""Gera um pdf com estágios e aberturas.
Keyword arguments:
Cenario -- Especifique o cenario de afluencia a ser utilizado no primeiro estagio
Estagios -- Especifique a profundidade da árvore, ou seja, quantas camadas terá a árvore
Aberturas -- Especifique o número aberturas para cada nó
Nome_Arq -- Especifique o Nome do arquivo de saída
"""
if Aberturas > self.sistema["DGer"]["Nr_Cen"]:
print ("Número de Cenários Menor que Número de Aberturas")
print ("Método plot_tree interrompido!")
return
if Cenario > self.sistema["DGer"]["Nr_Cen"]:
print ("Cenario escolhido superior ao Número de Cenários disponíveis")
print ("Método plot_tree interrompido!")
return
if Estagios > self.sistema["DGer"]["Nr_Est"]:
print ("Número de Estágios Superior aos dados informados no problema.")
print("Método plot_tree interrompido!")
return
def cria_tree(lista, CasoEstudo, Aberturas, Estagios):
estagio = lista[-1]["Estagio"] + 1
anterior = lista[-1]["Ordem"]
if estagio == Estagios:
return
for icen in range(Aberturas):
elemento = { "Anterior": anterior,
"Estagio": estagio,
"Afluencia": CasoEstudo.sistema["UHE"][0]["Afl"][estagio][icen],
"Ordem": len(lista),
}
lista.append(elemento)
cria_tree(lista, CasoEstudo, Aberturas, Estagios)
estagio = 0
elemento = {
"Anterior" : None,
"Estagio" : 0,
"Afluencia" : self.sistema["UHE"][0]["Afl"][estagio][0],
"Ordem" : 0,
}
lista = []
lista.append(elemento)
cria_tree(lista, self, Aberturas, Estagios)
g = Digraph('G', filename=Nome_Arq)
for elemento in lista:
if (elemento["Anterior"] != None):
probabilidade = 100/(Aberturas**elemento["Estagio"])
g.edge(str(elemento["Anterior"]), str(elemento["Ordem"]),
label=str(round(probabilidade,2))+'%')
for elemento in lista:
g.node(str(elemento["Ordem"]),label= " Afl: "+ str(elemento["Afluencia"]))
g.node("0", style="filled", fillcolor="green")
for iest in range(self.sistema["DGer"]["Nr_Est"]):
if (iest%2) == 0:
Cor = 'red'
Preenche = 'green:cyan'
else:
Cor = 'red'
Preenche = 'lightblue:cyan'
with g.subgraph(name='cluster'+str(iest+1)) as c:
c.attr(fillcolor=Preenche,
label='Estágio '+str(iest+1),
fontcolor=Cor,
style='filled',
gradientangle='270')
c.attr('node',
shape='box',
fillcolor='red:yellow',
style='filled',
gradientangle='90')
for elemento in lista:
if elemento["Estagio"]==iest:
c.node(str(elemento["Ordem"]))
g.attr("graph",pad="0.5", nodesep="1", ranksep="2")
g.view() | [
"def",
"plot_tree",
"(",
"self",
",",
"Cenario",
",",
"Estagios",
",",
"Aberturas",
",",
"Nome_Arq",
")",
":",
"if",
"Aberturas",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Cen\"",
"]",
":",
"print",
"(",
"\"Número de Cenários Menor que Número de Aberturas\")",
"",
"print",
"(",
"\"Método plot_tree interrompido!\")",
"",
"return",
"if",
"Cenario",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Cen\"",
"]",
":",
"print",
"(",
"\"Cenario escolhido superior ao Número de Cenários disponíveis\")",
"",
"print",
"(",
"\"Método plot_tree interrompido!\")",
"",
"return",
"if",
"Estagios",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Est\"",
"]",
":",
"print",
"(",
"\"Número de Estágios Superior aos dados informados no problema.\")",
"",
"print",
"(",
"\"Método plot_tree interrompido!\")",
"",
"return",
"def",
"cria_tree",
"(",
"lista",
",",
"CasoEstudo",
",",
"Aberturas",
",",
"Estagios",
")",
":",
"estagio",
"=",
"lista",
"[",
"-",
"1",
"]",
"[",
"\"Estagio\"",
"]",
"+",
"1",
"anterior",
"=",
"lista",
"[",
"-",
"1",
"]",
"[",
"\"Ordem\"",
"]",
"if",
"estagio",
"==",
"Estagios",
":",
"return",
"for",
"icen",
"in",
"range",
"(",
"Aberturas",
")",
":",
"elemento",
"=",
"{",
"\"Anterior\"",
":",
"anterior",
",",
"\"Estagio\"",
":",
"estagio",
",",
"\"Afluencia\"",
":",
"CasoEstudo",
".",
"sistema",
"[",
"\"UHE\"",
"]",
"[",
"0",
"]",
"[",
"\"Afl\"",
"]",
"[",
"estagio",
"]",
"[",
"icen",
"]",
",",
"\"Ordem\"",
":",
"len",
"(",
"lista",
")",
",",
"}",
"lista",
".",
"append",
"(",
"elemento",
")",
"cria_tree",
"(",
"lista",
",",
"CasoEstudo",
",",
"Aberturas",
",",
"Estagios",
")",
"estagio",
"=",
"0",
"elemento",
"=",
"{",
"\"Anterior\"",
":",
"None",
",",
"\"Estagio\"",
":",
"0",
",",
"\"Afluencia\"",
":",
"self",
".",
"sistema",
"[",
"\"UHE\"",
"]",
"[",
"0",
"]",
"[",
"\"Afl\"",
"]",
"[",
"estagio",
"]",
"[",
"0",
"]",
",",
"\"Ordem\"",
":",
"0",
",",
"}",
"lista",
"=",
"[",
"]",
"lista",
".",
"append",
"(",
"elemento",
")",
"cria_tree",
"(",
"lista",
",",
"self",
",",
"Aberturas",
",",
"Estagios",
")",
"g",
"=",
"Digraph",
"(",
"'G'",
",",
"filename",
"=",
"Nome_Arq",
")",
"for",
"elemento",
"in",
"lista",
":",
"if",
"(",
"elemento",
"[",
"\"Anterior\"",
"]",
"!=",
"None",
")",
":",
"probabilidade",
"=",
"100",
"/",
"(",
"Aberturas",
"**",
"elemento",
"[",
"\"Estagio\"",
"]",
")",
"g",
".",
"edge",
"(",
"str",
"(",
"elemento",
"[",
"\"Anterior\"",
"]",
")",
",",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
",",
"label",
"=",
"str",
"(",
"round",
"(",
"probabilidade",
",",
"2",
")",
")",
"+",
"'%'",
")",
"for",
"elemento",
"in",
"lista",
":",
"g",
".",
"node",
"(",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
",",
"label",
"=",
"\" Afl: \"",
"+",
"str",
"(",
"elemento",
"[",
"\"Afluencia\"",
"]",
")",
")",
"g",
".",
"node",
"(",
"\"0\"",
",",
"style",
"=",
"\"filled\"",
",",
"fillcolor",
"=",
"\"green\"",
")",
"for",
"iest",
"in",
"range",
"(",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Est\"",
"]",
")",
":",
"if",
"(",
"iest",
"%",
"2",
")",
"==",
"0",
":",
"Cor",
"=",
"'red'",
"Preenche",
"=",
"'green:cyan'",
"else",
":",
"Cor",
"=",
"'red'",
"Preenche",
"=",
"'lightblue:cyan'",
"with",
"g",
".",
"subgraph",
"(",
"name",
"=",
"'cluster'",
"+",
"str",
"(",
"iest",
"+",
"1",
")",
")",
"as",
"c",
":",
"c",
".",
"attr",
"(",
"fillcolor",
"=",
"Preenche",
",",
"label",
"=",
"'Estágio '+",
"s",
"tr(",
"i",
"est+",
"1",
")",
",",
"",
"fontcolor",
"=",
"Cor",
",",
"style",
"=",
"'filled'",
",",
"gradientangle",
"=",
"'270'",
")",
"c",
".",
"attr",
"(",
"'node'",
",",
"shape",
"=",
"'box'",
",",
"fillcolor",
"=",
"'red:yellow'",
",",
"style",
"=",
"'filled'",
",",
"gradientangle",
"=",
"'90'",
")",
"for",
"elemento",
"in",
"lista",
":",
"if",
"elemento",
"[",
"\"Estagio\"",
"]",
"==",
"iest",
":",
"c",
".",
"node",
"(",
"str",
"(",
"elemento",
"[",
"\"Ordem\"",
"]",
")",
")",
"g",
".",
"attr",
"(",
"\"graph\"",
",",
"pad",
"=",
"\"0.5\"",
",",
"nodesep",
"=",
"\"1\"",
",",
"ranksep",
"=",
"\"2\"",
")",
"g",
".",
"view",
"(",
")"
] | [
1594,
4
] | [
1683,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
check_documents_availability_in_website | (
pids: List[str], target_string: str, output: IO = None
) | Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis.
Params:
pids (List[str]): Lista de pids para verificar.
target_string (str): Endereço da página de artigo no site algo.
output (IO): Arquivo onde as URLs não disponíveis serão registradas.
Return:
None
| Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis.
Params:
pids (List[str]): Lista de pids para verificar.
target_string (str): Endereço da página de artigo no site algo.
output (IO): Arquivo onde as URLs não disponíveis serão registradas. | def check_documents_availability_in_website(
pids: List[str], target_string: str, output: IO = None
) -> None:
""" Dada uma lista de pids, esta função verifica no site informado quais
pids não estão disponíveis.
Params:
pids (List[str]): Lista de pids para verificar.
target_string (str): Endereço da página de artigo no site algo.
output (IO): Arquivo onde as URLs não disponíveis serão registradas.
Return:
None
"""
template = string.Template(target_string)
if "$id" not in target_string:
return logger.error(
"The target string must contain a $id variable. If you are facing"
"troubles try to scape the variable e.g '\$id'."
)
def access_website_and_report(url, output, poison_pill):
"""Acessa uma URL e reporta o seu status de resposta"""
if poison_pill.poisoned:
return
response = requests.head(url)
if response.status_code not in (200, 301, 302):
logger.error(
"The URL '%s' is not available. Returned the status code '%s'.",
url,
response.status_code,
)
if output is not None:
try:
output.write(url + "\n")
except IOError as exc:
logger.error(
"Cannot write in the file. The exception '%s' was raided ", exc
)
jobs = [
{"url": template.substitute({"id": pid.strip()}), "output": output}
for pid in pids
]
with tqdm(total=len(jobs)) as pbar:
def update_bar(pbar=pbar):
pbar.update(1)
def exception_callback(exception, job, logger=logger, output=output):
logger.error(
"Could not check availability for URL '%s'. The following exception "
"was raised: '%s'.",
job["url"],
exception,
)
logger.exception(exception)
DoJobsConcurrently(
access_website_and_report,
jobs,
max_workers=int(config.get("THREADPOOL_MAX_WORKERS")),
exception_callback=exception_callback,
update_bar=update_bar,
) | [
"def",
"check_documents_availability_in_website",
"(",
"pids",
":",
"List",
"[",
"str",
"]",
",",
"target_string",
":",
"str",
",",
"output",
":",
"IO",
"=",
"None",
")",
"->",
"None",
":",
"template",
"=",
"string",
".",
"Template",
"(",
"target_string",
")",
"if",
"\"$id\"",
"not",
"in",
"target_string",
":",
"return",
"logger",
".",
"error",
"(",
"\"The target string must contain a $id variable. If you are facing\"",
"\"troubles try to scape the variable e.g '\\$id'.\"",
")",
"def",
"access_website_and_report",
"(",
"url",
",",
"output",
",",
"poison_pill",
")",
":",
"\"\"\"Acessa uma URL e reporta o seu status de resposta\"\"\"",
"if",
"poison_pill",
".",
"poisoned",
":",
"return",
"response",
"=",
"requests",
".",
"head",
"(",
"url",
")",
"if",
"response",
".",
"status_code",
"not",
"in",
"(",
"200",
",",
"301",
",",
"302",
")",
":",
"logger",
".",
"error",
"(",
"\"The URL '%s' is not available. Returned the status code '%s'.\"",
",",
"url",
",",
"response",
".",
"status_code",
",",
")",
"if",
"output",
"is",
"not",
"None",
":",
"try",
":",
"output",
".",
"write",
"(",
"url",
"+",
"\"\\n\"",
")",
"except",
"IOError",
"as",
"exc",
":",
"logger",
".",
"error",
"(",
"\"Cannot write in the file. The exception '%s' was raided \"",
",",
"exc",
")",
"jobs",
"=",
"[",
"{",
"\"url\"",
":",
"template",
".",
"substitute",
"(",
"{",
"\"id\"",
":",
"pid",
".",
"strip",
"(",
")",
"}",
")",
",",
"\"output\"",
":",
"output",
"}",
"for",
"pid",
"in",
"pids",
"]",
"with",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"jobs",
")",
")",
"as",
"pbar",
":",
"def",
"update_bar",
"(",
"pbar",
"=",
"pbar",
")",
":",
"pbar",
".",
"update",
"(",
"1",
")",
"def",
"exception_callback",
"(",
"exception",
",",
"job",
",",
"logger",
"=",
"logger",
",",
"output",
"=",
"output",
")",
":",
"logger",
".",
"error",
"(",
"\"Could not check availability for URL '%s'. The following exception \"",
"\"was raised: '%s'.\"",
",",
"job",
"[",
"\"url\"",
"]",
",",
"exception",
",",
")",
"logger",
".",
"exception",
"(",
"exception",
")",
"DoJobsConcurrently",
"(",
"access_website_and_report",
",",
"jobs",
",",
"max_workers",
"=",
"int",
"(",
"config",
".",
"get",
"(",
"\"THREADPOOL_MAX_WORKERS\"",
")",
")",
",",
"exception_callback",
"=",
"exception_callback",
",",
"update_bar",
"=",
"update_bar",
",",
")"
] | [
13,
0
] | [
86,
9
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ProbDist.__getitem__ | (self, val) | Dado um valor, retornar P(valor). | Dado um valor, retornar P(valor). | def __getitem__(self, val):
"Dado um valor, retornar P(valor)."
try:
return self.prob[val]
except KeyError:
return 0 | [
"def",
"__getitem__",
"(",
"self",
",",
"val",
")",
":",
"try",
":",
"return",
"self",
".",
"prob",
"[",
"val",
"]",
"except",
"KeyError",
":",
"return",
"0"
] | [
58,
4
] | [
63,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
texto | (prog, r = 0, cab='',sep='\n',ind=recuo) | return cab | Retorna o texto da lista de linhas prog com o recuo geral inteiro r com os caracteres do dicionário ind, a string de cabeçalho cab e sep como separador de linha. | Retorna o texto da lista de linhas prog com o recuo geral inteiro r com os caracteres do dicionário ind, a string de cabeçalho cab e sep como separador de linha. | def texto (prog, r = 0, cab='',sep='\n',ind=recuo):
'''Retorna o texto da lista de linhas prog com o recuo geral inteiro r com os caracteres do dicionário ind, a string de cabeçalho cab e sep como separador de linha.'''
for ln in prog:
if type(r) != list:
r = [contarecuo(ln,r,ind)]
if type(ln) == list:
cab += texto(ln,r,sep=sep,ind=ind)
else:
cab += recua(r[0],ind) + str(ln.linha()) + sep
r[0] += ln.indentar()
return cab | [
"def",
"texto",
"(",
"prog",
",",
"r",
"=",
"0",
",",
"cab",
"=",
"''",
",",
"sep",
"=",
"'\\n'",
",",
"ind",
"=",
"recuo",
")",
":",
"for",
"ln",
"in",
"prog",
":",
"if",
"type",
"(",
"r",
")",
"!=",
"list",
":",
"r",
"=",
"[",
"contarecuo",
"(",
"ln",
",",
"r",
",",
"ind",
")",
"]",
"if",
"type",
"(",
"ln",
")",
"==",
"list",
":",
"cab",
"+=",
"texto",
"(",
"ln",
",",
"r",
",",
"sep",
"=",
"sep",
",",
"ind",
"=",
"ind",
")",
"else",
":",
"cab",
"+=",
"recua",
"(",
"r",
"[",
"0",
"]",
",",
"ind",
")",
"+",
"str",
"(",
"ln",
".",
"linha",
"(",
")",
")",
"+",
"sep",
"r",
"[",
"0",
"]",
"+=",
"ln",
".",
"indentar",
"(",
")",
"return",
"cab"
] | [
82,
0
] | [
92,
11
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
igual | (a, b) | return False | retorna true ou false , para testar | retorna true ou false , para testar | def igual(a, b):
''' retorna true ou false , para testar '''
''' tem que arrumar '''
return False | [
"def",
"igual",
"(",
"a",
",",
"b",
")",
":",
"''' tem que arrumar '''",
"return",
"False"
] | [
54,
0
] | [
57,
16
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Room.__init__ | (self, wumpus=Status.Absent, pit=Status.Absent, gold=Status.Absent) | Inicializa o status do quarto.
Por padrão, o quarto é seguro e sem ouro. | Inicializa o status do quarto.
Por padrão, o quarto é seguro e sem ouro. | def __init__(self, wumpus=Status.Absent, pit=Status.Absent, gold=Status.Absent):
"""Inicializa o status do quarto.
Por padrão, o quarto é seguro e sem ouro."""
self.wumpus = wumpus
self.pit = pit
self.gold = gold | [
"def",
"__init__",
"(",
"self",
",",
"wumpus",
"=",
"Status",
".",
"Absent",
",",
"pit",
"=",
"Status",
".",
"Absent",
",",
"gold",
"=",
"Status",
".",
"Absent",
")",
":",
"self",
".",
"wumpus",
"=",
"wumpus",
"self",
".",
"pit",
"=",
"pit",
"self",
".",
"gold",
"=",
"gold"
] | [
16,
2
] | [
23,
20
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ScoreBoard.prep_score | (self) | Transforema a pontuacao em uma imagem renderizada. | Transforema a pontuacao em uma imagem renderizada. | def prep_score(self):
"""Transforema a pontuacao em uma imagem renderizada."""
rounded_score = round(self.stats.score, -1)
score_str = "{:,}".format(rounded_score)
self.score_image = self.font.render('Score: '+score_str, True,
self.text_color,
self.ai_settings.bg_color)
# Exbe a pontuacao na parte superior direita da tela
self.score_rect = self.score_image.get_rect()
self.score_rect.right = self.screen_rect.right - 20
self.score_rect.top = 20 | [
"def",
"prep_score",
"(",
"self",
")",
":",
"rounded_score",
"=",
"round",
"(",
"self",
".",
"stats",
".",
"score",
",",
"-",
"1",
")",
"score_str",
"=",
"\"{:,}\"",
".",
"format",
"(",
"rounded_score",
")",
"self",
".",
"score_image",
"=",
"self",
".",
"font",
".",
"render",
"(",
"'Score: '",
"+",
"score_str",
",",
"True",
",",
"self",
".",
"text_color",
",",
"self",
".",
"ai_settings",
".",
"bg_color",
")",
"# Exbe a pontuacao na parte superior direita da tela",
"self",
".",
"score_rect",
"=",
"self",
".",
"score_image",
".",
"get_rect",
"(",
")",
"self",
".",
"score_rect",
".",
"right",
"=",
"self",
".",
"screen_rect",
".",
"right",
"-",
"20",
"self",
".",
"score_rect",
".",
"top",
"=",
"20"
] | [
29,
4
] | [
40,
32
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
ContractsSpider.parse_page | (self, response) | Extrai informações sobre um contrato.
Example:
CONTRATO N° 11-2017-1926C REFERENTE A CONTRATAÇÃO DE EMPRESA AQUISIÇÃO DE
ÁGUA MINERAL NATURAL PARA A...
OBJETO:REFERENTE A CONTRATAÇÃO DE EMPRESA AQUISIÇÃO DE ÁGUA MINERAL NATURAL
PARA ATENDER AS NECESSIDADES DA SUPERINTENDÊNCIA MUNICIPAL DE TRÂNSITO.
CONTRATADA: 74.096.231/0001-80 - WAMBERTO LOPES DE ARAUJO - ME
VALOR: R$ 62.960,00
DATA FINAL DE CONTRATO: 01/06/2018
| Extrai informações sobre um contrato. | def parse_page(self, response):
"""Extrai informações sobre um contrato.
Example:
CONTRATO N° 11-2017-1926C REFERENTE A CONTRATAÇÃO DE EMPRESA AQUISIÇÃO DE
ÁGUA MINERAL NATURAL PARA A...
OBJETO:REFERENTE A CONTRATAÇÃO DE EMPRESA AQUISIÇÃO DE ÁGUA MINERAL NATURAL
PARA ATENDER AS NECESSIDADES DA SUPERINTENDÊNCIA MUNICIPAL DE TRÂNSITO.
CONTRATADA: 74.096.231/0001-80 - WAMBERTO LOPES DE ARAUJO - ME
VALOR: R$ 62.960,00
DATA FINAL DE CONTRATO: 01/06/2018
"""
headlines = response.css('tbody tr:not([class^="informacao"])')
contract_details = response.css("tr.informacao")
base_url = "http://www.transparencia.feiradesantana.ba.gov.br"
for headline, raw_details in zip(headlines, contract_details):
contract_and_date = headline.css("th ::text").extract()
contract_id = identify_contract_id(contract_and_date[0])
starts_at = contract_and_date[1]
details = self.clean_details(raw_details)
document_url = raw_details.css("a.btn::attr(href)").get(default=None)
contractor = details[1].split(" - ")
contractor_document = contractor[0]
contractor_name = contractor[1]
item = CityHallContractItem(
contract_id=contract_id,
starts_at=starts_at,
summary=details[0],
contractor_document=contractor_document,
contractor_name=contractor_name,
value=details[2],
ends_at=details[3],
crawled_at=datetime_utcnow_aware(),
crawled_from=response.url,
)
if document_url:
item["files"] = [f"{base_url}{document_url}"]
yield item | [
"def",
"parse_page",
"(",
"self",
",",
"response",
")",
":",
"headlines",
"=",
"response",
".",
"css",
"(",
"'tbody tr:not([class^=\"informacao\"])'",
")",
"contract_details",
"=",
"response",
".",
"css",
"(",
"\"tr.informacao\"",
")",
"base_url",
"=",
"\"http://www.transparencia.feiradesantana.ba.gov.br\"",
"for",
"headline",
",",
"raw_details",
"in",
"zip",
"(",
"headlines",
",",
"contract_details",
")",
":",
"contract_and_date",
"=",
"headline",
".",
"css",
"(",
"\"th ::text\"",
")",
".",
"extract",
"(",
")",
"contract_id",
"=",
"identify_contract_id",
"(",
"contract_and_date",
"[",
"0",
"]",
")",
"starts_at",
"=",
"contract_and_date",
"[",
"1",
"]",
"details",
"=",
"self",
".",
"clean_details",
"(",
"raw_details",
")",
"document_url",
"=",
"raw_details",
".",
"css",
"(",
"\"a.btn::attr(href)\"",
")",
".",
"get",
"(",
"default",
"=",
"None",
")",
"contractor",
"=",
"details",
"[",
"1",
"]",
".",
"split",
"(",
"\" - \"",
")",
"contractor_document",
"=",
"contractor",
"[",
"0",
"]",
"contractor_name",
"=",
"contractor",
"[",
"1",
"]",
"item",
"=",
"CityHallContractItem",
"(",
"contract_id",
"=",
"contract_id",
",",
"starts_at",
"=",
"starts_at",
",",
"summary",
"=",
"details",
"[",
"0",
"]",
",",
"contractor_document",
"=",
"contractor_document",
",",
"contractor_name",
"=",
"contractor_name",
",",
"value",
"=",
"details",
"[",
"2",
"]",
",",
"ends_at",
"=",
"details",
"[",
"3",
"]",
",",
"crawled_at",
"=",
"datetime_utcnow_aware",
"(",
")",
",",
"crawled_from",
"=",
"response",
".",
"url",
",",
")",
"if",
"document_url",
":",
"item",
"[",
"\"files\"",
"]",
"=",
"[",
"f\"{base_url}{document_url}\"",
"]",
"yield",
"item"
] | [
224,
4
] | [
265,
22
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
test_get_prescriptions_by_idPrescription | (client) | Teste get /prescriptions/idPrescription - Compara response data com dados do banco e valida status_code 200 | Teste get /prescriptions/idPrescription - Compara response data com dados do banco e valida status_code 200 | def test_get_prescriptions_by_idPrescription(client):
"""Teste get /prescriptions/idPrescription - Compara response data com dados do banco e valida status_code 200"""
access_token = get_access(client)
idPrescription = '20'
response = client.get('/prescriptions/' + idPrescription, headers=make_headers(access_token))
data = json.loads(response.data)['data']
prescription = session.query(Prescription).get(idPrescription)
assert response.status_code == 200
assert data['idPrescription'] == str(prescription.id)
assert data['concilia'] == prescription.concilia
assert data['bed'] == prescription.bed
assert data['status'] == prescription.status | [
"def",
"test_get_prescriptions_by_idPrescription",
"(",
"client",
")",
":",
"access_token",
"=",
"get_access",
"(",
"client",
")",
"idPrescription",
"=",
"'20'",
"response",
"=",
"client",
".",
"get",
"(",
"'/prescriptions/'",
"+",
"idPrescription",
",",
"headers",
"=",
"make_headers",
"(",
"access_token",
")",
")",
"data",
"=",
"json",
".",
"loads",
"(",
"response",
".",
"data",
")",
"[",
"'data'",
"]",
"prescription",
"=",
"session",
".",
"query",
"(",
"Prescription",
")",
".",
"get",
"(",
"idPrescription",
")",
"assert",
"response",
".",
"status_code",
"==",
"200",
"assert",
"data",
"[",
"'idPrescription'",
"]",
"==",
"str",
"(",
"prescription",
".",
"id",
")",
"assert",
"data",
"[",
"'concilia'",
"]",
"==",
"prescription",
".",
"concilia",
"assert",
"data",
"[",
"'bed'",
"]",
"==",
"prescription",
".",
"bed",
"assert",
"data",
"[",
"'status'",
"]",
"==",
"prescription",
".",
"status"
] | [
26,
0
] | [
41,
48
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Room.is_unsafe | (self, danger=None) | return self.is_dangerous(danger) or self.is_deadly(danger) | Retorna True se a sala não contém o Wumpus ou um poço. | Retorna True se a sala não contém o Wumpus ou um poço. | def is_unsafe(self, danger=None):
"""Retorna True se a sala não contém o Wumpus ou um poço."""
return self.is_dangerous(danger) or self.is_deadly(danger) | [
"def",
"is_unsafe",
"(",
"self",
",",
"danger",
"=",
"None",
")",
":",
"return",
"self",
".",
"is_dangerous",
"(",
"danger",
")",
"or",
"self",
".",
"is_deadly",
"(",
"danger",
")"
] | [
46,
2
] | [
50,
62
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
conversion_issues_to_xylose | (issues: List[dict]) | return [Issue({"issue": issue}) for issue in issues] | Converte uma lista de issues em formato JSON para uma
lista de issues em formato xylose | Converte uma lista de issues em formato JSON para uma
lista de issues em formato xylose | def conversion_issues_to_xylose(issues: List[dict]) -> List[Issue]:
"""Converte uma lista de issues em formato JSON para uma
lista de issues em formato xylose"""
return [Issue({"issue": issue}) for issue in issues] | [
"def",
"conversion_issues_to_xylose",
"(",
"issues",
":",
"List",
"[",
"dict",
"]",
")",
"->",
"List",
"[",
"Issue",
"]",
":",
"return",
"[",
"Issue",
"(",
"{",
"\"issue\"",
":",
"issue",
"}",
")",
"for",
"issue",
"in",
"issues",
"]"
] | [
161,
0
] | [
165,
56
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Geladeira.pegar_comida | (self, comida) | Diminui em 1 a quantidade da Comida ou a remove da geladeira. | Diminui em 1 a quantidade da Comida ou a remove da geladeira. | def pegar_comida(self, comida):
"""Diminui em 1 a quantidade da Comida ou a remove da geladeira."""
self.alimentos[comida.nome][1] -= 1
if self.alimentos[comida.nome][1] == 0:
del self.alimentos[comida.nome] | [
"def",
"pegar_comida",
"(",
"self",
",",
"comida",
")",
":",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]",
"[",
"1",
"]",
"-=",
"1",
"if",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]",
"[",
"1",
"]",
"==",
"0",
":",
"del",
"self",
".",
"alimentos",
"[",
"comida",
".",
"nome",
"]"
] | [
35,
4
] | [
40,
43
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
match | (number, guess) | return ret | Compara o número com a tentativa do usuário | Compara o número com a tentativa do usuário | def match(number, guess):
"""Compara o número com a tentativa do usuário"""
ret = ""
rnge = min(len(number), len(guess))
for i in range(0, rnge):
if guess[i] == number[i]:
ret += '+'
elif number.find(guess[i]) != -1:
ret += '*'
else:
ret += '-'
return ret | [
"def",
"match",
"(",
"number",
",",
"guess",
")",
":",
"ret",
"=",
"\"\"",
"rnge",
"=",
"min",
"(",
"len",
"(",
"number",
")",
",",
"len",
"(",
"guess",
")",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"rnge",
")",
":",
"if",
"guess",
"[",
"i",
"]",
"==",
"number",
"[",
"i",
"]",
":",
"ret",
"+=",
"'+'",
"elif",
"number",
".",
"find",
"(",
"guess",
"[",
"i",
"]",
")",
"!=",
"-",
"1",
":",
"ret",
"+=",
"'*'",
"else",
":",
"ret",
"+=",
"'-'",
"return",
"ret"
] | [
2,
0
] | [
14,
14
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Basics.replace_vars | (cls, itter_list, pattern, replace) | return itter_list | Funcao generica para substituicao de padrao de string dentro de uma lista. | Funcao generica para substituicao de padrao de string dentro de uma lista. | def replace_vars(cls, itter_list, pattern, replace):
"""Funcao generica para substituicao de padrao de string dentro de uma lista."""
for index, line in enumerate(itter_list):
itter_list[index] = line.replace(pattern, replace)
return itter_list | [
"def",
"replace_vars",
"(",
"cls",
",",
"itter_list",
",",
"pattern",
",",
"replace",
")",
":",
"for",
"index",
",",
"line",
"in",
"enumerate",
"(",
"itter_list",
")",
":",
"itter_list",
"[",
"index",
"]",
"=",
"line",
".",
"replace",
"(",
"pattern",
",",
"replace",
")",
"return",
"itter_list"
] | [
48,
4
] | [
54,
25
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
my_max | (values) | return maximum | Retorna o elemento máximo de uma lista.
Considerando a lista recebida como parâmetro, identifica e retorna
o elemento máximo nela contido.
Parameters
----------
values : list
A lista cujo elemento máximo deve ser identificado
Return
------
maximum : ?
O elemento máximo da lista
| Retorna o elemento máximo de uma lista. | def my_max(values):
""" Retorna o elemento máximo de uma lista.
Considerando a lista recebida como parâmetro, identifica e retorna
o elemento máximo nela contido.
Parameters
----------
values : list
A lista cujo elemento máximo deve ser identificado
Return
------
maximum : ?
O elemento máximo da lista
"""
maximum = values[0]
for i in values:
if (i > maximum):
maximum = i
return maximum | [
"def",
"my_max",
"(",
"values",
")",
":",
"maximum",
"=",
"values",
"[",
"0",
"]",
"for",
"i",
"in",
"values",
":",
"if",
"(",
"i",
">",
"maximum",
")",
":",
"maximum",
"=",
"i",
"return",
"maximum"
] | [
107,
0
] | [
127,
18
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Player.pokemons | (self) | return self._pokemons | Lista de Pokemons que o usuario escolheu | Lista de Pokemons que o usuario escolheu | def pokemons(self) -> list:
"""Lista de Pokemons que o usuario escolheu"""
return self._pokemons | [
"def",
"pokemons",
"(",
"self",
")",
"->",
"list",
":",
"return",
"self",
".",
"_pokemons"
] | [
16,
4
] | [
18,
29
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
logout_view | (request) | return HttpResponseRedirect(reverse('learning_logs:index')) | Faz logout do usuário. | Faz logout do usuário. | def logout_view(request):
"""Faz logout do usuário."""
logout(request)
return HttpResponseRedirect(reverse('learning_logs:index')) | [
"def",
"logout_view",
"(",
"request",
")",
":",
"logout",
"(",
"request",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'learning_logs:index'",
")",
")"
] | [
8,
0
] | [
11,
63
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
find_word | (word) | return w.group(1).strip() if w else '' | Função para encontrar palavras dentro de iteráveis,
parando a busca ao encontrar vírgulas, pontos ou espaços
Retornará apenas a primeira palavra encontrada
Esta função retornará str com os valores encontrados ou ''(vazio) caso
não encontre nada. | Função para encontrar palavras dentro de iteráveis,
parando a busca ao encontrar vírgulas, pontos ou espaços
Retornará apenas a primeira palavra encontrada
Esta função retornará str com os valores encontrados ou ''(vazio) caso
não encontre nada. | def find_word(word):
"""Função para encontrar palavras dentro de iteráveis,
parando a busca ao encontrar vírgulas, pontos ou espaços
Retornará apenas a primeira palavra encontrada
Esta função retornará str com os valores encontrados ou ''(vazio) caso
não encontre nada."""
w = re.compile(r'(\w+)').search(str(word))
return w.group(1).strip() if w else '' | [
"def",
"find_word",
"(",
"word",
")",
":",
"w",
"=",
"re",
".",
"compile",
"(",
"r'(\\w+)'",
")",
".",
"search",
"(",
"str",
"(",
"word",
")",
")",
"return",
"w",
".",
"group",
"(",
"1",
")",
".",
"strip",
"(",
")",
"if",
"w",
"else",
"''"
] | [
16,
0
] | [
23,
42
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
RuspyTransformer.INT | (self, tk) | return int(data) | Às vezes precisamos nos esforçar um pouquinho mais para obter o | Às vezes precisamos nos esforçar um pouquinho mais para obter o | def INT(self, tk):
"""Às vezes precisamos nos esforçar um pouquinho mais para obter o """
"""resultado que simplesmente fazer a conversão int(x)"""
data = tk.replace('_', '')
if set(data) == {'0'}:
raise ValueError('# FIXME!') # (a solução aqui é trivial :)
return int(data) | [
"def",
"INT",
"(",
"self",
",",
"tk",
")",
":",
"\"\"\"resultado que simplesmente fazer a conversão int(x)\"\"\"",
"data",
"=",
"tk",
".",
"replace",
"(",
"'_'",
",",
"''",
")",
"if",
"set",
"(",
"data",
")",
"==",
"{",
"'0'",
"}",
":",
"raise",
"ValueError",
"(",
"'# FIXME!'",
")",
"# (a solução aqui é trivial :) ",
"return",
"int",
"(",
"data",
")"
] | [
54,
4
] | [
60,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
Classroom.pdde | (self, nr_est, nr_aberturas, nr_forwards, imprime) | return(ZINF_MED, ZSUP_MED, LINF, LSUP, pote_de_corte) | Gera um pdf com estágios e aberturas.
Keyword arguments:
nr_est -- Define horizonte de estudo
nr_aberturas -- Número de aberturas
nr_forwards -- Número de seqüências forward
| Gera um pdf com estágios e aberturas. | def pdde(self, nr_est, nr_aberturas, nr_forwards, imprime):
"""Gera um pdf com estágios e aberturas.
Keyword arguments:
nr_est -- Define horizonte de estudo
nr_aberturas -- Número de aberturas
nr_forwards -- Número de seqüências forward
"""
if nr_aberturas > self.sistema["DGer"]["Nr_Cen"]:
print ("Número de Aberturas Superior ao número de Cenários.")
print ("Método pdde interrompido!")
return
if nr_est > self.sistema["DGer"]["Nr_Est"]:
print ("Número de Estágios Superior aos dados informados no problema.")
print("Método pdde interrompido!")
return
random.seed(30)
# Calcula as aberturas
MatrizAberturas = np.zeros( (nr_est,nr_aberturas), dtype=int)
for i in range(nr_est):
sorteados = random.sample(range(0,self.sistema["DGer"]["Nr_Cen"]),nr_aberturas)
MatrizAberturas[i] = sorteados
# Calcula as sequencias forward
SeqForward = np.zeros( (nr_est,nr_forwards), dtype=int)
for iest in range(nr_est):
for ifwd in range(nr_forwards):
posicao = random.randint(0,nr_aberturas-1)
SeqForward[iest,ifwd] = MatrizAberturas[iest,posicao]
Num_UHE = len(self.sistema["UHE"])
#
# Esta é uma lista com dicionários contendo todos os cortes criados
# Inicia vazia
#
pote_de_corte = []
#
# Computa o instante de tempo no qual o processo iterativo iniciou
#
t = time.time()
iteracao = 0
Convergiu = False
ZSUP_MED = []
ZINF_MED = []
LINF = []
LSUP = []
while not Convergiu:
#
# Forward - Laço ou Loop direto de estágios (do início para o fim)
#
ZSUP_MED.append(0.)
ZINF_MED.append(0.)
memoria = []
ZSUP = np.zeros(nr_forwards, dtype=float)
for iest in range(nr_est):
linha = list()
for ifwd in range(nr_forwards):
VI = []
if iest == 0:
for i, iusi in enumerate(self.sistema["UHE"]):
VI.append(iusi["VI"])
else:
resultado = memoria[iest-1][ifwd]
for i, iusi in enumerate(resultado["UHE"]):
VI.append(iusi["vf"])
AFL = []
for i, iusi in enumerate(self.sistema["UHE"]):
AFL.append(iusi["Afl"][iest][SeqForward[iest,ifwd]])
#
# Chama função de despacho hidrotérmico
#
resultado = self.despacho_pdde(VI, AFL, pote_de_corte, iest + 1, imprime)
ZSUP[ifwd] += resultado["DGer"]["CustoTotal"] - resultado["DGer"]["CustoFuturo"]
if iest == 0:
ZINF_MED[iteracao] += resultado["DGer"]["CustoTotal"]
linha.append(resultado)
memoria.append(linha)
ZINF_MED[iteracao] = ZINF_MED[iteracao]/nr_forwards
for ifwd in range(nr_forwards):
ZSUP_MED[iteracao] = ZSUP_MED[iteracao] + ZSUP[ifwd]
ZSUP_MED[iteracao] = ZSUP_MED[iteracao] / nr_forwards
# Calcula Desvio Padrão do ZSUP
desvio = 0
for ifwd in range(nr_forwards):
desvio = desvio + (ZSUP_MED[iteracao] - ZSUP[ifwd])**2
desvio = np.sqrt(desvio/nr_forwards)
LINF.append(ZSUP_MED[iteracao] - 1.96*desvio)
LSUP.append(ZSUP_MED[iteracao] + 1.96*desvio)
if ZINF_MED[iteracao] >= LINF[iteracao] and ZINF_MED[iteracao] <= LSUP[iteracao]:
Convergiu = True
break
print(f"Fim da Iteração {(iteracao+1)}")
# Backward
for iest in np.arange(nr_est-1,0,-1):
for ifwd in range(nr_forwards):
#
# Corte Médio
#
Corte_Medio = {
"Estagio": iest,
"Termo_Indep": 0.,
"Coefs": [0.] * Num_UHE
}
for iabt in range(nr_aberturas):
resultado = memoria[iest-1][ifwd]
VI = []
for i, iusi in enumerate(resultado["UHE"]):
VI.append(iusi["vf"])
AFL = []
for i, iusi in enumerate(self.sistema["UHE"]):
AFL.append(iusi["Afl"][iest][MatrizAberturas[iest, iabt]])
#
# Chama função de despacho hidrotérmico
#
resultado = self.despacho_pdde(VI, AFL, pote_de_corte, iest + 1, imprime)
Corte = {
"Estagio": iest,
"Termo_Indep": resultado["DGer"]["CustoTotal"],
"Coefs": [0.] * Num_UHE
}
for i, iusi in enumerate(resultado["UHE"]):
Corte["Coefs"][i] = -iusi["cma"]
Corte["Termo_Indep"] -= VI[i] * Corte["Coefs"][i]
Corte_Medio["Termo_Indep"] = Corte_Medio["Termo_Indep"] + Corte["Termo_Indep"]
for i in range(Num_UHE):
Corte_Medio["Coefs"][i] = Corte_Medio["Coefs"][i] + Corte["Coefs"][i]
Corte_Medio["Termo_Indep"] = Corte_Medio["Termo_Indep"]/nr_aberturas
for i in range(Num_UHE):
Corte_Medio["Coefs"][i] = Corte_Medio["Coefs"][i]/nr_aberturas
#
# Insere o corte no final da lista pote_de_corte
#
pote_de_corte.append(Corte_Medio)
iteracao = iteracao + 1
if iteracao == 20:
Convergiu = True
print("Execução interrompida após vigésima iteração por número máximo de iteraçoes")
#
# Calcula o tempo decorrido desde o início do algoritmo
#
print("Tempo decorrido na PDDE", time.time() - t)
return(ZINF_MED, ZSUP_MED, LINF, LSUP, pote_de_corte) | [
"def",
"pdde",
"(",
"self",
",",
"nr_est",
",",
"nr_aberturas",
",",
"nr_forwards",
",",
"imprime",
")",
":",
"if",
"nr_aberturas",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Cen\"",
"]",
":",
"print",
"(",
"\"Número de Aberturas Superior ao número de Cenários.\")",
"",
"print",
"(",
"\"Método pdde interrompido!\")",
"",
"return",
"if",
"nr_est",
">",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Est\"",
"]",
":",
"print",
"(",
"\"Número de Estágios Superior aos dados informados no problema.\")",
"",
"print",
"(",
"\"Método pdde interrompido!\")",
"",
"return",
"random",
".",
"seed",
"(",
"30",
")",
"# Calcula as aberturas",
"MatrizAberturas",
"=",
"np",
".",
"zeros",
"(",
"(",
"nr_est",
",",
"nr_aberturas",
")",
",",
"dtype",
"=",
"int",
")",
"for",
"i",
"in",
"range",
"(",
"nr_est",
")",
":",
"sorteados",
"=",
"random",
".",
"sample",
"(",
"range",
"(",
"0",
",",
"self",
".",
"sistema",
"[",
"\"DGer\"",
"]",
"[",
"\"Nr_Cen\"",
"]",
")",
",",
"nr_aberturas",
")",
"MatrizAberturas",
"[",
"i",
"]",
"=",
"sorteados",
"# Calcula as sequencias forward",
"SeqForward",
"=",
"np",
".",
"zeros",
"(",
"(",
"nr_est",
",",
"nr_forwards",
")",
",",
"dtype",
"=",
"int",
")",
"for",
"iest",
"in",
"range",
"(",
"nr_est",
")",
":",
"for",
"ifwd",
"in",
"range",
"(",
"nr_forwards",
")",
":",
"posicao",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"nr_aberturas",
"-",
"1",
")",
"SeqForward",
"[",
"iest",
",",
"ifwd",
"]",
"=",
"MatrizAberturas",
"[",
"iest",
",",
"posicao",
"]",
"Num_UHE",
"=",
"len",
"(",
"self",
".",
"sistema",
"[",
"\"UHE\"",
"]",
")",
"#",
"# Esta é uma lista com dicionários contendo todos os cortes criados",
"# Inicia vazia",
"#",
"pote_de_corte",
"=",
"[",
"]",
"#",
"# Computa o instante de tempo no qual o processo iterativo iniciou",
"#",
"t",
"=",
"time",
".",
"time",
"(",
")",
"iteracao",
"=",
"0",
"Convergiu",
"=",
"False",
"ZSUP_MED",
"=",
"[",
"]",
"ZINF_MED",
"=",
"[",
"]",
"LINF",
"=",
"[",
"]",
"LSUP",
"=",
"[",
"]",
"while",
"not",
"Convergiu",
":",
"#",
"# Forward - Laço ou Loop direto de estágios (do início para o fim)",
"#",
"ZSUP_MED",
".",
"append",
"(",
"0.",
")",
"ZINF_MED",
".",
"append",
"(",
"0.",
")",
"memoria",
"=",
"[",
"]",
"ZSUP",
"=",
"np",
".",
"zeros",
"(",
"nr_forwards",
",",
"dtype",
"=",
"float",
")",
"for",
"iest",
"in",
"range",
"(",
"nr_est",
")",
":",
"linha",
"=",
"list",
"(",
")",
"for",
"ifwd",
"in",
"range",
"(",
"nr_forwards",
")",
":",
"VI",
"=",
"[",
"]",
"if",
"iest",
"==",
"0",
":",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"self",
".",
"sistema",
"[",
"\"UHE\"",
"]",
")",
":",
"VI",
".",
"append",
"(",
"iusi",
"[",
"\"VI\"",
"]",
")",
"else",
":",
"resultado",
"=",
"memoria",
"[",
"iest",
"-",
"1",
"]",
"[",
"ifwd",
"]",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"resultado",
"[",
"\"UHE\"",
"]",
")",
":",
"VI",
".",
"append",
"(",
"iusi",
"[",
"\"vf\"",
"]",
")",
"AFL",
"=",
"[",
"]",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"self",
".",
"sistema",
"[",
"\"UHE\"",
"]",
")",
":",
"AFL",
".",
"append",
"(",
"iusi",
"[",
"\"Afl\"",
"]",
"[",
"iest",
"]",
"[",
"SeqForward",
"[",
"iest",
",",
"ifwd",
"]",
"]",
")",
"#",
"# Chama função de despacho hidrotérmico",
"#",
"resultado",
"=",
"self",
".",
"despacho_pdde",
"(",
"VI",
",",
"AFL",
",",
"pote_de_corte",
",",
"iest",
"+",
"1",
",",
"imprime",
")",
"ZSUP",
"[",
"ifwd",
"]",
"+=",
"resultado",
"[",
"\"DGer\"",
"]",
"[",
"\"CustoTotal\"",
"]",
"-",
"resultado",
"[",
"\"DGer\"",
"]",
"[",
"\"CustoFuturo\"",
"]",
"if",
"iest",
"==",
"0",
":",
"ZINF_MED",
"[",
"iteracao",
"]",
"+=",
"resultado",
"[",
"\"DGer\"",
"]",
"[",
"\"CustoTotal\"",
"]",
"linha",
".",
"append",
"(",
"resultado",
")",
"memoria",
".",
"append",
"(",
"linha",
")",
"ZINF_MED",
"[",
"iteracao",
"]",
"=",
"ZINF_MED",
"[",
"iteracao",
"]",
"/",
"nr_forwards",
"for",
"ifwd",
"in",
"range",
"(",
"nr_forwards",
")",
":",
"ZSUP_MED",
"[",
"iteracao",
"]",
"=",
"ZSUP_MED",
"[",
"iteracao",
"]",
"+",
"ZSUP",
"[",
"ifwd",
"]",
"ZSUP_MED",
"[",
"iteracao",
"]",
"=",
"ZSUP_MED",
"[",
"iteracao",
"]",
"/",
"nr_forwards",
"# Calcula Desvio Padrão do ZSUP",
"desvio",
"=",
"0",
"for",
"ifwd",
"in",
"range",
"(",
"nr_forwards",
")",
":",
"desvio",
"=",
"desvio",
"+",
"(",
"ZSUP_MED",
"[",
"iteracao",
"]",
"-",
"ZSUP",
"[",
"ifwd",
"]",
")",
"**",
"2",
"desvio",
"=",
"np",
".",
"sqrt",
"(",
"desvio",
"/",
"nr_forwards",
")",
"LINF",
".",
"append",
"(",
"ZSUP_MED",
"[",
"iteracao",
"]",
"-",
"1.96",
"*",
"desvio",
")",
"LSUP",
".",
"append",
"(",
"ZSUP_MED",
"[",
"iteracao",
"]",
"+",
"1.96",
"*",
"desvio",
")",
"if",
"ZINF_MED",
"[",
"iteracao",
"]",
">=",
"LINF",
"[",
"iteracao",
"]",
"and",
"ZINF_MED",
"[",
"iteracao",
"]",
"<=",
"LSUP",
"[",
"iteracao",
"]",
":",
"Convergiu",
"=",
"True",
"break",
"print",
"(",
"f\"Fim da Iteração {(iteracao+1)}\")",
"",
"# Backward",
"for",
"iest",
"in",
"np",
".",
"arange",
"(",
"nr_est",
"-",
"1",
",",
"0",
",",
"-",
"1",
")",
":",
"for",
"ifwd",
"in",
"range",
"(",
"nr_forwards",
")",
":",
"#",
"# Corte Médio",
"#",
"Corte_Medio",
"=",
"{",
"\"Estagio\"",
":",
"iest",
",",
"\"Termo_Indep\"",
":",
"0.",
",",
"\"Coefs\"",
":",
"[",
"0.",
"]",
"*",
"Num_UHE",
"}",
"for",
"iabt",
"in",
"range",
"(",
"nr_aberturas",
")",
":",
"resultado",
"=",
"memoria",
"[",
"iest",
"-",
"1",
"]",
"[",
"ifwd",
"]",
"VI",
"=",
"[",
"]",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"resultado",
"[",
"\"UHE\"",
"]",
")",
":",
"VI",
".",
"append",
"(",
"iusi",
"[",
"\"vf\"",
"]",
")",
"AFL",
"=",
"[",
"]",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"self",
".",
"sistema",
"[",
"\"UHE\"",
"]",
")",
":",
"AFL",
".",
"append",
"(",
"iusi",
"[",
"\"Afl\"",
"]",
"[",
"iest",
"]",
"[",
"MatrizAberturas",
"[",
"iest",
",",
"iabt",
"]",
"]",
")",
"#",
"# Chama função de despacho hidrotérmico",
"#",
"resultado",
"=",
"self",
".",
"despacho_pdde",
"(",
"VI",
",",
"AFL",
",",
"pote_de_corte",
",",
"iest",
"+",
"1",
",",
"imprime",
")",
"Corte",
"=",
"{",
"\"Estagio\"",
":",
"iest",
",",
"\"Termo_Indep\"",
":",
"resultado",
"[",
"\"DGer\"",
"]",
"[",
"\"CustoTotal\"",
"]",
",",
"\"Coefs\"",
":",
"[",
"0.",
"]",
"*",
"Num_UHE",
"}",
"for",
"i",
",",
"iusi",
"in",
"enumerate",
"(",
"resultado",
"[",
"\"UHE\"",
"]",
")",
":",
"Corte",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"=",
"-",
"iusi",
"[",
"\"cma\"",
"]",
"Corte",
"[",
"\"Termo_Indep\"",
"]",
"-=",
"VI",
"[",
"i",
"]",
"*",
"Corte",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"Corte_Medio",
"[",
"\"Termo_Indep\"",
"]",
"=",
"Corte_Medio",
"[",
"\"Termo_Indep\"",
"]",
"+",
"Corte",
"[",
"\"Termo_Indep\"",
"]",
"for",
"i",
"in",
"range",
"(",
"Num_UHE",
")",
":",
"Corte_Medio",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"=",
"Corte_Medio",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"+",
"Corte",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"Corte_Medio",
"[",
"\"Termo_Indep\"",
"]",
"=",
"Corte_Medio",
"[",
"\"Termo_Indep\"",
"]",
"/",
"nr_aberturas",
"for",
"i",
"in",
"range",
"(",
"Num_UHE",
")",
":",
"Corte_Medio",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"=",
"Corte_Medio",
"[",
"\"Coefs\"",
"]",
"[",
"i",
"]",
"/",
"nr_aberturas",
"#",
"# Insere o corte no final da lista pote_de_corte",
"#",
"pote_de_corte",
".",
"append",
"(",
"Corte_Medio",
")",
"iteracao",
"=",
"iteracao",
"+",
"1",
"if",
"iteracao",
"==",
"20",
":",
"Convergiu",
"=",
"True",
"print",
"(",
"\"Execução interrompida após vigésima iteração por número máximo de iteraçoes\")",
"",
"#",
"# Calcula o tempo decorrido desde o início do algoritmo",
"#",
"print",
"(",
"\"Tempo decorrido na PDDE\"",
",",
"time",
".",
"time",
"(",
")",
"-",
"t",
")",
"return",
"(",
"ZINF_MED",
",",
"ZSUP_MED",
",",
"LINF",
",",
"LSUP",
",",
"pote_de_corte",
")"
] | [
2673,
4
] | [
2850,
61
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
trata_strs | (string: str) | return string.split(':')[1].strip() | Remove rótulos de descrição das caixas. | Remove rótulos de descrição das caixas. | def trata_strs(string: str) -> str:
"""Remove rótulos de descrição das caixas."""
return string.split(':')[1].strip() | [
"def",
"trata_strs",
"(",
"string",
":",
"str",
")",
"->",
"str",
":",
"return",
"string",
".",
"split",
"(",
"':'",
")",
"[",
"1",
"]",
".",
"strip",
"(",
")"
] | [
13,
0
] | [
15,
39
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
avalia_textos | (textos, ass_cp) | return texto_infectado | IMPLEMENTAR. Essa funcao recebe uma lista de textos e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH. | IMPLEMENTAR. Essa funcao recebe uma lista de textos e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH. | def avalia_textos(textos, ass_cp):
''' IMPLEMENTAR. Essa funcao recebe uma lista de textos e deve devolver o numero (1 a n) do texto com maior probabilidade de ter sido infectado por COH-PIAH.'''
i = 1
assinatura_texto = calcula_assinatura(textos[i])
grau_similaridade = compara_assinatura(assinatura_texto, ass_cp)
menor_grau = grau_similaridade
texto_infectado = i
i = i+1
while i <(len (textos)):
assinatura_texto = calcula_assinatura(textos[i])
grau_similaridade = compara_assinatura(assinatura_texto, ass_cp)
if grau_similaridade < menor_grau:
menor_grau = grau_similaridade
texto_infectado = i
i = i+1
print ("O autor do texto %d está infectado com COH-PIAH" %(texto_infectado))
return texto_infectado
pass | [
"def",
"avalia_textos",
"(",
"textos",
",",
"ass_cp",
")",
":",
"i",
"=",
"1",
"assinatura_texto",
"=",
"calcula_assinatura",
"(",
"textos",
"[",
"i",
"]",
")",
"grau_similaridade",
"=",
"compara_assinatura",
"(",
"assinatura_texto",
",",
"ass_cp",
")",
"menor_grau",
"=",
"grau_similaridade",
"texto_infectado",
"=",
"i",
"i",
"=",
"i",
"+",
"1",
"while",
"i",
"<",
"(",
"len",
"(",
"textos",
")",
")",
":",
"assinatura_texto",
"=",
"calcula_assinatura",
"(",
"textos",
"[",
"i",
"]",
")",
"grau_similaridade",
"=",
"compara_assinatura",
"(",
"assinatura_texto",
",",
"ass_cp",
")",
"if",
"grau_similaridade",
"<",
"menor_grau",
":",
"menor_grau",
"=",
"grau_similaridade",
"texto_infectado",
"=",
"i",
"i",
"=",
"i",
"+",
"1",
"print",
"(",
"\"O autor do texto %d está infectado com COH-PIAH\" ",
"(",
"t",
"exto_infectado)",
")",
"\r",
"return",
"texto_infectado",
"pass"
] | [
126,
0
] | [
144,
8
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
coletando_preco | (ativo, data_0, timeframe, data_1) | return precos | data_0 e data_1 são em pd.date_range | data_0 e data_1 são em pd.date_range | def coletando_preco(ativo, data_0, timeframe, data_1):
'data_0 e data_1 são em pd.date_range'
select = mt.symbol_select(ativo,True)
work_day = []
weekend_day = []
if not select:
print('O ativo {} não existe. Verificar se o código está correto. Coódigo do error = {}'.format(ativo, mt.last_error()))
else:
print('O ativo {} existe.'.format(ativo))
for i in np.arange(0,len(data_0)):
if calendar.day_name[data_0[i].weekday()] =='Saturday' or calendar.day_name[data_0[i].weekday()] =='Sunday':
weekend_day.append(i)
else:
work_day.append(i)
data_0 = data_0[work_day]
data_1 = data_1[work_day]
precos = pd.DataFrame()
for i in np.arange(0,len(data_0)):
rates_unico = mt.copy_rates_range(ativo,timeframe,data_0[i].to_pydatetime(),data_1[i].to_pydatetime())
df_unico = pd.DataFrame(rates_unico)
precos= pd.concat([precos,df_unico])
precos['time'] = pd.to_datetime(precos['time'], unit='s')
print('Os preços foram carregados com sucesso')
print('Total de {} registros'.format(len(precos)))
print('A coluna Time foi convertida pata Datetime.')
return precos | [
"def",
"coletando_preco",
"(",
"ativo",
",",
"data_0",
",",
"timeframe",
",",
"data_1",
")",
":",
"select",
"=",
"mt",
".",
"symbol_select",
"(",
"ativo",
",",
"True",
")",
"work_day",
"=",
"[",
"]",
"weekend_day",
"=",
"[",
"]",
"if",
"not",
"select",
":",
"print",
"(",
"'O ativo {} não existe. Verificar se o código está correto. Coódigo do error = {}'.for",
"m",
"at(ati",
"v",
"o, mt",
".",
"as",
"t",
"_error()))",
"",
"",
"",
"",
"else",
":",
"print",
"(",
"'O ativo {} existe.'",
".",
"format",
"(",
"ativo",
")",
")",
"for",
"i",
"in",
"np",
".",
"arange",
"(",
"0",
",",
"len",
"(",
"data_0",
")",
")",
":",
"if",
"calendar",
".",
"day_name",
"[",
"data_0",
"[",
"i",
"]",
".",
"weekday",
"(",
")",
"]",
"==",
"'Saturday'",
"or",
"calendar",
".",
"day_name",
"[",
"data_0",
"[",
"i",
"]",
".",
"weekday",
"(",
")",
"]",
"==",
"'Sunday'",
":",
"weekend_day",
".",
"append",
"(",
"i",
")",
"else",
":",
"work_day",
".",
"append",
"(",
"i",
")",
"data_0",
"=",
"data_0",
"[",
"work_day",
"]",
"data_1",
"=",
"data_1",
"[",
"work_day",
"]",
"precos",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"for",
"i",
"in",
"np",
".",
"arange",
"(",
"0",
",",
"len",
"(",
"data_0",
")",
")",
":",
"rates_unico",
"=",
"mt",
".",
"copy_rates_range",
"(",
"ativo",
",",
"timeframe",
",",
"data_0",
"[",
"i",
"]",
".",
"to_pydatetime",
"(",
")",
",",
"data_1",
"[",
"i",
"]",
".",
"to_pydatetime",
"(",
")",
")",
"df_unico",
"=",
"pd",
".",
"DataFrame",
"(",
"rates_unico",
")",
"precos",
"=",
"pd",
".",
"concat",
"(",
"[",
"precos",
",",
"df_unico",
"]",
")",
"precos",
"[",
"'time'",
"]",
"=",
"pd",
".",
"to_datetime",
"(",
"precos",
"[",
"'time'",
"]",
",",
"unit",
"=",
"'s'",
")",
"print",
"(",
"'Os preços foram carregados com sucesso')",
"",
"print",
"(",
"'Total de {} registros'",
".",
"format",
"(",
"len",
"(",
"precos",
")",
")",
")",
"print",
"(",
"'A coluna Time foi convertida pata Datetime.'",
")",
"return",
"precos"
] | [
50,
0
] | [
80,
17
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_formatted_name | (first_name, last_name, middle_name = '') | return full_name.title() | Devolve um nome completo formatado de modo elegante | Devolve um nome completo formatado de modo elegante | def get_formatted_name(first_name, last_name, middle_name = ''):
"""Devolve um nome completo formatado de modo elegante"""
if middle_name:
full_name = first_name + " " + middle_name + " " + last_name
else:
full_name = first_name + ' ' + last_name
return full_name.title() | [
"def",
"get_formatted_name",
"(",
"first_name",
",",
"last_name",
",",
"middle_name",
"=",
"''",
")",
":",
"if",
"middle_name",
":",
"full_name",
"=",
"first_name",
"+",
"\" \"",
"+",
"middle_name",
"+",
"\" \"",
"+",
"last_name",
"else",
":",
"full_name",
"=",
"first_name",
"+",
"' '",
"+",
"last_name",
"return",
"full_name",
".",
"title",
"(",
")"
] | [
2,
0
] | [
8,
28
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
get_issn_by_document | (journals: dict, document: dict) | Recupera o ISSN ID do Periódico em `journals` ao qual o documento pertence,
através dos ISSNs em `document`.
`journals`: dicionário obtido por `get_journals_from_json()`
`document`: dados de um registro do arquivo JSON resultado da importação
| Recupera o ISSN ID do Periódico em `journals` ao qual o documento pertence,
através dos ISSNs em `document`.
`journals`: dicionário obtido por `get_journals_from_json()`
`document`: dados de um registro do arquivo JSON resultado da importação
| def get_issn_by_document(journals: dict, document: dict):
"""Recupera o ISSN ID do Periódico em `journals` ao qual o documento pertence,
através dos ISSNs em `document`.
`journals`: dicionário obtido por `get_journals_from_json()`
`document`: dados de um registro do arquivo JSON resultado da importação
"""
for issn_type in ("eissn", "pissn", "issn"):
if document.get(issn_type) is not None:
issn_value = document[issn_type].strip()
if journals.get(issn_value) is not None:
logger.debug(
'Document "%s" published in ISSN "%s"',
document["pid_v3"],
journals[issn_value],
)
return journals[issn_value] | [
"def",
"get_issn_by_document",
"(",
"journals",
":",
"dict",
",",
"document",
":",
"dict",
")",
":",
"for",
"issn_type",
"in",
"(",
"\"eissn\"",
",",
"\"pissn\"",
",",
"\"issn\"",
")",
":",
"if",
"document",
".",
"get",
"(",
"issn_type",
")",
"is",
"not",
"None",
":",
"issn_value",
"=",
"document",
"[",
"issn_type",
"]",
".",
"strip",
"(",
")",
"if",
"journals",
".",
"get",
"(",
"issn_value",
")",
"is",
"not",
"None",
":",
"logger",
".",
"debug",
"(",
"'Document \"%s\" published in ISSN \"%s\"'",
",",
"document",
"[",
"\"pid_v3\"",
"]",
",",
"journals",
"[",
"issn_value",
"]",
",",
")",
"return",
"journals",
"[",
"issn_value",
"]"
] | [
103,
0
] | [
119,
43
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
BayesNode.__init__ | (self, X, parents, cpt) | X é um nome de variável, e os pais uma seqüência de variável
Nomes ou uma seqüência separada por espaço. Cpt, o condicional
Tabela de probabilidade, toma uma destas formas:
* Um número, a probabilidade incondicional P (X = verdadeiro). Você pode
Use este formulário quando não houver pais.
* A dict {v: p, ...}, a distribuição de probabilidade condicional
P (X = verdadeiro | pai = v) = p. Quando há apenas um pai.
* A dict {(v1, v2, ...): p, ...}, a distribuição P (X = true |
Parent1 = v1, parent2 = v2, ...) = p. Cada chave deve ter
Valores como existem pais. Você pode usar este formulário sempre;
Os dois primeiros são apenas conveniências.
Em todos os casos, a probabilidade de X ser falso é deixada implícita,
Pois segue de P (X = verdadeiro).
| X é um nome de variável, e os pais uma seqüência de variável
Nomes ou uma seqüência separada por espaço. Cpt, o condicional
Tabela de probabilidade, toma uma destas formas: | def __init__(self, X, parents, cpt):
"""X é um nome de variável, e os pais uma seqüência de variável
Nomes ou uma seqüência separada por espaço. Cpt, o condicional
Tabela de probabilidade, toma uma destas formas:
* Um número, a probabilidade incondicional P (X = verdadeiro). Você pode
Use este formulário quando não houver pais.
* A dict {v: p, ...}, a distribuição de probabilidade condicional
P (X = verdadeiro | pai = v) = p. Quando há apenas um pai.
* A dict {(v1, v2, ...): p, ...}, a distribuição P (X = true |
Parent1 = v1, parent2 = v2, ...) = p. Cada chave deve ter
Valores como existem pais. Você pode usar este formulário sempre;
Os dois primeiros são apenas conveniências.
Em todos os casos, a probabilidade de X ser falso é deixada implícita,
Pois segue de P (X = verdadeiro).
"""
if isinstance(parents, str):
parents = parents.split()
# Armazenamos a tabela sempre na terceira forma acima.
if isinstance(cpt, (float, int)):
cpt = {(): cpt}
elif isinstance(cpt, dict):
# one parent, 1-tuple
if cpt and isinstance(list(cpt.keys())[0], bool):
cpt = {(v,): p for v, p in cpt.items()}
assert isinstance(cpt, dict)
for vs, p in cpt.items():
assert isinstance(vs, tuple) and len(vs) == len(parents)
assert all(isinstance(v, bool) for v in vs)
assert 0 <= p <= 1
self.variable = X
self.parents = parents
self.cpt = cpt
self.children = [] | [
"def",
"__init__",
"(",
"self",
",",
"X",
",",
"parents",
",",
"cpt",
")",
":",
"if",
"isinstance",
"(",
"parents",
",",
"str",
")",
":",
"parents",
"=",
"parents",
".",
"split",
"(",
")",
"# Armazenamos a tabela sempre na terceira forma acima.",
"if",
"isinstance",
"(",
"cpt",
",",
"(",
"float",
",",
"int",
")",
")",
":",
"cpt",
"=",
"{",
"(",
")",
":",
"cpt",
"}",
"elif",
"isinstance",
"(",
"cpt",
",",
"dict",
")",
":",
"# one parent, 1-tuple",
"if",
"cpt",
"and",
"isinstance",
"(",
"list",
"(",
"cpt",
".",
"keys",
"(",
")",
")",
"[",
"0",
"]",
",",
"bool",
")",
":",
"cpt",
"=",
"{",
"(",
"v",
",",
")",
":",
"p",
"for",
"v",
",",
"p",
"in",
"cpt",
".",
"items",
"(",
")",
"}",
"assert",
"isinstance",
"(",
"cpt",
",",
"dict",
")",
"for",
"vs",
",",
"p",
"in",
"cpt",
".",
"items",
"(",
")",
":",
"assert",
"isinstance",
"(",
"vs",
",",
"tuple",
")",
"and",
"len",
"(",
"vs",
")",
"==",
"len",
"(",
"parents",
")",
"assert",
"all",
"(",
"isinstance",
"(",
"v",
",",
"bool",
")",
"for",
"v",
"in",
"vs",
")",
"assert",
"0",
"<=",
"p",
"<=",
"1",
"self",
".",
"variable",
"=",
"X",
"self",
".",
"parents",
"=",
"parents",
"self",
".",
"cpt",
"=",
"cpt",
"self",
".",
"children",
"=",
"[",
"]"
] | [
199,
4
] | [
238,
26
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Battery.__init__ | (self, battery_size = 70) | Inicializa os atributos de uma bateria para carro elétrico. | Inicializa os atributos de uma bateria para carro elétrico. | def __init__(self, battery_size = 70):
"""Inicializa os atributos de uma bateria para carro elétrico."""
self.battery_size = battery_size | [
"def",
"__init__",
"(",
"self",
",",
"battery_size",
"=",
"70",
")",
":",
"self",
".",
"battery_size",
"=",
"battery_size"
] | [
43,
4
] | [
45,
40
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
perfect_square | (x) | Verifica se um número é quadrado perfeito ou não.
Args:
x (int, float): Número fornecido pelo usuário.
Returns:
[bool]: True se for quadrado perfeito e False caso contrário.
>>> perfect_square(36)
True
>>> perfect_square(132)
False
| Verifica se um número é quadrado perfeito ou não. | def perfect_square(x):
"""Verifica se um número é quadrado perfeito ou não.
Args:
x (int, float): Número fornecido pelo usuário.
Returns:
[bool]: True se for quadrado perfeito e False caso contrário.
>>> perfect_square(36)
True
>>> perfect_square(132)
False
"""
# Validar apenas positivos
if x >= 0:
result = sqrt(x)
if result - round(result) == 0.0:
return True
else:
return False | [
"def",
"perfect_square",
"(",
"x",
")",
":",
"# Validar apenas positivos",
"if",
"x",
">=",
"0",
":",
"result",
"=",
"sqrt",
"(",
"x",
")",
"if",
"result",
"-",
"round",
"(",
"result",
")",
"==",
"0.0",
":",
"return",
"True",
"else",
":",
"return",
"False"
] | [
47,
0
] | [
67,
24
] | null | python | pt | ['pt', 'pt', 'pt'] | True | true | null |
|
Compara.rank_rentabilidade | (self, top) | return (
fundo_df.sort_values(by="Rentabilidade", ascending=False)
.head(top)
.to_string(float_format="{:.2f}%".format)
) | Retorna rank dos fundos considerando a rentabilidade da cota. | Retorna rank dos fundos considerando a rentabilidade da cota. | def rank_rentabilidade(self, top):
"""Retorna rank dos fundos considerando a rentabilidade da cota."""
self.informe.cria_df_informe(
cnpj=",".join(set(self.cnpjs)), columns=["VL_QUOTA"]
)
fundo_df = self.calc_rentabilidade_periodo()
fundo_df = self.adiciona_denom_social(fundo_df)
return (
fundo_df.sort_values(by="Rentabilidade", ascending=False)
.head(top)
.to_string(float_format="{:.2f}%".format)
) | [
"def",
"rank_rentabilidade",
"(",
"self",
",",
"top",
")",
":",
"self",
".",
"informe",
".",
"cria_df_informe",
"(",
"cnpj",
"=",
"\",\"",
".",
"join",
"(",
"set",
"(",
"self",
".",
"cnpjs",
")",
")",
",",
"columns",
"=",
"[",
"\"VL_QUOTA\"",
"]",
")",
"fundo_df",
"=",
"self",
".",
"calc_rentabilidade_periodo",
"(",
")",
"fundo_df",
"=",
"self",
".",
"adiciona_denom_social",
"(",
"fundo_df",
")",
"return",
"(",
"fundo_df",
".",
"sort_values",
"(",
"by",
"=",
"\"Rentabilidade\"",
",",
"ascending",
"=",
"False",
")",
".",
"head",
"(",
"top",
")",
".",
"to_string",
"(",
"float_format",
"=",
"\"{:.2f}%\"",
".",
"format",
")",
")"
] | [
675,
4
] | [
686,
9
] | 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.