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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
TarjetaCredito.pagar | (self, monto: float) | Procesa el pago del cliente y lo descuenta del balance.
:param monto: Monto a pagar.
:monto type: float
| Procesa el pago del cliente y lo descuenta del balance. | def pagar(self, monto: float) -> None:
"""Procesa el pago del cliente y lo descuenta del balance.
:param monto: Monto a pagar.
:monto type: float
"""
monto = validate_float(
monto, min=0, custom="El monto debe ser mayor a cero."
)
self._balance -= monto | [
"def",
"pagar",
"(",
"self",
",",
"monto",
":",
"float",
")",
"->",
"None",
":",
"monto",
"=",
"validate_float",
"(",
"monto",
",",
"min",
"=",
"0",
",",
"custom",
"=",
"\"El monto debe ser mayor a cero.\"",
")",
"self",
".",
"_balance",
"-=",
"monto"
] | [
98,
4
] | [
107,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.row | (self, i) | return self.transpose()[i] | Metodo para extraer una fila determinada de la matriz. | Metodo para extraer una fila determinada de la matriz. | def row(self, i):
""" Metodo para extraer una fila determinada de la matriz. """
return self.transpose()[i] | [
"def",
"row",
"(",
"self",
",",
"i",
")",
":",
"return",
"self",
".",
"transpose",
"(",
")",
"[",
"i",
"]"
] | [
109,
4
] | [
111,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_EXPT4 | (t) | EXP : cadenaString | EXP : cadenaString | def p_EXPT4(t):
'EXP : cadenaString'
t[0] = Terminal('varchar', t[1]) | [
"def",
"p_EXPT4",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Terminal",
"(",
"'varchar'",
",",
"t",
"[",
"1",
"]",
")"
] | [
732,
0
] | [
734,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solucion_a | (fuente: str, analizador: dict) | return salida | Reemplaza pares de caracteres si son encontrados en el
analizador.
:param fuente: Texto fuente
:fuente type: str
:param analizador: Mapeo de caracteres a reemplazar
:analizador type: dict
:returns: Texto modificado
:rtype: str
| Reemplaza pares de caracteres si son encontrados en el
analizador. | def solucion_a(fuente: str, analizador: dict) -> str:
"""Reemplaza pares de caracteres si son encontrados en el
analizador.
:param fuente: Texto fuente
:fuente type: str
:param analizador: Mapeo de caracteres a reemplazar
:analizador type: dict
:returns: Texto modificado
:rtype: str
"""
salida = ""
for impar, par in zip(fuente[::2], fuente[1::2]):
if impar + par in analizador.keys():
salida += analizador[impar + par]
return salida | [
"def",
"solucion_a",
"(",
"fuente",
":",
"str",
",",
"analizador",
":",
"dict",
")",
"->",
"str",
":",
"salida",
"=",
"\"\"",
"for",
"impar",
",",
"par",
"in",
"zip",
"(",
"fuente",
"[",
":",
":",
"2",
"]",
",",
"fuente",
"[",
"1",
":",
":",
"2",
"]",
")",
":",
"if",
"impar",
"+",
"par",
"in",
"analizador",
".",
"keys",
"(",
")",
":",
"salida",
"+=",
"analizador",
"[",
"impar",
"+",
"par",
"]",
"return",
"salida"
] | [
25,
0
] | [
40,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
test_error | (driver) | Checkea si esta desplegada la ventana de error y lo maneja
:param driver: driver a usar
:type driver: webdriver.WebDriver
:return: True si hay error, y False en caso contrario
:rtype: bool
| Checkea si esta desplegada la ventana de error y lo maneja
:param driver: driver a usar
:type driver: webdriver.WebDriver
:return: True si hay error, y False en caso contrario
:rtype: bool
| def test_error(driver):
"""Checkea si esta desplegada la ventana de error y lo maneja
:param driver: driver a usar
:type driver: webdriver.WebDriver
:return: True si hay error, y False en caso contrario
:rtype: bool
"""
try:
wait = WebDriverWait(driver, 3)
xpath = "//div[@id='modalError' and @style='display: block;']"
wait.until(ec.visibility_of_element_located((By.XPATH, xpath)))
handle_error(driver)
return True
except TimeoutException:
return False | [
"def",
"test_error",
"(",
"driver",
")",
":",
"try",
":",
"wait",
"=",
"WebDriverWait",
"(",
"driver",
",",
"3",
")",
"xpath",
"=",
"\"//div[@id='modalError' and @style='display: block;']\"",
"wait",
".",
"until",
"(",
"ec",
".",
"visibility_of_element_located",
"(",
"(",
"By",
".",
"XPATH",
",",
"xpath",
")",
")",
")",
"handle_error",
"(",
"driver",
")",
"return",
"True",
"except",
"TimeoutException",
":",
"return",
"False"
] | [
133,
0
] | [
149,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PointTracker._algorithm | (self) | Algoritmo de seguimiento:
#. Para cada frame de la secuencia:
#. Emparejar los objetos del frame actual con alguno de los objetos que constan como
registrados.
#. Registrar los objetos que no han podido ser emparejados.
#. Desregistrar los objetos que llevan sin detectarse un número de frames determinado.
:return: None.
| Algoritmo de seguimiento: | def _algorithm(self) -> None:
"""Algoritmo de seguimiento:
#. Para cada frame de la secuencia:
#. Emparejar los objetos del frame actual con alguno de los objetos que constan como
registrados.
#. Registrar los objetos que no han podido ser emparejados.
#. Desregistrar los objetos que llevan sin detectarse un número de frames determinado.
:return: None.
"""
t = tqdm(total=len(self.sequence), desc='PointTracker', disable=not self.verbose)
for frame_actual in range(0, len(self.sequence)):
objects_actual = self.frame_objects(frame_actual)
# 1. Emparejar.
matches = self._matching_step(frame_actual, objects_actual)
# 2. Registrar de los objetos no emparejados.
self._register_step(frame_actual, objects_actual, matches)
# 3. Desregistrar de los objetos desaparecidos.
self._unregister_step(frame_actual)
# Actualizar tqdm.
t.update() | [
"def",
"_algorithm",
"(",
"self",
")",
"->",
"None",
":",
"t",
"=",
"tqdm",
"(",
"total",
"=",
"len",
"(",
"self",
".",
"sequence",
")",
",",
"desc",
"=",
"'PointTracker'",
",",
"disable",
"=",
"not",
"self",
".",
"verbose",
")",
"for",
"frame_actual",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"sequence",
")",
")",
":",
"objects_actual",
"=",
"self",
".",
"frame_objects",
"(",
"frame_actual",
")",
"# 1. Emparejar.",
"matches",
"=",
"self",
".",
"_matching_step",
"(",
"frame_actual",
",",
"objects_actual",
")",
"# 2. Registrar de los objetos no emparejados.",
"self",
".",
"_register_step",
"(",
"frame_actual",
",",
"objects_actual",
",",
"matches",
")",
"# 3. Desregistrar de los objetos desaparecidos.",
"self",
".",
"_unregister_step",
"(",
"frame_actual",
")",
"# Actualizar tqdm.",
"t",
".",
"update",
"(",
")"
] | [
134,
4
] | [
155,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funcion1 | (t) | funcion : funciones_select | funcion : funciones_select | def p_funcion1(t):
'funcion : funciones_select'
reporte_bnf.append("<funcion> ::= <funciones_select>")
t[0] = Create_select_uno(OPCIONES_SELECT.FUNCIONES,None,t[1],None,None,None,None) | [
"def",
"p_funcion1",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<funcion> ::= <funciones_select>\"",
")",
"t",
"[",
"0",
"]",
"=",
"Create_select_uno",
"(",
"OPCIONES_SELECT",
".",
"FUNCIONES",
",",
"None",
",",
"t",
"[",
"1",
"]",
",",
"None",
",",
"None",
",",
"None",
",",
"None",
")"
] | [
1838,
0
] | [
1841,
85
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Atajo.slug | (self) | return s | Devuelve el slug correspondiente al
ID de este atajo
Básicamente un slug es un número en base 62, representado usando
a-zA-Z0-9 como "dígitos", y dado vuelta (más significativo
a la derecha.
Ejemplo:
100000 => '4aA'
100001 => '5aA'
| Devuelve el slug correspondiente al
ID de este atajo | def slug(self):
'''Devuelve el slug correspondiente al
ID de este atajo
Básicamente un slug es un número en base 62, representado usando
a-zA-Z0-9 como "dígitos", y dado vuelta (más significativo
a la derecha.
Ejemplo:
100000 => '4aA'
100001 => '5aA'
'''
s = ''
n = self.id
while n:
s += self.validos[n%62]
n = n // 62
return s | [
"def",
"slug",
"(",
"self",
")",
":",
"s",
"=",
"''",
"n",
"=",
"self",
".",
"id",
"while",
"n",
":",
"s",
"+=",
"self",
".",
"validos",
"[",
"n",
"%",
"62",
"]",
"n",
"=",
"n",
"//",
"62",
"return",
"s"
] | [
133,
4
] | [
152,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones16 | (p) | funciones : ASIN PABRE expresion PCIERRA | funciones : ASIN PABRE expresion PCIERRA | def p_funciones16(p):
'funciones : ASIN PABRE expresion PCIERRA' | [
"def",
"p_funciones16",
"(",
"p",
")",
":"
] | [
346,
0
] | [
347,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_random_point | () | return x, y | Creates random x, y coordinates. | Creates random x, y coordinates. | def get_random_point():
"""Creates random x, y coordinates."""
x = random.randint(-100, 100)
y = random.randint(-100, 100)
return x, y | [
"def",
"get_random_point",
"(",
")",
":",
"x",
"=",
"random",
".",
"randint",
"(",
"-",
"100",
",",
"100",
")",
"y",
"=",
"random",
".",
"randint",
"(",
"-",
"100",
",",
"100",
")",
"return",
"x",
",",
"y"
] | [
4,
0
] | [
8,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Battery.__init__ | (self, battery_size=60) | Inicializar los atributos del batteery. | Inicializar los atributos del batteery. | def __init__(self, battery_size=60):
"""Inicializar los atributos del batteery."""
self.battery_size = battery_size | [
"def",
"__init__",
"(",
"self",
",",
"battery_size",
"=",
"60",
")",
":",
"self",
".",
"battery_size",
"=",
"battery_size"
] | [
36,
4
] | [
38,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_s | (t) | s : instrucciones | s : instrucciones | def p_s(t):
's : instrucciones'
t[0] = t[1]
print(t[0])
varGramatical.append('s ::= intrucciones')
varSemantico.append('g ') | [
"def",
"p_s",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]",
"print",
"(",
"t",
"[",
"0",
"]",
")",
"varGramatical",
".",
"append",
"(",
"'s ::= intrucciones'",
")",
"varSemantico",
".",
"append",
"(",
"'g '",
")"
] | [
382,
0
] | [
387,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
find_element | (list_db: list, name: str) | return None | Funcion que busca en una lista obtenida de la informacion de una
base de datos de NCBI el nombre de aquel elemento de la lista que
coincida con un nombre dado, y si lo encuentra devuelve su
descripcion | Funcion que busca en una lista obtenida de la informacion de una
base de datos de NCBI el nombre de aquel elemento de la lista que
coincida con un nombre dado, y si lo encuentra devuelve su
descripcion | def find_element(list_db: list, name: str):
"""Funcion que busca en una lista obtenida de la informacion de una
base de datos de NCBI el nombre de aquel elemento de la lista que
coincida con un nombre dado, y si lo encuentra devuelve su
descripcion"""
# Buscar en cada elemento de la lista si su nombre coincide con el
# nombre a buscar
for element in list_db:
if element["Name"] == name:
return element["Description"]
return None | [
"def",
"find_element",
"(",
"list_db",
":",
"list",
",",
"name",
":",
"str",
")",
":",
"# Buscar en cada elemento de la lista si su nombre coincide con el",
"# nombre a buscar",
"for",
"element",
"in",
"list_db",
":",
"if",
"element",
"[",
"\"Name\"",
"]",
"==",
"name",
":",
"return",
"element",
"[",
"\"Description\"",
"]",
"return",
"None"
] | [
60,
0
] | [
71,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Residential.create_config | (self) | Divide la variable val y actualiza la configuración.
Recorre todas las keys del diccionario de configuracion
básico y va actualizando los valores y tras terminar
inserta el diccionario actualizado en una key del
diccionario de configuracion final.
| Divide la variable val y actualiza la configuración. | def create_config(self):
"""Divide la variable val y actualiza la configuración.
Recorre todas las keys del diccionario de configuracion
básico y va actualizando los valores y tras terminar
inserta el diccionario actualizado en una key del
diccionario de configuracion final.
"""
# Puede ser una lista, es para dar nombre a cada configuración.
x = 0
for val in range(0, len(self.labels)):
category, label = self.labels[val].split('|', 2)
var_can, var_esp = self.var_list[val].split('|', 2)
for keys in self.single_dict.keys():
if keys == 'category':
self.single_dict['category'] = category
if keys == 'label':
self.single_dict['label'] = label
if keys == 'rate_vars':
self.single_dict['rate_vars'] = [var_can, var_esp]
if keys == 'json':
self.single_dict['json'] = self.json_vars[x]
self.config_dict[x] = self.single_dict.copy()
x += 1 | [
"def",
"create_config",
"(",
"self",
")",
":",
"# Puede ser una lista, es para dar nombre a cada configuración.",
"x",
"=",
"0",
"for",
"val",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"labels",
")",
")",
":",
"category",
",",
"label",
"=",
"self",
".",
"labels",
"[",
"val",
"]",
".",
"split",
"(",
"'|'",
",",
"2",
")",
"var_can",
",",
"var_esp",
"=",
"self",
".",
"var_list",
"[",
"val",
"]",
".",
"split",
"(",
"'|'",
",",
"2",
")",
"for",
"keys",
"in",
"self",
".",
"single_dict",
".",
"keys",
"(",
")",
":",
"if",
"keys",
"==",
"'category'",
":",
"self",
".",
"single_dict",
"[",
"'category'",
"]",
"=",
"category",
"if",
"keys",
"==",
"'label'",
":",
"self",
".",
"single_dict",
"[",
"'label'",
"]",
"=",
"label",
"if",
"keys",
"==",
"'rate_vars'",
":",
"self",
".",
"single_dict",
"[",
"'rate_vars'",
"]",
"=",
"[",
"var_can",
",",
"var_esp",
"]",
"if",
"keys",
"==",
"'json'",
":",
"self",
".",
"single_dict",
"[",
"'json'",
"]",
"=",
"self",
".",
"json_vars",
"[",
"x",
"]",
"self",
".",
"config_dict",
"[",
"x",
"]",
"=",
"self",
".",
"single_dict",
".",
"copy",
"(",
")",
"x",
"+=",
"1"
] | [
95,
4
] | [
120,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Consulta.save | (self, *args, **kwargs) | crear la factura y analizar luego si se va a recuperar | crear la factura y analizar luego si se va a recuperar | def save(self, *args, **kwargs):
""" crear la factura y analizar luego si se va a recuperar """
super().save(*args, **kwargs)
if not hasattr(self, 'factura'):
# no funciona (?) if self.factura is None:
logger.info(f'Creación Consulta {self}')
else:
f = self.factura
logger.info(f'Factura {f.id} OK para la consulta {self}') | [
"def",
"save",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
")",
".",
"save",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"not",
"hasattr",
"(",
"self",
",",
"'factura'",
")",
":",
"# no funciona (?) if self.factura is None:",
"logger",
".",
"info",
"(",
"f'Creación Consulta {self}')",
"",
"else",
":",
"f",
"=",
"self",
".",
"factura",
"logger",
".",
"info",
"(",
"f'Factura {f.id} OK para la consulta {self}'",
")"
] | [
387,
4
] | [
395,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
_compute_y | (x, ll) | return np.sqrt(1 - ll ** 2 * (1 - x ** 2)) | Computes y.
| Computes y. | def _compute_y(x, ll):
"""Computes y.
"""
return np.sqrt(1 - ll ** 2 * (1 - x ** 2)) | [
"def",
"_compute_y",
"(",
"x",
",",
"ll",
")",
":",
"return",
"np",
".",
"sqrt",
"(",
"1",
"-",
"ll",
"**",
"2",
"*",
"(",
"1",
"-",
"x",
"**",
"2",
")",
")"
] | [
140,
0
] | [
144,
46
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
TraductorFiscal._imprimirPercepcion | (self, ds, importe) | return self.comando.addPerception(ds, float(importe)) | Imprime una linea con nombre de percepcion y monto | Imprime una linea con nombre de percepcion y monto | def _imprimirPercepcion(self, ds, importe):
"Imprime una linea con nombre de percepcion y monto"
self.factura["percepciones"].append(dict(ds=ds, importe=importe))
return self.comando.addPerception(ds, float(importe)) | [
"def",
"_imprimirPercepcion",
"(",
"self",
",",
"ds",
",",
"importe",
")",
":",
"self",
".",
"factura",
"[",
"\"percepciones\"",
"]",
".",
"append",
"(",
"dict",
"(",
"ds",
"=",
"ds",
",",
"importe",
"=",
"importe",
")",
")",
"return",
"self",
".",
"comando",
".",
"addPerception",
"(",
"ds",
",",
"float",
"(",
"importe",
")",
")"
] | [
181,
4
] | [
184,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Override_Bom._take_lines_bom | (self) | Toma las lineas de la lista de materiales. | Toma las lineas de la lista de materiales. | def _take_lines_bom(self):
""" Toma las lineas de la lista de materiales. """
lines_name = ''
for line in self.bom_line_ids:
if line.product_id.product_template_attribute_value_ids.name:
lines_name += line.product_id.product_tmpl_id.name +','+ line.product_id.product_template_attribute_value_ids.name +','+ str(line.product_qty_display) +','+ line.product_uom_id_display.name + '/'
else:
lines_name += line.product_id.product_tmpl_id.name +','+ str(line.product_qty_display) +','+ line.product_uom_id_display.name + '/'
self.mrp_bom_lines_tracking = lines_name | [
"def",
"_take_lines_bom",
"(",
"self",
")",
":",
"lines_name",
"=",
"''",
"for",
"line",
"in",
"self",
".",
"bom_line_ids",
":",
"if",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
":",
"lines_name",
"+=",
"line",
".",
"product_id",
".",
"product_tmpl_id",
".",
"name",
"+",
"','",
"+",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_qty_display",
")",
"+",
"','",
"+",
"line",
".",
"product_uom_id_display",
".",
"name",
"+",
"'/'",
"else",
":",
"lines_name",
"+=",
"line",
".",
"product_id",
".",
"product_tmpl_id",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_qty_display",
")",
"+",
"','",
"+",
"line",
".",
"product_uom_id_display",
".",
"name",
"+",
"'/'",
"self",
".",
"mrp_bom_lines_tracking",
"=",
"lines_name"
] | [
42,
4
] | [
50,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
nuevo_curso | () | Formulario para crear un nuevo usuario. | Formulario para crear un nuevo usuario. | def nuevo_curso():
"""Formulario para crear un nuevo usuario."""
form = CurseForm()
if form.validate_on_submit() or request.method == "POST":
nuevo_curso_ = Curso(
nombre=form.nombre.data,
codigo=form.codigo.data,
descripcion=form.descripcion.data,
estado="draft",
publico=form.publico.data,
auditable=form.auditable.data,
certificado=form.certificado.data,
precio=form.precio.data,
capacidad=form.capacidad.data,
fecha_inicio=form.fecha_inicio.data,
fecha_fin=form.fecha_fin.data,
duracion=form.duracion.data,
creado_por=current_user.usuario,
nivel=form.nivel.data,
)
try:
database.session.add(nuevo_curso_)
database.session.commit()
asignar_curso_a_instructor(curso_codigo=form.codigo.data, usuario_id=current_user.usuario)
flash("Curso creado exitosamente.")
return redirect(url_for("curso", course_code=form.codigo.data))
except OperationalError:
flash("Hubo en error al crear su curso.")
return redirect("/instructor")
else:
return render_template("learning/nuevo_curso.html", form=form) | [
"def",
"nuevo_curso",
"(",
")",
":",
"form",
"=",
"CurseForm",
"(",
")",
"if",
"form",
".",
"validate_on_submit",
"(",
")",
"or",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"nuevo_curso_",
"=",
"Curso",
"(",
"nombre",
"=",
"form",
".",
"nombre",
".",
"data",
",",
"codigo",
"=",
"form",
".",
"codigo",
".",
"data",
",",
"descripcion",
"=",
"form",
".",
"descripcion",
".",
"data",
",",
"estado",
"=",
"\"draft\"",
",",
"publico",
"=",
"form",
".",
"publico",
".",
"data",
",",
"auditable",
"=",
"form",
".",
"auditable",
".",
"data",
",",
"certificado",
"=",
"form",
".",
"certificado",
".",
"data",
",",
"precio",
"=",
"form",
".",
"precio",
".",
"data",
",",
"capacidad",
"=",
"form",
".",
"capacidad",
".",
"data",
",",
"fecha_inicio",
"=",
"form",
".",
"fecha_inicio",
".",
"data",
",",
"fecha_fin",
"=",
"form",
".",
"fecha_fin",
".",
"data",
",",
"duracion",
"=",
"form",
".",
"duracion",
".",
"data",
",",
"creado_por",
"=",
"current_user",
".",
"usuario",
",",
"nivel",
"=",
"form",
".",
"nivel",
".",
"data",
",",
")",
"try",
":",
"database",
".",
"session",
".",
"add",
"(",
"nuevo_curso_",
")",
"database",
".",
"session",
".",
"commit",
"(",
")",
"asignar_curso_a_instructor",
"(",
"curso_codigo",
"=",
"form",
".",
"codigo",
".",
"data",
",",
"usuario_id",
"=",
"current_user",
".",
"usuario",
")",
"flash",
"(",
"\"Curso creado exitosamente.\"",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"\"curso\"",
",",
"course_code",
"=",
"form",
".",
"codigo",
".",
"data",
")",
")",
"except",
"OperationalError",
":",
"flash",
"(",
"\"Hubo en error al crear su curso.\"",
")",
"return",
"redirect",
"(",
"\"/instructor\"",
")",
"else",
":",
"return",
"render_template",
"(",
"\"learning/nuevo_curso.html\"",
",",
"form",
"=",
"form",
")"
] | [
705,
0
] | [
735,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UserCallback.change_token_limit | (token_limit: int, userid: int, *, cursor) | Cambiar el límite de la cantidad de token's permitidos | Cambiar el límite de la cantidad de token's permitidos | async def change_token_limit(token_limit: int, userid: int, *, cursor) -> None:
"""Cambiar el límite de la cantidad de token's permitidos"""
await cursor.execute(
"UPDATE users SET token_limit=%s WHERE id = %s LIMIT 1", (token_limit, userid)
) | [
"async",
"def",
"change_token_limit",
"(",
"token_limit",
":",
"int",
",",
"userid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"None",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"UPDATE users SET token_limit=%s WHERE id = %s LIMIT 1\"",
",",
"(",
"token_limit",
",",
"userid",
")",
")"
] | [
155,
4
] | [
161,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObjects.tracked_objects | (self, tracked_objects: List[TrackedObject]) | Establecee la lista de objetos seguidos.
:param tracked_objects: lista de seguimientos de los objetos.
:return: None.
| Establecee la lista de objetos seguidos. | def tracked_objects(self, tracked_objects: List[TrackedObject]) -> None:
"""Establecee la lista de objetos seguidos.
:param tracked_objects: lista de seguimientos de los objetos.
:return: None.
"""
self._tracked_objects = tracked_objects | [
"def",
"tracked_objects",
"(",
"self",
",",
"tracked_objects",
":",
"List",
"[",
"TrackedObject",
"]",
")",
"->",
"None",
":",
"self",
".",
"_tracked_objects",
"=",
"tracked_objects"
] | [
273,
4
] | [
279,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
clean_file | (input_path, output_path) | Limpia los datos del input creando un nuevo archivo limpio. | Limpia los datos del input creando un nuevo archivo limpio. | def clean_file(input_path, output_path):
"""Limpia los datos del input creando un nuevo archivo limpio."""
print("Comenzando limpieza...")
# crea una instancia de la versión extendible del DataCleaner
dc = MyDataCleaner(input_path)
# aplica reglas de limpieza disponibles y customizadas
custom_cleaning_before_rules(dc)
dc.clean(RULES)
custom_cleaning_after_rules(dc)
# guarda la data limpia en el csv output
dc.save(output_path)
print("Limpieza finalizada exitosamente!") | [
"def",
"clean_file",
"(",
"input_path",
",",
"output_path",
")",
":",
"print",
"(",
"\"Comenzando limpieza...\"",
")",
"# crea una instancia de la versión extendible del DataCleaner",
"dc",
"=",
"MyDataCleaner",
"(",
"input_path",
")",
"# aplica reglas de limpieza disponibles y customizadas",
"custom_cleaning_before_rules",
"(",
"dc",
")",
"dc",
".",
"clean",
"(",
"RULES",
")",
"custom_cleaning_after_rules",
"(",
"dc",
")",
"# guarda la data limpia en el csv output",
"dc",
".",
"save",
"(",
"output_path",
")",
"print",
"(",
"\"Limpieza finalizada exitosamente!\"",
")"
] | [
119,
0
] | [
133,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BaseProfile.get_short_name | (self) | return self.market | Devuleve el nombre de la tienda | Devuleve el nombre de la tienda | def get_short_name(self):
"Devuleve el nombre de la tienda"
return self.market | [
"def",
"get_short_name",
"(",
"self",
")",
":",
"return",
"self",
".",
"market"
] | [
59,
4
] | [
61,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
limites_anual | (dict_: Dict[str, List[int]]) | return {k: (min(v), max(v)) for k, v in dict_.items()} | Determina el menor y el mayor registro de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Tupla con el nombre de la región, el menor registro y el
mayor registro.
:rtype: Tuple[str, int, int]
| Determina el menor y el mayor registro de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Tupla con el nombre de la región, el menor registro y el
mayor registro.
:rtype: Tuple[str, int, int]
| def limites_anual(dict_: Dict[str, List[int]]) -> Tuple[str, int, int]:
"""Determina el menor y el mayor registro de cada región.
:param dict_: Diccionario con los datos de las regiones.
:dict_ type: Dict[str, List[int]]
:return: Tupla con el nombre de la región, el menor registro y el
mayor registro.
:rtype: Tuple[str, int, int]
"""
return {k: (min(v), max(v)) for k, v in dict_.items()} | [
"def",
"limites_anual",
"(",
"dict_",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"int",
"]",
"]",
")",
"->",
"Tuple",
"[",
"str",
",",
"int",
",",
"int",
"]",
":",
"return",
"{",
"k",
":",
"(",
"min",
"(",
"v",
")",
",",
"max",
"(",
"v",
")",
")",
"for",
"k",
",",
"v",
"in",
"dict_",
".",
"items",
"(",
")",
"}"
] | [
51,
0
] | [
60,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
CajeroHandler.handle | (cantidad) | lo que ocurre | lo que ocurre | def handle(cantidad):
"""lo que ocurre""" | [
"def",
"handle",
"(",
"cantidad",
")",
":"
] | [
8,
4
] | [
9,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ServiceCallback.is_service_exists_for_id | (serviceid: int, *, cursor) | return bool(*exists) | Verifica si un servicio existe utilizando su identificador | Verifica si un servicio existe utilizando su identificador | async def is_service_exists_for_id(serviceid: int, *, cursor) -> bool:
"""Verifica si un servicio existe utilizando su identificador"""
await cursor.execute(
"SELECT COUNT(id_service) FROM services WHERE id_service = %s",
(serviceid)
)
exists = await cursor.fetchone()
return bool(*exists) | [
"async",
"def",
"is_service_exists_for_id",
"(",
"serviceid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"bool",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT COUNT(id_service) FROM services WHERE id_service = %s\"",
",",
"(",
"serviceid",
")",
")",
"exists",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"bool",
"(",
"*",
"exists",
")"
] | [
656,
4
] | [
667,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
nombres_repetidos_nivel_dif | (lista1,lista2) | return lista_rep_dif | genera una lista con los nombres repetidos dentro de 2 niveles de enseñanza diferentes | genera una lista con los nombres repetidos dentro de 2 niveles de enseñanza diferentes | def nombres_repetidos_nivel_dif(lista1,lista2):
"""genera una lista con los nombres repetidos dentro de 2 niveles de enseñanza diferentes"""
lista_rep_dif=[]
for i in range (len(lista1)):
for j in range (len(lista2)):
if lista1[i] == lista2[j]:
lista_rep_dif.append(lista1[i])
else:
continue
return lista_rep_dif | [
"def",
"nombres_repetidos_nivel_dif",
"(",
"lista1",
",",
"lista2",
")",
":",
"lista_rep_dif",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"lista1",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"lista2",
")",
")",
":",
"if",
"lista1",
"[",
"i",
"]",
"==",
"lista2",
"[",
"j",
"]",
":",
"lista_rep_dif",
".",
"append",
"(",
"lista1",
"[",
"i",
"]",
")",
"else",
":",
"continue",
"return",
"lista_rep_dif"
] | [
90,
0
] | [
99,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TwoPositionsSpeedAverage.calculate_time | (self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) | return self.convert_time_from_frames(time_frames) | Calcula el tiempo transcurrido entre las dos detecciones del objeto.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: tiempo transcurrido.
| Calcula el tiempo transcurrido entre las dos detecciones del objeto. | def calculate_time(self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) -> float:
"""Calcula el tiempo transcurrido entre las dos detecciones del objeto.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: tiempo transcurrido.
"""
initial_frame = tracked_object[index_initial].frame
final_frame = tracked_object[index_final].frame
time_frames = final_frame - initial_frame
return self.convert_time_from_frames(time_frames) | [
"def",
"calculate_time",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
",",
"index_initial",
":",
"int",
"=",
"0",
",",
"index_final",
":",
"int",
"=",
"-",
"1",
")",
"->",
"float",
":",
"initial_frame",
"=",
"tracked_object",
"[",
"index_initial",
"]",
".",
"frame",
"final_frame",
"=",
"tracked_object",
"[",
"index_final",
"]",
".",
"frame",
"time_frames",
"=",
"final_frame",
"-",
"initial_frame",
"return",
"self",
".",
"convert_time_from_frames",
"(",
"time_frames",
")"
] | [
44,
4
] | [
58,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AbstractGMapsExtractor.__init__ | (self, driver_location=None, output_config=None) | Constructor genérico común para todos los `extractores`. Todas las clases que extiendan esta clase, deben
llamar a este constructor para inicializar campos comunes.
Parameters
----------
driver_location: str
ubicación del selenium chromedriver para instanciar el driver usado para realizar el scraping.
output_config: dict
diccionario de python que contiene la configuración del soporte de salida para esta instancia.
| Constructor genérico común para todos los `extractores`. Todas las clases que extiendan esta clase, deben
llamar a este constructor para inicializar campos comunes. | def __init__(self, driver_location=None, output_config=None):
"""Constructor genérico común para todos los `extractores`. Todas las clases que extiendan esta clase, deben
llamar a este constructor para inicializar campos comunes.
Parameters
----------
driver_location: str
ubicación del selenium chromedriver para instanciar el driver usado para realizar el scraping.
output_config: dict
diccionario de python que contiene la configuración del soporte de salida para esta instancia.
"""
super(AbstractGMapsExtractor, self).__init__()
self.logger = logging.getLogger(self.__class__.__name__)
self._default_driver_args = ["--disable-extensions", "--disable-gpu", "start-maximized",
"disable-infobars", "--headless", "--no-sandbox", "--disable-dev-shm-usage"]
self._default_experimental_driver_args = {}
self.shared_result_elements_xpath_query = "//div[contains(@class, 'section-result-content')]"
self._driver_location = driver_location
self._driver_options = None
self._driver_implicit_wait = 1
self._driver = None
self.sleep_xs = 2
self.sleep_m = 5
self.sleep_l = 10
self.sleep_xl = 20
self._driver_wait = self.sleep_l
self._output_config = output_config
self._writer = None
self._postal_code = None
self._driver_build_intent = 0
self._max_driver_build_intent = 5 | [
"def",
"__init__",
"(",
"self",
",",
"driver_location",
"=",
"None",
",",
"output_config",
"=",
"None",
")",
":",
"super",
"(",
"AbstractGMapsExtractor",
",",
"self",
")",
".",
"__init__",
"(",
")",
"self",
".",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"self",
".",
"__class__",
".",
"__name__",
")",
"self",
".",
"_default_driver_args",
"=",
"[",
"\"--disable-extensions\"",
",",
"\"--disable-gpu\"",
",",
"\"start-maximized\"",
",",
"\"disable-infobars\"",
",",
"\"--headless\"",
",",
"\"--no-sandbox\"",
",",
"\"--disable-dev-shm-usage\"",
"]",
"self",
".",
"_default_experimental_driver_args",
"=",
"{",
"}",
"self",
".",
"shared_result_elements_xpath_query",
"=",
"\"//div[contains(@class, 'section-result-content')]\"",
"self",
".",
"_driver_location",
"=",
"driver_location",
"self",
".",
"_driver_options",
"=",
"None",
"self",
".",
"_driver_implicit_wait",
"=",
"1",
"self",
".",
"_driver",
"=",
"None",
"self",
".",
"sleep_xs",
"=",
"2",
"self",
".",
"sleep_m",
"=",
"5",
"self",
".",
"sleep_l",
"=",
"10",
"self",
".",
"sleep_xl",
"=",
"20",
"self",
".",
"_driver_wait",
"=",
"self",
".",
"sleep_l",
"self",
".",
"_output_config",
"=",
"output_config",
"self",
".",
"_writer",
"=",
"None",
"self",
".",
"_postal_code",
"=",
"None",
"self",
".",
"_driver_build_intent",
"=",
"0",
"self",
".",
"_max_driver_build_intent",
"=",
"5"
] | [
76,
4
] | [
106,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
MyDataCleaner.nueva_regla | (self, field, sufix=None, keep_original=False,
inplace=False) | return clean_series | One liner sobre lo que hace la regla.
Descripción extendida (si correponde) sobre lo que hace la regla.
Args:
field (str): Campo a limpiar.
sufix (str): Sufijo del nuevo campo creado después de limpiar.
keep_original (bool): True si se mantiene el campo original y el
nuevo se agrega con un sufijo. False para reemplazar el campo
original.
inplace (bool): True si los cambios deben impactar en el estado del
objeto. False si sólo se quiere retornar una serie limpia sin
impactar en el estado del objeto.
Returns:
pandas.Series: Serie de strings limpios
| One liner sobre lo que hace la regla. | def nueva_regla(self, field, sufix=None, keep_original=False,
inplace=False):
"""One liner sobre lo que hace la regla.
Descripción extendida (si correponde) sobre lo que hace la regla.
Args:
field (str): Campo a limpiar.
sufix (str): Sufijo del nuevo campo creado después de limpiar.
keep_original (bool): True si se mantiene el campo original y el
nuevo se agrega con un sufijo. False para reemplazar el campo
original.
inplace (bool): True si los cambios deben impactar en el estado del
objeto. False si sólo se quiere retornar una serie limpia sin
impactar en el estado del objeto.
Returns:
pandas.Series: Serie de strings limpios
"""
# si no se provee un sufijo, se utiliza el default
sufix = sufix or self.DEFAULT_SUFIX
# debe normalizarse el nombre del campo primero
field = self._normalize_field(field)
# toma la serie a limpiar del DataFrame
series = self.df[field]
# ________________________________________________________
# en este espacio se aplica el nuevo algoritmo de limpieza
# y se guarda la serie limpia en una nueva variable
clean_series = series
# ________________________________________________________
# guarda los cambios en el objeto, si inplace=True
if inplace:
self._update_series(field=field, sufix=sufix,
keep_original=keep_original,
new_series=clean_series)
return clean_series | [
"def",
"nueva_regla",
"(",
"self",
",",
"field",
",",
"sufix",
"=",
"None",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"# si no se provee un sufijo, se utiliza el default",
"sufix",
"=",
"sufix",
"or",
"self",
".",
"DEFAULT_SUFIX",
"# debe normalizarse el nombre del campo primero",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"# toma la serie a limpiar del DataFrame",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
"# ________________________________________________________",
"# en este espacio se aplica el nuevo algoritmo de limpieza",
"# y se guarda la serie limpia en una nueva variable",
"clean_series",
"=",
"series",
"# ________________________________________________________",
"# guarda los cambios en el objeto, si inplace=True",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"sufix",
"=",
"sufix",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"clean_series",
")",
"return",
"clean_series"
] | [
75,
4
] | [
116,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_funcion_gcd | (t) | lista_funciones : GCD PARIZQ ENTERO COMA ENTERO PARDER | lista_funciones : GCD PARIZQ ENTERO COMA ENTERO PARDER | def p_instrucciones_funcion_gcd(t) :
'lista_funciones : GCD PARIZQ ENTERO COMA ENTERO PARDER' | [
"def",
"p_instrucciones_funcion_gcd",
"(",
"t",
")",
":"
] | [
909,
0
] | [
910,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BioPortalApi.annotator | (self, text: str, ontologies: list = []) | return self.__get_json('/annotator?include=prefLabel&text=' + urllib.parse.quote(text)+query_ontologies) | examina el texto pasado y retorna las classes relevantes asociadas al termino see http://data.bioontology.org/documentation#nav_annotator | examina el texto pasado y retorna las classes relevantes asociadas al termino see http://data.bioontology.org/documentation#nav_annotator | def annotator(self, text: str, ontologies: list = []):
"""examina el texto pasado y retorna las classes relevantes asociadas al termino see http://data.bioontology.org/documentation#nav_annotator"""
query_ontologies = '&ontologies=' + \
','.join(map(urllib.parse.quote, ontologies)
) if len(ontologies) > 0 else ''
return self.__get_json('/annotator?include=prefLabel&text=' + urllib.parse.quote(text)+query_ontologies) | [
"def",
"annotator",
"(",
"self",
",",
"text",
":",
"str",
",",
"ontologies",
":",
"list",
"=",
"[",
"]",
")",
":",
"query_ontologies",
"=",
"'&ontologies='",
"+",
"','",
".",
"join",
"(",
"map",
"(",
"urllib",
".",
"parse",
".",
"quote",
",",
"ontologies",
")",
")",
"if",
"len",
"(",
"ontologies",
")",
">",
"0",
"else",
"''",
"return",
"self",
".",
"__get_json",
"(",
"'/annotator?include=prefLabel&text='",
"+",
"urllib",
".",
"parse",
".",
"quote",
"(",
"text",
")",
"+",
"query_ontologies",
")"
] | [
13,
4
] | [
18,
112
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sort_data | (data_list: list) | return sort_list_data | Función para organizar los archivos XML en orden ascendente con base,
en el tamaño del archivo.
Args:
data_list (list): Recibe la lista con los nombres de los archivos XML.
Returns:
list: Retorna una lista con los archivos XML organizados de forma ascendente.
| Función para organizar los archivos XML en orden ascendente con base,
en el tamaño del archivo. | def sort_data(data_list: list) -> list:
""" Función para organizar los archivos XML en orden ascendente con base,
en el tamaño del archivo.
Args:
data_list (list): Recibe la lista con los nombres de los archivos XML.
Returns:
list: Retorna una lista con los archivos XML organizados de forma ascendente.
"""
dictionary_files: dict = {}
list_of_file_sizes: list = []
for value in data_list:
file_size: int = os.stat(value).st_size
dictionary_files.update({file_size: value})
list_of_file_sizes.append(file_size)
# Organiza los archivos de menor a mayor
list_of_file_sizes.sort()
sort_list_data: list = [dictionary_files[size] for size in list_of_file_sizes]
return sort_list_data | [
"def",
"sort_data",
"(",
"data_list",
":",
"list",
")",
"->",
"list",
":",
"dictionary_files",
":",
"dict",
"=",
"{",
"}",
"list_of_file_sizes",
":",
"list",
"=",
"[",
"]",
"for",
"value",
"in",
"data_list",
":",
"file_size",
":",
"int",
"=",
"os",
".",
"stat",
"(",
"value",
")",
".",
"st_size",
"dictionary_files",
".",
"update",
"(",
"{",
"file_size",
":",
"value",
"}",
")",
"list_of_file_sizes",
".",
"append",
"(",
"file_size",
")",
"# Organiza los archivos de menor a mayor",
"list_of_file_sizes",
".",
"sort",
"(",
")",
"sort_list_data",
":",
"list",
"=",
"[",
"dictionary_files",
"[",
"size",
"]",
"for",
"size",
"in",
"list_of_file_sizes",
"]",
"return",
"sort_list_data"
] | [
94,
0
] | [
113,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Blockchain_Window.__init__ | (self, win, database, table, show) | FRAME PARA MOSTRAR ESTRUCTURA HASH QUE ALMACENA LOS REGISTROS | FRAME PARA MOSTRAR ESTRUCTURA HASH QUE ALMACENA LOS REGISTROS | def __init__(self, win, database, table, show):
temp=""
if win=="":
temp=Toplevel()
else:
temp=win
Label(self.new_frame(temp, 0, 0, 30, 10), text="Database: ", font=("Arial Black", 8)).pack()
Label(self.new_frame(temp, 0, 0, 100, 10), text=str(database), font=("Arial", 9)).pack()
Label(self.new_frame(temp, 0, 0, 300, 10), text="Table: ", font=("Arial Black", 8)).pack()
Label(self.new_frame(temp, 0, 0, 360, 10), text=str(table), font=("Arial", 9)).pack()
Label(self.new_frame(temp, 0, 0, 70, 50), text="SafeModoOn", font=("Arial Black", 8)).pack()
Button(self.new_frame(temp, 0, 0, 20, 40), text=" 🔒 ", font=("", 14), foreground="green", command=self.command_SafeModeOn(database, table)).pack()
Label(self.new_frame(temp, 0, 0, 235,50), text="SafeModoOff", font=("Arial Black", 8)).pack()
Button(self.new_frame(temp, 0, 0, 180, 40), text=" 🔐 ", font=("", 14), foreground="red", command=self.command_SafeModeOff(database, table)).pack()
Label(self.new_frame(temp, 0, 0, 430, 50), text="Show Blockchain", font=("Arial Black", 8)).pack()
Button(self.new_frame(temp, 0, 0, 375, 40), text=" ☄ ", font=("", 14), foreground="blue", command=self.show_blockchain(database,table, temp)).pack()
''' FRAME PARA MOSTRAR ESTRUCTURA HASH QUE ALMACENA LOS REGISTROS '''
Frame1 = LabelFrame(temp)
can = Canvas(Frame1, width=600, height=220)
Scrollbar_x = Scrollbar(Frame1, orient="vertical", command=can.yview)
Scrollbar_y = Scrollbar(Frame1, orient="horizontal", command=can.xview)
Scrollbar_y.pack(side="bottom", fill="x")
Scrollbar_x.pack(side="right", fill="y")
can.pack(expand=True, fill="both")
can.configure(yscrollcommand=Scrollbar_x.set, xscrollcommand=Scrollbar_y.set)
frame = Frame(can)
can.create_window((False, False), window=frame, anchor="nw")
can.bind("<Configure>", lambda e: can.configure(scrollregion=can.bbox("all")))
Frame1.place(x=30, y=100)
''' AGREGARA LA IMAGEN DE LAS TABLAS'''
photo = PhotoImage(file=show)
Label(frame, image=photo).pack()
temp.geometry('{}x{}'.format(700, 400))
temp.title("BLOCKCHAIN")
temp.resizable(0, 0)
temp.mainloop() | [
"def",
"__init__",
"(",
"self",
",",
"win",
",",
"database",
",",
"table",
",",
"show",
")",
":",
"temp",
"=",
"\"\"",
"if",
"win",
"==",
"\"\"",
":",
"temp",
"=",
"Toplevel",
"(",
")",
"else",
":",
"temp",
"=",
"win",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"30",
",",
"10",
")",
",",
"text",
"=",
"\"Database: \"",
",",
"font",
"=",
"(",
"\"Arial Black\"",
",",
"8",
")",
")",
".",
"pack",
"(",
")",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"100",
",",
"10",
")",
",",
"text",
"=",
"str",
"(",
"database",
")",
",",
"font",
"=",
"(",
"\"Arial\"",
",",
"9",
")",
")",
".",
"pack",
"(",
")",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"300",
",",
"10",
")",
",",
"text",
"=",
"\"Table: \"",
",",
"font",
"=",
"(",
"\"Arial Black\"",
",",
"8",
")",
")",
".",
"pack",
"(",
")",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"360",
",",
"10",
")",
",",
"text",
"=",
"str",
"(",
"table",
")",
",",
"font",
"=",
"(",
"\"Arial\"",
",",
"9",
")",
")",
".",
"pack",
"(",
")",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"70",
",",
"50",
")",
",",
"text",
"=",
"\"SafeModoOn\"",
",",
"font",
"=",
"(",
"\"Arial Black\"",
",",
"8",
")",
")",
".",
"pack",
"(",
")",
"Button",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"20",
",",
"40",
")",
",",
"text",
"=",
"\" 🔒 \", f",
"o",
"t=(\"",
"\"",
",",
" 1",
"4",
", ",
"f",
"o",
"eground=\"g",
"r",
"een\", c",
"o",
"mand=se",
"l",
"f.co",
"m",
"mand_SafeModeOn(da",
"t",
"abase, t",
"a",
"le)).",
"p",
"a",
"c",
"k()",
"",
"",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"235",
",",
"50",
")",
",",
"text",
"=",
"\"SafeModoOff\"",
",",
"font",
"=",
"(",
"\"Arial Black\"",
",",
"8",
")",
")",
".",
"pack",
"(",
")",
"Button",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"180",
",",
"40",
")",
",",
"text",
"=",
"\" 🔐 \", f",
"o",
"t=(\"",
"\"",
",",
" 1",
"4",
", ",
"f",
"o",
"eground=\"r",
"e",
"d\", c",
"o",
"mand=se",
"l",
"f.co",
"m",
"mand_SafeModeOff(da",
"t",
"abase, t",
"a",
"le)).",
"p",
"a",
"c",
"k()",
"",
"",
"Label",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"430",
",",
"50",
")",
",",
"text",
"=",
"\"Show Blockchain\"",
",",
"font",
"=",
"(",
"\"Arial Black\"",
",",
"8",
")",
")",
".",
"pack",
"(",
")",
"Button",
"(",
"self",
".",
"new_frame",
"(",
"temp",
",",
"0",
",",
"0",
",",
"375",
",",
"40",
")",
",",
"text",
"=",
"\" ☄ \", ",
"f",
"nt=(",
"\"",
"\"",
", ",
"1",
"),",
" ",
"f",
"reground=\"",
"b",
"lue\", ",
"c",
"mmand=s",
"e",
"lf.s",
"h",
"ow_blockchain(d",
"a",
"tabase,t",
"a",
"ble, ",
"t",
"mp))",
".",
"p",
"a",
"ck()",
"",
"",
"Frame1",
"=",
"LabelFrame",
"(",
"temp",
")",
"can",
"=",
"Canvas",
"(",
"Frame1",
",",
"width",
"=",
"600",
",",
"height",
"=",
"220",
")",
"Scrollbar_x",
"=",
"Scrollbar",
"(",
"Frame1",
",",
"orient",
"=",
"\"vertical\"",
",",
"command",
"=",
"can",
".",
"yview",
")",
"Scrollbar_y",
"=",
"Scrollbar",
"(",
"Frame1",
",",
"orient",
"=",
"\"horizontal\"",
",",
"command",
"=",
"can",
".",
"xview",
")",
"Scrollbar_y",
".",
"pack",
"(",
"side",
"=",
"\"bottom\"",
",",
"fill",
"=",
"\"x\"",
")",
"Scrollbar_x",
".",
"pack",
"(",
"side",
"=",
"\"right\"",
",",
"fill",
"=",
"\"y\"",
")",
"can",
".",
"pack",
"(",
"expand",
"=",
"True",
",",
"fill",
"=",
"\"both\"",
")",
"can",
".",
"configure",
"(",
"yscrollcommand",
"=",
"Scrollbar_x",
".",
"set",
",",
"xscrollcommand",
"=",
"Scrollbar_y",
".",
"set",
")",
"frame",
"=",
"Frame",
"(",
"can",
")",
"can",
".",
"create_window",
"(",
"(",
"False",
",",
"False",
")",
",",
"window",
"=",
"frame",
",",
"anchor",
"=",
"\"nw\"",
")",
"can",
".",
"bind",
"(",
"\"<Configure>\"",
",",
"lambda",
"e",
":",
"can",
".",
"configure",
"(",
"scrollregion",
"=",
"can",
".",
"bbox",
"(",
"\"all\"",
")",
")",
")",
"Frame1",
".",
"place",
"(",
"x",
"=",
"30",
",",
"y",
"=",
"100",
")",
"''' AGREGARA LA IMAGEN DE LAS TABLAS'''",
"photo",
"=",
"PhotoImage",
"(",
"file",
"=",
"show",
")",
"Label",
"(",
"frame",
",",
"image",
"=",
"photo",
")",
".",
"pack",
"(",
")",
"temp",
".",
"geometry",
"(",
"'{}x{}'",
".",
"format",
"(",
"700",
",",
"400",
")",
")",
"temp",
".",
"title",
"(",
"\"BLOCKCHAIN\"",
")",
"temp",
".",
"resizable",
"(",
"0",
",",
"0",
")",
"temp",
".",
"mainloop",
"(",
")"
] | [
1530,
4
] | [
1571,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ServiceCallback.get_services | (
limit: int = 0, *,
only: Optional[int] = None,
basic: bool = True,
cursor
) | Obtiene los servicios
Obtiene los servicios remotos registrados de otras redes de confianza
Args:
limit:
El límite de registros a obtener
only:
Cuando ``basic`` es **False** ``only`` es usado para obtener todos
los servicios de un nodo específico.
basic:
Si ``basic`` es **True** se obtiene sólo el servicio y el tiempo de
modificación.
Returns:
Un iterador asincrónico con los servicios obtenidos
| Obtiene los servicios
Obtiene los servicios remotos registrados de otras redes de confianza | async def get_services(
limit: int = 0, *,
only: Optional[int] = None,
basic: bool = True,
cursor
) -> AsyncIterator[Union[Tuple[str, int], Tuple[int, int, str, int]]]:
"""Obtiene los servicios
Obtiene los servicios remotos registrados de otras redes de confianza
Args:
limit:
El límite de registros a obtener
only:
Cuando ``basic`` es **False** ``only`` es usado para obtener todos
los servicios de un nodo específico.
basic:
Si ``basic`` es **True** se obtiene sólo el servicio y el tiempo de
modificación.
Returns:
Un iterador asincrónico con los servicios obtenidos
"""
if (basic):
await cursor.execute(
"SELECT service FROM services"
)
else:
sql = ["SELECT id_service, id_network, service, priority FROM services"]
args = []
if (only is not None):
networkid = int(only)
sql.append("WHERE id_network = %s")
args.append(networkid)
if (limit > 0):
sql.append("LIMIT %s")
args.append(int(limit))
await cursor.execute(
" ".join(sql), args
)
while (result := await cursor.fetchone()):
yield result | [
"async",
"def",
"get_services",
"(",
"limit",
":",
"int",
"=",
"0",
",",
"*",
",",
"only",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
",",
"basic",
":",
"bool",
"=",
"True",
",",
"cursor",
")",
"->",
"AsyncIterator",
"[",
"Union",
"[",
"Tuple",
"[",
"str",
",",
"int",
"]",
",",
"Tuple",
"[",
"int",
",",
"int",
",",
"str",
",",
"int",
"]",
"]",
"]",
":",
"if",
"(",
"basic",
")",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT service FROM services\"",
")",
"else",
":",
"sql",
"=",
"[",
"\"SELECT id_service, id_network, service, priority FROM services\"",
"]",
"args",
"=",
"[",
"]",
"if",
"(",
"only",
"is",
"not",
"None",
")",
":",
"networkid",
"=",
"int",
"(",
"only",
")",
"sql",
".",
"append",
"(",
"\"WHERE id_network = %s\"",
")",
"args",
".",
"append",
"(",
"networkid",
")",
"if",
"(",
"limit",
">",
"0",
")",
":",
"sql",
".",
"append",
"(",
"\"LIMIT %s\"",
")",
"args",
".",
"append",
"(",
"int",
"(",
"limit",
")",
")",
"await",
"cursor",
".",
"execute",
"(",
"\" \"",
".",
"join",
"(",
"sql",
")",
",",
"args",
")",
"while",
"(",
"result",
":=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
")",
":",
"yield",
"result"
] | [
748,
4
] | [
802,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
links | (request) | return render(request, "links.html") | **Muestra la página de enlaces de interés**
Vista encargada de mostrar la sección de ligas de interés con la página de
Elotl, el blog de Elotl y el diccionario del otomi
:param request: Objeto ``HttpRequets`` para pasar el estado de
la app a través del sistema
:type: ``HttpRequest``
:return: Vista de enlaces de interés
| **Muestra la página de enlaces de interés** | def links(request):
"""**Muestra la página de enlaces de interés**
Vista encargada de mostrar la sección de ligas de interés con la página de
Elotl, el blog de Elotl y el diccionario del otomi
:param request: Objeto ``HttpRequets`` para pasar el estado de
la app a través del sistema
:type: ``HttpRequest``
:return: Vista de enlaces de interés
"""
LOGGER.info("Entrando a links")
return render(request, "links.html") | [
"def",
"links",
"(",
"request",
")",
":",
"LOGGER",
".",
"info",
"(",
"\"Entrando a links\"",
")",
"return",
"render",
"(",
"request",
",",
"\"links.html\"",
")"
] | [
58,
0
] | [
71,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects.unregister_missing_objects | (self, frame, max_frames_missing: int) | Elimina los objetos que han desaparecido durante una cantidad de frames mayor que la
indicada por parámetro.
:param frame: identificador del frame actual.
:param max_frames_missing: cantidad de frames para borrar los objetos.
:return: lista de tuplas (uid, objeto) desaparecidos eliminados.
| Elimina los objetos que han desaparecido durante una cantidad de frames mayor que la
indicada por parámetro. | def unregister_missing_objects(self, frame, max_frames_missing: int) -> None:
"""Elimina los objetos que han desaparecido durante una cantidad de frames mayor que la
indicada por parámetro.
:param frame: identificador del frame actual.
:param max_frames_missing: cantidad de frames para borrar los objetos.
:return: lista de tuplas (uid, objeto) desaparecidos eliminados.
"""
# Analizar la situación de cada objeto.
for tracked_object in self._tracked_objects:
# Comprobar que haya más de un seguimiento, o puede resultar en un error inesperado.
if len(tracked_object) > 0:
frames_elapsed = frame - tracked_object[-1].frame
# Si ha desaparecido una cantidad de frames mayor que la indicada, cambiar el estado
# de registro a False. Esto indicará que el objeto está desregistrado.
if frames_elapsed > max_frames_missing:
tracked_object.status = False | [
"def",
"unregister_missing_objects",
"(",
"self",
",",
"frame",
",",
"max_frames_missing",
":",
"int",
")",
"->",
"None",
":",
"# Analizar la situación de cada objeto.",
"for",
"tracked_object",
"in",
"self",
".",
"_tracked_objects",
":",
"# Comprobar que haya más de un seguimiento, o puede resultar en un error inesperado.",
"if",
"len",
"(",
"tracked_object",
")",
">",
"0",
":",
"frames_elapsed",
"=",
"frame",
"-",
"tracked_object",
"[",
"-",
"1",
"]",
".",
"frame",
"# Si ha desaparecido una cantidad de frames mayor que la indicada, cambiar el estado",
"# de registro a False. Esto indicará que el objeto está desregistrado.",
"if",
"frames_elapsed",
">",
"max_frames_missing",
":",
"tracked_object",
".",
"status",
"=",
"False"
] | [
233,
4
] | [
249,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
es_bisiesto | (year: int) | return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) | Calcula si el año es bisiesto.
:param year: Año a calcular.
:year type: int
:return: True si es bisiesto, False en caso contrario.
:rtype: bool
| Calcula si el año es bisiesto. | def es_bisiesto(year: int) -> bool:
"""Calcula si el año es bisiesto.
:param year: Año a calcular.
:year type: int
:return: True si es bisiesto, False en caso contrario.
:rtype: bool
"""
return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0) | [
"def",
"es_bisiesto",
"(",
"year",
":",
"int",
")",
"->",
"bool",
":",
"return",
"year",
"%",
"4",
"==",
"0",
"and",
"(",
"year",
"%",
"100",
"!=",
"0",
"or",
"year",
"%",
"400",
"==",
"0",
")"
] | [
8,
0
] | [
16,
65
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
CubeShell.do_mover_especifico | (self, args) | Realiza el movimiento que le indiques al cubo actual | Realiza el movimiento que le indiques al cubo actual | def do_mover_especifico(self, args):
'''Realiza el movimiento que le indiques al cubo actual'''
mov = str(input('Tipo de movimiento: '))
fila = None
cubo_actual = Objeto_Cubo(utils.jsonRead(ruta_json))
try:
if not isinstance(mov, str):
raise ArithmeticError
fila = int(input('Fila/columna en la que hacerlo: '))
if not isinstance(fila, int):
raise ArithmeticError
except ArithmeticError:
print('Datatype missmatch')
utils.moverCubo(cubo_actual, mov, fila) | [
"def",
"do_mover_especifico",
"(",
"self",
",",
"args",
")",
":",
"mov",
"=",
"str",
"(",
"input",
"(",
"'Tipo de movimiento: '",
")",
")",
"fila",
"=",
"None",
"cubo_actual",
"=",
"Objeto_Cubo",
"(",
"utils",
".",
"jsonRead",
"(",
"ruta_json",
")",
")",
"try",
":",
"if",
"not",
"isinstance",
"(",
"mov",
",",
"str",
")",
":",
"raise",
"ArithmeticError",
"fila",
"=",
"int",
"(",
"input",
"(",
"'Fila/columna en la que hacerlo: '",
")",
")",
"if",
"not",
"isinstance",
"(",
"fila",
",",
"int",
")",
":",
"raise",
"ArithmeticError",
"except",
"ArithmeticError",
":",
"print",
"(",
"'Datatype missmatch'",
")",
"utils",
".",
"moverCubo",
"(",
"cubo_actual",
",",
"mov",
",",
"fila",
")"
] | [
42,
4
] | [
56,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PlaceDbWriter.auto_boot | (self) | Función encargada de abrir la conexión a la base de datos. | Función encargada de abrir la conexión a la base de datos. | def auto_boot(self):
"""Función encargada de abrir 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",
")"
] | [
136,
4
] | [
143,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_expresion_aritmetica_3 | (t) | expresionaritmetica : cualquiernumero
| cualquieridentificador | expresionaritmetica : cualquiernumero
| cualquieridentificador | def p_expresion_aritmetica_3(t) :
'''expresionaritmetica : cualquiernumero
| cualquieridentificador'''
t[1].gramatica = '<expresionaritmetica> ::= <cualquiernumero>\n' + t[1].gramatica
t[0] = t[1] | [
"def",
"p_expresion_aritmetica_3",
"(",
"t",
")",
":",
"t",
"[",
"1",
"]",
".",
"gramatica",
"=",
"'<expresionaritmetica> ::= <cualquiernumero>\\n'",
"+",
"t",
"[",
"1",
"]",
".",
"gramatica",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
1165,
0
] | [
1169,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_opcion_select_tm2 | (t) | opcion_select_tm : opcion_select_lista FROM opciones_sobrenombres opcion_from | opcion_select_tm : opcion_select_lista FROM opciones_sobrenombres opcion_from | def p_opcion_select_tm2(t):
'opcion_select_tm : opcion_select_lista FROM opciones_sobrenombres opcion_from '
reporte_bnf.append("<opcion_select_tm> ::= <opcion_select_lista> FROM <opciones_sobrenombres> <opcion_from>")
t[0] = Create_select_general(OPCIONES_SELECT.SELECT,t[1],t[4],None,None,t[3]) | [
"def",
"p_opcion_select_tm2",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<opcion_select_tm> ::= <opcion_select_lista> FROM <opciones_sobrenombres> <opcion_from>\"",
")",
"t",
"[",
"0",
"]",
"=",
"Create_select_general",
"(",
"OPCIONES_SELECT",
".",
"SELECT",
",",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"4",
"]",
",",
"None",
",",
"None",
",",
"t",
"[",
"3",
"]",
")"
] | [
1769,
0
] | [
1772,
81
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
suma | (numeros: List[int]) | return sum(numeros) | Suma los elemntos de una lista
:param numeros: Lista de números
:numeros type: List[int]
:return: Suma de los elemntos de la lista
:rtype: int
| Suma los elemntos de una lista | def suma(numeros: List[int]) -> int:
"""Suma los elemntos de una lista
:param numeros: Lista de números
:numeros type: List[int]
:return: Suma de los elemntos de la lista
:rtype: int
"""
return sum(numeros) | [
"def",
"suma",
"(",
"numeros",
":",
"List",
"[",
"int",
"]",
")",
"->",
"int",
":",
"return",
"sum",
"(",
"numeros",
")"
] | [
45,
0
] | [
53,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
handle_error | (driver) | Busca el boton de ´´Cerrar´´ y lo presiona
:param driver: driver a usar
:type driver: webdriver.WebDriver
| Busca el boton de ´´Cerrar´´ y lo presiona
:param driver: driver a usar
:type driver: webdriver.WebDriver
| def handle_error(driver):
"""Busca el boton de ´´Cerrar´´ y lo presiona
:param driver: driver a usar
:type driver: webdriver.WebDriver
"""
logger.debug("Presionando boton cerrar")
xpath = "//div[@id='modalError']//*/td/input[@value='Cerrar' and @type='button']"
element_error_button = driver.find_element_by_xpath(xpath)
element_error_button.click()
logger.debug("Presionando boton cerrar: ok") | [
"def",
"handle_error",
"(",
"driver",
")",
":",
"logger",
".",
"debug",
"(",
"\"Presionando boton cerrar\"",
")",
"xpath",
"=",
"\"//div[@id='modalError']//*/td/input[@value='Cerrar' and @type='button']\"",
"element_error_button",
"=",
"driver",
".",
"find_element_by_xpath",
"(",
"xpath",
")",
"element_error_button",
".",
"click",
"(",
")",
"logger",
".",
"debug",
"(",
"\"Presionando boton cerrar: ok\"",
")"
] | [
119,
0
] | [
130,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_update_condsopsE | (t) | condicionesops : | condicionesops : | def p_instrucciones_update_condsopsE(t):
'condicionesops : '
grafo.newnode('CONDSOPS')
t[0] = {'ast' : None, 'graph' : grafo.index} | [
"def",
"p_instrucciones_update_condsopsE",
"(",
"t",
")",
":",
"grafo",
".",
"newnode",
"(",
"'CONDSOPS'",
")",
"t",
"[",
"0",
"]",
"=",
"{",
"'ast'",
":",
"None",
",",
"'graph'",
":",
"grafo",
".",
"index",
"}"
] | [
1742,
0
] | [
1745,
48
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
|
p_declaraciones1 | (t) | declaraciones : empty | declaraciones : empty | def p_declaraciones1(t):
'declaraciones : empty'
t[0] = None | [
"def",
"p_declaraciones1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"None"
] | [
588,
0
] | [
590,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BomRegister.add_product | (data, bom, total) | Añade los datos relevantes de un producto al diccionario 'data'.
Parametros:
data: dict -- Diccionario de datos
bom: mrp.bom -- Lista de materiales de la que proviene el producto
total:int -- Cantidad total de veces que se repetira la lista
| Añade los datos relevantes de un producto al diccionario 'data'. | def add_product(data, bom, total):
"""Añade los datos relevantes de un producto al diccionario 'data'.
Parametros:
data: dict -- Diccionario de datos
bom: mrp.bom -- Lista de materiales de la que proviene el producto
total:int -- Cantidad total de veces que se repetira la lista
"""
warehouse = bom.bom_id.picking_type_id[0].warehouse_id[0]
warehouse_availible = warehouse.lot_stock_id[0].quant_ids
warehouse_availible = list(filter(lambda q: q.product_id == bom.product_id, warehouse_availible))
availible_qty = sum(q.quantity for q in warehouse_availible)
reserved = sum(q.reserved_quantity for q in warehouse_availible)
if bom.product_id.id in data:
data[bom.product_id.id]['qty'] += bom.product_qty * total
data[bom.product_id.id]['availible_qty'] = availible_qty
data[bom.product_id.id]['reserved'] = reserved
data[bom.product_id.id]['warehouse'] = warehouse.name
else:
data[bom.product_id.id] = {
'product': bom.product_id,
'availible_qty': availible_qty,
'reserved': reserved,
'warehouse': warehouse.name,
'qty': bom.product_qty * total,
'uom': bom.product_uom_id
} | [
"def",
"add_product",
"(",
"data",
",",
"bom",
",",
"total",
")",
":",
"warehouse",
"=",
"bom",
".",
"bom_id",
".",
"picking_type_id",
"[",
"0",
"]",
".",
"warehouse_id",
"[",
"0",
"]",
"warehouse_availible",
"=",
"warehouse",
".",
"lot_stock_id",
"[",
"0",
"]",
".",
"quant_ids",
"warehouse_availible",
"=",
"list",
"(",
"filter",
"(",
"lambda",
"q",
":",
"q",
".",
"product_id",
"==",
"bom",
".",
"product_id",
",",
"warehouse_availible",
")",
")",
"availible_qty",
"=",
"sum",
"(",
"q",
".",
"quantity",
"for",
"q",
"in",
"warehouse_availible",
")",
"reserved",
"=",
"sum",
"(",
"q",
".",
"reserved_quantity",
"for",
"q",
"in",
"warehouse_availible",
")",
"if",
"bom",
".",
"product_id",
".",
"id",
"in",
"data",
":",
"data",
"[",
"bom",
".",
"product_id",
".",
"id",
"]",
"[",
"'qty'",
"]",
"+=",
"bom",
".",
"product_qty",
"*",
"total",
"data",
"[",
"bom",
".",
"product_id",
".",
"id",
"]",
"[",
"'availible_qty'",
"]",
"=",
"availible_qty",
"data",
"[",
"bom",
".",
"product_id",
".",
"id",
"]",
"[",
"'reserved'",
"]",
"=",
"reserved",
"data",
"[",
"bom",
".",
"product_id",
".",
"id",
"]",
"[",
"'warehouse'",
"]",
"=",
"warehouse",
".",
"name",
"else",
":",
"data",
"[",
"bom",
".",
"product_id",
".",
"id",
"]",
"=",
"{",
"'product'",
":",
"bom",
".",
"product_id",
",",
"'availible_qty'",
":",
"availible_qty",
",",
"'reserved'",
":",
"reserved",
",",
"'warehouse'",
":",
"warehouse",
".",
"name",
",",
"'qty'",
":",
"bom",
".",
"product_qty",
"*",
"total",
",",
"'uom'",
":",
"bom",
".",
"product_uom_id",
"}"
] | [
31,
4
] | [
63,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
create_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de crear las tablas en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de crear las tablas en la base de datos. | def create_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de crear las tablas en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
"""
tables = [sql_main_table,
sql_comments,
sql_ocupation,
sql_zip_codes_info,
sql_types_table_creation,
sql_execution_table,
sql_index_creation]
_exec_create(host=host, user=user, passwd=passwd, db_name=db_name, queries=tables) | [
"def",
"create_schema",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"tables",
"=",
"[",
"sql_main_table",
",",
"sql_comments",
",",
"sql_ocupation",
",",
"sql_zip_codes_info",
",",
"sql_types_table_creation",
",",
"sql_execution_table",
",",
"sql_index_creation",
"]",
"_exec_create",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"tables",
")"
] | [
203,
0
] | [
225,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Chimp.addMember | (self,id, data) | En este método agregamos contactos a nuestras audiencias/listas existentes
recibiendo como parametros el id de la lista a la que vamos a agregar el contacto
y los datos del contacto en un diccionario con los siguientes datos:
data = {
'email_address': contacto['email'],
'status': 'subscribed',
'merge_fields': {
'FNAME': contacto['first'],
'LNAME': contacto['last'],
},
}
| En este método agregamos contactos a nuestras audiencias/listas existentes
recibiendo como parametros el id de la lista a la que vamos a agregar el contacto
y los datos del contacto en un diccionario con los siguientes datos:
data = {
'email_address': contacto['email'],
'status': 'subscribed',
'merge_fields': {
'FNAME': contacto['first'],
'LNAME': contacto['last'],
},
}
| def addMember(self,id, data):
"""En este método agregamos contactos a nuestras audiencias/listas existentes
recibiendo como parametros el id de la lista a la que vamos a agregar el contacto
y los datos del contacto en un diccionario con los siguientes datos:
data = {
'email_address': contacto['email'],
'status': 'subscribed',
'merge_fields': {
'FNAME': contacto['first'],
'LNAME': contacto['last'],
},
}
"""
self.client.lists.members.create(id,data) | [
"def",
"addMember",
"(",
"self",
",",
"id",
",",
"data",
")",
":",
"self",
".",
"client",
".",
"lists",
".",
"members",
".",
"create",
"(",
"id",
",",
"data",
")"
] | [
14,
4
] | [
27,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
sort_por_dano | () | return sorted(champions_in_csv(), reverse=True, key=lambda x: x[23]) | Champions que mas daño hacen en lvl 18 | Champions que mas daño hacen en lvl 18 | def sort_por_dano():
"""Champions que mas daño hacen en lvl 18"""
return sorted(champions_in_csv(), reverse=True, key=lambda x: x[23]) | [
"def",
"sort_por_dano",
"(",
")",
":",
"return",
"sorted",
"(",
"champions_in_csv",
"(",
")",
",",
"reverse",
"=",
"True",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"23",
"]",
")"
] | [
45,
0
] | [
47,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Dominio.validar | (self, sol) | Valida que la solución dada cumpla con todos los requerimientos del problema.
Entradas:
sol (estructura de datos)
La solución a validar
Salidas:
(bool) True si la solución es valida, False en cualquier otro caso.
| Valida que la solución dada cumpla con todos los requerimientos del problema. | def validar(self, sol):
"""Valida que la solución dada cumpla con todos los requerimientos del problema.
Entradas:
sol (estructura de datos)
La solución a validar
Salidas:
(bool) True si la solución es valida, False en cualquier otro caso.
"""
pass | [
"def",
"validar",
"(",
"self",
",",
"sol",
")",
":",
"pass"
] | [
75,
4
] | [
86,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ManejadorDePermisos.permiso_de_mapa | (user, mapa) | return None | Devuelve alguno de estos casos en orden: owner|superuser|read|None | Devuelve alguno de estos casos en orden: owner|superuser|read|None | def permiso_de_mapa(user, mapa):
""" Devuelve alguno de estos casos en orden: owner|superuser|read|None"""
if type(user) in (str,unicode):
try:
user = User.objects.get(username=user)
except:
return None
if type(mapa) in (str,unicode):
try:
mapa = Mapa.objects.get(id_mapa=mapa)
except:
return None
if mapa.tipo_de_mapa in ('layer', 'layer_raster_band'):
return ManejadorDePermisos.permiso_de_capa(user, mapa.capas.first())
elif mapa.tipo_de_mapa=='general':
if mapa.owner==user:
return 'owner'
if user.is_superuser:
return 'superuser'
try:
p=PermisoDeMapa.objects.get(user=user, mapa=mapa) # por el momento no implementamos permisos a nivel de mapa, lo simplificamos a mapa publico o privado
return p.permiso # si existe, esto devuelve read o write
except: # si no existe, verificamos si hay algun grupo write, y sino, luego algun grupo read
if mapa.publico:
return 'read'
return None | [
"def",
"permiso_de_mapa",
"(",
"user",
",",
"mapa",
")",
":",
"if",
"type",
"(",
"user",
")",
"in",
"(",
"str",
",",
"unicode",
")",
":",
"try",
":",
"user",
"=",
"User",
".",
"objects",
".",
"get",
"(",
"username",
"=",
"user",
")",
"except",
":",
"return",
"None",
"if",
"type",
"(",
"mapa",
")",
"in",
"(",
"str",
",",
"unicode",
")",
":",
"try",
":",
"mapa",
"=",
"Mapa",
".",
"objects",
".",
"get",
"(",
"id_mapa",
"=",
"mapa",
")",
"except",
":",
"return",
"None",
"if",
"mapa",
".",
"tipo_de_mapa",
"in",
"(",
"'layer'",
",",
"'layer_raster_band'",
")",
":",
"return",
"ManejadorDePermisos",
".",
"permiso_de_capa",
"(",
"user",
",",
"mapa",
".",
"capas",
".",
"first",
"(",
")",
")",
"elif",
"mapa",
".",
"tipo_de_mapa",
"==",
"'general'",
":",
"if",
"mapa",
".",
"owner",
"==",
"user",
":",
"return",
"'owner'",
"if",
"user",
".",
"is_superuser",
":",
"return",
"'superuser'",
"try",
":",
"p",
"=",
"PermisoDeMapa",
".",
"objects",
".",
"get",
"(",
"user",
"=",
"user",
",",
"mapa",
"=",
"mapa",
")",
"# por el momento no implementamos permisos a nivel de mapa, lo simplificamos a mapa publico o privado",
"return",
"p",
".",
"permiso",
"# si existe, esto devuelve read o write",
"except",
":",
"# si no existe, verificamos si hay algun grupo write, y sino, luego algun grupo read",
"if",
"mapa",
".",
"publico",
":",
"return",
"'read'",
"return",
"None"
] | [
158,
4
] | [
184,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones47 | (p) | funciones : EXP PABRE expresion PCIERRA | funciones : EXP PABRE expresion PCIERRA | def p_funciones47(p):
'funciones : EXP PABRE expresion PCIERRA' | [
"def",
"p_funciones47",
"(",
"p",
")",
":"
] | [
439,
0
] | [
440,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Counter.calc | (self) | return self.__namedtuple(
self.calc_seconds(),
self.calc_minutes(),
self.calc_hours(),
self.calc_days(),
self.calc_weeks()
) | Calcula los segundos, los minutos, las horas, los días y los meses | Calcula los segundos, los minutos, las horas, los días y los meses | def calc(self):
"""Calcula los segundos, los minutos, las horas, los días y los meses"""
return self.__namedtuple(
self.calc_seconds(),
self.calc_minutes(),
self.calc_hours(),
self.calc_days(),
self.calc_weeks()
) | [
"def",
"calc",
"(",
"self",
")",
":",
"return",
"self",
".",
"__namedtuple",
"(",
"self",
".",
"calc_seconds",
"(",
")",
",",
"self",
".",
"calc_minutes",
"(",
")",
",",
"self",
".",
"calc_hours",
"(",
")",
",",
"self",
".",
"calc_days",
"(",
")",
",",
"self",
".",
"calc_weeks",
"(",
")",
")"
] | [
49,
4
] | [
59,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
salir | (estado=0) | Finaliza la ejecución de la aplicación. | Finaliza la ejecución de la aplicación. | def salir(estado=0):
"""Finaliza la ejecución de la aplicación."""
out()
sys.exit(estado) | [
"def",
"salir",
"(",
"estado",
"=",
"0",
")",
":",
"out",
"(",
")",
"sys",
".",
"exit",
"(",
"estado",
")"
] | [
41,
0
] | [
44,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Expediente.firmantes | (self) | return self.expedientepersona_set.filter(Q(propietario=True) | Q(sucesor=True)).exclude(sucesion=True) | Devuelve las personas que deben firmar la Solicitud de Inscripción. | Devuelve las personas que deben firmar la Solicitud de Inscripción. | def firmantes(self):
"""Devuelve las personas que deben firmar la Solicitud de Inscripción."""
return self.expedientepersona_set.filter(Q(propietario=True) | Q(sucesor=True)).exclude(sucesion=True) | [
"def",
"firmantes",
"(",
"self",
")",
":",
"return",
"self",
".",
"expedientepersona_set",
".",
"filter",
"(",
"Q",
"(",
"propietario",
"=",
"True",
")",
"|",
"Q",
"(",
"sucesor",
"=",
"True",
")",
")",
".",
"exclude",
"(",
"sucesion",
"=",
"True",
")"
] | [
292,
4
] | [
294,
110
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
update_config | (config) | return 0 | Actualiza las configuraciones locales de elasticsearch
| Actualiza las configuraciones locales de elasticsearch | def update_config(config):
"""Actualiza las configuraciones locales de elasticsearch
"""
with open('user-elastic-config.json', 'w') as json_file:
json.dump(config, json_file, indent=2)
return 0 | [
"def",
"update_config",
"(",
"config",
")",
":",
"with",
"open",
"(",
"'user-elastic-config.json'",
",",
"'w'",
")",
"as",
"json_file",
":",
"json",
".",
"dump",
"(",
"config",
",",
"json_file",
",",
"indent",
"=",
"2",
")",
"return",
"0"
] | [
241,
0
] | [
247,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_funcion_sum | (t) | funciones_math_esenciales : SUM PARIZQ lista_funciones_math_esenciales PARDER parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER | funciones_math_esenciales : SUM PARIZQ lista_funciones_math_esenciales PARDER parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER | def p_instrucciones_funcion_sum(t):
'''funciones_math_esenciales : SUM PARIZQ lista_funciones_math_esenciales PARDER parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER''' | [
"def",
"p_instrucciones_funcion_sum",
"(",
"t",
")",
":"
] | [
855,
0
] | [
857,
90
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instruccion | (t) | sentencia : sentencia_ddl
| sentencia_dml | sentencia : sentencia_ddl
| sentencia_dml | def p_instruccion(t):
'''sentencia : sentencia_ddl
| sentencia_dml''' | [
"def",
"p_instruccion",
"(",
"t",
")",
":"
] | [
128,
0
] | [
130,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ApiRequest.Auth | (self) | Realiza la Auth y guarda el token
Returns
----------
Bool : -
Indica si ha sido posible o no hacer la Auth. False si hay status code distinto de 200
Excepctions:
---------
ImposibleObtenerToken : En caso de que haya un fallo no espeerado
| Realiza la Auth y guarda el token | def Auth(self):
""" Realiza la Auth y guarda el token
Returns
----------
Bool : -
Indica si ha sido posible o no hacer la Auth. False si hay status code distinto de 200
Excepctions:
---------
ImposibleObtenerToken : En caso de que haya un fallo no espeerado
"""
r=self._ProcessResponse(requests.post(self.host+self.secendpoint, headers = self.secheaders,json = self.secpayload))
if isinstance(r,int):
self._log ("Auth: No es posible hacer la Authenticicacion",1)
return False
else:
self._log ("Auth: Autentificacion Correcta, ",1)
y=json.loads(r.text)
try:
self.token=(y[self.tokenparser])
except:
self._log ("Auth: Imposible recoger la variable token: " +self.tokenparser+ " del Json response, ",1)
raise ImposibleObtenerToken
return True | [
"def",
"Auth",
"(",
"self",
")",
":",
"r",
"=",
"self",
".",
"_ProcessResponse",
"(",
"requests",
".",
"post",
"(",
"self",
".",
"host",
"+",
"self",
".",
"secendpoint",
",",
"headers",
"=",
"self",
".",
"secheaders",
",",
"json",
"=",
"self",
".",
"secpayload",
")",
")",
"if",
"isinstance",
"(",
"r",
",",
"int",
")",
":",
"self",
".",
"_log",
"(",
"\"Auth: No es posible hacer la Authenticicacion\"",
",",
"1",
")",
"return",
"False",
"else",
":",
"self",
".",
"_log",
"(",
"\"Auth: Autentificacion Correcta, \"",
",",
"1",
")",
"y",
"=",
"json",
".",
"loads",
"(",
"r",
".",
"text",
")",
"try",
":",
"self",
".",
"token",
"=",
"(",
"y",
"[",
"self",
".",
"tokenparser",
"]",
")",
"except",
":",
"self",
".",
"_log",
"(",
"\"Auth: Imposible recoger la variable token: \"",
"+",
"self",
".",
"tokenparser",
"+",
"\" del Json response, \"",
",",
"1",
")",
"raise",
"ImposibleObtenerToken",
"return",
"True"
] | [
142,
4
] | [
167,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Ventana5.anterior | (self) | Si el valor i es mayor o igual a 0 se debe
de detener y pasar al anterior valor de la lista y reproducirlo | Si el valor i es mayor o igual a 0 se debe
de detener y pasar al anterior valor de la lista y reproducirlo | def anterior(self):
self.i=self.i-1
self.media.stop()
'''Si el valor i es mayor o igual a 0 se debe
de detener y pasar al anterior valor de la lista y reproducirlo'''
if(self.i>=0):
self.media=vlc.MediaPlayer(self.n[self.i])
self.media.play()
'''En caso contrario, significa que i vale 0 y por ende al disminuirlo en 1
se obtiene un índice negativo generando un error, por ende, se debe de reiniciar desde el ultimo
valor de la lista'''
else:
self.i=len(self.n)-1
self.media=vlc.MediaPlayer(self.n[self.i])
self.media.play() | [
"def",
"anterior",
"(",
"self",
")",
":",
"self",
".",
"i",
"=",
"self",
".",
"i",
"-",
"1",
"self",
".",
"media",
".",
"stop",
"(",
")",
"if",
"(",
"self",
".",
"i",
">=",
"0",
")",
":",
"self",
".",
"media",
"=",
"vlc",
".",
"MediaPlayer",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"self",
".",
"media",
".",
"play",
"(",
")",
"'''En caso contrario, significa que i vale 0 y por ende al disminuirlo en 1\n se obtiene un índice negativo generando un error, por ende, se debe de reiniciar desde el ultimo\n valor de la lista'''",
"else",
":",
"self",
".",
"i",
"=",
"len",
"(",
"self",
".",
"n",
")",
"-",
"1",
"self",
".",
"media",
"=",
"vlc",
".",
"MediaPlayer",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"self",
".",
"media",
".",
"play",
"(",
")"
] | [
328,
4
] | [
342,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_judicializados | (limit=50, days_ago=300) | return dominios | dominios que vencieron hace mucho pero no cayeron
TODO ver si el registrante "NIC Juridicos" es mejor | dominios que vencieron hace mucho pero no cayeron
TODO ver si el registrante "NIC Juridicos" es mejor | def get_judicializados(limit=50, days_ago=300):
""" dominios que vencieron hace mucho pero no cayeron
TODO ver si el registrante "NIC Juridicos" es mejor """
starts = timezone.now() - timedelta(days=days_ago)
dominios = Dominio.objects.filter(
estado=STATUS_NO_DISPONIBLE,
expire__lt=starts)
dominios = dominios.order_by('expire')[:limit]
return dominios | [
"def",
"get_judicializados",
"(",
"limit",
"=",
"50",
",",
"days_ago",
"=",
"300",
")",
":",
"starts",
"=",
"timezone",
".",
"now",
"(",
")",
"-",
"timedelta",
"(",
"days",
"=",
"days_ago",
")",
"dominios",
"=",
"Dominio",
".",
"objects",
".",
"filter",
"(",
"estado",
"=",
"STATUS_NO_DISPONIBLE",
",",
"expire__lt",
"=",
"starts",
")",
"dominios",
"=",
"dominios",
".",
"order_by",
"(",
"'expire'",
")",
"[",
":",
"limit",
"]",
"return",
"dominios"
] | [
37,
0
] | [
46,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObject.index_detection | (self, detection: Object) | Devuelve el índice dentro de los seguimientos del objeto en el que se encontró esa
detección.
:param detection: detección de la que se busca el índice.
:return: índice si es que está esa detección.
| Devuelve el índice dentro de los seguimientos del objeto en el que se encontró esa
detección. | def index_detection(self, detection: Object) -> Optional[int]:
"""Devuelve el índice dentro de los seguimientos del objeto en el que se encontró esa
detección.
:param detection: detección de la que se busca el índice.
:return: índice si es que está esa detección.
"""
try:
return self.detections.index(detection)
except ValueError:
return None | [
"def",
"index_detection",
"(",
"self",
",",
"detection",
":",
"Object",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"try",
":",
"return",
"self",
".",
"detections",
".",
"index",
"(",
"detection",
")",
"except",
"ValueError",
":",
"return",
"None"
] | [
114,
4
] | [
124,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Molecule.get_coords | (self) | return todos | Metodo para obtener una lista con el id coordenadas
y carga de la molecula. | Metodo para obtener una lista con el id coordenadas
y carga de la molecula. | def get_coords(self):
""" Metodo para obtener una lista con el id coordenadas
y carga de la molecula. """
todos = []
for a in self.atoms:
x, y, z = a.get_coordinates()
todos.append([a.element, x, y, z, a.charge])
return todos | [
"def",
"get_coords",
"(",
"self",
")",
":",
"todos",
"=",
"[",
"]",
"for",
"a",
"in",
"self",
".",
"atoms",
":",
"x",
",",
"y",
",",
"z",
"=",
"a",
".",
"get_coordinates",
"(",
")",
"todos",
".",
"append",
"(",
"[",
"a",
".",
"element",
",",
"x",
",",
"y",
",",
"z",
",",
"a",
".",
"charge",
"]",
")",
"return",
"todos"
] | [
135,
4
] | [
142,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
download_results | (request) | **Descarga los resultados de la busqueda actual**
Vista asociada a botón que se encarga de descargar los resultados
de la consulta actual
:param request: Objeto ``HttpRequet`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Los resultados de busqueda en formato ``csv``
| **Descarga los resultados de la busqueda actual** | def download_results(request):
"""**Descarga los resultados de la busqueda actual**
Vista asociada a botón que se encarga de descargar los resultados
de la consulta actual
:param request: Objeto ``HttpRequet`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Los resultados de busqueda en formato ``csv``
"""
file_path = settings.BASE_DIR + settings.MEDIA_ROOT + "query-results.csv"
if os.path.exists(file_path):
with open(file_path, 'r') as csv_file:
data = csv_file.read()
response = HttpResponse(data, content_type="text/csv")
response['Content-Disposition'] = f"inline; filename=resultados.csv"
return response
raise Http404 | [
"def",
"download_results",
"(",
"request",
")",
":",
"file_path",
"=",
"settings",
".",
"BASE_DIR",
"+",
"settings",
".",
"MEDIA_ROOT",
"+",
"\"query-results.csv\"",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"file_path",
")",
":",
"with",
"open",
"(",
"file_path",
",",
"'r'",
")",
"as",
"csv_file",
":",
"data",
"=",
"csv_file",
".",
"read",
"(",
")",
"response",
"=",
"HttpResponse",
"(",
"data",
",",
"content_type",
"=",
"\"text/csv\"",
")",
"response",
"[",
"'Content-Disposition'",
"]",
"=",
"f\"inline; filename=resultados.csv\"",
"return",
"response",
"raise",
"Http404"
] | [
163,
0
] | [
181,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_select_lista2 | (t) | opcion_select_lista : opciones_select_lista | opcion_select_lista : opciones_select_lista | def p_select_lista2(t):
' opcion_select_lista : opciones_select_lista'
reporte_bnf.append("<opcion_select_lista> ::= <opciones_select_lista>")
t[0] = Create_select_uno(OPCIONES_SELECT.SUBCONSULTA,None,None,None,t[1],None,None) | [
"def",
"p_select_lista2",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<opcion_select_lista> ::= <opciones_select_lista>\"",
")",
"t",
"[",
"0",
"]",
"=",
"Create_select_uno",
"(",
"OPCIONES_SELECT",
".",
"SUBCONSULTA",
",",
"None",
",",
"None",
",",
"None",
",",
"t",
"[",
"1",
"]",
",",
"None",
",",
"None",
")"
] | [
1748,
0
] | [
1751,
87
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Tipo.getTipo | (self) | Metodo Abstracto para obtener el valor de la Instrruccion | Metodo Abstracto para obtener el valor de la Instrruccion | def getTipo(self):
'Metodo Abstracto para obtener el valor de la Instrruccion'
if self.tipo == 'int':
return self.tipoInt(self)
elif self.tipo == 'decimal':
return self.tipoDecimal(self)
else:
return self.tipo | [
"def",
"getTipo",
"(",
"self",
")",
":",
"if",
"self",
".",
"tipo",
"==",
"'int'",
":",
"return",
"self",
".",
"tipoInt",
"(",
"self",
")",
"elif",
"self",
".",
"tipo",
"==",
"'decimal'",
":",
"return",
"self",
".",
"tipoDecimal",
"(",
"self",
")",
"else",
":",
"return",
"self",
".",
"tipo"
] | [
35,
4
] | [
42,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_document_info | (_id) | return {"name": name, "file": file, "id": _id} | **Obtiene información de un documento de Elasticsearch**
Función encargada de obtener el nombre de documento,
nombre del archivo asociado al documento e identificador
por medio del id
:param _id: Identificador del documento
:type: str
:return: Diccionario con nombre, archivo e identificador
:rtype: dict
| **Obtiene información de un documento de Elasticsearch** | def get_document_info(_id):
"""**Obtiene información de un documento de Elasticsearch**
Función encargada de obtener el nombre de documento,
nombre del archivo asociado al documento e identificador
por medio del id
:param _id: Identificador del documento
:type: str
:return: Diccionario con nombre, archivo e identificador
:rtype: dict
"""
query_base = {
"version": True, "size": 1,
"query": {
"query_string": {
"query": 'document_id:' + _id,
"analyze_wildcard": True
}
}
}
r = es.search(index=settings.INDEX, body=query_base)
if r['hits']['hits']:
data = r['hits']['hits'][0]['_source']
else:
LOGGER.error("Data not found ID::{}".format(_id))
data = {"name": "Not Found", "pdf_file": "Not Found",
"document_name": "Not_Found"}
name = data['document_name']
file = data['pdf_file']
# TODO: Agregar mas información útil
return {"name": name, "file": file, "id": _id} | [
"def",
"get_document_info",
"(",
"_id",
")",
":",
"query_base",
"=",
"{",
"\"version\"",
":",
"True",
",",
"\"size\"",
":",
"1",
",",
"\"query\"",
":",
"{",
"\"query_string\"",
":",
"{",
"\"query\"",
":",
"'document_id:'",
"+",
"_id",
",",
"\"analyze_wildcard\"",
":",
"True",
"}",
"}",
"}",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"query_base",
")",
"if",
"r",
"[",
"'hits'",
"]",
"[",
"'hits'",
"]",
":",
"data",
"=",
"r",
"[",
"'hits'",
"]",
"[",
"'hits'",
"]",
"[",
"0",
"]",
"[",
"'_source'",
"]",
"else",
":",
"LOGGER",
".",
"error",
"(",
"\"Data not found ID::{}\"",
".",
"format",
"(",
"_id",
")",
")",
"data",
"=",
"{",
"\"name\"",
":",
"\"Not Found\"",
",",
"\"pdf_file\"",
":",
"\"Not Found\"",
",",
"\"document_name\"",
":",
"\"Not_Found\"",
"}",
"name",
"=",
"data",
"[",
"'document_name'",
"]",
"file",
"=",
"data",
"[",
"'pdf_file'",
"]",
"# TODO: Agregar mas información útil",
"return",
"{",
"\"name\"",
":",
"name",
",",
"\"file\"",
":",
"file",
",",
"\"id\"",
":",
"_id",
"}"
] | [
174,
0
] | [
205,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_CuerpoS_CuerpoS | (t) | CUERPOS : CUERPOS CUERPO | CUERPOS : CUERPOS CUERPO | def p_CuerpoS_CuerpoS(t):
'CUERPOS : CUERPOS CUERPO'
t[1].append(t[2])
t[0] = t[1]
rep_gramatica('\n <TR><TD> CUERPOS → CUERPOS CUERPO ARRAY[] </TD><TD> t[1].append(t[2]) t[0] = t[1] </TD></TR>') | [
"def",
"p_CuerpoS_CuerpoS",
"(",
"t",
")",
":",
"t",
"[",
"1",
"]",
".",
"append",
"(",
"t",
"[",
"2",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]",
"rep_gramatica",
"(",
"'\\n <TR><TD> CUERPOS → CUERPOS CUERPO ARRAY[] </TD><TD> t[1].append(t[2]) t[0] = t[1] </TD></TR>')",
""
] | [
759,
0
] | [
763,
124
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
crear_carpeta | (nombre) | return ruta | Crea nueva carpeta en disco si no existe.
Si no es ruta absoluta será creada relativo a carpeta de trabajo.
Parameters
----------
nombre : str | Path
Nombre de carpeta a crear.
Returns
-------
Path
Ruta absoluta de carpeta.
| Crea nueva carpeta en disco si no existe. | def crear_carpeta(nombre):
"""Crea nueva carpeta en disco si no existe.
Si no es ruta absoluta será creada relativo a carpeta de trabajo.
Parameters
----------
nombre : str | Path
Nombre de carpeta a crear.
Returns
-------
Path
Ruta absoluta de carpeta.
"""
ruta = Path(nombre).resolve()
if not ruta.is_dir():
ruta.mkdir(parents=True, exist_ok=True)
return ruta | [
"def",
"crear_carpeta",
"(",
"nombre",
")",
":",
"ruta",
"=",
"Path",
"(",
"nombre",
")",
".",
"resolve",
"(",
")",
"if",
"not",
"ruta",
".",
"is_dir",
"(",
")",
":",
"ruta",
".",
"mkdir",
"(",
"parents",
"=",
"True",
",",
"exist_ok",
"=",
"True",
")",
"return",
"ruta"
] | [
14,
0
] | [
34,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
carga_csv | (file_name) | return valores | carga el fichero csv especificado y lo devuelve en un array de numpy
| carga el fichero csv especificado y lo devuelve en un array de numpy
| def carga_csv(file_name):
"""carga el fichero csv especificado y lo devuelve en un array de numpy
"""
valores = read_csv(file_name, header=None).values
# suponemos que siempre trabajaremos con float
return valores | [
"def",
"carga_csv",
"(",
"file_name",
")",
":",
"valores",
"=",
"read_csv",
"(",
"file_name",
",",
"header",
"=",
"None",
")",
".",
"values",
"# suponemos que siempre trabajaremos con float\r",
"return",
"valores"
] | [
25,
0
] | [
30,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones39 | (p) | funciones : CEILING PABRE expresion PCIERRA | funciones : CEILING PABRE expresion PCIERRA | def p_funciones39(p):
'funciones : CEILING PABRE expresion PCIERRA' | [
"def",
"p_funciones39",
"(",
"p",
")",
":"
] | [
415,
0
] | [
416,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_opcion5 | (t) | opcion : UNIQUE
| opcion : UNIQUE
| def p_opcion5(t):
'''opcion : UNIQUE
''' | [
"def",
"p_opcion5",
"(",
"t",
")",
":"
] | [
1012,
0
] | [
1014,
7
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_sentencia_case_when | (t) | sentencia_when : WHEN exp THEN lfuncionalidad
| ELSE lfuncionalidad | sentencia_when : WHEN exp THEN lfuncionalidad
| ELSE lfuncionalidad | def p_sentencia_case_when(t):
'''sentencia_when : WHEN exp THEN lfuncionalidad
| ELSE lfuncionalidad'''
if len(t) == 5:
t[0] = Sentencia_When_Else(t[2],t[4])
else:
t[0] = Sentencia_When_Else(None,t[2]) | [
"def",
"p_sentencia_case_when",
"(",
"t",
")",
":",
"if",
"len",
"(",
"t",
")",
"==",
"5",
":",
"t",
"[",
"0",
"]",
"=",
"Sentencia_When_Else",
"(",
"t",
"[",
"2",
"]",
",",
"t",
"[",
"4",
"]",
")",
"else",
":",
"t",
"[",
"0",
"]",
"=",
"Sentencia_When_Else",
"(",
"None",
",",
"t",
"[",
"2",
"]",
")"
] | [
1584,
0
] | [
1590,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TokenCallback.count_token | (userid: int, *, cursor) | return token_number | Contar cuántos token's de acceso tiene un usuario actualmente | Contar cuántos token's de acceso tiene un usuario actualmente | async def count_token(userid: int, *, cursor) -> int:
"""Contar cuántos token's de acceso tiene un usuario actualmente"""
await cursor.execute(
"SELECT COUNT(id_user) FROM tokens WHERE id_user = %s", (userid,)
)
token_number = await cursor.fetchone()
return token_number | [
"async",
"def",
"count_token",
"(",
"userid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"int",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT COUNT(id_user) FROM tokens WHERE id_user = %s\"",
",",
"(",
"userid",
",",
")",
")",
"token_number",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"token_number"
] | [
296,
4
] | [
306,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
CompanyTypeItem.create | (self, request, company_pk) | return Response({"Error": serializer.errors}, status=status.HTTP_400_BAD_REQUEST) | Este metodo se encuentra des-habilitado | Este metodo se encuentra des-habilitado | def create(self, request, company_pk):
"""Este metodo se encuentra des-habilitado"""
return Response(status=status.HTTP_405_METHOD_NOT_ALLOWED)
data = request.data
serializer = TypeItemSerializer(data=data)
try:
company = Company.objects.get(id=company_pk)
except ObjectDoesNotExist:
return Response({"company": ["La compañía no está registrada"]}, status=status.HTTP_400_BAD_REQUEST)
if serializer.is_valid():
serializer.validated_data['company'] = company
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response({"Error": serializer.errors}, status=status.HTTP_400_BAD_REQUEST) | [
"def",
"create",
"(",
"self",
",",
"request",
",",
"company_pk",
")",
":",
"return",
"Response",
"(",
"status",
"=",
"status",
".",
"HTTP_405_METHOD_NOT_ALLOWED",
")",
"data",
"=",
"request",
".",
"data",
"serializer",
"=",
"TypeItemSerializer",
"(",
"data",
"=",
"data",
")",
"try",
":",
"company",
"=",
"Company",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"company_pk",
")",
"except",
"ObjectDoesNotExist",
":",
"return",
"Response",
"(",
"{",
"\"company\"",
":",
"[",
"\"La compañía no está registrada\"]},",
" ",
"s",
"t",
"tus=st",
"a",
"tus.HT",
"T",
"P_400_BAD_REQUEST)",
"",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"serializer",
".",
"validated_data",
"[",
"'company'",
"]",
"=",
"company",
"serializer",
".",
"save",
"(",
")",
"return",
"Response",
"(",
"serializer",
".",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_201_CREATED",
")",
"return",
"Response",
"(",
"{",
"\"Error\"",
":",
"serializer",
".",
"errors",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
439,
4
] | [
452,
89
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
verpdf | () | return salida | verpdf entrega el archivo pdf en stream para se visualido en pantalla | verpdf entrega el archivo pdf en stream para se visualido en pantalla | def verpdf():
'''verpdf entrega el archivo pdf en stream para se visualido en pantalla'''
id_recepccion=request.vars.idpdf
salida = F2s_VerPDF(id_recepccion)
return salida | [
"def",
"verpdf",
"(",
")",
":",
"id_recepccion",
"=",
"request",
".",
"vars",
".",
"idpdf",
"salida",
"=",
"F2s_VerPDF",
"(",
"id_recepccion",
")",
"return",
"salida"
] | [
323,
0
] | [
327,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
paises_asiaticos_oceania | () | return lista_a_devolver | Paises Asiaticos y de Oceania | Paises Asiaticos y de Oceania | def paises_asiaticos_oceania():
"""Paises Asiaticos y de Oceania"""
lista_a_devolver = []
for linea in sort_por_nombre():
if asia_oceania(linea):
aux = str.rstrip(linea[0])
lista_a_devolver.append(aux)
return lista_a_devolver | [
"def",
"paises_asiaticos_oceania",
"(",
")",
":",
"lista_a_devolver",
"=",
"[",
"]",
"for",
"linea",
"in",
"sort_por_nombre",
"(",
")",
":",
"if",
"asia_oceania",
"(",
"linea",
")",
":",
"aux",
"=",
"str",
".",
"rstrip",
"(",
"linea",
"[",
"0",
"]",
")",
"lista_a_devolver",
".",
"append",
"(",
"aux",
")",
"return",
"lista_a_devolver"
] | [
61,
0
] | [
68,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
main | () | Solicitamos la cantidad a retirar y
prosegimos a dar los diferentes
tipos de villetes
| Solicitamos la cantidad a retirar y
prosegimos a dar los diferentes
tipos de villetes
| def main():
""" Solicitamos la cantidad a retirar y
prosegimos a dar los diferentes
tipos de villetes
"""
ATM = dispensador_chain()
Cantidad = int(input("Ingrese cantidad a retirar en multiplo de 10: "))
ATM.chain1.handle(Cantidad) | [
"def",
"main",
"(",
")",
":",
"ATM",
"=",
"dispensador_chain",
"(",
")",
"Cantidad",
"=",
"int",
"(",
"input",
"(",
"\"Ingrese cantidad a retirar en multiplo de 10: \"",
")",
")",
"ATM",
".",
"chain1",
".",
"handle",
"(",
"Cantidad",
")"
] | [
89,
0
] | [
96,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ordenar | (diccionario: Dict[str, List[str]]) | return {
key: diccionario[key]
for key in sorted(diccionario, key=lambda x: len(diccionario[x]))
} | Funcion que ordena el diccionario basado en la cantidad de personas
que consumen cada platillo.
:param diccionario: Diccionario con los datos a ordenar
:diccionario: Dict[str, List[str]]
:return: Diccionario ordenado
:rtype: Dict[str, List[str]]
| Funcion que ordena el diccionario basado en la cantidad de personas
que consumen cada platillo. | def ordenar(diccionario: Dict[str, List[str]]) -> Dict[str, List[str]]:
"""Funcion que ordena el diccionario basado en la cantidad de personas
que consumen cada platillo.
:param diccionario: Diccionario con los datos a ordenar
:diccionario: Dict[str, List[str]]
:return: Diccionario ordenado
:rtype: Dict[str, List[str]]
"""
return {
key: diccionario[key]
for key in sorted(diccionario, key=lambda x: len(diccionario[x]))
} | [
"def",
"ordenar",
"(",
"diccionario",
":",
"Dict",
"[",
"str",
",",
"List",
"[",
"str",
"]",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"List",
"[",
"str",
"]",
"]",
":",
"return",
"{",
"key",
":",
"diccionario",
"[",
"key",
"]",
"for",
"key",
"in",
"sorted",
"(",
"diccionario",
",",
"key",
"=",
"lambda",
"x",
":",
"len",
"(",
"diccionario",
"[",
"x",
"]",
")",
")",
"}"
] | [
29,
0
] | [
41,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
create | (
database: Optional[str] = None,
only_pool: bool = False,
config: Optional[dict] = None
) | Crear y autoconfigura un conector para MySQL
Args:
database:
El nombre de la base de datos.
Si no se define, se configura según el valor de la clave
`mysql_db` en el archivo de configuración.
only_pool:
Retornar las piscina de conexiones en vez de usar directamente el envoltorio
config:
La configuración para el cliente MySQL
Returns:
Si `only_pool` es **True** retorna la piscina de conexiones; **False** para
retornar el envoltorio.
| Crear y autoconfigura un conector para MySQL
Args:
database:
El nombre de la base de datos.
Si no se define, se configura según el valor de la clave
`mysql_db` en el archivo de configuración. | async def create(
database: Optional[str] = None,
only_pool: bool = False,
config: Optional[dict] = None
) -> object:
"""Crear y autoconfigura un conector para MySQL
Args:
database:
El nombre de la base de datos.
Si no se define, se configura según el valor de la clave
`mysql_db` en el archivo de configuración.
only_pool:
Retornar las piscina de conexiones en vez de usar directamente el envoltorio
config:
La configuración para el cliente MySQL
Returns:
Si `only_pool` es **True** retorna la piscina de conexiones; **False** para
retornar el envoltorio.
"""
if (config is None):
config = parse_config.parse()
db_config = config["MySQL"]
server_config = config["Server"]
ssl_context = None
ssl_key = db_config.get("ssl_key")
ssl_cert = db_config.get("ssl_cert")
ssl_ca = db_config.get("ssl_ca")
if (ssl_key is not None) and (ssl_cert is not None) and (ssl_ca is not None):
if (server_config["verify_mysql_cert"]):
ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH, cafile=ssl_ca)
ssl_context.load_cert_chain(
certfile=ssl_cert, keyfile=ssl_key
)
else:
ssl_context = ssl._create_unverified_context(
certfile=ssl_cert,
keyfile=ssl_key,
cafile=ssl_ca
)
if (database is None):
database = server_config["mysql_db"]
pool = await aiomysql.create_pool(
read_default_file=defaults.fileconfig,
read_default_group="MySQL",
db=database,
autocommit=True,
ssl=ssl_context
)
if (only_pool):
return pool
else:
return dbConnector.UTeslaConnector(pool) | [
"async",
"def",
"create",
"(",
"database",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"only_pool",
":",
"bool",
"=",
"False",
",",
"config",
":",
"Optional",
"[",
"dict",
"]",
"=",
"None",
")",
"->",
"object",
":",
"if",
"(",
"config",
"is",
"None",
")",
":",
"config",
"=",
"parse_config",
".",
"parse",
"(",
")",
"db_config",
"=",
"config",
"[",
"\"MySQL\"",
"]",
"server_config",
"=",
"config",
"[",
"\"Server\"",
"]",
"ssl_context",
"=",
"None",
"ssl_key",
"=",
"db_config",
".",
"get",
"(",
"\"ssl_key\"",
")",
"ssl_cert",
"=",
"db_config",
".",
"get",
"(",
"\"ssl_cert\"",
")",
"ssl_ca",
"=",
"db_config",
".",
"get",
"(",
"\"ssl_ca\"",
")",
"if",
"(",
"ssl_key",
"is",
"not",
"None",
")",
"and",
"(",
"ssl_cert",
"is",
"not",
"None",
")",
"and",
"(",
"ssl_ca",
"is",
"not",
"None",
")",
":",
"if",
"(",
"server_config",
"[",
"\"verify_mysql_cert\"",
"]",
")",
":",
"ssl_context",
"=",
"ssl",
".",
"create_default_context",
"(",
"ssl",
".",
"Purpose",
".",
"CLIENT_AUTH",
",",
"cafile",
"=",
"ssl_ca",
")",
"ssl_context",
".",
"load_cert_chain",
"(",
"certfile",
"=",
"ssl_cert",
",",
"keyfile",
"=",
"ssl_key",
")",
"else",
":",
"ssl_context",
"=",
"ssl",
".",
"_create_unverified_context",
"(",
"certfile",
"=",
"ssl_cert",
",",
"keyfile",
"=",
"ssl_key",
",",
"cafile",
"=",
"ssl_ca",
")",
"if",
"(",
"database",
"is",
"None",
")",
":",
"database",
"=",
"server_config",
"[",
"\"mysql_db\"",
"]",
"pool",
"=",
"await",
"aiomysql",
".",
"create_pool",
"(",
"read_default_file",
"=",
"defaults",
".",
"fileconfig",
",",
"read_default_group",
"=",
"\"MySQL\"",
",",
"db",
"=",
"database",
",",
"autocommit",
"=",
"True",
",",
"ssl",
"=",
"ssl_context",
")",
"if",
"(",
"only_pool",
")",
":",
"return",
"pool",
"else",
":",
"return",
"dbConnector",
".",
"UTeslaConnector",
"(",
"pool",
")"
] | [
12,
0
] | [
80,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
drop_results_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de borrar las tablas de resultados de la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de borrar las tablas de resultados de la base de datos. | def drop_results_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de borrar las tablas de resultados de la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
"""
drop_sql = ["DROP TABLE IF EXISTS commercial_premise_occupation",
"DROP TABLE IF EXISTS commercial_premise_comments",
"DROP TABLE IF EXISTS commercial_premise",
"DROP INDEX IF EXISTS commercial_premise_index"
]
_exec_drop(host=host, user=user, passwd=passwd, db_name=db_name, queries=drop_sql) | [
"def",
"drop_results_schema",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"drop_sql",
"=",
"[",
"\"DROP TABLE IF EXISTS commercial_premise_occupation\"",
",",
"\"DROP TABLE IF EXISTS commercial_premise_comments\"",
",",
"\"DROP TABLE IF EXISTS commercial_premise\"",
",",
"\"DROP INDEX IF EXISTS commercial_premise_index\"",
"]",
"_exec_drop",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"drop_sql",
")"
] | [
281,
0
] | [
302,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EspacioEstados.sucesores | (self, NodoArbolActual) | return listaSucesores | Este método genera tripetas (Acción realizada, New_Objeto_Cubo, CosteAcción = 1)
que son añadidas a la lista de sucesores, total de tripletas generadas es igual a
el número de movimientos (estático) multiplicado por el numero de filas del cubo,
es decir, todas las acciones posibles | Este método genera tripetas (Acción realizada, New_Objeto_Cubo, CosteAcción = 1)
que son añadidas a la lista de sucesores, total de tripletas generadas es igual a
el número de movimientos (estático) multiplicado por el numero de filas del cubo,
es decir, todas las acciones posibles | def sucesores(self, NodoArbolActual):
'''Este método genera tripetas (Acción realizada, New_Objeto_Cubo, CosteAcción = 1)
que son añadidas a la lista de sucesores, total de tripletas generadas es igual a
el número de movimientos (estático) multiplicado por el numero de filas del cubo,
es decir, todas las acciones posibles'''
listaSucesores = []
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientoB(x)
listaSucesores.append(("B" + str(x), new_cubo, 1))
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientob(x)
listaSucesores.append(("b" + str(x), new_cubo, 1))
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientoD(x)
listaSucesores.append(("D" + str(x), new_cubo, 1))
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientod(x)
listaSucesores.append(("d" + str(x), new_cubo, 1))
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientoL(x)
listaSucesores.append(("L" + str(x), new_cubo, 1))
for x in range(0, NodoArbolActual.cubo.getCuboSize()):
new_cubo = copy.deepcopy(NodoArbolActual.cubo)
new_cubo.desplazamientol(x)
listaSucesores.append(("l" + str(x), new_cubo, 1))
return listaSucesores | [
"def",
"sucesores",
"(",
"self",
",",
"NodoArbolActual",
")",
":",
"listaSucesores",
"=",
"[",
"]",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientoB",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"B\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientob",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"b\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientoD",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"D\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientod",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"d\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientoL",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"L\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"NodoArbolActual",
".",
"cubo",
".",
"getCuboSize",
"(",
")",
")",
":",
"new_cubo",
"=",
"copy",
".",
"deepcopy",
"(",
"NodoArbolActual",
".",
"cubo",
")",
"new_cubo",
".",
"desplazamientol",
"(",
"x",
")",
"listaSucesores",
".",
"append",
"(",
"(",
"\"l\"",
"+",
"str",
"(",
"x",
")",
",",
"new_cubo",
",",
"1",
")",
")",
"return",
"listaSucesores"
] | [
8,
4
] | [
45,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instruciones_funciones_math_esenciales | (t) | lista_funciones_math_esenciales : COUNT PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| AVG PARIZQ lista_funciones_math_esenciales PARDER o_parametro | lista_funciones_math_esenciales : COUNT PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| AVG PARIZQ lista_funciones_math_esenciales PARDER o_parametro | def p_instruciones_funciones_math_esenciales(t) :
'''lista_funciones_math_esenciales : COUNT PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| SUM PARIZQ lista_funciones_math_esenciales PARDER o_parametro
| AVG PARIZQ lista_funciones_math_esenciales PARDER o_parametro''' | [
"def",
"p_instruciones_funciones_math_esenciales",
"(",
"t",
")",
":"
] | [
550,
0
] | [
553,
106
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Ventana4.siguiente | (self) | Si el valor es menor al tamaño de la lista solo
carga el siguiente valor de la lista y la reproduce | Si el valor es menor al tamaño de la lista solo
carga el siguiente valor de la lista y la reproduce | def siguiente(self):
self.media.stop()#Detiene el contenido multimedia
self.i=self.i+1#Incrementa el valor del índice en 1
'''Si el valor es menor al tamaño de la lista solo
carga el siguiente valor de la lista y la reproduce'''
if(self.i<len(self.n)):
self.media=vlc.MediaPlayer(self.n[self.i])#Carga el valor de n[i] para poder
#utilizarlo en el reproductor multimedia
self.media.play()#Reproduce el archivo
'''Sino se reinicia el valor de i en 0 se carga el valor
de la lista y la reproduce'''
else:
self.i=0#Reinicia indice
self.media=vlc.MediaPlayer(self.n[self.i])#Carga el valor de n[i] para poder
#utilizarlo en el reproductor multimedia
self.media.play()#Reproduce el archivo | [
"def",
"siguiente",
"(",
"self",
")",
":",
"self",
".",
"media",
".",
"stop",
"(",
")",
"#Detiene el contenido multimedia",
"self",
".",
"i",
"=",
"self",
".",
"i",
"+",
"1",
"#Incrementa el valor del índice en 1",
"if",
"(",
"self",
".",
"i",
"<",
"len",
"(",
"self",
".",
"n",
")",
")",
":",
"self",
".",
"media",
"=",
"vlc",
".",
"MediaPlayer",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"#Carga el valor de n[i] para poder",
"#utilizarlo en el reproductor multimedia",
"self",
".",
"media",
".",
"play",
"(",
")",
"#Reproduce el archivo",
"'''Sino se reinicia el valor de i en 0 se carga el valor\n de la lista y la reproduce'''",
"else",
":",
"self",
".",
"i",
"=",
"0",
"#Reinicia indice",
"self",
".",
"media",
"=",
"vlc",
".",
"MediaPlayer",
"(",
"self",
".",
"n",
"[",
"self",
".",
"i",
"]",
")",
"#Carga el valor de n[i] para poder",
"#utilizarlo en el reproductor multimedia",
"self",
".",
"media",
".",
"play",
"(",
")",
"#Reproduce el archivo"
] | [
241,
4
] | [
256,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones23 | (p) | funciones : COSD PABRE expresion PCIERRA | funciones : COSD PABRE expresion PCIERRA | def p_funciones23(p):
'funciones : COSD PABRE expresion PCIERRA' | [
"def",
"p_funciones23",
"(",
"p",
")",
":"
] | [
367,
0
] | [
368,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_intruccion | (t) | instruccion : limportaciones
| ldeclaracionesg
| decorador
| def main PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| def ID PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| if _name_ IGUAL IGUAL CADENA DOS_PUNTOS main PARIZQ PARDER
| instruccion : limportaciones
| ldeclaracionesg
| decorador
| def main PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| def ID PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| if _name_ IGUAL IGUAL CADENA DOS_PUNTOS main PARIZQ PARDER
| def p_intruccion(t):
'''instruccion : limportaciones
| ldeclaracionesg
| decorador
| def main PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| def ID PARIZQ PARDER DOS_PUNTOS ldeclaracionesg
| if _name_ IGUAL IGUAL CADENA DOS_PUNTOS main PARIZQ PARDER
'''
print("paso por todas las condicionales de instruccion ")
if len(t) > 2:
if t[2] == "main":
print("paso por el main") | [
"def",
"p_intruccion",
"(",
"t",
")",
":",
"print",
"(",
"\"paso por todas las condicionales de instruccion \"",
")",
"if",
"len",
"(",
"t",
")",
">",
"2",
":",
"if",
"t",
"[",
"2",
"]",
"==",
"\"main\"",
":",
"print",
"(",
"\"paso por el main\"",
")"
] | [
37,
0
] | [
49,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_BLOCK | (t) | BLOCK : sentencias
| ASIGNACION
| RETORNO
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
| BLOCK : sentencias
| ASIGNACION
| RETORNO
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
| def p_BLOCK(t):
''' BLOCK : sentencias
| ASIGNACION
| RETORNO
| SENTENCIAS_CONTROL
| DECLARACION_RAICENOTE
| STATEMENT
'''
t[0] = t[1] | [
"def",
"p_BLOCK",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
787,
0
] | [
795,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AdministrativosTest.test_profesionales_corresponden_especialidad | (self) | Profesionales listados en el formulario de turno
deberían ser solamente los que corresponen al
servicio elegido | Profesionales listados en el formulario de turno
deberían ser solamente los que corresponen al
servicio elegido | def test_profesionales_corresponden_especialidad(self):
''' Profesionales listados en el formulario de turno
deberían ser solamente los que corresponen al
servicio elegido '''
self.client.login(username=self.user_admin_1, password=self.user_admin_1)
servicio1 = Servicio.objects.filter(centro__nombre='Centro de Salud 1').get()
# Url que devuelve los profesionales en base al servicio colocado en el form
url = f'/core/profesional-autocomplete-por-servicio/{servicio1.id}'
response = self.client.get(url)
# Sacar los profesionales de la response
profesionales = response.json().get('results')
# Guardo el nombre de cada profesional en un array
nombres_profs = []
for prof in profesionales:
nombres_profs.append(prof['text'])
valor_esperado = ['Profesional 1A ', 'Profesional 1B ', 'Profesional 1C ', 'Profesional 1D ', 'Profesional 1E ']
self.assertEqual(nombres_profs, valor_esperado) | [
"def",
"test_profesionales_corresponden_especialidad",
"(",
"self",
")",
":",
"self",
".",
"client",
".",
"login",
"(",
"username",
"=",
"self",
".",
"user_admin_1",
",",
"password",
"=",
"self",
".",
"user_admin_1",
")",
"servicio1",
"=",
"Servicio",
".",
"objects",
".",
"filter",
"(",
"centro__nombre",
"=",
"'Centro de Salud 1'",
")",
".",
"get",
"(",
")",
"# Url que devuelve los profesionales en base al servicio colocado en el form",
"url",
"=",
"f'/core/profesional-autocomplete-por-servicio/{servicio1.id}'",
"response",
"=",
"self",
".",
"client",
".",
"get",
"(",
"url",
")",
"# Sacar los profesionales de la response",
"profesionales",
"=",
"response",
".",
"json",
"(",
")",
".",
"get",
"(",
"'results'",
")",
"# Guardo el nombre de cada profesional en un array",
"nombres_profs",
"=",
"[",
"]",
"for",
"prof",
"in",
"profesionales",
":",
"nombres_profs",
".",
"append",
"(",
"prof",
"[",
"'text'",
"]",
")",
"valor_esperado",
"=",
"[",
"'Profesional 1A '",
",",
"'Profesional 1B '",
",",
"'Profesional 1C '",
",",
"'Profesional 1D '",
",",
"'Profesional 1E '",
"]",
"self",
".",
"assertEqual",
"(",
"nombres_profs",
",",
"valor_esperado",
")"
] | [
72,
4
] | [
96,
55
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_CONTENIDO5 | (t) | CONTENIDO : ASIGNACION nueval
| CONTENIDO : ASIGNACION nueval
| def p_CONTENIDO5(t):
'''CONTENIDO : ASIGNACION nueval
'''
t[0] = t[1] | [
"def",
"p_CONTENIDO5",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
219,
0
] | [
222,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Textos.texto_pantalla_rect | (texto,fuente,coloracio,pantalla,x,y) | Muestra el texto en pantalla
Parametros:
texto (str): El texto a mostrar.
fuente (pygame.font): Fuente del texto.
coloracio (int/rgb): Color del texto.
pantalla (pygame.display): Pantalla pygame donde se ubicará el texto.
x (int): Valor en el eje X de la pantalla.
y (int): Valor en el eje Y de la pantalla.
| Muestra el texto en pantalla
Parametros:
texto (str): El texto a mostrar.
fuente (pygame.font): Fuente del texto.
coloracio (int/rgb): Color del texto.
pantalla (pygame.display): Pantalla pygame donde se ubicará el texto.
x (int): Valor en el eje X de la pantalla.
y (int): Valor en el eje Y de la pantalla.
| def texto_pantalla_rect(texto,fuente,coloracio,pantalla,x,y):
"""Muestra el texto en pantalla
Parametros:
texto (str): El texto a mostrar.
fuente (pygame.font): Fuente del texto.
coloracio (int/rgb): Color del texto.
pantalla (pygame.display): Pantalla pygame donde se ubicará el texto.
x (int): Valor en el eje X de la pantalla.
y (int): Valor en el eje Y de la pantalla.
"""
objetoTXT = fuente.render(texto, 1, coloracio)
rectTXT = objetoTXT.get_rect()
rectTXT.topleft = (x, y)
pantalla.blit(objetoTXT, rectTXT) | [
"def",
"texto_pantalla_rect",
"(",
"texto",
",",
"fuente",
",",
"coloracio",
",",
"pantalla",
",",
"x",
",",
"y",
")",
":",
"objetoTXT",
"=",
"fuente",
".",
"render",
"(",
"texto",
",",
"1",
",",
"coloracio",
")",
"rectTXT",
"=",
"objetoTXT",
".",
"get_rect",
"(",
")",
"rectTXT",
".",
"topleft",
"=",
"(",
"x",
",",
"y",
")",
"pantalla",
".",
"blit",
"(",
"objetoTXT",
",",
"rectTXT",
")"
] | [
16,
4
] | [
30,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
contar_impares | (arr: List[int]) | return len([x for x in arr if x % 2 != 0]) | Determina la cantidad de números impares en una lista.
:param arr: Lista de números enteros.
:arr type: List[int]
:return: Cantidad de números impares en la lista.
:rtype: int
| Determina la cantidad de números impares en una lista. | def contar_impares(arr: List[int]) -> int: # helper function
"""Determina la cantidad de números impares en una lista.
:param arr: Lista de números enteros.
:arr type: List[int]
:return: Cantidad de números impares en la lista.
:rtype: int
"""
return len([x for x in arr if x % 2 != 0]) | [
"def",
"contar_impares",
"(",
"arr",
":",
"List",
"[",
"int",
"]",
")",
"->",
"int",
":",
"# helper function",
"return",
"len",
"(",
"[",
"x",
"for",
"x",
"in",
"arr",
"if",
"x",
"%",
"2",
"!=",
"0",
"]",
")"
] | [
31,
0
] | [
39,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
verifica_docente_asignado_a_curso | (id_curso: Union[None, str] = None) | Si el usuario no esta asignado como docente al curso devuelve None. | Si el usuario no esta asignado como docente al curso devuelve None. | def verifica_docente_asignado_a_curso(id_curso: Union[None, str] = None):
"""Si el usuario no esta asignado como docente al curso devuelve None."""
if current_user.is_authenticated:
return DocenteCurso.query.filter(DocenteCurso.usuario == current_user.usuario, DocenteCurso.curso == id_curso)
else:
return False | [
"def",
"verifica_docente_asignado_a_curso",
"(",
"id_curso",
":",
"Union",
"[",
"None",
",",
"str",
"]",
"=",
"None",
")",
":",
"if",
"current_user",
".",
"is_authenticated",
":",
"return",
"DocenteCurso",
".",
"query",
".",
"filter",
"(",
"DocenteCurso",
".",
"usuario",
"==",
"current_user",
".",
"usuario",
",",
"DocenteCurso",
".",
"curso",
"==",
"id_curso",
")",
"else",
":",
"return",
"False"
] | [
243,
0
] | [
248,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Simulador.tiempo_restante | (self) | return tiempo_restante.total_seconds() | Tiempo restante del vuelo en segundos. | Tiempo restante del vuelo en segundos. | def tiempo_restante(self):
"""Tiempo restante del vuelo en segundos."""
tiempo_actual = datetime.fromtimestamp(time.time())
tiempo_restante = self.tiempo_fin - tiempo_actual
return tiempo_restante.total_seconds() | [
"def",
"tiempo_restante",
"(",
"self",
")",
":",
"tiempo_actual",
"=",
"datetime",
".",
"fromtimestamp",
"(",
"time",
".",
"time",
"(",
")",
")",
"tiempo_restante",
"=",
"self",
".",
"tiempo_fin",
"-",
"tiempo_actual",
"return",
"tiempo_restante",
".",
"total_seconds",
"(",
")"
] | [
76,
4
] | [
80,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraLiborScraperTestCase.test_fetch_content_with_invalid_dates | (self) | comprueba, dependiendo de un rango invalido de fechas,
que el contenido esté vacío. | comprueba, dependiendo de un rango invalido de fechas,
que el contenido esté vacío. | def test_fetch_content_with_invalid_dates(self):
"""comprueba, dependiendo de un rango invalido de fechas,
que el contenido esté vacío."""
url = "http://www.bcra.gov.ar/PublicacionesEstadisticas/libor.asp"
rates = {
"30": "libor_30_dias",
"60": "libor_60_dias",
"90": "libor_90_dias",
"180": "libor_180_dias",
"360": "libor_360_dias"
}
scraper = BCRALiborScraper(url, rates, intermediate_panel_path=None, use_intermediate_panel=False)
start_day = date(2019, 3, 10)
end_day = date(2019, 3, 4)
contents = scraper.fetch_contents(start_day, end_day)
assert contents == [] | [
"def",
"test_fetch_content_with_invalid_dates",
"(",
"self",
")",
":",
"url",
"=",
"\"http://www.bcra.gov.ar/PublicacionesEstadisticas/libor.asp\"",
"rates",
"=",
"{",
"\"30\"",
":",
"\"libor_30_dias\"",
",",
"\"60\"",
":",
"\"libor_60_dias\"",
",",
"\"90\"",
":",
"\"libor_90_dias\"",
",",
"\"180\"",
":",
"\"libor_180_dias\"",
",",
"\"360\"",
":",
"\"libor_360_dias\"",
"}",
"scraper",
"=",
"BCRALiborScraper",
"(",
"url",
",",
"rates",
",",
"intermediate_panel_path",
"=",
"None",
",",
"use_intermediate_panel",
"=",
"False",
")",
"start_day",
"=",
"date",
"(",
"2019",
",",
"3",
",",
"10",
")",
"end_day",
"=",
"date",
"(",
"2019",
",",
"3",
",",
"4",
")",
"contents",
"=",
"scraper",
".",
"fetch_contents",
"(",
"start_day",
",",
"end_day",
")",
"assert",
"contents",
"==",
"[",
"]"
] | [
61,
4
] | [
80,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Estante.__iter__ | (self) | return iter(self.dic.keys()) | Retorna un iterador en base a las claves del archivo shelve. | Retorna un iterador en base a las claves del archivo shelve. | def __iter__(self):
"""Retorna un iterador en base a las claves del archivo shelve."""
return iter(self.dic.keys()) | [
"def",
"__iter__",
"(",
"self",
")",
":",
"return",
"iter",
"(",
"self",
".",
"dic",
".",
"keys",
"(",
")",
")"
] | [
41,
4
] | [
43,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Matrix.__repr__ | (self) | return out | Metodo para representar la matriz de una manera facil de entender. | Metodo para representar la matriz de una manera facil de entender. | def __repr__(self):
""" Metodo para representar la matriz de una manera facil de entender. """
c = len(self)
f = len(self[0])
out = "\t"
for y in xrange(f):
for x in xrange(c):
out += str(round(self[x][y], 5)) + "\t"
out += "\n\t"
return out | [
"def",
"__repr__",
"(",
"self",
")",
":",
"c",
"=",
"len",
"(",
"self",
")",
"f",
"=",
"len",
"(",
"self",
"[",
"0",
"]",
")",
"out",
"=",
"\"\\t\"",
"for",
"y",
"in",
"xrange",
"(",
"f",
")",
":",
"for",
"x",
"in",
"xrange",
"(",
"c",
")",
":",
"out",
"+=",
"str",
"(",
"round",
"(",
"self",
"[",
"x",
"]",
"[",
"y",
"]",
",",
"5",
")",
")",
"+",
"\"\\t\"",
"out",
"+=",
"\"\\n\\t\"",
"return",
"out"
] | [
5,
4
] | [
14,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
comprobar | (cad) | funcion destinada a comprobar que sólo se introducen letras y espacios para
los nombres | funcion destinada a comprobar que sólo se introducen letras y espacios para
los nombres | def comprobar(cad):
"""funcion destinada a comprobar que sólo se introducen letras y espacios para
los nombres"""
list2 = cad.split()
if len (list2) > 0:
for i in range(0, len(list2)):
if list2[i].isalpha()==False:
return False
return True
else:
return False | [
"def",
"comprobar",
"(",
"cad",
")",
":",
"list2",
"=",
"cad",
".",
"split",
"(",
")",
"if",
"len",
"(",
"list2",
")",
">",
"0",
":",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"list2",
")",
")",
":",
"if",
"list2",
"[",
"i",
"]",
".",
"isalpha",
"(",
")",
"==",
"False",
":",
"return",
"False",
"return",
"True",
"else",
":",
"return",
"False"
] | [
18,
0
] | [
28,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_parametros_funciones | (t) | parametro : lista_funciones | parametro : lista_funciones | def p_parametros_funciones(t) :
'parametro : lista_funciones'
t[0] = t[1] | [
"def",
"p_parametros_funciones",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
377,
0
] | [
379,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_opcion6 | (t) | opcion : CONSTRAINT ID UNIQUE
| opcion : CONSTRAINT ID UNIQUE
| def p_opcion6(t):
'''opcion : CONSTRAINT ID UNIQUE
''' | [
"def",
"p_opcion6",
"(",
"t",
")",
":"
] | [
1016,
0
] | [
1018,
7
] | 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.