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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
cargar_sesion | (identidad) | return None | Devuelve la entrada correspondiente al usuario que inicio sesión. | Devuelve la entrada correspondiente al usuario que inicio sesión. | def cargar_sesion(identidad):
"""Devuelve la entrada correspondiente al usuario que inicio sesión."""
if identidad is not None:
return Usuario.query.get(identidad)
return None | [
"def",
"cargar_sesion",
"(",
"identidad",
")",
":",
"if",
"identidad",
"is",
"not",
"None",
":",
"return",
"Usuario",
".",
"query",
".",
"get",
"(",
"identidad",
")",
"return",
"None"
] | [
272,
0
] | [
276,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_obj_from_file | (file_path=None) | return config_obj | Función para leer un fichero json del que se conoce su ubicación.
Parameters
----------
file_path : str
ubicación del fichero que se leerá
Returns
-------
config_obj : dict
contenido del fichero en un diccionario de python
| Función para leer un fichero json del que se conoce su ubicación. | def get_obj_from_file(file_path=None):
"""Función para leer un fichero json del que se conoce su ubicación.
Parameters
----------
file_path : str
ubicación del fichero que se leerá
Returns
-------
config_obj : dict
contenido del fichero en un diccionario de python
"""
with open(file_path, 'r') as f:
config_obj = json.load(f)
return config_obj | [
"def",
"get_obj_from_file",
"(",
"file_path",
"=",
"None",
")",
":",
"with",
"open",
"(",
"file_path",
",",
"'r'",
")",
"as",
"f",
":",
"config_obj",
"=",
"json",
".",
"load",
"(",
"f",
")",
"return",
"config_obj"
] | [
39,
0
] | [
54,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
parse | (net: str, default_port: int = 17000, default_path: str = "/") | return network(**info) | Parsea una dirección
Esta función convierte una cadena como `localhost:17000/service`
en algo más manejable como `Network(address, port, path)`.
Args:
net:
La dirección parsear
default_port:
Si `net` no se especifica un puerto, se usa el valor por
defecto de esta opción.
default_path:
Si `path` no se especifica la ruta del servicio, se usa
el valor por defecto de esta opción.
Returns:
Una tupla con la dirección, el puerto y la ruta del servicio
Raises:
ValueError: Cuando el puerto sea inválido
| Parsea una dirección
Esta función convierte una cadena como `localhost:17000/service`
en algo más manejable como `Network(address, port, path)`. | def parse(net: str, default_port: int = 17000, default_path: str = "/") -> Tuple[str, int, str]:
"""Parsea una dirección
Esta función convierte una cadena como `localhost:17000/service`
en algo más manejable como `Network(address, port, path)`.
Args:
net:
La dirección parsear
default_port:
Si `net` no se especifica un puerto, se usa el valor por
defecto de esta opción.
default_path:
Si `path` no se especifica la ruta del servicio, se usa
el valor por defecto de esta opción.
Returns:
Una tupla con la dirección, el puerto y la ruta del servicio
Raises:
ValueError: Cuando el puerto sea inválido
"""
info = {}
path = None
port = None
default_path = __set_correct_path(default_path)
network = namedtuple(
"Network",
("address", "port", "path"),
defaults=(__check_port(default_port), default_path)
)
try:
(addr, path) = net.split("/", 1)
except ValueError:
(addr,) = net.split("/", 1)
else:
if not (path):
path = "/"
try:
(addr, port) = addr.split(":", 1)
except ValueError:
(addr,) = addr.split(":", 1)
else:
port = __check_port(port)
info["address"] = addr
if (path is not None):
info["path"] = __set_correct_path(path)
if (port is not None):
info["port"] = port
return network(**info) | [
"def",
"parse",
"(",
"net",
":",
"str",
",",
"default_port",
":",
"int",
"=",
"17000",
",",
"default_path",
":",
"str",
"=",
"\"/\"",
")",
"->",
"Tuple",
"[",
"str",
",",
"int",
",",
"str",
"]",
":",
"info",
"=",
"{",
"}",
"path",
"=",
"None",
"port",
"=",
"None",
"default_path",
"=",
"__set_correct_path",
"(",
"default_path",
")",
"network",
"=",
"namedtuple",
"(",
"\"Network\"",
",",
"(",
"\"address\"",
",",
"\"port\"",
",",
"\"path\"",
")",
",",
"defaults",
"=",
"(",
"__check_port",
"(",
"default_port",
")",
",",
"default_path",
")",
")",
"try",
":",
"(",
"addr",
",",
"path",
")",
"=",
"net",
".",
"split",
"(",
"\"/\"",
",",
"1",
")",
"except",
"ValueError",
":",
"(",
"addr",
",",
")",
"=",
"net",
".",
"split",
"(",
"\"/\"",
",",
"1",
")",
"else",
":",
"if",
"not",
"(",
"path",
")",
":",
"path",
"=",
"\"/\"",
"try",
":",
"(",
"addr",
",",
"port",
")",
"=",
"addr",
".",
"split",
"(",
"\":\"",
",",
"1",
")",
"except",
"ValueError",
":",
"(",
"addr",
",",
")",
"=",
"addr",
".",
"split",
"(",
"\":\"",
",",
"1",
")",
"else",
":",
"port",
"=",
"__check_port",
"(",
"port",
")",
"info",
"[",
"\"address\"",
"]",
"=",
"addr",
"if",
"(",
"path",
"is",
"not",
"None",
")",
":",
"info",
"[",
"\"path\"",
"]",
"=",
"__set_correct_path",
"(",
"path",
")",
"if",
"(",
"port",
"is",
"not",
"None",
")",
":",
"info",
"[",
"\"port\"",
"]",
"=",
"port",
"return",
"network",
"(",
"*",
"*",
"info",
")"
] | [
26,
0
] | [
91,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects._next_uid_and_increment | (self) | return actual_uid | Devuelve el uid siguiente para asignar e incrementa el contador para el siguiente.
:return: identificador único siguiente.
| Devuelve el uid siguiente para asignar e incrementa el contador para el siguiente. | def _next_uid_and_increment(self) -> int:
"""Devuelve el uid siguiente para asignar e incrementa el contador para el siguiente.
:return: identificador único siguiente.
"""
actual_uid = self._next_uid
self._next_uid += 1
return actual_uid | [
"def",
"_next_uid_and_increment",
"(",
"self",
")",
"->",
"int",
":",
"actual_uid",
"=",
"self",
".",
"_next_uid",
"self",
".",
"_next_uid",
"+=",
"1",
"return",
"actual_uid"
] | [
359,
4
] | [
366,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
db_ops | () | Función principal que se encarga de revisar que los argumentos pasados por la configuración es la correcta
para realizar una ejecución.
Esta función no tiene argumentos, pero usa los argumentos pasados por línea de comando cuando se ejecuta. Una vez se
encuentra la operación a realizar llama a la función correspondiente.
| Función principal que se encarga de revisar que los argumentos pasados por la configuración es la correcta
para realizar una ejecución. | def db_ops():
"""Función principal que se encarga de revisar que los argumentos pasados por la configuración es la correcta
para realizar una ejecución.
Esta función no tiene argumentos, pero usa los argumentos pasados por línea de comando cuando se ejecuta. Una vez se
encuentra la operación a realizar llama a la función correspondiente.
"""
parser = get_parser()
args = parser.parse_args()
config = None
supported_ops = ["reset-all", "init", "drop", "reset-results", "reset-executions"]
required_keys = ["db_name", "host", "user", "passwd"]
with open(args.config_file, 'r') as f:
config = json.load(f)
is_present = [k in config.keys() for k in required_keys]
operation = args.operation
if operation is None:
print("\t-> operation has not been provided as command option, it will try to find operation value in "
"configuration file")
if config.get("operation"):
operation = config.get("operation")
else:
print("\t-> operation has not be found. Aborting execution.")
print("\t-> provide an operation value: {options}".format(options=supported_ops))
exit(-1)
if all(is_present):
if operation in supported_ops:
op = operation
op_config = {
"host": config.get("host"),
"user": config.get("user"),
"passwd": config.get("passwd"),
"db_name": config.get("db_name")
}
if op == "reset-all":
drop_schema(**op_config)
create_schema(**op_config)
elif op == "init":
create_database(**op_config)
create_schema(**op_config)
elif op == "reset-results":
drop_results_schema(**op_config)
create_results_schema(**op_config)
elif op == "reset-executions":
drop_execution_schema(**op_config)
create_execution_schema(**op_config)
else:
drop_schema(**op_config)
else:
print("\t -> operation {op} is not supported".format(op=config.get("operation")))
print("\t -> try one of the following ones: {options}".format(options=supported_ops))
exit(-1)
else:
print("\t -> there is not all the required keys present in configuration file")
print("\t\t - {required_keys}".format(required_keys=required_keys))
parser.print_help()
exit(-1) | [
"def",
"db_ops",
"(",
")",
":",
"parser",
"=",
"get_parser",
"(",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"config",
"=",
"None",
"supported_ops",
"=",
"[",
"\"reset-all\"",
",",
"\"init\"",
",",
"\"drop\"",
",",
"\"reset-results\"",
",",
"\"reset-executions\"",
"]",
"required_keys",
"=",
"[",
"\"db_name\"",
",",
"\"host\"",
",",
"\"user\"",
",",
"\"passwd\"",
"]",
"with",
"open",
"(",
"args",
".",
"config_file",
",",
"'r'",
")",
"as",
"f",
":",
"config",
"=",
"json",
".",
"load",
"(",
"f",
")",
"is_present",
"=",
"[",
"k",
"in",
"config",
".",
"keys",
"(",
")",
"for",
"k",
"in",
"required_keys",
"]",
"operation",
"=",
"args",
".",
"operation",
"if",
"operation",
"is",
"None",
":",
"print",
"(",
"\"\\t-> operation has not been provided as command option, it will try to find operation value in \"",
"\"configuration file\"",
")",
"if",
"config",
".",
"get",
"(",
"\"operation\"",
")",
":",
"operation",
"=",
"config",
".",
"get",
"(",
"\"operation\"",
")",
"else",
":",
"print",
"(",
"\"\\t-> operation has not be found. Aborting execution.\"",
")",
"print",
"(",
"\"\\t-> provide an operation value: {options}\"",
".",
"format",
"(",
"options",
"=",
"supported_ops",
")",
")",
"exit",
"(",
"-",
"1",
")",
"if",
"all",
"(",
"is_present",
")",
":",
"if",
"operation",
"in",
"supported_ops",
":",
"op",
"=",
"operation",
"op_config",
"=",
"{",
"\"host\"",
":",
"config",
".",
"get",
"(",
"\"host\"",
")",
",",
"\"user\"",
":",
"config",
".",
"get",
"(",
"\"user\"",
")",
",",
"\"passwd\"",
":",
"config",
".",
"get",
"(",
"\"passwd\"",
")",
",",
"\"db_name\"",
":",
"config",
".",
"get",
"(",
"\"db_name\"",
")",
"}",
"if",
"op",
"==",
"\"reset-all\"",
":",
"drop_schema",
"(",
"*",
"*",
"op_config",
")",
"create_schema",
"(",
"*",
"*",
"op_config",
")",
"elif",
"op",
"==",
"\"init\"",
":",
"create_database",
"(",
"*",
"*",
"op_config",
")",
"create_schema",
"(",
"*",
"*",
"op_config",
")",
"elif",
"op",
"==",
"\"reset-results\"",
":",
"drop_results_schema",
"(",
"*",
"*",
"op_config",
")",
"create_results_schema",
"(",
"*",
"*",
"op_config",
")",
"elif",
"op",
"==",
"\"reset-executions\"",
":",
"drop_execution_schema",
"(",
"*",
"*",
"op_config",
")",
"create_execution_schema",
"(",
"*",
"*",
"op_config",
")",
"else",
":",
"drop_schema",
"(",
"*",
"*",
"op_config",
")",
"else",
":",
"print",
"(",
"\"\\t -> operation {op} is not supported\"",
".",
"format",
"(",
"op",
"=",
"config",
".",
"get",
"(",
"\"operation\"",
")",
")",
")",
"print",
"(",
"\"\\t -> try one of the following ones: {options}\"",
".",
"format",
"(",
"options",
"=",
"supported_ops",
")",
")",
"exit",
"(",
"-",
"1",
")",
"else",
":",
"print",
"(",
"\"\\t -> there is not all the required keys present in configuration file\"",
")",
"print",
"(",
"\"\\t\\t - {required_keys}\"",
".",
"format",
"(",
"required_keys",
"=",
"required_keys",
")",
")",
"parser",
".",
"print_help",
"(",
")",
"exit",
"(",
"-",
"1",
")"
] | [
362,
0
] | [
419,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_sentencia_if_1 | (t) | sentencia_if : IF Exp THEN instrucciones_procedure sentencias_opcionales_if END IF | sentencia_if : IF Exp THEN instrucciones_procedure sentencias_opcionales_if END IF | def p_sentencia_if_1(t):
'''sentencia_if : IF Exp THEN instrucciones_procedure sentencias_opcionales_if END IF'''
t[0] = Start("SENTENCIA_IF")
t[0].addChild(t[2])
t[0].addChild(t[4])
t[0].addChild(t[5]) | [
"def",
"p_sentencia_if_1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"SENTENCIA_IF\"",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"2",
"]",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"4",
"]",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"5",
"]",
")"
] | [
1633,
0
] | [
1638,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
area_circulo | (radio: float) | return pi * radio ** 2 | Calcula el área de un círculo.
:param radio: Radio del círculo.
:type radio: float
:return: Área del círculo.
:rtype: float
| Calcula el área de un círculo.
:param radio: Radio del círculo.
:type radio: float
:return: Área del círculo.
:rtype: float
| def area_circulo(radio: float) -> float:
"""Calcula el área de un círculo.
:param radio: Radio del círculo.
:type radio: float
:return: Área del círculo.
:rtype: float
"""
return pi * radio ** 2 | [
"def",
"area_circulo",
"(",
"radio",
":",
"float",
")",
"->",
"float",
":",
"return",
"pi",
"*",
"radio",
"**",
"2"
] | [
9,
0
] | [
17,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
del_gap | (seq) | return seq.replace('-', '').replace('.', '') | Elimina gaps de la secuencia | Elimina gaps de la secuencia | def del_gap(seq):
"""Elimina gaps de la secuencia"""
return seq.replace('-', '').replace('.', '') | [
"def",
"del_gap",
"(",
"seq",
")",
":",
"return",
"seq",
".",
"replace",
"(",
"'-'",
",",
"''",
")",
".",
"replace",
"(",
"'.'",
",",
"''",
")"
] | [
73,
0
] | [
75,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_propiedades5 | (t) | propiedades : null | propiedades : null | def p_propiedades5(t):
'''propiedades : null'''
node = grammer.nodoDireccion('propiedades')
node1 = grammer.nodoDireccion(t[1])
node.agregar(node1)
t[0] = node | [
"def",
"p_propiedades5",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'propiedades'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
311,
0
] | [
317,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.dim | (self) | return len(self[0]), len(self) | Metodo para indicar las dimensiones de la matriz: fila, columna. | Metodo para indicar las dimensiones de la matriz: fila, columna. | def dim(self):
""" Metodo para indicar las dimensiones de la matriz: fila, columna. """
return len(self[0]), len(self) | [
"def",
"dim",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
"[",
"0",
"]",
")",
",",
"len",
"(",
"self",
")"
] | [
179,
4
] | [
181,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UrlsExtractor.boot_writer | (self) | Arranca y configura el writer que corresponda dependiendo del soporte de salida que se haya configurado para
la ejecución del programa.
| Arranca y configura el writer que corresponda dependiendo del soporte de salida que se haya configurado para
la ejecución del programa.
| def boot_writer(self):
"""Arranca y configura el writer que corresponda dependiendo del soporte de salida que se haya configurado para
la ejecución del programa.
"""
if self._output_config.get("type") == "file":
# soporte de salida: `output_config.type="file"`
config = self._output_config.get("file")
required_keys = ["results_path"]
if validate_required_keys(required_keys, config):
self._writer = UrlFileWriter(config=config)
self._writer.auto_boot()
else:
self.logger.error("wrong writer config. required configuration is not present")
self.logger.error("make sure the output_config has the required configuration set: {required}"
.format(required=required_keys))
elif self._output_config.get("type") == "db":
# soporte de salida: `output_config.type="db"`
config = self._output_config.get("db").get("config")
required_keys = ["host", "database", "db_user", "db_pass"]
if validate_required_keys(required_keys, config):
self._writer = UrlDbWriter(config=config)
self._writer.auto_boot()
else:
self.logger.error("wrong writer config. required configuration is not present")
self.logger.error("make sure the output_config has the required configuration set: {required}"
.format(required=required_keys))
else:
self.logger.error("writer type is not supported") | [
"def",
"boot_writer",
"(",
"self",
")",
":",
"if",
"self",
".",
"_output_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"file\"",
":",
"# soporte de salida: `output_config.type=\"file\"`",
"config",
"=",
"self",
".",
"_output_config",
".",
"get",
"(",
"\"file\"",
")",
"required_keys",
"=",
"[",
"\"results_path\"",
"]",
"if",
"validate_required_keys",
"(",
"required_keys",
",",
"config",
")",
":",
"self",
".",
"_writer",
"=",
"UrlFileWriter",
"(",
"config",
"=",
"config",
")",
"self",
".",
"_writer",
".",
"auto_boot",
"(",
")",
"else",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"wrong writer config. required configuration is not present\"",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"make sure the output_config has the required configuration set: {required}\"",
".",
"format",
"(",
"required",
"=",
"required_keys",
")",
")",
"elif",
"self",
".",
"_output_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"db\"",
":",
"# soporte de salida: `output_config.type=\"db\"`",
"config",
"=",
"self",
".",
"_output_config",
".",
"get",
"(",
"\"db\"",
")",
".",
"get",
"(",
"\"config\"",
")",
"required_keys",
"=",
"[",
"\"host\"",
",",
"\"database\"",
",",
"\"db_user\"",
",",
"\"db_pass\"",
"]",
"if",
"validate_required_keys",
"(",
"required_keys",
",",
"config",
")",
":",
"self",
".",
"_writer",
"=",
"UrlDbWriter",
"(",
"config",
"=",
"config",
")",
"self",
".",
"_writer",
".",
"auto_boot",
"(",
")",
"else",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"wrong writer config. required configuration is not present\"",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"make sure the output_config has the required configuration set: {required}\"",
".",
"format",
"(",
"required",
"=",
"required_keys",
")",
")",
"else",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"writer type is not supported\"",
")"
] | [
75,
4
] | [
102,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
anio_bisiesto | () | Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones:
- Si el año es divisible por 4 es bisiesto, a menos que:
- Si el año es divisible por 100 no es bisiesto a menos que:
- Si el año es divisible por 400 es bisiesto.
Retorna True o False
| Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones: | def anio_bisiesto():
'''Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones:
- Si el año es divisible por 4 es bisiesto, a menos que:
- Si el año es divisible por 100 no es bisiesto a menos que:
- Si el año es divisible por 400 es bisiesto.
Retorna True o False
'''
pass | [
"def",
"anio_bisiesto",
"(",
")",
":",
"pass"
] | [
11,
0
] | [
23,
8
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Datos.__iter__ | (self) | Texto y metadata de cada registro en DataFrame. | Texto y metadata de cada registro en DataFrame. | def __iter__(self):
"""Texto y metadata de cada registro en DataFrame."""
for row in self.df.itertuples():
texto = getattr(row, self.textcol)
meta = {k: getattr(row, k) for k in self.metacols}
if self.chars:
texto = filtrar_cortas(texto, chars=self.chars)
yield texto, meta | [
"def",
"__iter__",
"(",
"self",
")",
":",
"for",
"row",
"in",
"self",
".",
"df",
".",
"itertuples",
"(",
")",
":",
"texto",
"=",
"getattr",
"(",
"row",
",",
"self",
".",
"textcol",
")",
"meta",
"=",
"{",
"k",
":",
"getattr",
"(",
"row",
",",
"k",
")",
"for",
"k",
"in",
"self",
".",
"metacols",
"}",
"if",
"self",
".",
"chars",
":",
"texto",
"=",
"filtrar_cortas",
"(",
"texto",
",",
"chars",
"=",
"self",
".",
"chars",
")",
"yield",
"texto",
",",
"meta"
] | [
352,
4
] | [
361,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
populate | () | Carga los íconos en la variable 'DATA'. | Carga los íconos en la variable 'DATA'. | def populate():
"""Carga los íconos en la variable 'DATA'."""
for path in ICON_DIR.iterdir():
try:
DATA[path.name] = {
"path": path,
"url": STATIC_URL + "icons/" + path.name,
"data": open(path, "r").read(),
}
except (IOError) as e:
warnings.warn(e) | [
"def",
"populate",
"(",
")",
":",
"for",
"path",
"in",
"ICON_DIR",
".",
"iterdir",
"(",
")",
":",
"try",
":",
"DATA",
"[",
"path",
".",
"name",
"]",
"=",
"{",
"\"path\"",
":",
"path",
",",
"\"url\"",
":",
"STATIC_URL",
"+",
"\"icons/\"",
"+",
"path",
".",
"name",
",",
"\"data\"",
":",
"open",
"(",
"path",
",",
"\"r\"",
")",
".",
"read",
"(",
")",
",",
"}",
"except",
"(",
"IOError",
")",
"as",
"e",
":",
"warnings",
".",
"warn",
"(",
"e",
")"
] | [
26,
0
] | [
36,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
promedio_anual | (dict_: Dict[str, List[int]]) | return {k: round(sum(v) / len(v), 2) for k, v in dict_.items()} | Calcula el promedio anual de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Diccionario con los promedios anuales de cada región.
:rtype: Dict[str, int]
| Calcula el promedio anual de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Diccionario con los promedios anuales de cada región.
:rtype: Dict[str, int]
| def promedio_anual(dict_: Dict[str, List[int]]) -> Dict[str, int]:
"""Calcula el promedio anual de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Diccionario con los promedios anuales de cada región.
:rtype: Dict[str, int]
"""
return {k: round(sum(v) / len(v), 2) for k, v in dict_.items()} | [
"def",
"promedio_anual",
"(",
"dict_",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"int",
"]",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"int",
"]",
":",
"return",
"{",
"k",
":",
"round",
"(",
"sum",
"(",
"v",
")",
"/",
"len",
"(",
"v",
")",
",",
"2",
")",
"for",
"k",
",",
"v",
"in",
"dict_",
".",
"items",
"(",
")",
"}"
] | [
30,
0
] | [
38,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instruccioneslista2 | (t) | instru : instrucciones | instru : instrucciones | def p_instruccioneslista2(t):
'''instru : instrucciones'''
id = inc()
t[0] = id
dot.node(str(id),str("instrus"))
dot.edge(str(id),str(t[1])) | [
"def",
"p_instruccioneslista2",
"(",
"t",
")",
":",
"id",
"=",
"inc",
"(",
")",
"t",
"[",
"0",
"]",
"=",
"id",
"dot",
".",
"node",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"\"instrus\"",
")",
")",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"t",
"[",
"1",
"]",
")",
")"
] | [
185,
0
] | [
190,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
apply_homography_objects_detections | (objects_detections: List[List[Object]],
h: np.ndarray) | return [apply_homography_objects(objects, h) for objects in objects_detections] | Aplica la homografía a una lista de listas de detecciones de objetos.
:param objects_detections: lista la lista de detecciones de objetos de cada frame.
:param h: matriz de homografía.
:return: lista de listas de detecciones de objetos con la homografía aplicada.
| Aplica la homografía a una lista de listas de detecciones de objetos. | def apply_homography_objects_detections(objects_detections: List[List[Object]],
h: np.ndarray) -> List[List[Object]]:
"""Aplica la homografía a una lista de listas de detecciones de objetos.
:param objects_detections: lista la lista de detecciones de objetos de cada frame.
:param h: matriz de homografía.
:return: lista de listas de detecciones de objetos con la homografía aplicada.
"""
return [apply_homography_objects(objects, h) for objects in objects_detections] | [
"def",
"apply_homography_objects_detections",
"(",
"objects_detections",
":",
"List",
"[",
"List",
"[",
"Object",
"]",
"]",
",",
"h",
":",
"np",
".",
"ndarray",
")",
"->",
"List",
"[",
"List",
"[",
"Object",
"]",
"]",
":",
"return",
"[",
"apply_homography_objects",
"(",
"objects",
",",
"h",
")",
"for",
"objects",
"in",
"objects_detections",
"]"
] | [
64,
0
] | [
72,
83
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones56 | (p) | funciones : TRUNC PABRE tipo_numero COMA NUMERO PCIERRA | funciones : TRUNC PABRE tipo_numero COMA NUMERO PCIERRA | def p_funciones56(p):
'funciones : TRUNC PABRE tipo_numero COMA NUMERO PCIERRA' | [
"def",
"p_funciones56",
"(",
"p",
")",
":"
] | [
466,
0
] | [
467,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
pubmed_search | (auth: str, wd_list: list[str], file_path: str) | Funcion que realiza una busqueda en Entrez dado un autor y una
lista de palabras contenidas en el titulo, generando un archivo con
los IDs en caso de obtener resultados | Funcion que realiza una busqueda en Entrez dado un autor y una
lista de palabras contenidas en el titulo, generando un archivo con
los IDs en caso de obtener resultados | def pubmed_search(auth: str, wd_list: list[str], file_path: str):
"""Funcion que realiza una busqueda en Entrez dado un autor y una
lista de palabras contenidas en el titulo, generando un archivo con
los IDs en caso de obtener resultados"""
# Obtener termino con palabras a buscar en el titulo uniendolos
# mediante OR
wds_term = ""
for wd in wd_list[0:len(wd_list) - 1]:
wds_term += f"{wd}[Title] OR "
wds_term += f"{wd_list[len(wd_list) - 1]}[Title]"
# Crear termino de busqueda con autor y palabras del titulo
term = f"{auth}[AUTH] AND ({wds_term})"
# Realizar busqueda
hdl = Entrez.esearch(db="pubmed", term=term)
result = Entrez.read(hdl)
hdl.close()
# Evaluar si se encontraron resultados
if int(result["Count"]) > 0:
# Guardar en archivo los resultados
file = open(file_path, "w")
file.write(str(result["IdList"]))
file.close()
else:
print("No results found") | [
"def",
"pubmed_search",
"(",
"auth",
":",
"str",
",",
"wd_list",
":",
"list",
"[",
"str",
"]",
",",
"file_path",
":",
"str",
")",
":",
"# Obtener termino con palabras a buscar en el titulo uniendolos",
"# mediante OR",
"wds_term",
"=",
"\"\"",
"for",
"wd",
"in",
"wd_list",
"[",
"0",
":",
"len",
"(",
"wd_list",
")",
"-",
"1",
"]",
":",
"wds_term",
"+=",
"f\"{wd}[Title] OR \"",
"wds_term",
"+=",
"f\"{wd_list[len(wd_list) - 1]}[Title]\"",
"# Crear termino de busqueda con autor y palabras del titulo",
"term",
"=",
"f\"{auth}[AUTH] AND ({wds_term})\"",
"# Realizar busqueda",
"hdl",
"=",
"Entrez",
".",
"esearch",
"(",
"db",
"=",
"\"pubmed\"",
",",
"term",
"=",
"term",
")",
"result",
"=",
"Entrez",
".",
"read",
"(",
"hdl",
")",
"hdl",
".",
"close",
"(",
")",
"# Evaluar si se encontraron resultados",
"if",
"int",
"(",
"result",
"[",
"\"Count\"",
"]",
")",
">",
"0",
":",
"# Guardar en archivo los resultados",
"file",
"=",
"open",
"(",
"file_path",
",",
"\"w\"",
")",
"file",
".",
"write",
"(",
"str",
"(",
"result",
"[",
"\"IdList\"",
"]",
")",
")",
"file",
".",
"close",
"(",
")",
"else",
":",
"print",
"(",
"\"No results found\"",
")"
] | [
88,
0
] | [
114,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RoomViewSet.create | (self, request, *args, **kwargs) | Crea la sala y el usuario banquero.
Devuelve el código de la sala y el token del usuario. | Crea la sala y el usuario banquero.
Devuelve el código de la sala y el token del usuario. | def create(self, request, *args, **kwargs):
""" Crea la sala y el usuario banquero.
Devuelve el código de la sala y el token del usuario. """
serializer = RoomSerializer(data=request.data)
if serializer.is_valid():
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
name = list(serializer.data['userBanker'].items())[0][1]
banquero = User.objects.get(username=name)
room = serializer.instance
idroom = room.idRoom
token, created = Token.objects.get_or_create(user=banquero)
data={
'idroom':idroom,
'access_token':token.key
}
return Response(data, status=status.HTTP_201_CREATED, headers=headers)
else:
return Response({"errors": (serializer.errors,)}, status=status.HTTP_400_BAD_REQUEST) | [
"def",
"create",
"(",
"self",
",",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"serializer",
"=",
"RoomSerializer",
"(",
"data",
"=",
"request",
".",
"data",
")",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"self",
".",
"perform_create",
"(",
"serializer",
")",
"headers",
"=",
"self",
".",
"get_success_headers",
"(",
"serializer",
".",
"data",
")",
"name",
"=",
"list",
"(",
"serializer",
".",
"data",
"[",
"'userBanker'",
"]",
".",
"items",
"(",
")",
")",
"[",
"0",
"]",
"[",
"1",
"]",
"banquero",
"=",
"User",
".",
"objects",
".",
"get",
"(",
"username",
"=",
"name",
")",
"room",
"=",
"serializer",
".",
"instance",
"idroom",
"=",
"room",
".",
"idRoom",
"token",
",",
"created",
"=",
"Token",
".",
"objects",
".",
"get_or_create",
"(",
"user",
"=",
"banquero",
")",
"data",
"=",
"{",
"'idroom'",
":",
"idroom",
",",
"'access_token'",
":",
"token",
".",
"key",
"}",
"return",
"Response",
"(",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_201_CREATED",
",",
"headers",
"=",
"headers",
")",
"else",
":",
"return",
"Response",
"(",
"{",
"\"errors\"",
":",
"(",
"serializer",
".",
"errors",
",",
")",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
32,
4
] | [
50,
97
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UrlsExtractor.get_gmaps_zip_url | (self, provided_driver=None) | return {"zip_code": self._postal_code, "gmaps_url": url, "gmaps_coordinates": coords, "country": self._country} | Función encargada de extraer la url exacta de búsqueda por código postal.
Parameters
----------
provided_driver : webdriver.Chrome
driver que se usará para acceder a las urls por código postal y país
Returns
-------
dict
devuelve un diccionario que contiene el código postal, el país, la url y coordenadas de google para el
código postal y país.
example:
{
"zip_code": "48005",
"gmaps_url": "https://www.google.com/maps/place/48005+Bilbao,+Biscay/@43.2598164,-2.9304266,15z",
"gmaps_coordinates": "@43.2598164,-2.9304266,15z",
"country": "Spain"
}
| Función encargada de extraer la url exacta de búsqueda por código postal. | def get_gmaps_zip_url(self, provided_driver=None):
"""Función encargada de extraer la url exacta de búsqueda por código postal.
Parameters
----------
provided_driver : webdriver.Chrome
driver que se usará para acceder a las urls por código postal y país
Returns
-------
dict
devuelve un diccionario que contiene el código postal, el país, la url y coordenadas de google para el
código postal y país.
example:
{
"zip_code": "48005",
"gmaps_url": "https://www.google.com/maps/place/48005+Bilbao,+Biscay/@43.2598164,-2.9304266,15z",
"gmaps_coordinates": "@43.2598164,-2.9304266,15z",
"country": "Spain"
}
"""
driver = provided_driver if provided_driver else self.get_driver()
# se accede a la url de búsqueda del código postal y país
url_get_coord = self._url_base_template.format(postal_code=self._postal_code,
country=self._country)
self.logger.info("-{postal_code}-: url to get coord: {url}".format(postal_code=self._postal_code,
url=url_get_coord))
driver.get(url_get_coord)
driver.wait.until(ec.url_changes(url_get_coord))
# una vez haya cargado la página, google maps actualiza la url con información extra para hacer más exacta la
# búsqueda. Para ser más exactos, le añade unas coordenadas e informacion extra al código postal y país.
current_url = driver.current_url
self.logger.debug("-{postal_code}-: url with coords: {url}".format(postal_code=self._postal_code,
url=current_url))
coords = current_url.split("/")[-2]
postal_code_extra_info = current_url.split("/")[-3]
self.logger.debug("-{postal_code}-: coords found -{coords}-".format(postal_code=self._postal_code,
coords=coords))
# {postal_code_info}/{coords}
url = self._url_coords_template.format(postal_code_info=postal_code_extra_info, coords=coords)
self.logger.info(
"-{postal_code}-: formatted url to look up results: {url}".format(postal_code=self._postal_code,
url=url))
return {"zip_code": self._postal_code, "gmaps_url": url, "gmaps_coordinates": coords, "country": self._country} | [
"def",
"get_gmaps_zip_url",
"(",
"self",
",",
"provided_driver",
"=",
"None",
")",
":",
"driver",
"=",
"provided_driver",
"if",
"provided_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"# se accede a la url de búsqueda del código postal y país",
"url_get_coord",
"=",
"self",
".",
"_url_base_template",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"country",
"=",
"self",
".",
"_country",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: url to get coord: {url}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"url",
"=",
"url_get_coord",
")",
")",
"driver",
".",
"get",
"(",
"url_get_coord",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"url_changes",
"(",
"url_get_coord",
")",
")",
"# una vez haya cargado la página, google maps actualiza la url con información extra para hacer más exacta la",
"# búsqueda. Para ser más exactos, le añade unas coordenadas e informacion extra al código postal y país.",
"current_url",
"=",
"driver",
".",
"current_url",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: url with coords: {url}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"url",
"=",
"current_url",
")",
")",
"coords",
"=",
"current_url",
".",
"split",
"(",
"\"/\"",
")",
"[",
"-",
"2",
"]",
"postal_code_extra_info",
"=",
"current_url",
".",
"split",
"(",
"\"/\"",
")",
"[",
"-",
"3",
"]",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: coords found -{coords}-\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"coords",
"=",
"coords",
")",
")",
"# {postal_code_info}/{coords}",
"url",
"=",
"self",
".",
"_url_coords_template",
".",
"format",
"(",
"postal_code_info",
"=",
"postal_code_extra_info",
",",
"coords",
"=",
"coords",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: formatted url to look up results: {url}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"url",
"=",
"url",
")",
")",
"return",
"{",
"\"zip_code\"",
":",
"self",
".",
"_postal_code",
",",
"\"gmaps_url\"",
":",
"url",
",",
"\"gmaps_coordinates\"",
":",
"coords",
",",
"\"country\"",
":",
"self",
".",
"_country",
"}"
] | [
112,
4
] | [
155,
119
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TraductorFiscal._cerrarComprobante | (self, *args) | return self.comando.closeDocument() | Envia el comando para cerrar un comprobante Fiscal | Envia el comando para cerrar un comprobante Fiscal | def _cerrarComprobante(self, *args):
"Envia el comando para cerrar un comprobante Fiscal"
return self.comando.closeDocument() | [
"def",
"_cerrarComprobante",
"(",
"self",
",",
"*",
"args",
")",
":",
"return",
"self",
".",
"comando",
".",
"closeDocument",
"(",
")"
] | [
186,
4
] | [
188,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BotClient.create_embed | (self, content: dict) | return embed | Crea un embed basado en el contenido de un diccionario | Crea un embed basado en el contenido de un diccionario | def create_embed(self, content: dict) -> object:
"""Crea un embed basado en el contenido de un diccionario"""
embed = discord.Embed(
title = content["title"],
description = content["description"],
color = int(content["color"], 16),
)
# Añade una miniatura a la pagina:
embed.set_thumbnail(url = content["thumbnail"])
# Añade texto en el cuerpo de la pagina:
for key, value in content["content"].items():
embed.add_field(name = key, value = value, inline = content["inline"])
# Añade texto en pie de pagina:
footertext = f'Powered by: LordFitoi/BasicBot v{bot_config["Version"]}'
embed.set_footer(text = footertext)
return embed | [
"def",
"create_embed",
"(",
"self",
",",
"content",
":",
"dict",
")",
"->",
"object",
":",
"embed",
"=",
"discord",
".",
"Embed",
"(",
"title",
"=",
"content",
"[",
"\"title\"",
"]",
",",
"description",
"=",
"content",
"[",
"\"description\"",
"]",
",",
"color",
"=",
"int",
"(",
"content",
"[",
"\"color\"",
"]",
",",
"16",
")",
",",
")",
"# Añade una miniatura a la pagina:",
"embed",
".",
"set_thumbnail",
"(",
"url",
"=",
"content",
"[",
"\"thumbnail\"",
"]",
")",
"# Añade texto en el cuerpo de la pagina:",
"for",
"key",
",",
"value",
"in",
"content",
"[",
"\"content\"",
"]",
".",
"items",
"(",
")",
":",
"embed",
".",
"add_field",
"(",
"name",
"=",
"key",
",",
"value",
"=",
"value",
",",
"inline",
"=",
"content",
"[",
"\"inline\"",
"]",
")",
"# Añade texto en pie de pagina:",
"footertext",
"=",
"f'Powered by: LordFitoi/BasicBot v{bot_config[\"Version\"]}'",
"embed",
".",
"set_footer",
"(",
"text",
"=",
"footertext",
")",
"return",
"embed"
] | [
24,
4
] | [
42,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NDD_eval | (x_sample, a, x) | return y | Evaluar el polinomio interpolante.
Args:
a : array
Diferencias divididas
x_sample : list or array
Valores donde quiero evaluar al polinomio
x : list or array
Valores X interpolados
Returns:
y : list or array
Valores del polinomio en x
| Evaluar el polinomio interpolante. | def NDD_eval(x_sample, a, x):
"""Evaluar el polinomio interpolante.
Args:
a : array
Diferencias divididas
x_sample : list or array
Valores donde quiero evaluar al polinomio
x : list or array
Valores X interpolados
Returns:
y : list or array
Valores del polinomio en x
"""
N = len(dd)
print(f"P = a[{N-1}]")
for i in range(N-2, -1, -1):
print(f"P = a[{i}] + p*(x-x[{i}])")
N = len(a)
y = []
for xx in x_sample:
p = a[N-1]
for i in range(N-2, -1, -1):
p = a[i] + p*(xx-x[i])
y.append(p)
return y | [
"def",
"NDD_eval",
"(",
"x_sample",
",",
"a",
",",
"x",
")",
":",
"N",
"=",
"len",
"(",
"dd",
")",
"print",
"(",
"f\"P = a[{N-1}]\"",
")",
"for",
"i",
"in",
"range",
"(",
"N",
"-",
"2",
",",
"-",
"1",
",",
"-",
"1",
")",
":",
"print",
"(",
"f\"P = a[{i}] + p*(x-x[{i}])\"",
")",
"N",
"=",
"len",
"(",
"a",
")",
"y",
"=",
"[",
"]",
"for",
"xx",
"in",
"x_sample",
":",
"p",
"=",
"a",
"[",
"N",
"-",
"1",
"]",
"for",
"i",
"in",
"range",
"(",
"N",
"-",
"2",
",",
"-",
"1",
",",
"-",
"1",
")",
":",
"p",
"=",
"a",
"[",
"i",
"]",
"+",
"p",
"*",
"(",
"xx",
"-",
"x",
"[",
"i",
"]",
")",
"y",
".",
"append",
"(",
"p",
")",
"return",
"y"
] | [
39,
0
] | [
66,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_cuerpo_funcion | (t) | cuerpo_funcion : declare_variables funcion_begin | cuerpo_funcion : declare_variables funcion_begin | def p_cuerpo_funcion(t):
'''cuerpo_funcion : declare_variables funcion_begin'''
t[0] = Cuerpo_Funcion(t[1],t[2]) | [
"def",
"p_cuerpo_funcion",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Cuerpo_Funcion",
"(",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"2",
"]",
")"
] | [
1445,
0
] | [
1447,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
visualization | (x,y,title) | Función para visualizar una muesta etiquetada en 2D,
tras reducir su dimensionalidad con PCA y posteriormente con T-SNE
Args:
x: muestra de puntos a visualizar
y: vector de etiquetas asociado a la muestra x
title: título para el gráfico generado
| Función para visualizar una muesta etiquetada en 2D,
tras reducir su dimensionalidad con PCA y posteriormente con T-SNE | def visualization(x,y,title):
""" Función para visualizar una muesta etiquetada en 2D,
tras reducir su dimensionalidad con PCA y posteriormente con T-SNE
Args:
x: muestra de puntos a visualizar
y: vector de etiquetas asociado a la muestra x
title: título para el gráfico generado
"""
#Escalamos las características para que tengan media 0 y varianza 1
x = StandardScaler().fit_transform(x)
#Realizamos un análisis de componentes principales, para quedarnos con 2 componentes y poder visualizar los datos
pca=PCA(n_components=2, random_state=1)
x_pca=pca.fit_transform(x)
#Visualizamos los datos resultantes en 2D
plot2D(x_pca, y, 'PCA\n'+title)
#Vemos la varianza explicada por cada una de las dos componentes
print("Varianza explicada: ", pca.explained_variance_ratio_)
#Reducimos ahora la dimensionalidad con t-SNE, partiendo de los resultados obtenidos con pca
x_tsne = TSNE(n_components=2, init=x_pca,perplexity=30).fit_transform(x)
#Visualizamos los datos resultantes en 2D
plot2D(x_tsne, y, 'TSNE\n'+title) | [
"def",
"visualization",
"(",
"x",
",",
"y",
",",
"title",
")",
":",
"#Escalamos las características para que tengan media 0 y varianza 1",
"x",
"=",
"StandardScaler",
"(",
")",
".",
"fit_transform",
"(",
"x",
")",
"#Realizamos un análisis de componentes principales, para quedarnos con 2 componentes y poder visualizar los datos",
"pca",
"=",
"PCA",
"(",
"n_components",
"=",
"2",
",",
"random_state",
"=",
"1",
")",
"x_pca",
"=",
"pca",
".",
"fit_transform",
"(",
"x",
")",
"#Visualizamos los datos resultantes en 2D",
"plot2D",
"(",
"x_pca",
",",
"y",
",",
"'PCA\\n'",
"+",
"title",
")",
"#Vemos la varianza explicada por cada una de las dos componentes",
"print",
"(",
"\"Varianza explicada: \"",
",",
"pca",
".",
"explained_variance_ratio_",
")",
"#Reducimos ahora la dimensionalidad con t-SNE, partiendo de los resultados obtenidos con pca",
"x_tsne",
"=",
"TSNE",
"(",
"n_components",
"=",
"2",
",",
"init",
"=",
"x_pca",
",",
"perplexity",
"=",
"30",
")",
".",
"fit_transform",
"(",
"x",
")",
"#Visualizamos los datos resultantes en 2D",
"plot2D",
"(",
"x_tsne",
",",
"y",
",",
"'TSNE\\n'",
"+",
"title",
")"
] | [
136,
0
] | [
158,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ArregloDinamico.insert | (self, k: int, obj: py_object) | Inserta un elemento en la posición k
:param k: posición del elemento
:k type: int
:param obj: elemento a insertar
:obj type: py_object
| Inserta un elemento en la posición k
:param k: posición del elemento
:k type: int
:param obj: elemento a insertar
:obj type: py_object
| def insert(self, k: int, obj: py_object) -> None:
"""Inserta un elemento en la posición k
:param k: posición del elemento
:k type: int
:param obj: elemento a insertar
:obj type: py_object
"""
if k < 0 or k > self._n:
raise IndexError("El indice esta fuera de rango")
if self._n == self._capacidad:
B = self._crear(self._capacidad * self._factor)
for i in range(self._n + 1):
if i < k:
B[i] = self._A[i]
elif i == k:
B[i] = obj
else:
B[i] = self._A[i - 1]
self._A = B
self._capacidad *= self._factor
else:
for i in range(self._n, k, -1):
self._A[i] = self._A[i - 1]
self._A[k] = obj
self._n += 1 | [
"def",
"insert",
"(",
"self",
",",
"k",
":",
"int",
",",
"obj",
":",
"py_object",
")",
"->",
"None",
":",
"if",
"k",
"<",
"0",
"or",
"k",
">",
"self",
".",
"_n",
":",
"raise",
"IndexError",
"(",
"\"El indice esta fuera de rango\"",
")",
"if",
"self",
".",
"_n",
"==",
"self",
".",
"_capacidad",
":",
"B",
"=",
"self",
".",
"_crear",
"(",
"self",
".",
"_capacidad",
"*",
"self",
".",
"_factor",
")",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_n",
"+",
"1",
")",
":",
"if",
"i",
"<",
"k",
":",
"B",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"i",
"]",
"elif",
"i",
"==",
"k",
":",
"B",
"[",
"i",
"]",
"=",
"obj",
"else",
":",
"B",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"i",
"-",
"1",
"]",
"self",
".",
"_A",
"=",
"B",
"self",
".",
"_capacidad",
"*=",
"self",
".",
"_factor",
"else",
":",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_n",
",",
"k",
",",
"-",
"1",
")",
":",
"self",
".",
"_A",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"i",
"-",
"1",
"]",
"self",
".",
"_A",
"[",
"k",
"]",
"=",
"obj",
"self",
".",
"_n",
"+=",
"1"
] | [
56,
4
] | [
81,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
parse | (function: Callable[..., Any]) | return args | Analiza una función y extrae los parámetros junto con
sus argumentos pre-determinados (si los contiene) | Analiza una función y extrae los parámetros junto con
sus argumentos pre-determinados (si los contiene) | def parse(function: Callable[..., Any]) -> Dict[int, dict]:
"""Analiza una función y extrae los parámetros junto con
sus argumentos pre-determinados (si los contiene)"""
sig = inspect.signature(function)
args = {
POSITIONAL_ONLY : {},
POSITIONAL_OR_KEYWORD : {},
VAR_POSITIONAL : {},
KEYWORD_ONLY : {},
VAR_KEYWORD : {}
}
for name, parameter in sig.parameters.items():
args[parameter.kind][name] = {
"default" : parameter.default,
"annotation" : parameter.annotation
}
return args | [
"def",
"parse",
"(",
"function",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
")",
"->",
"Dict",
"[",
"int",
",",
"dict",
"]",
":",
"sig",
"=",
"inspect",
".",
"signature",
"(",
"function",
")",
"args",
"=",
"{",
"POSITIONAL_ONLY",
":",
"{",
"}",
",",
"POSITIONAL_OR_KEYWORD",
":",
"{",
"}",
",",
"VAR_POSITIONAL",
":",
"{",
"}",
",",
"KEYWORD_ONLY",
":",
"{",
"}",
",",
"VAR_KEYWORD",
":",
"{",
"}",
"}",
"for",
"name",
",",
"parameter",
"in",
"sig",
".",
"parameters",
".",
"items",
"(",
")",
":",
"args",
"[",
"parameter",
".",
"kind",
"]",
"[",
"name",
"]",
"=",
"{",
"\"default\"",
":",
"parameter",
".",
"default",
",",
"\"annotation\"",
":",
"parameter",
".",
"annotation",
"}",
"return",
"args"
] | [
42,
0
] | [
64,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NanopubRequest.splitDeep | (step: Annotation, annotations: list) | return NanopubRequest(request_annotations) | construye una NanopubRequest para el step base pasado \n
y las anotaciones que se encuentre en el rango de este ('step.start'|'step.end')
| construye una NanopubRequest para el step base pasado \n
y las anotaciones que se encuentre en el rango de este ('step.start'|'step.end')
| def splitDeep(step: Annotation, annotations: list) -> NanopubRequest:
""" construye una NanopubRequest para el step base pasado \n
y las anotaciones que se encuentre en el rango de este ('step.start'|'step.end')
"""
request_annotations = [step]
for annotation in annotations:
if step.id != annotation.id and annotation.start >= step.start and annotation.end <= step.end:
request_annotations.append(annotation)
return NanopubRequest(request_annotations) | [
"def",
"splitDeep",
"(",
"step",
":",
"Annotation",
",",
"annotations",
":",
"list",
")",
"->",
"NanopubRequest",
":",
"request_annotations",
"=",
"[",
"step",
"]",
"for",
"annotation",
"in",
"annotations",
":",
"if",
"step",
".",
"id",
"!=",
"annotation",
".",
"id",
"and",
"annotation",
".",
"start",
">=",
"step",
".",
"start",
"and",
"annotation",
".",
"end",
"<=",
"step",
".",
"end",
":",
"request_annotations",
".",
"append",
"(",
"annotation",
")",
"return",
"NanopubRequest",
"(",
"request_annotations",
")"
] | [
68,
4
] | [
76,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Atom.__repr__ | (self) | return text | Metodo para representar el objeto Atom. | Metodo para representar el objeto Atom. | def __repr__(self):
""" Metodo para representar el objeto Atom. """
if self.flag:
temp = "*"
else:
temp = "x"
text = "<" + self.element + "-" + temp + ">"
return text | [
"def",
"__repr__",
"(",
"self",
")",
":",
"if",
"self",
".",
"flag",
":",
"temp",
"=",
"\"*\"",
"else",
":",
"temp",
"=",
"\"x\"",
"text",
"=",
"\"<\"",
"+",
"self",
".",
"element",
"+",
"\"-\"",
"+",
"temp",
"+",
"\">\"",
"return",
"text"
] | [
51,
4
] | [
58,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_inicio | (t) | inicio : instrucciones | inicio : instrucciones | def p_inicio(t):
'''inicio : instrucciones ''' | [
"def",
"p_inicio",
"(",
"t",
")",
":"
] | [
180,
0
] | [
181,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
HelloApiView.path | (self, request, pk=None) | return Response({'method':'PATCH'}) | Para hacer updates parciales | Para hacer updates parciales | def path(self, request, pk=None):
"""Para hacer updates parciales"""
return Response({'method':'PATCH'}) | [
"def",
"path",
"(",
"self",
",",
"request",
",",
"pk",
"=",
"None",
")",
":",
"return",
"Response",
"(",
"{",
"'method'",
":",
"'PATCH'",
"}",
")"
] | [
52,
4
] | [
54,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_binary_string2 | (t) | binary_string : funciones_string2 par1 operacion_aritmetica par2 | binary_string : funciones_string2 par1 operacion_aritmetica par2 | def p_binary_string2(t):
'binary_string : funciones_string2 par1 operacion_aritmetica par2'
node= grammer.nodoDireccion('binary_string')
node.agregar(t[1])
node.agregar(t[3])
t[0]= node | [
"def",
"p_binary_string2",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'binary_string'",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"3",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1920,
0
] | [
1925,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Annotation.var_includes | (self, var_key: str, value: str) | return _var == None or value in _var | true si el valor buscado se encuentra en el array de valores del var_key en el settings del annotation request
false de lo contrario
| true si el valor buscado se encuentra en el array de valores del var_key en el settings del annotation request
false de lo contrario
| def var_includes(self, var_key: str, value: str):
""" true si el valor buscado se encuentra en el array de valores del var_key en el settings del annotation request
false de lo contrario
"""
_var = self.var(var_key)
return _var == None or value in _var | [
"def",
"var_includes",
"(",
"self",
",",
"var_key",
":",
"str",
",",
"value",
":",
"str",
")",
":",
"_var",
"=",
"self",
".",
"var",
"(",
"var_key",
")",
"return",
"_var",
"==",
"None",
"or",
"value",
"in",
"_var"
] | [
40,
4
] | [
45,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
suma | (a: int, b: int) | Suma los números desde el inicio del rango (número menor) hasta
el final del rango (número mayor).
:param a: Número menor.
:a type: int
:param b: Número mayor.
:b type: int
:return: Suma de los números.
:rtype: int
| Suma los números desde el inicio del rango (número menor) hasta
el final del rango (número mayor). | def suma(a: int, b: int) -> int:
"""Suma los números desde el inicio del rango (número menor) hasta
el final del rango (número mayor).
:param a: Número menor.
:a type: int
:param b: Número mayor.
:b type: int
:return: Suma de los números.
:rtype: int
"""
if a > b:
b, a = a, b
if a == b:
return a
else:
return a + suma(a + 1, b) | [
"def",
"suma",
"(",
"a",
":",
"int",
",",
"b",
":",
"int",
")",
"->",
"int",
":",
"if",
"a",
">",
"b",
":",
"b",
",",
"a",
"=",
"a",
",",
"b",
"if",
"a",
"==",
"b",
":",
"return",
"a",
"else",
":",
"return",
"a",
"+",
"suma",
"(",
"a",
"+",
"1",
",",
"b",
")"
] | [
24,
0
] | [
40,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
findBestK | (x_train, y_train, params, R) | return scores | Función que calcula los valores de accuracy media obtenidos con validación
cruzada para los valores del parámetro K que se indican como parámetro, y
visualiza dichos valores en un gráfico
Args:
x_train: conjunto de entrenamiento
y_train: vector de etiquetas asociado al conjunto de entrenamiento
params: lista de valores para el parámetro K a probar
R: diámetro del conjunto de datos de entrenamiento
Returns:
scores: valores de accuracy en validación cruzada
para cada valor de K proporcionado
| Función que calcula los valores de accuracy media obtenidos con validación
cruzada para los valores del parámetro K que se indican como parámetro, y
visualiza dichos valores en un gráfico
Args:
x_train: conjunto de entrenamiento
y_train: vector de etiquetas asociado al conjunto de entrenamiento
params: lista de valores para el parámetro K a probar
R: diámetro del conjunto de datos de entrenamiento
Returns:
scores: valores de accuracy en validación cruzada
para cada valor de K proporcionado
| def findBestK(x_train, y_train, params, R):
""" Función que calcula los valores de accuracy media obtenidos con validación
cruzada para los valores del parámetro K que se indican como parámetro, y
visualiza dichos valores en un gráfico
Args:
x_train: conjunto de entrenamiento
y_train: vector de etiquetas asociado al conjunto de entrenamiento
params: lista de valores para el parámetro K a probar
R: diámetro del conjunto de datos de entrenamiento
Returns:
scores: valores de accuracy en validación cruzada
para cada valor de K proporcionado
"""
scores = []
print("Búsqueda del mejor valor para el parámetro K")
for i in range(len(params)):
#Aplicamos cross_validation con 3 particiones para determinar el accuracy del modelo
#y el resultado se añade al vector de scores
scores.append(cross_val_rbf(x_train, y_train, K_FOLDS, params[i], R=R))
print(params[i],":",scores[i])
params = np.array(params)
scores = np.array(scores)
plotScores(params, scores, 'lightcoral', 'Accuracy media frente a K', 'Número de clusters K', log=True)
return scores | [
"def",
"findBestK",
"(",
"x_train",
",",
"y_train",
",",
"params",
",",
"R",
")",
":",
"scores",
"=",
"[",
"]",
"print",
"(",
"\"Búsqueda del mejor valor para el parámetro K\")",
"",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"params",
")",
")",
":",
"#Aplicamos cross_validation con 3 particiones para determinar el accuracy del modelo",
"#y el resultado se añade al vector de scores",
"scores",
".",
"append",
"(",
"cross_val_rbf",
"(",
"x_train",
",",
"y_train",
",",
"K_FOLDS",
",",
"params",
"[",
"i",
"]",
",",
"R",
"=",
"R",
")",
")",
"print",
"(",
"params",
"[",
"i",
"]",
",",
"\":\"",
",",
"scores",
"[",
"i",
"]",
")",
"params",
"=",
"np",
".",
"array",
"(",
"params",
")",
"scores",
"=",
"np",
".",
"array",
"(",
"scores",
")",
"plotScores",
"(",
"params",
",",
"scores",
",",
"'lightcoral'",
",",
"'Accuracy media frente a K'",
",",
"'Número de clusters K',",
" ",
"og=",
"T",
"rue)",
"",
"return",
"scores"
] | [
178,
0
] | [
206,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
results_to_csv | (data, variants) | return True | **Función que escribe los resultados de la consulta en archivo csv**
Guarda los resultados de la consulta en formato ``csv`` en caso de
que la usuaria quiera descargarlos.
:param data_response: Resultados de la consulta devueltos
por el índice de ``elasticsearch``
:type: list
:param variants: Variantes actuales para saber si escribir variante
o dejar el campo vacío.
:type: dict
:return: Estatus del archivo. ``True`` si fue escrito, ``False`` en
caso contrario
:rtype: bool
| **Función que escribe los resultados de la consulta en archivo csv** | def results_to_csv(data, variants):
"""**Función que escribe los resultados de la consulta en archivo csv**
Guarda los resultados de la consulta en formato ``csv`` en caso de
que la usuaria quiera descargarlos.
:param data_response: Resultados de la consulta devueltos
por el índice de ``elasticsearch``
:type: list
:param variants: Variantes actuales para saber si escribir variante
o dejar el campo vacío.
:type: dict
:return: Estatus del archivo. ``True`` si fue escrito, ``False`` en
caso contrario
:rtype: bool
"""
row = []
file_name = "query-results.csv"
path_to_save = settings.BASE_DIR + settings.MEDIA_ROOT + file_name
mappings = es.indices.get_mapping(index=settings.INDEX)
del mappings[settings.INDEX]['mappings']['properties']['document_id']
del mappings[settings.INDEX]['mappings']['properties']['pdf_file']
del mappings[settings.INDEX]['mappings']['properties']['document_name']
with open(path_to_save, "w") as csv_file:
writer = csv.writer(csv_file)
csv_header = list(mappings[settings.INDEX]['mappings']['properties'].keys())
# Writing header
writer.writerow(csv_header)
for hit in data:
result = hit["_source"]
row = ["" for _ in range(len(csv_header))]
for field in result:
# Exclude fields when export query results to csv
if field in ["document_id", "pdf_file", "document_name"]:
continue
else:
header_position = csv_header.index(field)
row[header_position] = result[field]
writer.writerow(row)
return True | [
"def",
"results_to_csv",
"(",
"data",
",",
"variants",
")",
":",
"row",
"=",
"[",
"]",
"file_name",
"=",
"\"query-results.csv\"",
"path_to_save",
"=",
"settings",
".",
"BASE_DIR",
"+",
"settings",
".",
"MEDIA_ROOT",
"+",
"file_name",
"mappings",
"=",
"es",
".",
"indices",
".",
"get_mapping",
"(",
"index",
"=",
"settings",
".",
"INDEX",
")",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'document_id'",
"]",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'pdf_file'",
"]",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'document_name'",
"]",
"with",
"open",
"(",
"path_to_save",
",",
"\"w\"",
")",
"as",
"csv_file",
":",
"writer",
"=",
"csv",
".",
"writer",
"(",
"csv_file",
")",
"csv_header",
"=",
"list",
"(",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
".",
"keys",
"(",
")",
")",
"# Writing header",
"writer",
".",
"writerow",
"(",
"csv_header",
")",
"for",
"hit",
"in",
"data",
":",
"result",
"=",
"hit",
"[",
"\"_source\"",
"]",
"row",
"=",
"[",
"\"\"",
"for",
"_",
"in",
"range",
"(",
"len",
"(",
"csv_header",
")",
")",
"]",
"for",
"field",
"in",
"result",
":",
"# Exclude fields when export query results to csv",
"if",
"field",
"in",
"[",
"\"document_id\"",
",",
"\"pdf_file\"",
",",
"\"document_name\"",
"]",
":",
"continue",
"else",
":",
"header_position",
"=",
"csv_header",
".",
"index",
"(",
"field",
")",
"row",
"[",
"header_position",
"]",
"=",
"result",
"[",
"field",
"]",
"writer",
".",
"writerow",
"(",
"row",
")",
"return",
"True"
] | [
182,
0
] | [
221,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ColumnsDatabase.type_column_list | (self) | return self.type_column | Método consultor que nos devuevle la lista de los tipos de cada columna | Método consultor que nos devuevle la lista de los tipos de cada columna | def type_column_list(self):
"""Método consultor que nos devuevle la lista de los tipos de cada columna"""
return self.type_column | [
"def",
"type_column_list",
"(",
"self",
")",
":",
"return",
"self",
".",
"type_column"
] | [
52,
4
] | [
54,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TraductoresHandler.getWarnings | (self) | return collect_warnings | Recolecta los warning que puedan ir arrojando las impresoraas
devuelve un listado de warnings
| Recolecta los warning que puedan ir arrojando las impresoraas
devuelve un listado de warnings
| def getWarnings(self):
""" Recolecta los warning que puedan ir arrojando las impresoraas
devuelve un listado de warnings
"""
collect_warnings = {}
for trad in self.traductores:
if self.traductores[trad]:
warn = self.traductores[trad].comando.getWarnings()
if warn:
collect_warnings[trad] = warn
return collect_warnings | [
"def",
"getWarnings",
"(",
"self",
")",
":",
"collect_warnings",
"=",
"{",
"}",
"for",
"trad",
"in",
"self",
".",
"traductores",
":",
"if",
"self",
".",
"traductores",
"[",
"trad",
"]",
":",
"warn",
"=",
"self",
".",
"traductores",
"[",
"trad",
"]",
".",
"comando",
".",
"getWarnings",
"(",
")",
"if",
"warn",
":",
"collect_warnings",
"[",
"trad",
"]",
"=",
"warn",
"return",
"collect_warnings"
] | [
168,
4
] | [
178,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
User.describe_user | (self) | Informacion de usuario | Informacion de usuario | def describe_user(self):
"""Informacion de usuario"""
print("\n" + self.first_name + " " + self.last_name)
print(" Username: " + self.username)
print(" Email: " + self.email)
print(" Location: " + self.location) | [
"def",
"describe_user",
"(",
"self",
")",
":",
"print",
"(",
"\"\\n\"",
"+",
"self",
".",
"first_name",
"+",
"\" \"",
"+",
"self",
".",
"last_name",
")",
"print",
"(",
"\" Username: \"",
"+",
"self",
".",
"username",
")",
"print",
"(",
"\" Email: \"",
"+",
"self",
".",
"email",
")",
"print",
"(",
"\" Location: \"",
"+",
"self",
".",
"location",
")"
] | [
16,
4
] | [
21,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ReceiptDirectJetDriver.__init__ | (self, host, port=9100, timeout=10, codepage="cp858", mac="", vendor="", *args, **kwargs) | escrito aqui solo para tener bien en claro las variables iniciales | escrito aqui solo para tener bien en claro las variables iniciales | def __init__(self, host, port=9100, timeout=10, codepage="cp858", mac="", vendor="", *args, **kwargs):
""" escrito aqui solo para tener bien en claro las variables iniciales"""
"""
:param host : Printer's hostname or IP address
:param port : Port to write to
:param timeout : timeout in seconds for the socket-library
:param codepage : codepage default to cp858
"""
escpos.Escpos.__init__(self, *args, **kwargs)
self.host = host
self.port = int(port)
self.timeout = timeout
self.codepage = codepage | [
"def",
"__init__",
"(",
"self",
",",
"host",
",",
"port",
"=",
"9100",
",",
"timeout",
"=",
"10",
",",
"codepage",
"=",
"\"cp858\"",
",",
"mac",
"=",
"\"\"",
",",
"vendor",
"=",
"\"\"",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"\r\n :param host : Printer's hostname or IP address\r\n :param port : Port to write to\r\n :param timeout : timeout in seconds for the socket-library\r\n :param codepage : codepage default to cp858\r\n \"\"\"",
"escpos",
".",
"Escpos",
".",
"__init__",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"host",
"=",
"host",
"self",
".",
"port",
"=",
"int",
"(",
"port",
")",
"self",
".",
"timeout",
"=",
"timeout",
"self",
".",
"codepage",
"=",
"codepage"
] | [
16,
4
] | [
28,
32
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Optimizador.GenerarReporte | (self) | Generar el reporte en graphviz y el archivo de optimizacion | Generar el reporte en graphviz y el archivo de optimizacion | def GenerarReporte(self):
global CodigoOptimizado
"Generar el reporte en graphviz y el archivo de optimizacion"
#PARA EL ARCHIVO
Nombre = "Salidas/CodigoOptimizado.py"
texto = ""
for elem in ResultadoFinal:
if isinstance(elem, obj.Temporal):
texto += str(elem.indice) + " = " + str(elem.valor) + "\n"
else:
texto += elem + "\n"
try:
os.makedirs(os.path.dirname(Nombre), exist_ok=True)
with open(Nombre, "w") as f:
f.write('''
from datetime import date
from variables import tabla as ts
from variables import NombreDB
from variables import cont
import tablaDGA as TAS
import sql as sql
import mathtrig as mt
from reportTable import *
pila = []
for i in range(100):
pila.append(i)
def ejecutar():
\tglobal cont
\tglobal ts
\tNombreDB = ts.nameDB
\n''')
f.write(texto)
f.write('''ejecutar()''')
f.close()
except:
print("No se pudo generar el archivo del codigo generado")
#PARA REPORTE
reporteopt.graphTable(CodigoOptimizado) | [
"def",
"GenerarReporte",
"(",
"self",
")",
":",
"global",
"CodigoOptimizado",
"#PARA EL ARCHIVO",
"Nombre",
"=",
"\"Salidas/CodigoOptimizado.py\"",
"texto",
"=",
"\"\"",
"for",
"elem",
"in",
"ResultadoFinal",
":",
"if",
"isinstance",
"(",
"elem",
",",
"obj",
".",
"Temporal",
")",
":",
"texto",
"+=",
"str",
"(",
"elem",
".",
"indice",
")",
"+",
"\" = \"",
"+",
"str",
"(",
"elem",
".",
"valor",
")",
"+",
"\"\\n\"",
"else",
":",
"texto",
"+=",
"elem",
"+",
"\"\\n\"",
"try",
":",
"os",
".",
"makedirs",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"Nombre",
")",
",",
"exist_ok",
"=",
"True",
")",
"with",
"open",
"(",
"Nombre",
",",
"\"w\"",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"'''\nfrom datetime import date\nfrom variables import tabla as ts\nfrom variables import NombreDB \nfrom variables import cont \nimport tablaDGA as TAS\nimport sql as sql \nimport mathtrig as mt\nfrom reportTable import *\n \n \npila = []\nfor i in range(100):\n pila.append(i)\n \ndef ejecutar():\n\\tglobal cont\n\\tglobal ts\n\\tNombreDB = ts.nameDB\n\\n'''",
")",
"f",
".",
"write",
"(",
"texto",
")",
"f",
".",
"write",
"(",
"'''ejecutar()'''",
")",
"f",
".",
"close",
"(",
")",
"except",
":",
"print",
"(",
"\"No se pudo generar el archivo del codigo generado\"",
")",
"#PARA REPORTE",
"reporteopt",
".",
"graphTable",
"(",
"CodigoOptimizado",
")"
] | [
229,
4
] | [
269,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Parser.destroy | (
self,
message: bytes,
real_user: Union[str, bytes],
*args, **kwargs
) | return hibrid.decrypt(
verify_key,
self.session.destination,
self.session.source.private,
message,
*args, **kwargs
) | Descifra la petición del usuario.
Esta es la contraparte de `build()`
Args:
message:
El mensaje a descifrar
real_user:
El identificador de usuario. Si es un tipo ``bytes`` se convierte
a una cadena hexadecimal. La longitud no puede ser diferente a
28 o 56 digitos.
*args:
Argumentos variables para `hibrid.decrypt()`
**kwargs:
Argumentos variables para `hibrid.decrypt()`
Returns:
Los datos descifrados y verificados
| Descifra la petición del usuario. | async def destroy(
self,
message: bytes,
real_user: Union[str, bytes],
*args, **kwargs
) -> bytes:
"""Descifra la petición del usuario.
Esta es la contraparte de `build()`
Args:
message:
El mensaje a descifrar
real_user:
El identificador de usuario. Si es un tipo ``bytes`` se convierte
a una cadena hexadecimal. La longitud no puede ser diferente a
28 o 56 digitos.
*args:
Argumentos variables para `hibrid.decrypt()`
**kwargs:
Argumentos variables para `hibrid.decrypt()`
Returns:
Los datos descifrados y verificados
"""
real_user = self.__user2hex(real_user)
key_path = os.path.join(self.user_dir, real_user)
self.__check_key(key_path)
async with aiofiles.open(key_path, "rb") as fd:
verify_key = await fd.read()
logging.debug(_("Descifrando datos del identificador '%s'..."), real_user)
return hibrid.decrypt(
verify_key,
self.session.destination,
self.session.source.private,
message,
*args, **kwargs
) | [
"async",
"def",
"destroy",
"(",
"self",
",",
"message",
":",
"bytes",
",",
"real_user",
":",
"Union",
"[",
"str",
",",
"bytes",
"]",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"bytes",
":",
"real_user",
"=",
"self",
".",
"__user2hex",
"(",
"real_user",
")",
"key_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"user_dir",
",",
"real_user",
")",
"self",
".",
"__check_key",
"(",
"key_path",
")",
"async",
"with",
"aiofiles",
".",
"open",
"(",
"key_path",
",",
"\"rb\"",
")",
"as",
"fd",
":",
"verify_key",
"=",
"await",
"fd",
".",
"read",
"(",
")",
"logging",
".",
"debug",
"(",
"_",
"(",
"\"Descifrando datos del identificador '%s'...\"",
")",
",",
"real_user",
")",
"return",
"hibrid",
".",
"decrypt",
"(",
"verify_key",
",",
"self",
".",
"session",
".",
"destination",
",",
"self",
".",
"session",
".",
"source",
".",
"private",
",",
"message",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | [
128,
4
] | [
176,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_lista_instrucciones_funcion_math | (t) | lista_funciones_math_esenciales : aritmetica
| lista_id
| lista_funciones_math_esenciales : aritmetica
| lista_id
| def p_lista_instrucciones_funcion_math(t):
'''lista_funciones_math_esenciales : aritmetica
| lista_id
''' | [
"def",
"p_lista_instrucciones_funcion_math",
"(",
"t",
")",
":"
] | [
1003,
0
] | [
1006,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RatTube.limpiar_Mostrar_Banner | (self) | Este método limpia la pantalla y muestra el banner.
Se usa llamando los dos métodos juntos porque en la mayoría de los
llamados se necesita que el banner siga ejecutándose manteniendo la pantalla
limpia para dar enfoque a la tarea de descarga | Este método limpia la pantalla y muestra el banner.
Se usa llamando los dos métodos juntos porque en la mayoría de los
llamados se necesita que el banner siga ejecutándose manteniendo la pantalla
limpia para dar enfoque a la tarea de descarga | def limpiar_Mostrar_Banner(self):
self.limpiar_Pantalla()
self.mostrar_Banner()
'''Este método limpia la pantalla y muestra el banner.
Se usa llamando los dos métodos juntos porque en la mayoría de los
llamados se necesita que el banner siga ejecutándose manteniendo la pantalla
limpia para dar enfoque a la tarea de descarga''' | [
"def",
"limpiar_Mostrar_Banner",
"(",
"self",
")",
":",
"self",
".",
"limpiar_Pantalla",
"(",
")",
"self",
".",
"mostrar_Banner",
"(",
")"
] | [
39,
1
] | [
46,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Dominio.vecino | (self, sol) | Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (estructura de datos)
Solución a partir de la cual se calculará una nueva solución vecina.
Salidas:
(estructura de datos) nueva solución construida con base en la solución de la entrada.
| Calcula una solución vecina a partir de una solución dada. | def vecino(self, sol):
"""Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (estructura de datos)
Solución a partir de la cual se calculará una nueva solución vecina.
Salidas:
(estructura de datos) nueva solución construida con base en la solución de la entrada.
"""
pass | [
"def",
"vecino",
"(",
"self",
",",
"sol",
")",
":",
"pass"
] | [
56,
4
] | [
72,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
extract | () | Función principal del programa y que lleva la lógica completa para la extracción de los locales comerciales por
código postal, país y tipos. Los resultados los vuelca directamente en el soporte de salida que se haya establecido
en el fichero de configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del
programa `gmaps-zip-scrapper`.
| Función principal del programa y que lleva la lógica completa para la extracción de los locales comerciales por
código postal, país y tipos. Los resultados los vuelca directamente en el soporte de salida que se haya establecido
en el fichero de configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del
programa `gmaps-zip-scrapper`.
| def extract():
"""Función principal del programa y que lleva la lógica completa para la extracción de los locales comerciales por
código postal, país y tipos. Los resultados los vuelca directamente en el soporte de salida que se haya establecido
en el fichero de configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del
programa `gmaps-zip-scrapper`.
"""
parser = get_parser()
args = parser.parse_args()
main_name = "gmaps_zip_extractor"
init_time = time.time()
required_keys = ["driver_path", "executors", "input_config", "output_config", "results_pages", "num_reviews"]
execution_config = get_obj_from_file(args.config_file)
today_date = datetime.now()
init_default_handler(name=main_name, date=today_date, root_dir=execution_config.get("log_dir"),
level="INFO")
logger = logging.getLogger(main_name)
logger.info("configuration that will be used in the extraction is the following")
logger.info("{config}".format(config=execution_config))
# si el fichero de configuración que se ha pasado a la ejecución contiene las claves requeridas se procede a la
# ejecución
if validate_required_keys(keys=required_keys, obj=execution_config):
if execution_config.get("operation", "") == "recovery":
is_forced = execution_config.get("forced_recovery", False)
recovery(logger=logger, execution_config=execution_config, today_date=today_date, is_forced=is_forced)
else:
extraction(logger=logger, execution_config=execution_config, today_date=today_date)
recovery(logger=logger, execution_config=execution_config, today_date=today_date)
recovery(logger=logger, execution_config=execution_config, today_date=today_date, is_forced=True)
else:
logger.error("there are error in configuration files. Some required configurations are not present")
logger.error("required keys: {keys}".format(keys=required_keys))
exit(-1)
end_time = time.time()
elapsed_time = int(end_time - init_time)
logger.info("elapsed time in this execution: {elapsed_time} seconds".format(elapsed_time=elapsed_time)) | [
"def",
"extract",
"(",
")",
":",
"parser",
"=",
"get_parser",
"(",
")",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"main_name",
"=",
"\"gmaps_zip_extractor\"",
"init_time",
"=",
"time",
".",
"time",
"(",
")",
"required_keys",
"=",
"[",
"\"driver_path\"",
",",
"\"executors\"",
",",
"\"input_config\"",
",",
"\"output_config\"",
",",
"\"results_pages\"",
",",
"\"num_reviews\"",
"]",
"execution_config",
"=",
"get_obj_from_file",
"(",
"args",
".",
"config_file",
")",
"today_date",
"=",
"datetime",
".",
"now",
"(",
")",
"init_default_handler",
"(",
"name",
"=",
"main_name",
",",
"date",
"=",
"today_date",
",",
"root_dir",
"=",
"execution_config",
".",
"get",
"(",
"\"log_dir\"",
")",
",",
"level",
"=",
"\"INFO\"",
")",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"main_name",
")",
"logger",
".",
"info",
"(",
"\"configuration that will be used in the extraction is the following\"",
")",
"logger",
".",
"info",
"(",
"\"{config}\"",
".",
"format",
"(",
"config",
"=",
"execution_config",
")",
")",
"# si el fichero de configuración que se ha pasado a la ejecución contiene las claves requeridas se procede a la",
"# ejecución",
"if",
"validate_required_keys",
"(",
"keys",
"=",
"required_keys",
",",
"obj",
"=",
"execution_config",
")",
":",
"if",
"execution_config",
".",
"get",
"(",
"\"operation\"",
",",
"\"\"",
")",
"==",
"\"recovery\"",
":",
"is_forced",
"=",
"execution_config",
".",
"get",
"(",
"\"forced_recovery\"",
",",
"False",
")",
"recovery",
"(",
"logger",
"=",
"logger",
",",
"execution_config",
"=",
"execution_config",
",",
"today_date",
"=",
"today_date",
",",
"is_forced",
"=",
"is_forced",
")",
"else",
":",
"extraction",
"(",
"logger",
"=",
"logger",
",",
"execution_config",
"=",
"execution_config",
",",
"today_date",
"=",
"today_date",
")",
"recovery",
"(",
"logger",
"=",
"logger",
",",
"execution_config",
"=",
"execution_config",
",",
"today_date",
"=",
"today_date",
")",
"recovery",
"(",
"logger",
"=",
"logger",
",",
"execution_config",
"=",
"execution_config",
",",
"today_date",
"=",
"today_date",
",",
"is_forced",
"=",
"True",
")",
"else",
":",
"logger",
".",
"error",
"(",
"\"there are error in configuration files. Some required configurations are not present\"",
")",
"logger",
".",
"error",
"(",
"\"required keys: {keys}\"",
".",
"format",
"(",
"keys",
"=",
"required_keys",
")",
")",
"exit",
"(",
"-",
"1",
")",
"end_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed_time",
"=",
"int",
"(",
"end_time",
"-",
"init_time",
")",
"logger",
".",
"info",
"(",
"\"elapsed time in this execution: {elapsed_time} seconds\"",
".",
"format",
"(",
"elapsed_time",
"=",
"elapsed_time",
")",
")"
] | [
249,
0
] | [
283,
107
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
verifica_moderador_asignado_a_curso | (id_curso: Union[None, str] = None) | Si el usuario no esta asignado como moderador al curso devuelve None. | Si el usuario no esta asignado como moderador al curso devuelve None. | def verifica_moderador_asignado_a_curso(id_curso: Union[None, str] = None):
"""Si el usuario no esta asignado como moderador al curso devuelve None."""
if current_user.is_authenticated:
return ModeradorCurso.query.filter(ModeradorCurso.usuario == current_user.usuario, ModeradorCurso.curso == id_curso)
else:
return False | [
"def",
"verifica_moderador_asignado_a_curso",
"(",
"id_curso",
":",
"Union",
"[",
"None",
",",
"str",
"]",
"=",
"None",
")",
":",
"if",
"current_user",
".",
"is_authenticated",
":",
"return",
"ModeradorCurso",
".",
"query",
".",
"filter",
"(",
"ModeradorCurso",
".",
"usuario",
"==",
"current_user",
".",
"usuario",
",",
"ModeradorCurso",
".",
"curso",
"==",
"id_curso",
")",
"else",
":",
"return",
"False"
] | [
251,
0
] | [
256,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Counter.calc_hours | (self) | return int(self.calc_seconds() // HOUR) | Calcula las horas transcurridas | Calcula las horas transcurridas | def calc_hours(self):
"""Calcula las horas transcurridas"""
return int(self.calc_seconds() // HOUR) | [
"def",
"calc_hours",
"(",
"self",
")",
":",
"return",
"int",
"(",
"self",
".",
"calc_seconds",
"(",
")",
"//",
"HOUR",
")"
] | [
34,
4
] | [
37,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BematechComandos.__init__ | (self, path=None, driver="ReceipDirectJet", *args) | path indica la IP o puerto donde se encuentra la impresora | path indica la IP o puerto donde se encuentra la impresora | def __init__(self, path=None, driver="ReceipDirectJet", *args):
"path indica la IP o puerto donde se encuentra la impresora"
ComandoInterface.__init__(args)
self.conector = ConectorDriverComando(self, driver, path) | [
"def",
"__init__",
"(",
"self",
",",
"path",
"=",
"None",
",",
"driver",
"=",
"\"ReceipDirectJet\"",
",",
"*",
"args",
")",
":",
"ComandoInterface",
".",
"__init__",
"(",
"args",
")",
"self",
".",
"conector",
"=",
"ConectorDriverComando",
"(",
"self",
",",
"driver",
",",
"path",
")"
] | [
47,
4
] | [
52,
65
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
permutar | (arr: List[int]) | return t | Devuelve todas las permutaciones del array.
:param arr: Lista de enteros únicos.
:arr type: List[int]
:return: Lista de permutaciones.
:rtype: List[List[int]]
| Devuelve todas las permutaciones del array.
:param arr: Lista de enteros únicos.
:arr type: List[int]
:return: Lista de permutaciones.
:rtype: List[List[int]]
| def permutar(arr: List[int]) -> List[List[int]]:
"""Devuelve todas las permutaciones del array.
:param arr: Lista de enteros únicos.
:arr type: List[int]
:return: Lista de permutaciones.
:rtype: List[List[int]]
"""
if len(arr) == 0:
return []
if len(arr) == 1:
return [arr]
t = []
for i in range(len(arr)):
r = arr[:i] + arr[i+1:]
for p in permutar(r):
t.append([arr[i]] + p)
return t | [
"def",
"permutar",
"(",
"arr",
":",
"List",
"[",
"int",
"]",
")",
"->",
"List",
"[",
"List",
"[",
"int",
"]",
"]",
":",
"if",
"len",
"(",
"arr",
")",
"==",
"0",
":",
"return",
"[",
"]",
"if",
"len",
"(",
"arr",
")",
"==",
"1",
":",
"return",
"[",
"arr",
"]",
"t",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"arr",
")",
")",
":",
"r",
"=",
"arr",
"[",
":",
"i",
"]",
"+",
"arr",
"[",
"i",
"+",
"1",
":",
"]",
"for",
"p",
"in",
"permutar",
"(",
"r",
")",
":",
"t",
".",
"append",
"(",
"[",
"arr",
"[",
"i",
"]",
"]",
"+",
"p",
")",
"return",
"t"
] | [
12,
0
] | [
29,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationResults.add | (self, estimation_result: EstimationResult) | Añade un resultado de una estimación.
:param estimation_result: estimación.
:return: None.
| Añade un resultado de una estimación. | def add(self, estimation_result: EstimationResult) -> None:
"""Añade un resultado de una estimación.
:param estimation_result: estimación.
:return: None.
"""
self._estimations_results.append(estimation_result) | [
"def",
"add",
"(",
"self",
",",
"estimation_result",
":",
"EstimationResult",
")",
"->",
"None",
":",
"self",
".",
"_estimations_results",
".",
"append",
"(",
"estimation_result",
")"
] | [
99,
4
] | [
105,
59
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
alta | () | return data | Crea un nuevo slug | Crea un nuevo slug | def alta():
"""Crea un nuevo slug"""
# Requerimos que el usuario esté autenticado.
if not 'REMOTE_USER' in bottle.request.environ:
bottle.abort(401, "Sorry, access denied.")
usuario = bottle.request.environ['REMOTE_USER'].decode('utf8')
# Data va a contener todo lo que el template
# requiere para hacer la página
data ={}
# Esto probablemente debería obtenerse de una
# configuración
data['baseurl'] = 'http://localhost:8080/'
# Si tenemos un parámetro URL, estamos en esta
# funcion porque el usuario envió una URL a acortar.
if 'url' in bottle.request.GET:
# La acortamos
url = bottle.request.GET['url'].decode('utf8')
a = Atajo(url=url, user=usuario)
data['short'] = a.slug()
data['url'] = url
# La probamos
a.run_test()
# Mensaje para el usuario de que el acortamiento
# tuvo éxito.
data['mensaje'] = u'''La URL <a href="%(url)s">%(url)s</a>
se convirtió en:
<a href="%(baseurl)s%(short)s">%(baseurl)s%(short)s</a>'''%data
# Clase CSS que muestra las cosas como buenas
data['clasemensaje']='success'
else:
# No se acortó nada, no hay nada para mostrar.
data['url']=None
data['short']=None
data['mensaje']=None
# Lista de atajos del usuario.
data ['atajos'] = Atajo.get (user = usuario)
# Crear la página con esos datos.
return data | [
"def",
"alta",
"(",
")",
":",
"# Requerimos que el usuario esté autenticado.",
"if",
"not",
"'REMOTE_USER'",
"in",
"bottle",
".",
"request",
".",
"environ",
":",
"bottle",
".",
"abort",
"(",
"401",
",",
"\"Sorry, access denied.\"",
")",
"usuario",
"=",
"bottle",
".",
"request",
".",
"environ",
"[",
"'REMOTE_USER'",
"]",
".",
"decode",
"(",
"'utf8'",
")",
"# Data va a contener todo lo que el template",
"# requiere para hacer la página",
"data",
"=",
"{",
"}",
"# Esto probablemente debería obtenerse de una",
"# configuración",
"data",
"[",
"'baseurl'",
"]",
"=",
"'http://localhost:8080/'",
"# Si tenemos un parámetro URL, estamos en esta",
"# funcion porque el usuario envió una URL a acortar.",
"if",
"'url'",
"in",
"bottle",
".",
"request",
".",
"GET",
":",
"# La acortamos",
"url",
"=",
"bottle",
".",
"request",
".",
"GET",
"[",
"'url'",
"]",
".",
"decode",
"(",
"'utf8'",
")",
"a",
"=",
"Atajo",
"(",
"url",
"=",
"url",
",",
"user",
"=",
"usuario",
")",
"data",
"[",
"'short'",
"]",
"=",
"a",
".",
"slug",
"(",
")",
"data",
"[",
"'url'",
"]",
"=",
"url",
"# La probamos",
"a",
".",
"run_test",
"(",
")",
"# Mensaje para el usuario de que el acortamiento",
"# tuvo éxito.",
"data",
"[",
"'mensaje'",
"]",
"=",
"u'''La URL <a href=\"%(url)s\">%(url)s</a>\n se convirtió en:\n <a href=\"%(baseurl)s%(short)s\">%(baseurl)s%(short)s</a>'''",
"%",
"data",
"# Clase CSS que muestra las cosas como buenas",
"data",
"[",
"'clasemensaje'",
"]",
"=",
"'success'",
"else",
":",
"# No se acortó nada, no hay nada para mostrar.",
"data",
"[",
"'url'",
"]",
"=",
"None",
"data",
"[",
"'short'",
"]",
"=",
"None",
"data",
"[",
"'mensaje'",
"]",
"=",
"None",
"# Lista de atajos del usuario.",
"data",
"[",
"'atajos'",
"]",
"=",
"Atajo",
".",
"get",
"(",
"user",
"=",
"usuario",
")",
"# Crear la página con esos datos.",
"return",
"data"
] | [
205,
0
] | [
252,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_tipo_funcionalidad | (t) | tipo_funcionalidad : lfuncionalidad
| lista_proc | tipo_funcionalidad : lfuncionalidad
| lista_proc | def p_tipo_funcionalidad(t):
'''tipo_funcionalidad : lfuncionalidad
| lista_proc'''
t[0]=t[1] | [
"def",
"p_tipo_funcionalidad",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
1470,
0
] | [
1473,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
f | (grado: int, coeficientes: List[int], x: float) | return sum(coeficientes[i] * x**i for i in range(grado + 1)) | Calcula el valor de un polinomio de grado n
:param grado: grado del polinomio
:grado type: int
:param coeficientes: coeficientes del polinomio
:coeficientes type: List[int]
:param x: valor de x
:x type: float
:return: valor del polinomio
:rtype: float
| Calcula el valor de un polinomio de grado n
:param grado: grado del polinomio
:grado type: int
:param coeficientes: coeficientes del polinomio
:coeficientes type: List[int]
:param x: valor de x
:x type: float
:return: valor del polinomio
:rtype: float
| def f(grado: int, coeficientes: List[int], x: float) -> float:
"""Calcula el valor de un polinomio de grado n
:param grado: grado del polinomio
:grado type: int
:param coeficientes: coeficientes del polinomio
:coeficientes type: List[int]
:param x: valor de x
:x type: float
:return: valor del polinomio
:rtype: float
"""
return sum(coeficientes[i] * x**i for i in range(grado + 1)) | [
"def",
"f",
"(",
"grado",
":",
"int",
",",
"coeficientes",
":",
"List",
"[",
"int",
"]",
",",
"x",
":",
"float",
")",
"->",
"float",
":",
"return",
"sum",
"(",
"coeficientes",
"[",
"i",
"]",
"*",
"x",
"**",
"i",
"for",
"i",
"in",
"range",
"(",
"grado",
"+",
"1",
")",
")"
] | [
7,
0
] | [
19,
64
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones64 | (p) | funciones : tipo_numero NUMERAL tipo_numero | funciones : tipo_numero NUMERAL tipo_numero | def p_funciones64(p):
'funciones : tipo_numero NUMERAL tipo_numero' | [
"def",
"p_funciones64",
"(",
"p",
")",
":"
] | [
490,
0
] | [
491,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
NewDomains.download_pdf | (self, date, path) | return True | descargar el PDF "actual" (la pagina guarda en sesion o algo similar el dia elegido) | descargar el PDF "actual" (la pagina guarda en sesion o algo similar el dia elegido) | def download_pdf(self, date, path):
""" descargar el PDF "actual" (la pagina guarda en sesion o algo similar el dia elegido) """
if os.path.isfile(path):
logger.info(f'Skip download. File already exists {date} {path}')
return
response = self.session.post(f'{self.base_domain}/pdf/download_section', data={'nombreSeccion': 'cuarta'})
try:
data = response.json()
except Exception:
logger.error(f'INVALID JSON for {date} {path}')
return None
b64 = data['pdfBase64']
bin_pdf = base64.b64decode(b64)
f = open(path, 'wb')
f.write(bin_pdf)
f.close()
return True | [
"def",
"download_pdf",
"(",
"self",
",",
"date",
",",
"path",
")",
":",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"path",
")",
":",
"logger",
".",
"info",
"(",
"f'Skip download. File already exists {date} {path}'",
")",
"return",
"response",
"=",
"self",
".",
"session",
".",
"post",
"(",
"f'{self.base_domain}/pdf/download_section'",
",",
"data",
"=",
"{",
"'nombreSeccion'",
":",
"'cuarta'",
"}",
")",
"try",
":",
"data",
"=",
"response",
".",
"json",
"(",
")",
"except",
"Exception",
":",
"logger",
".",
"error",
"(",
"f'INVALID JSON for {date} {path}'",
")",
"return",
"None",
"b64",
"=",
"data",
"[",
"'pdfBase64'",
"]",
"bin_pdf",
"=",
"base64",
".",
"b64decode",
"(",
"b64",
")",
"f",
"=",
"open",
"(",
"path",
",",
"'wb'",
")",
"f",
".",
"write",
"(",
"bin_pdf",
")",
"f",
".",
"close",
"(",
")",
"return",
"True"
] | [
122,
4
] | [
140,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo._draw_frame_timestamp | (self, fid: int, frame: Image) | return frame | Escribe el instante de tiempo en el que se encuentra la secuencia (en segundos)..
:param fid: número del frame.
:param frame: frame.
:return: frame con el instante de tiempo en segundos.
| Escribe el instante de tiempo en el que se encuentra la secuencia (en segundos).. | def _draw_frame_timestamp(self, fid: int, frame: Image) -> Image:
"""Escribe el instante de tiempo en el que se encuentra la secuencia (en segundos)..
:param fid: número del frame.
:param frame: frame.
:return: frame con el instante de tiempo en segundos.
"""
# Propiedades del texto.
text_format = self.get_property(TrackingVideoProperty.TEXT_FRAME_INFORMATION)
font, color, linetype, thickness, font_scale, _ = text_format
# Dibujar texto.
second = fid / self.input_sequence.properties().fps
text = f'Timestamp {second} s'
position = (30, self.input_sequence.properties().height - 80)
cv2.putText(frame, text, position, font, font_scale, color, thickness, linetype)
return frame | [
"def",
"_draw_frame_timestamp",
"(",
"self",
",",
"fid",
":",
"int",
",",
"frame",
":",
"Image",
")",
"->",
"Image",
":",
"# Propiedades del texto.",
"text_format",
"=",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"TEXT_FRAME_INFORMATION",
")",
"font",
",",
"color",
",",
"linetype",
",",
"thickness",
",",
"font_scale",
",",
"_",
"=",
"text_format",
"# Dibujar texto.",
"second",
"=",
"fid",
"/",
"self",
".",
"input_sequence",
".",
"properties",
"(",
")",
".",
"fps",
"text",
"=",
"f'Timestamp {second} s'",
"position",
"=",
"(",
"30",
",",
"self",
".",
"input_sequence",
".",
"properties",
"(",
")",
".",
"height",
"-",
"80",
")",
"cv2",
".",
"putText",
"(",
"frame",
",",
"text",
",",
"position",
",",
"font",
",",
"font_scale",
",",
"color",
",",
"thickness",
",",
"linetype",
")",
"return",
"frame"
] | [
241,
4
] | [
256,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
resumen | (path: str, gene_list: list[str]) | Funcion que pide como input un path de tipo str, y una lista
de nombres de genes de tipo list[str], la cual imprime lo
siguiente:
* Organismo
* Version de la secuencia
* Fuente del aislado
* Pais
* Para cada gen en la lista:
* Nombre del gen
* Los primeros 15 nucleotidos de ADN
* Los primeros 15 nucleotidos de ARN
* Los primeros 15 aminoacidos de proteina | Funcion que pide como input un path de tipo str, y una lista
de nombres de genes de tipo list[str], la cual imprime lo
siguiente: | def resumen(path: str, gene_list: list[str]):
"""Funcion que pide como input un path de tipo str, y una lista
de nombres de genes de tipo list[str], la cual imprime lo
siguiente:
* Organismo
* Version de la secuencia
* Fuente del aislado
* Pais
* Para cada gen en la lista:
* Nombre del gen
* Los primeros 15 nucleotidos de ADN
* Los primeros 15 nucleotidos de ARN
* Los primeros 15 aminoacidos de proteina"""
# Acceder a los records del archivo de genbank
for gb_record in SeqIO.parse(path, "genbank"):
# Imprimir organismo, version de la secuencia, fuente de
# aislado y pais
print("Organismo:", gb_record.annotations["organism"])
print("Version de la secuencia:", gb_record.annotations[
"sequence_version"])
print("Fuente de aislado:", gb_record.features[0].qualifiers[
"isolation_source"])
print("Pais:", gb_record.features[0].qualifiers["country"])
# Acceder a cada uno de los features que sean CDS
for ft in gb_record.features[1:]:
if ft.type == "CDS":
# Acceder a cada gen de la lista de genes
for i, gene in enumerate(gene_list, 1):
# Evaluar si el gen de la lista coincide con el CDS
if gene == ft.qualifiers["gene"][0]:
start = ft.location.nofuzzy_start
end = ft.location.nofuzzy_end
seq = gb_record.seq[start:end]
# Imprimir el nombre del gen, los primeros 15
# nucleotidos de ADN, los primeros 15
# nucleotidos de ARN y los primeros 15
# aminoacidos de proteina
print(f"gen_{i}: {gene}")
print(f"ADN: {seq[:15]}")
print(f"ARN: {seq[:15].replace('T', 'U')}")
print(f"Proteina: {ft.qualifiers['translation'][0][:15]}") | [
"def",
"resumen",
"(",
"path",
":",
"str",
",",
"gene_list",
":",
"list",
"[",
"str",
"]",
")",
":",
"# Acceder a los records del archivo de genbank",
"for",
"gb_record",
"in",
"SeqIO",
".",
"parse",
"(",
"path",
",",
"\"genbank\"",
")",
":",
"# Imprimir organismo, version de la secuencia, fuente de",
"# aislado y pais",
"print",
"(",
"\"Organismo:\"",
",",
"gb_record",
".",
"annotations",
"[",
"\"organism\"",
"]",
")",
"print",
"(",
"\"Version de la secuencia:\"",
",",
"gb_record",
".",
"annotations",
"[",
"\"sequence_version\"",
"]",
")",
"print",
"(",
"\"Fuente de aislado:\"",
",",
"gb_record",
".",
"features",
"[",
"0",
"]",
".",
"qualifiers",
"[",
"\"isolation_source\"",
"]",
")",
"print",
"(",
"\"Pais:\"",
",",
"gb_record",
".",
"features",
"[",
"0",
"]",
".",
"qualifiers",
"[",
"\"country\"",
"]",
")",
"# Acceder a cada uno de los features que sean CDS",
"for",
"ft",
"in",
"gb_record",
".",
"features",
"[",
"1",
":",
"]",
":",
"if",
"ft",
".",
"type",
"==",
"\"CDS\"",
":",
"# Acceder a cada gen de la lista de genes",
"for",
"i",
",",
"gene",
"in",
"enumerate",
"(",
"gene_list",
",",
"1",
")",
":",
"# Evaluar si el gen de la lista coincide con el CDS",
"if",
"gene",
"==",
"ft",
".",
"qualifiers",
"[",
"\"gene\"",
"]",
"[",
"0",
"]",
":",
"start",
"=",
"ft",
".",
"location",
".",
"nofuzzy_start",
"end",
"=",
"ft",
".",
"location",
".",
"nofuzzy_end",
"seq",
"=",
"gb_record",
".",
"seq",
"[",
"start",
":",
"end",
"]",
"# Imprimir el nombre del gen, los primeros 15",
"# nucleotidos de ADN, los primeros 15",
"# nucleotidos de ARN y los primeros 15",
"# aminoacidos de proteina",
"print",
"(",
"f\"gen_{i}: {gene}\"",
")",
"print",
"(",
"f\"ADN: {seq[:15]}\"",
")",
"print",
"(",
"f\"ARN: {seq[:15].replace('T', 'U')}\"",
")",
"print",
"(",
"f\"Proteina: {ft.qualifiers['translation'][0][:15]}\"",
")"
] | [
32,
0
] | [
79,
82
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
to_raw | (
keys: Tuple["nacl.signing.VerifyKey", "nacl.signing.SigningKey"] = None
) | return tuple(keys.public._key, keys.private._seed) | Convierte un par de claves Ed25519 en un formato válido
Args:
keys:
Las claves generadas por ``generate()``.
Si no se especifica ninguna, se generan.
Returns:
Una tupla con clave de verificación y la clave
para firmar en bytes.
| Convierte un par de claves Ed25519 en un formato válido | def to_raw(
keys: Tuple["nacl.signing.VerifyKey", "nacl.signing.SigningKey"] = None
) -> Tuple[bytes, bytes]:
"""Convierte un par de claves Ed25519 en un formato válido
Args:
keys:
Las claves generadas por ``generate()``.
Si no se especifica ninguna, se generan.
Returns:
Una tupla con clave de verificación y la clave
para firmar en bytes.
"""
tuple = _tuple()
if (keys is None):
keys = generate()
return tuple(keys.public._key, keys.private._seed) | [
"def",
"to_raw",
"(",
"keys",
":",
"Tuple",
"[",
"\"nacl.signing.VerifyKey\"",
",",
"\"nacl.signing.SigningKey\"",
"]",
"=",
"None",
")",
"->",
"Tuple",
"[",
"bytes",
",",
"bytes",
"]",
":",
"tuple",
"=",
"_tuple",
"(",
")",
"if",
"(",
"keys",
"is",
"None",
")",
":",
"keys",
"=",
"generate",
"(",
")",
"return",
"tuple",
"(",
"keys",
".",
"public",
".",
"_key",
",",
"keys",
".",
"private",
".",
"_seed",
")"
] | [
26,
0
] | [
48,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
group_fingerprint_strings | (raw_strs, sort_tokens=False,
remove_duplicates=False) | return res, counts | Clusteriza un conjunto de strings, según sus fingerprints.
Args:
raw_strs (list): Lista de strings sin procesar.
Returns:
(dict, dict): En el primer dict las keys son los fingerprints y los
valores las strings originales. En el segundo las keys son las
strings sin normalizar y los valores el conteo de la cantidad de
veces que aparecen.
| Clusteriza un conjunto de strings, según sus fingerprints. | def group_fingerprint_strings(raw_strs, sort_tokens=False,
remove_duplicates=False):
"""Clusteriza un conjunto de strings, según sus fingerprints.
Args:
raw_strs (list): Lista de strings sin procesar.
Returns:
(dict, dict): En el primer dict las keys son los fingerprints y los
valores las strings originales. En el segundo las keys son las
strings sin normalizar y los valores el conteo de la cantidad de
veces que aparecen.
"""
res = {}
counts = {}
fingerprint_keyer_with_args = partial(fingerprint_keyer,
sort_tokens=sort_tokens,
remove_duplicates=remove_duplicates)
for (key, raw_str) in zip(map(fingerprint_keyer_with_args, raw_strs),
raw_strs):
res[key] = res.get(key, []) + [raw_str]
counts[raw_str] = counts.get(raw_str, 0) + 1
return res, counts | [
"def",
"group_fingerprint_strings",
"(",
"raw_strs",
",",
"sort_tokens",
"=",
"False",
",",
"remove_duplicates",
"=",
"False",
")",
":",
"res",
"=",
"{",
"}",
"counts",
"=",
"{",
"}",
"fingerprint_keyer_with_args",
"=",
"partial",
"(",
"fingerprint_keyer",
",",
"sort_tokens",
"=",
"sort_tokens",
",",
"remove_duplicates",
"=",
"remove_duplicates",
")",
"for",
"(",
"key",
",",
"raw_str",
")",
"in",
"zip",
"(",
"map",
"(",
"fingerprint_keyer_with_args",
",",
"raw_strs",
")",
",",
"raw_strs",
")",
":",
"res",
"[",
"key",
"]",
"=",
"res",
".",
"get",
"(",
"key",
",",
"[",
"]",
")",
"+",
"[",
"raw_str",
"]",
"counts",
"[",
"raw_str",
"]",
"=",
"counts",
".",
"get",
"(",
"raw_str",
",",
"0",
")",
"+",
"1",
"return",
"res",
",",
"counts"
] | [
63,
0
] | [
85,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
find_closest_position_to_line | (positions: List[Point2D], line: Tuple[Point2D, Point2D]) | return distances.index(min(distances)) | Busca el índice de las posiciones en la que la posición 2D es la más cercana a la recta
definida por dos puntos.
:param positions: lista de posiciones.
:param line: recta definida por dos puntos.
:return: índice de la posición más cercana a la recta.
| Busca el índice de las posiciones en la que la posición 2D es la más cercana a la recta
definida por dos puntos. | def find_closest_position_to_line(positions: List[Point2D], line: Tuple[Point2D, Point2D]) -> int:
"""Busca el índice de las posiciones en la que la posición 2D es la más cercana a la recta
definida por dos puntos.
:param positions: lista de posiciones.
:param line: recta definida por dos puntos.
:return: índice de la posición más cercana a la recta.
"""
distances = [point_distance_to_line(p, line) for p in positions]
return distances.index(min(distances)) | [
"def",
"find_closest_position_to_line",
"(",
"positions",
":",
"List",
"[",
"Point2D",
"]",
",",
"line",
":",
"Tuple",
"[",
"Point2D",
",",
"Point2D",
"]",
")",
"->",
"int",
":",
"distances",
"=",
"[",
"point_distance_to_line",
"(",
"p",
",",
"line",
")",
"for",
"p",
"in",
"positions",
"]",
"return",
"distances",
".",
"index",
"(",
"min",
"(",
"distances",
")",
")"
] | [
21,
0
] | [
30,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
planilla.crear_lista | (self) | return self.Participantes_ | Crea una lista con los ALIAS | Crea una lista con los ALIAS | def crear_lista(self):
"Crea una lista con los ALIAS"
participantes_= []
for key, value in self.Planilla_.items():
participantes_.append(str(value[0]))
self.Participantes_=participantes_
return self.Participantes_ | [
"def",
"crear_lista",
"(",
"self",
")",
":",
"participantes_",
"=",
"[",
"]",
"for",
"key",
",",
"value",
"in",
"self",
".",
"Planilla_",
".",
"items",
"(",
")",
":",
"participantes_",
".",
"append",
"(",
"str",
"(",
"value",
"[",
"0",
"]",
")",
")",
"self",
".",
"Participantes_",
"=",
"participantes_",
"return",
"self",
".",
"Participantes_"
] | [
86,
4
] | [
92,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ExecutionDbReader.auto_boot | (self) | Función encargada de crear la conexión a la base de datos. | Función encargada de crear la conexión a la base de datos. | def auto_boot(self):
"""Función encargada de crear la conexión a la base de datos."""
self.db = psycopg2.connect(
host=self.host,
user=self.db_user,
password=self.db_pass,
database=self.db_name
) | [
"def",
"auto_boot",
"(",
"self",
")",
":",
"self",
".",
"db",
"=",
"psycopg2",
".",
"connect",
"(",
"host",
"=",
"self",
".",
"host",
",",
"user",
"=",
"self",
".",
"db_user",
",",
"password",
"=",
"self",
".",
"db_pass",
",",
"database",
"=",
"self",
".",
"db_name",
")"
] | [
67,
4
] | [
74,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ordenar_palabras_alt | () | Pide tres palabras distintas y las devuelve en orden alfabético.
| Pide tres palabras distintas y las devuelve en orden alfabético.
| def ordenar_palabras_alt() -> None:
"""Pide tres palabras distintas y las devuelve en orden alfabético.
"""
palabras = []
while True:
if len(palabras) == 3:
break
palabra = input("Ingrese una palabra: ")
if palabra in palabras:
print("La palabra ya existe.")
continue
palabras.append(palabra)
print(definir_orden_builtin(*palabras)) | [
"def",
"ordenar_palabras_alt",
"(",
")",
"->",
"None",
":",
"palabras",
"=",
"[",
"]",
"while",
"True",
":",
"if",
"len",
"(",
"palabras",
")",
"==",
"3",
":",
"break",
"palabra",
"=",
"input",
"(",
"\"Ingrese una palabra: \"",
")",
"if",
"palabra",
"in",
"palabras",
":",
"print",
"(",
"\"La palabra ya existe.\"",
")",
"continue",
"palabras",
".",
"append",
"(",
"palabra",
")",
"print",
"(",
"definir_orden_builtin",
"(",
"*",
"palabras",
")",
")"
] | [
111,
0
] | [
123,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
writeBlockChain | (db, table, data, falg = True) | escribe el blockchain | escribe el blockchain | def writeBlockChain(db, table, data, falg = True):
"""escribe el blockchain"""
initCheck()
if not pathlib.Path("blockchain/" + db + "_" + table + ".json").is_file() and falg:
return
bchain ={}
f = list(map(_toHash, data))
for x in range(0, len(f)):
temp ={}
if x == 0:
temp["prev"] = "--"
else:
temp["prev"] = f[x-1]
try:
temp["next"] = f[x+1]
except:
temp["next"] = "--"
bchain[f[x]] = temp
target = {"list" : f, "bchain" : bchain}
name = db + "_" + table
write("blockchain\\"+name+".json",target) | [
"def",
"writeBlockChain",
"(",
"db",
",",
"table",
",",
"data",
",",
"falg",
"=",
"True",
")",
":",
"initCheck",
"(",
")",
"if",
"not",
"pathlib",
".",
"Path",
"(",
"\"blockchain/\"",
"+",
"db",
"+",
"\"_\"",
"+",
"table",
"+",
"\".json\"",
")",
".",
"is_file",
"(",
")",
"and",
"falg",
":",
"return",
"bchain",
"=",
"{",
"}",
"f",
"=",
"list",
"(",
"map",
"(",
"_toHash",
",",
"data",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"f",
")",
")",
":",
"temp",
"=",
"{",
"}",
"if",
"x",
"==",
"0",
":",
"temp",
"[",
"\"prev\"",
"]",
"=",
"\"--\"",
"else",
":",
"temp",
"[",
"\"prev\"",
"]",
"=",
"f",
"[",
"x",
"-",
"1",
"]",
"try",
":",
"temp",
"[",
"\"next\"",
"]",
"=",
"f",
"[",
"x",
"+",
"1",
"]",
"except",
":",
"temp",
"[",
"\"next\"",
"]",
"=",
"\"--\"",
"bchain",
"[",
"f",
"[",
"x",
"]",
"]",
"=",
"temp",
"target",
"=",
"{",
"\"list\"",
":",
"f",
",",
"\"bchain\"",
":",
"bchain",
"}",
"name",
"=",
"db",
"+",
"\"_\"",
"+",
"table",
"write",
"(",
"\"blockchain\\\\\"",
"+",
"name",
"+",
"\".json\"",
",",
"target",
")"
] | [
7,
0
] | [
27,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.Eigen | (self) | return M[-1].round_m(6), EV | Metodo para calcular valores y vectores propios mediante
descomposicion QR. | Metodo para calcular valores y vectores propios mediante
descomposicion QR. | def Eigen(self):
""" Metodo para calcular valores y vectores propios mediante
descomposicion QR. """
M = []
M.append(self)
Q, R = M[0].QR()
M.append(R * Q)
EV = Q
while Matrix([(M[-1] - M[-2]).diag()]).norm() > 1e-10:
Q, R = M[-1].QR()
M.append(R * Q)
EV *= Q
return M[-1].round_m(6), EV | [
"def",
"Eigen",
"(",
"self",
")",
":",
"M",
"=",
"[",
"]",
"M",
".",
"append",
"(",
"self",
")",
"Q",
",",
"R",
"=",
"M",
"[",
"0",
"]",
".",
"QR",
"(",
")",
"M",
".",
"append",
"(",
"R",
"*",
"Q",
")",
"EV",
"=",
"Q",
"while",
"Matrix",
"(",
"[",
"(",
"M",
"[",
"-",
"1",
"]",
"-",
"M",
"[",
"-",
"2",
"]",
")",
".",
"diag",
"(",
")",
"]",
")",
".",
"norm",
"(",
")",
">",
"1e-10",
":",
"Q",
",",
"R",
"=",
"M",
"[",
"-",
"1",
"]",
".",
"QR",
"(",
")",
"M",
".",
"append",
"(",
"R",
"*",
"Q",
")",
"EV",
"*=",
"Q",
"return",
"M",
"[",
"-",
"1",
"]",
".",
"round_m",
"(",
"6",
")",
",",
"EV"
] | [
249,
4
] | [
261,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationResult.angles | (self) | return angles | Lista de los ángulos de los vectores de velocidad.
:return: lista de ángulos en grados.
| Lista de los ángulos de los vectores de velocidad. | def angles(self) -> List[float]:
"""Lista de los ángulos de los vectores de velocidad.
:return: lista de ángulos en grados.
"""
velocities_x, velocities_y = zip(*self.velocities)
angles = list(np.arctan2(velocities_y, velocities_x) * 180 / np.pi)
return angles | [
"def",
"angles",
"(",
"self",
")",
"->",
"List",
"[",
"float",
"]",
":",
"velocities_x",
",",
"velocities_y",
"=",
"zip",
"(",
"*",
"self",
".",
"velocities",
")",
"angles",
"=",
"list",
"(",
"np",
".",
"arctan2",
"(",
"velocities_y",
",",
"velocities_x",
")",
"*",
"180",
"/",
"np",
".",
"pi",
")",
"return",
"angles"
] | [
51,
4
] | [
58,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
QMolecule.y_dipole_integrals | (self) | return QMolecule.onee_to_spin(self.y_dip_mo_ints, self.y_dip_mo_ints_b) | returns y_dipole_integrals | returns y_dipole_integrals | def y_dipole_integrals(self):
"""returns y_dipole_integrals"""
return QMolecule.onee_to_spin(self.y_dip_mo_ints, self.y_dip_mo_ints_b) | [
"def",
"y_dipole_integrals",
"(",
"self",
")",
":",
"return",
"QMolecule",
".",
"onee_to_spin",
"(",
"self",
".",
"y_dip_mo_ints",
",",
"self",
".",
"y_dip_mo_ints_b",
")"
] | [
148,
4
] | [
150,
79
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
p_instrucciones2 | (t) | instrucciones : instruccion | instrucciones : instruccion | def p_instrucciones2(t):
'instrucciones : instruccion'
node = grammer.nodoDireccion('instrucciones')
node.agregar(t[1])
t[0]= node | [
"def",
"p_instrucciones2",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'instrucciones'",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
34,
0
] | [
38,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
procesar_matriz | (matriz) | return [int(i) for i in x] | Este es el procedimiento para convertir a enteros los valores | Este es el procedimiento para convertir a enteros los valores | def procesar_matriz(matriz):
"""Este es el procedimiento para convertir a enteros los valores"""
x = matriz.split('x')
return [int(i) for i in x] | [
"def",
"procesar_matriz",
"(",
"matriz",
")",
":",
"x",
"=",
"matriz",
".",
"split",
"(",
"'x'",
")",
"return",
"[",
"int",
"(",
"i",
")",
"for",
"i",
"in",
"x",
"]"
] | [
5,
0
] | [
8,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UrlsExtractor.scrap | (self) | return url_found | Función principal que se encargará de acceder a una url de búsqueda genérica por código postal y para extraer la
url específica y más exacta que usa google maps y registrarlo en el `writer` configurado para el soporte que se
haya establecido para la ejecución.
Returns
-------
dict
devuelve un diccionario que contiene el código postal, el país, la url y coordenadas de google para el
código postal y país.
example:
{
"zip_code": "48005",
"gmaps_url": "https://www.google.com/maps/place/48005+Bilbao,+Biscay/@43.2598164,-2.9304266,15z",
"gmaps_coordinates": "@43.2598164,-2.9304266,15z",
"country": "Spain"
}
| Función principal que se encargará de acceder a una url de búsqueda genérica por código postal y para extraer la
url específica y más exacta que usa google maps y registrarlo en el `writer` configurado para el soporte que se
haya establecido para la ejecución. | def scrap(self):
"""Función principal que se encargará de acceder a una url de búsqueda genérica por código postal y para extraer la
url específica y más exacta que usa google maps y registrarlo en el `writer` configurado para el soporte que se
haya establecido para la ejecución.
Returns
-------
dict
devuelve un diccionario que contiene el código postal, el país, la url y coordenadas de google para el
código postal y país.
example:
{
"zip_code": "48005",
"gmaps_url": "https://www.google.com/maps/place/48005+Bilbao,+Biscay/@43.2598164,-2.9304266,15z",
"gmaps_coordinates": "@43.2598164,-2.9304266,15z",
"country": "Spain"
}
"""
driver = self.get_driver()
url_found = {}
total_time = 0
init_page_time = time.time()
self.logger.info("-{postal_code}-: looking for results url".format(postal_code=self._postal_code))
try:
url_obj = self.get_gmaps_zip_url(driver)
self.logger.debug("-{postal_code}-: url object rendered: {obj}".format(postal_code=self._postal_code,
obj=url_obj))
self._writer.write(url_obj)
except Exception as e:
self.logger.error(
"-{postal_code}-: something went wrong during trying to extract url for look up results"
.format(postal_code=self._postal_code))
self.logger.error(str(e))
finally:
self.finish()
end_page_time = time.time()
elapsed = int(end_page_time - init_page_time)
total_time += elapsed
self.logger.info("-{postal_code}-: total time elapsed: -{elapsed}- seconds".format(
postal_code=self._postal_code, elapsed=total_time))
return url_found | [
"def",
"scrap",
"(",
"self",
")",
":",
"driver",
"=",
"self",
".",
"get_driver",
"(",
")",
"url_found",
"=",
"{",
"}",
"total_time",
"=",
"0",
"init_page_time",
"=",
"time",
".",
"time",
"(",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: looking for results url\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
")",
")",
"try",
":",
"url_obj",
"=",
"self",
".",
"get_gmaps_zip_url",
"(",
"driver",
")",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: url object rendered: {obj}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"obj",
"=",
"url_obj",
")",
")",
"self",
".",
"_writer",
".",
"write",
"(",
"url_obj",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{postal_code}-: something went wrong during trying to extract url for look up results\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"finally",
":",
"self",
".",
"finish",
"(",
")",
"end_page_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed",
"=",
"int",
"(",
"end_page_time",
"-",
"init_page_time",
")",
"total_time",
"+=",
"elapsed",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{postal_code}-: total time elapsed: -{elapsed}- seconds\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"elapsed",
"=",
"total_time",
")",
")",
"return",
"url_found"
] | [
157,
4
] | [
197,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ModelBase.get_last_update_history | (self) | Obtiene el registro historico de la última modificación. | Obtiene el registro historico de la última modificación. | def get_last_update_history(self):
"""Obtiene el registro historico de la última modificación."""
history_qs = self.get_history()
if history_qs != None:
return history_qs.filter(history_type="~").last()
# Si no existe un historial, se intentará retornar un diccionario con
# los valores de create_user y create_date si existen.
elif hasattr(self, "update_user"):
return {
"history_user": self.update_user,
"history_date": getattr(self, "update_date", "")
} | [
"def",
"get_last_update_history",
"(",
"self",
")",
":",
"history_qs",
"=",
"self",
".",
"get_history",
"(",
")",
"if",
"history_qs",
"!=",
"None",
":",
"return",
"history_qs",
".",
"filter",
"(",
"history_type",
"=",
"\"~\"",
")",
".",
"last",
"(",
")",
"# Si no existe un historial, se intentará retornar un diccionario con ",
"# los valores de create_user y create_date si existen.",
"elif",
"hasattr",
"(",
"self",
",",
"\"update_user\"",
")",
":",
"return",
"{",
"\"history_user\"",
":",
"self",
".",
"update_user",
",",
"\"history_date\"",
":",
"getattr",
"(",
"self",
",",
"\"update_date\"",
",",
"\"\"",
")",
"}"
] | [
437,
4
] | [
449,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_clean_data_xlsx | (xlsx_filename,cols) | return clean_data | Este método se encargará de recoger los datos de cualquier xlsx y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja | Este método se encargará de recoger los datos de cualquier xlsx y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja | def get_clean_data_xlsx(xlsx_filename,cols):
''' Este método se encargará de recoger los datos de cualquier xlsx y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja'''
raw_data=pd.read_excel(xlsx_filename,usecols=cols,na_filter=True,keep_default_na=False,engine='openpyxl')
col_names=raw_data.columns.values
clean_data=pd.DataFrame()
for cn in col_names:
aux_field=raw_data[cn]
try:
clean_data[cn]=[aux_row.lower().replace(" ","_") for aux_row in raw_data[cn]]
except Exception as e:
clean_data[cn]=raw_data[cn]
pass
return clean_data | [
"def",
"get_clean_data_xlsx",
"(",
"xlsx_filename",
",",
"cols",
")",
":",
"raw_data",
"=",
"pd",
".",
"read_excel",
"(",
"xlsx_filename",
",",
"usecols",
"=",
"cols",
",",
"na_filter",
"=",
"True",
",",
"keep_default_na",
"=",
"False",
",",
"engine",
"=",
"'openpyxl'",
")",
"col_names",
"=",
"raw_data",
".",
"columns",
".",
"values",
"clean_data",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"for",
"cn",
"in",
"col_names",
":",
"aux_field",
"=",
"raw_data",
"[",
"cn",
"]",
"try",
":",
"clean_data",
"[",
"cn",
"]",
"=",
"[",
"aux_row",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"\" \"",
",",
"\"_\"",
")",
"for",
"aux_row",
"in",
"raw_data",
"[",
"cn",
"]",
"]",
"except",
"Exception",
"as",
"e",
":",
"clean_data",
"[",
"cn",
"]",
"=",
"raw_data",
"[",
"cn",
"]",
"pass",
"return",
"clean_data"
] | [
14,
0
] | [
29,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones15 | (p) | funciones : ACOSD PABRE expresion PCIERRA | funciones : ACOSD PABRE expresion PCIERRA | def p_funciones15(p):
'funciones : ACOSD PABRE expresion PCIERRA' | [
"def",
"p_funciones15",
"(",
"p",
")",
":"
] | [
343,
0
] | [
344,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ConexionPostgres.__unicode__ | (self) | return conexion | Devuelve algo de la forma 'Nombre (user@host:port.dbname)' | Devuelve algo de la forma 'Nombre (user | def __unicode__(self):
if self.nombre != '':
return unicode(self.nombre)
""" Devuelve algo de la forma 'Nombre (user@host:port.dbname)' """
conexion = '%s@%s' % (self.user, self.host)
if self.port != '':
conexion += ':%s' % (self.port)
conexion += '.%s' % (self.dbname)
# if self.nombre!='':
# conexion='%s (%s)'%(unicode(self.nombre),conexion)
return conexion | [
"def",
"__unicode__",
"(",
"self",
")",
":",
"if",
"self",
".",
"nombre",
"!=",
"''",
":",
"return",
"unicode",
"(",
"self",
".",
"nombre",
")",
"conexion",
"=",
"'%s@%s'",
"%",
"(",
"self",
".",
"user",
",",
"self",
".",
"host",
")",
"if",
"self",
".",
"port",
"!=",
"''",
":",
"conexion",
"+=",
"':%s'",
"%",
"(",
"self",
".",
"port",
")",
"conexion",
"+=",
"'.%s'",
"%",
"(",
"self",
".",
"dbname",
")",
"# if self.nombre!='':",
"# conexion='%s (%s)'%(unicode(self.nombre),conexion)",
"return",
"conexion"
] | [
400,
4
] | [
410,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TraductoresHandler._rebootFiscalberry | (self) | return resdict | reinicia el servicio fiscalberry | reinicia el servicio fiscalberry | def _rebootFiscalberry(self):
"reinicia el servicio fiscalberry"
from subprocess import call
resdict = {
"action": "rebootFiscalberry",
"rta": call(["reboot"])
}
return resdict | [
"def",
"_rebootFiscalberry",
"(",
"self",
")",
":",
"from",
"subprocess",
"import",
"call",
"resdict",
"=",
"{",
"\"action\"",
":",
"\"rebootFiscalberry\"",
",",
"\"rta\"",
":",
"call",
"(",
"[",
"\"reboot\"",
"]",
")",
"}",
"return",
"resdict"
] | [
266,
4
] | [
275,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instruccion16 | (t) | instruccion : DECLARACIONES ptcoma | instruccion : DECLARACIONES ptcoma | def p_instruccion16(t):
'instruccion : DECLARACIONES ptcoma'
t[0] = t[1] | [
"def",
"p_instruccion16",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
440,
0
] | [
442,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Molecule.get_center_of_mass | (self) | return centro | Metodo para obtener el centro de masa de la molecula. | Metodo para obtener el centro de masa de la molecula. | def get_center_of_mass(self):
""" Metodo para obtener el centro de masa de la molecula. """
atomos = self.get_coords()
M = self.mol_weight
centro = Matrix([[0, 0, 0]])
for a in atomos:
centro = centro + (Matrix([[a[1], a[2], a[3]]]) * PERIODIC_TABLE[a[0]]["mass"])
centro *= (1 / M)
return centro | [
"def",
"get_center_of_mass",
"(",
"self",
")",
":",
"atomos",
"=",
"self",
".",
"get_coords",
"(",
")",
"M",
"=",
"self",
".",
"mol_weight",
"centro",
"=",
"Matrix",
"(",
"[",
"[",
"0",
",",
"0",
",",
"0",
"]",
"]",
")",
"for",
"a",
"in",
"atomos",
":",
"centro",
"=",
"centro",
"+",
"(",
"Matrix",
"(",
"[",
"[",
"a",
"[",
"1",
"]",
",",
"a",
"[",
"2",
"]",
",",
"a",
"[",
"3",
"]",
"]",
"]",
")",
"*",
"PERIODIC_TABLE",
"[",
"a",
"[",
"0",
"]",
"]",
"[",
"\"mass\"",
"]",
")",
"centro",
"*=",
"(",
"1",
"/",
"M",
")",
"return",
"centro"
] | [
144,
4
] | [
152,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TextEditor.create_memento | (self) | return pickle.dumps(vars(self)) | Función que se encarga de serializar el objeto, lo guardamos | Función que se encarga de serializar el objeto, lo guardamos | def create_memento(self):
"""Función que se encarga de serializar el objeto, lo guardamos"""
return pickle.dumps(vars(self)) | [
"def",
"create_memento",
"(",
"self",
")",
":",
"return",
"pickle",
".",
"dumps",
"(",
"vars",
"(",
"self",
")",
")"
] | [
18,
4
] | [
20,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
cuad_trapecio_funcion | (a, b, f) | return aprox | Implementación de la regla del trapecio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del trapecio
Notes
-----
Este código es parte del curso "Computación", Famaf
| Implementación de la regla del trapecio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del trapecio
Notes
-----
Este código es parte del curso "Computación", Famaf
| def cuad_trapecio_funcion(a, b, f):
"""Implementación de la regla del trapecio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del trapecio
Notes
-----
Este código es parte del curso "Computación", Famaf
"""
if a > b:
raise ValueError("Oops! Debe ser a<b")
return None
try:
h = f(a) + f(b)
aprox = (b-a)/2*h
except:
print('Error: no fue posible calcular la función')
return aprox | [
"def",
"cuad_trapecio_funcion",
"(",
"a",
",",
"b",
",",
"f",
")",
":",
"if",
"a",
">",
"b",
":",
"raise",
"ValueError",
"(",
"\"Oops! Debe ser a<b\"",
")",
"return",
"None",
"try",
":",
"h",
"=",
"f",
"(",
"a",
")",
"+",
"f",
"(",
"b",
")",
"aprox",
"=",
"(",
"b",
"-",
"a",
")",
"/",
"2",
"*",
"h",
"except",
":",
"print",
"(",
"'Error: no fue posible calcular la función')",
"",
"return",
"aprox"
] | [
38,
0
] | [
63,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Warrior.get_all_queue | (self) | return fm | Obtiene la relacion "nombre",pid de los mensajes de la cola | Obtiene la relacion "nombre",pid de los mensajes de la cola | def get_all_queue(self):
'''Obtiene la relacion "nombre",pid de los mensajes de la cola'''
msgs = []
fm = {}
while not self.q.empty():
msgs.append(self.q.get())
for msg in msgs:
msgsplit = msg.split(",")
if len(msgsplit) > 1:
fm[msgsplit[0]] = msgsplit[1]
return fm | [
"def",
"get_all_queue",
"(",
"self",
")",
":",
"msgs",
"=",
"[",
"]",
"fm",
"=",
"{",
"}",
"while",
"not",
"self",
".",
"q",
".",
"empty",
"(",
")",
":",
"msgs",
".",
"append",
"(",
"self",
".",
"q",
".",
"get",
"(",
")",
")",
"for",
"msg",
"in",
"msgs",
":",
"msgsplit",
"=",
"msg",
".",
"split",
"(",
"\",\"",
")",
"if",
"len",
"(",
"msgsplit",
")",
">",
"1",
":",
"fm",
"[",
"msgsplit",
"[",
"0",
"]",
"]",
"=",
"msgsplit",
"[",
"1",
"]",
"return",
"fm"
] | [
80,
4
] | [
91,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Simulador.iniciar_vuelo | (self) | Inicia la simulación, llamar luego de
definir las coordenadas de origen destino.
| Inicia la simulación, llamar luego de
definir las coordenadas de origen destino.
| def iniciar_vuelo(self):
"""Inicia la simulación, llamar luego de
definir las coordenadas de origen destino.
"""
self.tiempo_inicio = datetime.fromtimestamp(time.time())
self.calcular_ruta()
self.calc_tiempo_fin() | [
"def",
"iniciar_vuelo",
"(",
"self",
")",
":",
"self",
".",
"tiempo_inicio",
"=",
"datetime",
".",
"fromtimestamp",
"(",
"time",
".",
"time",
"(",
")",
")",
"self",
".",
"calcular_ruta",
"(",
")",
"self",
".",
"calc_tiempo_fin",
"(",
")"
] | [
91,
4
] | [
97,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Restaurant.open_restaurant | (self) | mostrar un mensaje que el restaurante esta abierto. | mostrar un mensaje que el restaurante esta abierto. | def open_restaurant(self):
"""mostrar un mensaje que el restaurante esta abierto."""
msg = self.name + " esta abierto vamos!"
print("\n" + msg) | [
"def",
"open_restaurant",
"(",
"self",
")",
":",
"msg",
"=",
"self",
".",
"name",
"+",
"\" esta abierto vamos!\"",
"print",
"(",
"\"\\n\"",
"+",
"msg",
")"
] | [
14,
4
] | [
17,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
set_config_default | (values) | return values | le carga a un usuario nuevo los valores defaults | le carga a un usuario nuevo los valores defaults | def set_config_default(values):
"""le carga a un usuario nuevo los valores defaults"""
datos = cargar_usuarios()
values["config"] = datos["default"]["config"]
return values | [
"def",
"set_config_default",
"(",
"values",
")",
":",
"datos",
"=",
"cargar_usuarios",
"(",
")",
"values",
"[",
"\"config\"",
"]",
"=",
"datos",
"[",
"\"default\"",
"]",
"[",
"\"config\"",
"]",
"return",
"values"
] | [
40,
0
] | [
44,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_definicion_procedure_1 | (t) | definicion_procedure : declaraciones_procedure cuerpo_procedure END | definicion_procedure : declaraciones_procedure cuerpo_procedure END | def p_definicion_procedure_1(t):
'''definicion_procedure : declaraciones_procedure cuerpo_procedure END'''
t[0] = Start("DEFINICION_PROCEDURE")
t[0].addChild(t[1])
t[0].addChild(t[2]) | [
"def",
"p_definicion_procedure_1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"DEFINICION_PROCEDURE\"",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"2",
"]",
")"
] | [
1784,
0
] | [
1788,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
NormalizarUnidadTerritorialTestCase.test_get_api_response | (self) | Realiza un búsquedas sobre una entidad territorial. | Realiza un búsquedas sobre una entidad territorial. | def test_get_api_response(self):
"""Realiza un búsquedas sobre una entidad territorial."""
entity = 'localidad'
data_test = {'localidades': [
{'nombre': 'laferrere', 'aplanar': True,
'provincia': 'buenos aires', 'max': 1}
]}
res_test = [
{'localidades': [
{u'departamento_nombre': u'La Matanza',
u'tipo': u'Entidad (E)',
u'centroide_lon': -58.592533,
u'municipio_nombre': u'La Matanza', u'provincia_id': u'06',
u'departamento_id': u'06427', u'id': u'06427010004',
u'centroide_lat': -34.746838,
u'provincia_nombre': u'Buenos Aires',
u'nombre': u'GREGORIO DE LAFERRERE',
u'municipio_id': u'060427'}]
}]
input_path = get_input('normalize_unidad_territorial')
dc = DataCleaner(input_path)
res = dc._get_api_response(entity, data_test)
self.assertEqual(res_test, res) | [
"def",
"test_get_api_response",
"(",
"self",
")",
":",
"entity",
"=",
"'localidad'",
"data_test",
"=",
"{",
"'localidades'",
":",
"[",
"{",
"'nombre'",
":",
"'laferrere'",
",",
"'aplanar'",
":",
"True",
",",
"'provincia'",
":",
"'buenos aires'",
",",
"'max'",
":",
"1",
"}",
"]",
"}",
"res_test",
"=",
"[",
"{",
"'localidades'",
":",
"[",
"{",
"u'departamento_nombre'",
":",
"u'La Matanza'",
",",
"u'tipo'",
":",
"u'Entidad (E)'",
",",
"u'centroide_lon'",
":",
"-",
"58.592533",
",",
"u'municipio_nombre'",
":",
"u'La Matanza'",
",",
"u'provincia_id'",
":",
"u'06'",
",",
"u'departamento_id'",
":",
"u'06427'",
",",
"u'id'",
":",
"u'06427010004'",
",",
"u'centroide_lat'",
":",
"-",
"34.746838",
",",
"u'provincia_nombre'",
":",
"u'Buenos Aires'",
",",
"u'nombre'",
":",
"u'GREGORIO DE LAFERRERE'",
",",
"u'municipio_id'",
":",
"u'060427'",
"}",
"]",
"}",
"]",
"input_path",
"=",
"get_input",
"(",
"'normalize_unidad_territorial'",
")",
"dc",
"=",
"DataCleaner",
"(",
"input_path",
")",
"res",
"=",
"dc",
".",
"_get_api_response",
"(",
"entity",
",",
"data_test",
")",
"self",
".",
"assertEqual",
"(",
"res_test",
",",
"res",
")"
] | [
545,
4
] | [
568,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Ventana3.siguiente | (self) | Si el valor i es menor al tamaño de la lista se debe
de detener y pasar al siguiente valor de la lista y reproducirlo | Si el valor i es menor al tamaño de la lista se debe
de detener y pasar al siguiente valor de la lista y reproducirlo | def siguiente(self):
self.i=self.i+1
'''Si el valor i es menor al tamaño de la lista se debe
de detener y pasar al siguiente valor de la lista y reproducirlo'''
if(self.i<len(self.n)):
pygame.mixer.music.stop()#Detiene el archivo de audio cargado
pygame.mixer.music.load(self.n[self.i])#Carga el nuevo archivo de audio de la lista
pygame.mixer.music.play()#Se reproduce el archivo de audio
'''En caso contrario, significa que se llegó al límite de la lista
y se debe de reiniciar desde cero'''
else:
self.i=0
pygame.mixer.music.stop()
pygame.mixer.music.load(self.n[self.i])
pygame.mixer.music.play() | [
"def",
"siguiente",
"(",
"self",
")",
":",
"self",
".",
"i",
"=",
"self",
".",
"i",
"+",
"1",
"if",
"(",
"self",
".",
"i",
"<",
"len",
"(",
"self",
".",
"n",
")",
")",
":",
"pygame",
".",
"mixer",
".",
"music",
".",
"stop",
"(",
")",
"#Detiene el archivo de audio cargado",
"pygame",
".",
"mixer",
".",
"music",
".",
"load",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"#Carga el nuevo archivo de audio de la lista",
"pygame",
".",
"mixer",
".",
"music",
".",
"play",
"(",
")",
"#Se reproduce el archivo de audio",
"'''En caso contrario, significa que se llegó al límite de la lista\n y se debe de reiniciar desde cero'''",
"else",
":",
"self",
".",
"i",
"=",
"0",
"pygame",
".",
"mixer",
".",
"music",
".",
"stop",
"(",
")",
"pygame",
".",
"mixer",
".",
"music",
".",
"load",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"pygame",
".",
"mixer",
".",
"music",
".",
"play",
"(",
")"
] | [
164,
4
] | [
178,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TransactionViewSet.cobrar | (self, request, pk=None) | Método que permite al banquero cobrar a un usuario.
Nota: solo el usuario banquero tiene acceso a este método. | Método que permite al banquero cobrar a un usuario.
Nota: solo el usuario banquero tiene acceso a este método. | def cobrar(self, request, pk=None):
""" Método que permite al banquero cobrar a un usuario.
Nota: solo el usuario banquero tiene acceso a este método."""
banquero = self.request.user
serializer = TransactionSerializer(data=request.data)
if serializer.is_valid():
transaction = serializer.save(userReceiver=banquero)
jugador = serializer.validated_data['userTransmitter']
amount = serializer.validated_data['amount']
banquero.amount += amount
jugador.amount -= amount
banquero.save()
jugador.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response({"errors": (serializer.errors,)}, status=status.HTTP_400_BAD_REQUEST) | [
"def",
"cobrar",
"(",
"self",
",",
"request",
",",
"pk",
"=",
"None",
")",
":",
"banquero",
"=",
"self",
".",
"request",
".",
"user",
"serializer",
"=",
"TransactionSerializer",
"(",
"data",
"=",
"request",
".",
"data",
")",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"transaction",
"=",
"serializer",
".",
"save",
"(",
"userReceiver",
"=",
"banquero",
")",
"jugador",
"=",
"serializer",
".",
"validated_data",
"[",
"'userTransmitter'",
"]",
"amount",
"=",
"serializer",
".",
"validated_data",
"[",
"'amount'",
"]",
"banquero",
".",
"amount",
"+=",
"amount",
"jugador",
".",
"amount",
"-=",
"amount",
"banquero",
".",
"save",
"(",
")",
"jugador",
".",
"save",
"(",
")",
"return",
"Response",
"(",
"serializer",
".",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_201_CREATED",
")",
"else",
":",
"return",
"Response",
"(",
"{",
"\"errors\"",
":",
"(",
"serializer",
".",
"errors",
",",
")",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
59,
4
] | [
76,
97
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_procedure_2 | (t) | instrucciones_procedure : instruccion_procedure PUNTOYCOMA | instrucciones_procedure : instruccion_procedure PUNTOYCOMA | def p_instrucciones_procedure_2(t):
'''instrucciones_procedure : instruccion_procedure PUNTOYCOMA'''
t[0] = Start("INSTRUCCIONES_PROCEDURE")
t[0].addChild(t[1]) | [
"def",
"p_instrucciones_procedure_2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"INSTRUCCIONES_PROCEDURE\"",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"1",
"]",
")"
] | [
1813,
0
] | [
1816,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_propcol | (p) | propcol : propcol propiedadescol | propcol : propcol propiedadescol | def p_propcol(p):
"propcol : propcol propiedadescol"
p[0] = p[1] + p[2] | [
"def",
"p_propcol",
"(",
"p",
")",
":",
"p",
"[",
"0",
"]",
"=",
"p",
"[",
"1",
"]",
"+",
"p",
"[",
"2",
"]"
] | [
360,
0
] | [
362,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cambia_curso_publico | (id_curso: Union[None, str, int] = None) | Cambia el estatus publico de un curso. | Cambia el estatus publico de un curso. | def cambia_curso_publico(id_curso: Union[None, str, int] = None):
"""Cambia el estatus publico de un curso."""
CURSO = Curso.query.filter_by(codigo=id_curso).first()
if CURSO.publico:
CURSO.publico = False
else:
CURSO.publico = True
database.session.commit() | [
"def",
"cambia_curso_publico",
"(",
"id_curso",
":",
"Union",
"[",
"None",
",",
"str",
",",
"int",
"]",
"=",
"None",
")",
":",
"CURSO",
"=",
"Curso",
".",
"query",
".",
"filter_by",
"(",
"codigo",
"=",
"id_curso",
")",
".",
"first",
"(",
")",
"if",
"CURSO",
".",
"publico",
":",
"CURSO",
".",
"publico",
"=",
"False",
"else",
":",
"CURSO",
".",
"publico",
"=",
"True",
"database",
".",
"session",
".",
"commit",
"(",
")"
] | [
519,
0
] | [
526,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cuad_simpson_datos | (x0, x2, f=None, y0=None, y1=None, y2=None,
nargs_in=None) | return aprox | Implementación de la regla de simpson
Parameters
----------
x0: float
Límite inferior del intervalo
x2: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y2: float
El valor de y en el punto medio.
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson(x0, x2, f=f)
cuad_simpson(x0, x2, y0=f(x0), y2=f(x2))
cuad_simpson(x0, x2, f)
cuad_simpson(x0, x2, y0, y2)
| Implementación de la regla de simpson
Parameters
----------
x0: float
Límite inferior del intervalo
x2: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y2: float
El valor de y en el punto medio.
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson(x0, x2, f=f)
cuad_simpson(x0, x2, y0=f(x0), y2=f(x2))
cuad_simpson(x0, x2, f)
cuad_simpson(x0, x2, y0, y2)
| def cuad_simpson_datos(x0, x2, f=None, y0=None, y1=None, y2=None,
nargs_in=None):
"""Implementación de la regla de simpson
Parameters
----------
x0: float
Límite inferior del intervalo
x2: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y2: float
El valor de y en el punto medio.
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson(x0, x2, f=f)
cuad_simpson(x0, x2, y0=f(x0), y2=f(x2))
cuad_simpson(x0, x2, f)
cuad_simpson(x0, x2, y0, y2)
"""
if nargs_in==5:
y2=y1
y1=y0
y0=f
f = None
elif nargs_in==3:
if type(f) is float:
raise ValueError("Verificar los argumentos")
else:
raise ValueError("Verificar el número de argumentos")
if x0 > x2:
raise ValueError("Oops! Debe ser a<b")
x1 = (x0+x2)/2
if (f is None) and (y0 is not None) and (y1 is not None):
aprox = (x2-x0)/6 * (y0 + 4*y1 + y2)
elif (f is not None) and (y0 is None):
try:
y0 = f(x0)
y1 = f(x1)
y2 = f(x2)
except:
print(('Error: no fue posible calcular la función'
' Si desea ingresar un dato use y0='))
aprox = (x2-x0)/6 * (y0 + 4*y1 + y2)
else:
raise ValueError("Debe ingresar la función o los datos!")
return aprox | [
"def",
"cuad_simpson_datos",
"(",
"x0",
",",
"x2",
",",
"f",
"=",
"None",
",",
"y0",
"=",
"None",
",",
"y1",
"=",
"None",
",",
"y2",
"=",
"None",
",",
"nargs_in",
"=",
"None",
")",
":",
"if",
"nargs_in",
"==",
"5",
":",
"y2",
"=",
"y1",
"y1",
"=",
"y0",
"y0",
"=",
"f",
"f",
"=",
"None",
"elif",
"nargs_in",
"==",
"3",
":",
"if",
"type",
"(",
"f",
")",
"is",
"float",
":",
"raise",
"ValueError",
"(",
"\"Verificar los argumentos\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Verificar el número de argumentos\")",
"",
"if",
"x0",
">",
"x2",
":",
"raise",
"ValueError",
"(",
"\"Oops! Debe ser a<b\"",
")",
"x1",
"=",
"(",
"x0",
"+",
"x2",
")",
"/",
"2",
"if",
"(",
"f",
"is",
"None",
")",
"and",
"(",
"y0",
"is",
"not",
"None",
")",
"and",
"(",
"y1",
"is",
"not",
"None",
")",
":",
"aprox",
"=",
"(",
"x2",
"-",
"x0",
")",
"/",
"6",
"*",
"(",
"y0",
"+",
"4",
"*",
"y1",
"+",
"y2",
")",
"elif",
"(",
"f",
"is",
"not",
"None",
")",
"and",
"(",
"y0",
"is",
"None",
")",
":",
"try",
":",
"y0",
"=",
"f",
"(",
"x0",
")",
"y1",
"=",
"f",
"(",
"x1",
")",
"y2",
"=",
"f",
"(",
"x2",
")",
"except",
":",
"print",
"(",
"(",
"'Error: no fue posible calcular la función'",
"' Si desea ingresar un dato use y0='",
")",
")",
"aprox",
"=",
"(",
"x2",
"-",
"x0",
")",
"/",
"6",
"*",
"(",
"y0",
"+",
"4",
"*",
"y1",
"+",
"y2",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Debe ingresar la función o los datos!\")",
" ",
"return",
"aprox"
] | [
332,
0
] | [
394,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
batchCollect | (
apiclient: ApiClient, collect_data: Dict[str, Any]
) | Este servicio envía de forma masiva un lote de cobros a clientes.
Similar al servicio collect pero masivo y asíncrono. Este servicio
responde con un token identificador del lote y el número de filas
recibidas.
| Este servicio envía de forma masiva un lote de cobros a clientes.
Similar al servicio collect pero masivo y asíncrono. Este servicio
responde con un token identificador del lote y el número de filas
recibidas.
| def batchCollect(
apiclient: ApiClient, collect_data: Dict[str, Any]
) -> Union[BatchCollectResponse, Error]:
"""Este servicio envía de forma masiva un lote de cobros a clientes.
Similar al servicio collect pero masivo y asíncrono. Este servicio
responde con un token identificador del lote y el número de filas
recibidas.
"""
url = f"{apiclient.api_url}/customer/batchCollect"
batch_collect = BatchCollectRequest.from_dict(collect_data)
if batch_collect.apiKey is None:
batch_collect.apiKey = apiclient.api_key
batch_collect.s = apiclient.make_signature(asdict(batch_collect))
logging.debug("Before Request:" + str(batch_collect))
response = apiclient.post(url, asdict(batch_collect))
if response.status_code == 200:
return BatchCollectResponse.from_dict(cast(Dict[str, Any], response.json()))
if response.status_code == 400:
return Error.from_dict(cast(Dict[str, Any], response.json()))
if response.status_code == 401:
return Error.from_dict(cast(Dict[str, Any], response.json()))
else:
raise Exception(response=response) | [
"def",
"batchCollect",
"(",
"apiclient",
":",
"ApiClient",
",",
"collect_data",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Union",
"[",
"BatchCollectResponse",
",",
"Error",
"]",
":",
"url",
"=",
"f\"{apiclient.api_url}/customer/batchCollect\"",
"batch_collect",
"=",
"BatchCollectRequest",
".",
"from_dict",
"(",
"collect_data",
")",
"if",
"batch_collect",
".",
"apiKey",
"is",
"None",
":",
"batch_collect",
".",
"apiKey",
"=",
"apiclient",
".",
"api_key",
"batch_collect",
".",
"s",
"=",
"apiclient",
".",
"make_signature",
"(",
"asdict",
"(",
"batch_collect",
")",
")",
"logging",
".",
"debug",
"(",
"\"Before Request:\"",
"+",
"str",
"(",
"batch_collect",
")",
")",
"response",
"=",
"apiclient",
".",
"post",
"(",
"url",
",",
"asdict",
"(",
"batch_collect",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"BatchCollectResponse",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"400",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"401",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"else",
":",
"raise",
"Exception",
"(",
"response",
"=",
"response",
")"
] | [
307,
0
] | [
333,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProcControl.AsyncClear | (self, *args, **kwargs) | Ejecuta `autoStop()` y `autoRemove()` juntos | Ejecuta `autoStop()` y `autoRemove()` juntos | async def AsyncClear(self, *args, **kwargs) -> None:
"""Ejecuta `autoStop()` y `autoRemove()` juntos"""
for target in super().keys():
self.autoStop(*args, **kwargs)
# Esperamos que terminen los procesos, aunque pueden no terminar :-p
await asyncio.sleep(self.interval)
self.autoRemove() | [
"async",
"def",
"AsyncClear",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"None",
":",
"for",
"target",
"in",
"super",
"(",
")",
".",
"keys",
"(",
")",
":",
"self",
".",
"autoStop",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"# Esperamos que terminen los procesos, aunque pueden no terminar :-p",
"await",
"asyncio",
".",
"sleep",
"(",
"self",
".",
"interval",
")",
"self",
".",
"autoRemove",
"(",
")"
] | [
237,
4
] | [
244,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
decrypt | (
verifyKey: bytes,
publicKey: bytes,
secretKey: bytes,
data: bytes,
is_packed: bool = options.IS_PACKED
) | Descifra y verifica el mensaje
Args:
verifyKey:
La clave de verificación
publickey:
La clave pública del destinatario
secretKey:
La clave secreta
data:
Los datos a descifrar
Returns:
Los datos verificados y descifrados
| Descifra y verifica el mensaje | def decrypt(
verifyKey: bytes,
publicKey: bytes,
secretKey: bytes,
data: bytes,
is_packed: bool = options.IS_PACKED
) -> bytes:
"""Descifra y verifica el mensaje
Args:
verifyKey:
La clave de verificación
publickey:
La clave pública del destinatario
secretKey:
La clave secreta
data:
Los datos a descifrar
Returns:
Los datos verificados y descifrados
"""
scheme = x25519_xsalsa20_poly1305MAC.InitSession(publicKey, secretKey)
result = scheme.decrypt(ed25519.verify(verifyKey, data))
if (is_packed):
return msgpack.loads(result)
else:
return result | [
"def",
"decrypt",
"(",
"verifyKey",
":",
"bytes",
",",
"publicKey",
":",
"bytes",
",",
"secretKey",
":",
"bytes",
",",
"data",
":",
"bytes",
",",
"is_packed",
":",
"bool",
"=",
"options",
".",
"IS_PACKED",
")",
"->",
"bytes",
":",
"scheme",
"=",
"x25519_xsalsa20_poly1305MAC",
".",
"InitSession",
"(",
"publicKey",
",",
"secretKey",
")",
"result",
"=",
"scheme",
".",
"decrypt",
"(",
"ed25519",
".",
"verify",
"(",
"verifyKey",
",",
"data",
")",
")",
"if",
"(",
"is_packed",
")",
":",
"return",
"msgpack",
".",
"loads",
"(",
"result",
")",
"else",
":",
"return",
"result"
] | [
43,
0
] | [
78,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObject.remove_tracked_positions | (self, ids: List[int]) | Elimina los seguimientos indicados.
Útil por ejemplo para las detecciones iniciales o finales que produzcan valores extraños.
:param ids: lista de identificadores de seguimiento para eliminar.
:return: None.
| Elimina los seguimientos indicados. | def remove_tracked_positions(self, ids: List[int]) -> None:
"""Elimina los seguimientos indicados.
Útil por ejemplo para las detecciones iniciales o finales que produzcan valores extraños.
:param ids: lista de identificadores de seguimiento para eliminar.
:return: None.
"""
frames = [frame for fid, frame in enumerate(self.frames) if fid in ids]
detections = [detection for did, detection in enumerate(self.detections) if did in ids]
# Proceder a la eliminación.
for frame in frames:
self.frames.remove(frame)
for detection in detections:
self.detections.remove(detection) | [
"def",
"remove_tracked_positions",
"(",
"self",
",",
"ids",
":",
"List",
"[",
"int",
"]",
")",
"->",
"None",
":",
"frames",
"=",
"[",
"frame",
"for",
"fid",
",",
"frame",
"in",
"enumerate",
"(",
"self",
".",
"frames",
")",
"if",
"fid",
"in",
"ids",
"]",
"detections",
"=",
"[",
"detection",
"for",
"did",
",",
"detection",
"in",
"enumerate",
"(",
"self",
".",
"detections",
")",
"if",
"did",
"in",
"ids",
"]",
"# Proceder a la eliminación.",
"for",
"frame",
"in",
"frames",
":",
"self",
".",
"frames",
".",
"remove",
"(",
"frame",
")",
"for",
"detection",
"in",
"detections",
":",
"self",
".",
"detections",
".",
"remove",
"(",
"detection",
")"
] | [
98,
4
] | [
112,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Page.__init__ | (self, URL: str, RUTA: str, FORMATO:str, CONTENIDO:str, TITULO: str, SLUG:str, METATAGS:list) | Cree unos objetos en la clase ya que el parametro self se refiere al objeto instanciado de esta clase sobre el cual se esta invocando dicho metodo | Cree unos objetos en la clase ya que el parametro self se refiere al objeto instanciado de esta clase sobre el cual se esta invocando dicho metodo | def __init__(self, URL: str, RUTA: str, FORMATO:str, CONTENIDO:str, TITULO: str, SLUG:str, METATAGS:list):
self.URL = URL
self.RUTA = RUTA
self.FORMATO=FORMATO
self.CONTENIDO = CONTENIDO
self.TITULO = TITULO
self.SLUG= SLUG
self.METATAGS=METATAGS
'Cree unos objetos en la clase ya que el parametro self se refiere al objeto instanciado de esta clase sobre el cual se esta invocando dicho metodo' | [
"def",
"__init__",
"(",
"self",
",",
"URL",
":",
"str",
",",
"RUTA",
":",
"str",
",",
"FORMATO",
":",
"str",
",",
"CONTENIDO",
":",
"str",
",",
"TITULO",
":",
"str",
",",
"SLUG",
":",
"str",
",",
"METATAGS",
":",
"list",
")",
":",
"self",
".",
"URL",
"=",
"URL",
"self",
".",
"RUTA",
"=",
"RUTA",
"self",
".",
"FORMATO",
"=",
"FORMATO",
"self",
".",
"CONTENIDO",
"=",
"CONTENIDO",
"self",
".",
"TITULO",
"=",
"TITULO",
"self",
".",
"SLUG",
"=",
"SLUG",
"self",
".",
"METATAGS",
"=",
"METATAGS"
] | [
1,
4
] | [
9,
156
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
scrap_zip_code | (arguments) | return places_results | Función que crea una instancia de `OptimizedResultsExtractor` y ejecuta su función `scrap`. Esta función
(`scrap_zip_code`) es llamada por el pool de procesos para paralelizar la extracción de las urls de acceso a cada
local comercial que se encuentre en las páginas de resultados para un código postal y tipos de locales comerciales.
Parameters
----------
arguments : dict
diccionario que contiene los campos para instanciar un objecto de la clase `OptimizedResultsExtractor` y además
los campos que necesite una instancia de `PlacesExtractor` ya que como resultado de la función `scrap_zip_code`
se devuelve una lista de diccionarios, los que contienen los parámetros para instanciar los scrappers de los
locales comerciales (`PlacesExtractor`)
Returns
-------
list
lista da diccionarios cuyas claves y valores serán los argumentos para instanciar objetos de `PlacesExtractor`
| Función que crea una instancia de `OptimizedResultsExtractor` y ejecuta su función `scrap`. Esta función
(`scrap_zip_code`) es llamada por el pool de procesos para paralelizar la extracción de las urls de acceso a cada
local comercial que se encuentre en las páginas de resultados para un código postal y tipos de locales comerciales. | def scrap_zip_code(arguments):
""" Función que crea una instancia de `OptimizedResultsExtractor` y ejecuta su función `scrap`. Esta función
(`scrap_zip_code`) es llamada por el pool de procesos para paralelizar la extracción de las urls de acceso a cada
local comercial que se encuentre en las páginas de resultados para un código postal y tipos de locales comerciales.
Parameters
----------
arguments : dict
diccionario que contiene los campos para instanciar un objecto de la clase `OptimizedResultsExtractor` y además
los campos que necesite una instancia de `PlacesExtractor` ya que como resultado de la función `scrap_zip_code`
se devuelve una lista de diccionarios, los que contienen los parámetros para instanciar los scrappers de los
locales comerciales (`PlacesExtractor`)
Returns
-------
list
lista da diccionarios cuyas claves y valores serán los argumentos para instanciar objetos de `PlacesExtractor`
"""
postal_code = arguments.get("postal_code")
driver_location = arguments.get("driver_location")
num_reviews = arguments.get("num_reviews")
output_config = arguments.get("output_config")
extraction_date = arguments.get("extraction_date")
places_types = arguments.get("places_types")
executors = arguments.get("executors")
scraper = OptimizedResultsExtractor(driver_location=driver_location,
postal_code=postal_code,
places_types=places_types,
num_pages=arguments.get("num_pages"),
base_url=arguments.get("base_url"))
results = scraper.scrap()
parsed_results = [{"url": place_found.get("url"),
"place_name": place_found.get("name"),
"place_address": place_found.get("address"),
"postal_code": postal_code,
"driver_location": driver_location,
"num_reviews": num_reviews,
"output_config": output_config,
"places_types": places_types,
"extraction_date": extraction_date} for place_found in results]
with Pool(processes=executors) as pool:
places_results = pool.map(func=scrap_place, iterable=iter(parsed_results))
return places_results | [
"def",
"scrap_zip_code",
"(",
"arguments",
")",
":",
"postal_code",
"=",
"arguments",
".",
"get",
"(",
"\"postal_code\"",
")",
"driver_location",
"=",
"arguments",
".",
"get",
"(",
"\"driver_location\"",
")",
"num_reviews",
"=",
"arguments",
".",
"get",
"(",
"\"num_reviews\"",
")",
"output_config",
"=",
"arguments",
".",
"get",
"(",
"\"output_config\"",
")",
"extraction_date",
"=",
"arguments",
".",
"get",
"(",
"\"extraction_date\"",
")",
"places_types",
"=",
"arguments",
".",
"get",
"(",
"\"places_types\"",
")",
"executors",
"=",
"arguments",
".",
"get",
"(",
"\"executors\"",
")",
"scraper",
"=",
"OptimizedResultsExtractor",
"(",
"driver_location",
"=",
"driver_location",
",",
"postal_code",
"=",
"postal_code",
",",
"places_types",
"=",
"places_types",
",",
"num_pages",
"=",
"arguments",
".",
"get",
"(",
"\"num_pages\"",
")",
",",
"base_url",
"=",
"arguments",
".",
"get",
"(",
"\"base_url\"",
")",
")",
"results",
"=",
"scraper",
".",
"scrap",
"(",
")",
"parsed_results",
"=",
"[",
"{",
"\"url\"",
":",
"place_found",
".",
"get",
"(",
"\"url\"",
")",
",",
"\"place_name\"",
":",
"place_found",
".",
"get",
"(",
"\"name\"",
")",
",",
"\"place_address\"",
":",
"place_found",
".",
"get",
"(",
"\"address\"",
")",
",",
"\"postal_code\"",
":",
"postal_code",
",",
"\"driver_location\"",
":",
"driver_location",
",",
"\"num_reviews\"",
":",
"num_reviews",
",",
"\"output_config\"",
":",
"output_config",
",",
"\"places_types\"",
":",
"places_types",
",",
"\"extraction_date\"",
":",
"extraction_date",
"}",
"for",
"place_found",
"in",
"results",
"]",
"with",
"Pool",
"(",
"processes",
"=",
"executors",
")",
"as",
"pool",
":",
"places_results",
"=",
"pool",
".",
"map",
"(",
"func",
"=",
"scrap_place",
",",
"iterable",
"=",
"iter",
"(",
"parsed_results",
")",
")",
"return",
"places_results"
] | [
108,
0
] | [
150,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
FingerprintKeyerUnitTestCase.test_fingerprint_keyer | (self) | Testea la creación de una key fingerprint. | Testea la creación de una key fingerprint. | def test_fingerprint_keyer(self):
"""Testea la creación de una key fingerprint."""
input_output_strings = [
("schön", "schon"),
# ("Ære Øre Åre", "are aere ore"),
# ("Straße","strasse"),
# test leading and trailing whitespace
("\tABC \t DEF ", "abc def"),
("bbb\taaa", "aaa bbb"),
("müller", "muller"),
# ("müller","mueller"), # another possible interpretation
# ("fiflij","fiflij"),
# ("ﭏ","אל"),
# ("œ ӕ","ae oe"),
("", ""),
]
for inp_string, out_exp in input_output_strings:
self.assertEqual(fingerprint_keyer(inp_string, True, True),
out_exp) | [
"def",
"test_fingerprint_keyer",
"(",
"self",
")",
":",
"input_output_strings",
"=",
"[",
"(",
"\"schön\",",
" ",
"schon\")",
",",
"",
"# (\"Ære Øre Åre\", \"are aere ore\"),",
"# (\"Straße\",\"strasse\"),",
"# test leading and trailing whitespace",
"(",
"\"\\tABC \\t DEF \"",
",",
"\"abc def\"",
")",
",",
"(",
"\"bbb\\taaa\"",
",",
"\"aaa bbb\"",
")",
",",
"(",
"\"müller\",",
" ",
"muller\")",
",",
"",
"# (\"müller\",\"mueller\"), # another possible interpretation",
"# (\"fiflij\",\"fiflij\"),",
"# (\"ﭏ\",\"אל\"),",
"# (\"œ ӕ\",\"ae oe\"),",
"(",
"\"\"",
",",
"\"\"",
")",
",",
"]",
"for",
"inp_string",
",",
"out_exp",
"in",
"input_output_strings",
":",
"self",
".",
"assertEqual",
"(",
"fingerprint_keyer",
"(",
"inp_string",
",",
"True",
",",
"True",
")",
",",
"out_exp",
")"
] | [
42,
4
] | [
60,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.