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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
p_funciones36 | (p) | funciones : ABS PABRE expresion PCIERRA | funciones : ABS PABRE expresion PCIERRA | def p_funciones36(p):
'funciones : ABS PABRE expresion PCIERRA' | [
"def",
"p_funciones36",
"(",
"p",
")",
":"
] | [
406,
0
] | [
407,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Dominio.generar | (self) | Construye una estructura de datos que representa una posible solución al problema.
Entradas:
ninguna
Salidas:
Una estructura de datos que representa una posible solución válida al problema
| Construye una estructura de datos que representa una posible solución al problema. | def generar(self):
"""Construye una estructura de datos que representa una posible solución al problema.
Entradas:
ninguna
Salidas:
Una estructura de datos que representa una posible solución válida al problema
"""
pass | [
"def",
"generar",
"(",
"self",
")",
":",
"pass"
] | [
29,
4
] | [
39,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
derivar | (update, context) | Toma la función base y muestra su derivada | Toma la función base y muestra su derivada | def derivar(update, context):
""" Toma la función base y muestra su derivada """
#se declara un diccionario de patrones para contrastar la funcion recibida
patron_funciones = {
'^[0-9]+$': '0',
'x$': '1',
'^[0-9]+x$': 'kx',
}
#Tomamos el primer argumento que se le pasa al comando como función f(x)
funcion = context.args[0]
resultado = None
for key in patron_funciones.keys():
#compilamos el patron de esta entrada particular del diccionario para compararlo con la funcion recibida
#y guardamos el resultado en la variable match
regex_matcher = re.compile(key)
match = regex_matcher.match(funcion)
#si hubo una coincidencia, guardamos en la variable resultado el valor asociado a esa clave en el diccionario
#devolvemos resultado y detenemos el ciclo for
if match:
resultado = patron_funciones.get(key)
break
# Si encuentra una coincidencia usa la API de Latex2PNG
if(resultado):
if(resultado == 'kx'):
r = re.compile("([0-9]+)(x)")
m = r.match(funcion)
resultado = m.group(1)
# Data para mandar a la API de latex2png
payload = "{\n\"auth\": {\n\"user\": \"guest\",\n\"password\": \"guest\"\n},\n\"latex\": \"%(latex)s\" ,\n\"resolution\": 600,\n\"color\": \"111111\"\n}"%{'latex': resultado}
# Headers del Request
headers = {
'Content-Type': 'application/json'
}
r = requests.request("POST", 'http://latex2png.com/api/convert', headers=headers, data=payload)
json_response = r.json()
img_url = json_response["url"]
update.message.reply_photo('http://latex2png.com' + img_url)
else:
update.message.reply_text('No encontré una función base que coincida con '+ context.args[0]) | [
"def",
"derivar",
"(",
"update",
",",
"context",
")",
":",
"#se declara un diccionario de patrones para contrastar la funcion recibida",
"patron_funciones",
"=",
"{",
"'^[0-9]+$'",
":",
"'0'",
",",
"'x$'",
":",
"'1'",
",",
"'^[0-9]+x$'",
":",
"'kx'",
",",
"}",
"#Tomamos el primer argumento que se le pasa al comando como función f(x)",
"funcion",
"=",
"context",
".",
"args",
"[",
"0",
"]",
"resultado",
"=",
"None",
"for",
"key",
"in",
"patron_funciones",
".",
"keys",
"(",
")",
":",
"#compilamos el patron de esta entrada particular del diccionario para compararlo con la funcion recibida",
"#y guardamos el resultado en la variable match",
"regex_matcher",
"=",
"re",
".",
"compile",
"(",
"key",
")",
"match",
"=",
"regex_matcher",
".",
"match",
"(",
"funcion",
")",
"#si hubo una coincidencia, guardamos en la variable resultado el valor asociado a esa clave en el diccionario",
"#devolvemos resultado y detenemos el ciclo for",
"if",
"match",
":",
"resultado",
"=",
"patron_funciones",
".",
"get",
"(",
"key",
")",
"break",
"# Si encuentra una coincidencia usa la API de Latex2PNG",
"if",
"(",
"resultado",
")",
":",
"if",
"(",
"resultado",
"==",
"'kx'",
")",
":",
"r",
"=",
"re",
".",
"compile",
"(",
"\"([0-9]+)(x)\"",
")",
"m",
"=",
"r",
".",
"match",
"(",
"funcion",
")",
"resultado",
"=",
"m",
".",
"group",
"(",
"1",
")",
"# Data para mandar a la API de latex2png",
"payload",
"=",
"\"{\\n\\\"auth\\\": {\\n\\\"user\\\": \\\"guest\\\",\\n\\\"password\\\": \\\"guest\\\"\\n},\\n\\\"latex\\\": \\\"%(latex)s\\\" ,\\n\\\"resolution\\\": 600,\\n\\\"color\\\": \\\"111111\\\"\\n}\"",
"%",
"{",
"'latex'",
":",
"resultado",
"}",
"# Headers del Request",
"headers",
"=",
"{",
"'Content-Type'",
":",
"'application/json'",
"}",
"r",
"=",
"requests",
".",
"request",
"(",
"\"POST\"",
",",
"'http://latex2png.com/api/convert'",
",",
"headers",
"=",
"headers",
",",
"data",
"=",
"payload",
")",
"json_response",
"=",
"r",
".",
"json",
"(",
")",
"img_url",
"=",
"json_response",
"[",
"\"url\"",
"]",
"update",
".",
"message",
".",
"reply_photo",
"(",
"'http://latex2png.com'",
"+",
"img_url",
")",
"else",
":",
"update",
".",
"message",
".",
"reply_text",
"(",
"'No encontré una función base que coincida con '+ ",
"c",
"ntext.a",
"r",
"gs[0",
"]",
")",
"",
""
] | [
58,
0
] | [
104,
102
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones_string3 | (t) | funciones_string3 : get_byte
| encode | funciones_string3 : get_byte
| encode | def p_funciones_string3(t):
'''funciones_string3 : get_byte
| encode'''
node= grammer.nodoDireccion('funciones_string1')
node1= grammer.nodoDireccion(t[1])
node.agregar(node1)
t[0]= node | [
"def",
"p_funciones_string3",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'funciones_string1'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1989,
0
] | [
1995,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_funcion_width_bucket | (t) | lista_funciones : WIDTH_BUCKET PARIZQ funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro PARDER | lista_funciones : WIDTH_BUCKET PARIZQ funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro PARDER | def p_instrucciones_funcion_width_bucket(t) :
'lista_funciones : WIDTH_BUCKET PARIZQ funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro COMA funcion_math_parametro PARDER' | [
"def",
"p_instrucciones_funcion_width_bucket",
"(",
"t",
")",
":"
] | [
939,
0
] | [
940,
160
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
evalTrajectory | (individual) | return R, | Función objetivo, calcula la distancia que recorre el viajante | Función objetivo, calcula la distancia que recorre el viajante | def evalTrajectory(individual):
""" Función objetivo, calcula la distancia que recorre el viajante"""
# distancia entre el último elemento y el primero
env.reset()
R = 0
for t in range(0,len(individual), NUM_OF_AGENTS):
_, reward = env.step(individual[t: t+NUM_OF_AGENTS])
R += np.sum(reward)
return R, | [
"def",
"evalTrajectory",
"(",
"individual",
")",
":",
"# distancia entre el último elemento y el primero",
"env",
".",
"reset",
"(",
")",
"R",
"=",
"0",
"for",
"t",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"individual",
")",
",",
"NUM_OF_AGENTS",
")",
":",
"_",
",",
"reward",
"=",
"env",
".",
"step",
"(",
"individual",
"[",
"t",
":",
"t",
"+",
"NUM_OF_AGENTS",
"]",
")",
"R",
"+=",
"np",
".",
"sum",
"(",
"reward",
")",
"return",
"R",
","
] | [
70,
0
] | [
81,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_create_opciones | (t) | create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones | create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones | def p_create_opciones(t):
'''create_opciones : OWNER SIGNO_IGUAL ID create_opciones
| MODE SIGNO_IGUAL NUMERO create_opciones''' | [
"def",
"p_create_opciones",
"(",
"t",
")",
":"
] | [
311,
0
] | [
313,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AdministrativosTest.test_centro_salud_permitido | (self) | Usuario `administrativo1` solo puede ver el centro de salud que se le asignó | Usuario `administrativo1` solo puede ver el centro de salud que se le asignó | def test_centro_salud_permitido(self):
''' Usuario `administrativo1` solo puede ver el centro de salud que se le asignó '''
self.client.login(username=self.user_admin_1, password=self.user_admin_1)
response = self.client.get('/turnos/')
# Sacar CS permitidos del context (list)
CS_Permitidos = response.context['user__centros_de_salud_autorizados']
self.assertTrue(len(CS_Permitidos) == 1)
self.assertEqual('Centro de Salud 1', CS_Permitidos[0].nombre) | [
"def",
"test_centro_salud_permitido",
"(",
"self",
")",
":",
"self",
".",
"client",
".",
"login",
"(",
"username",
"=",
"self",
".",
"user_admin_1",
",",
"password",
"=",
"self",
".",
"user_admin_1",
")",
"response",
"=",
"self",
".",
"client",
".",
"get",
"(",
"'/turnos/'",
")",
"# Sacar CS permitidos del context (list)",
"CS_Permitidos",
"=",
"response",
".",
"context",
"[",
"'user__centros_de_salud_autorizados'",
"]",
"self",
".",
"assertTrue",
"(",
"len",
"(",
"CS_Permitidos",
")",
"==",
"1",
")",
"self",
".",
"assertEqual",
"(",
"'Centro de Salud 1'",
",",
"CS_Permitidos",
"[",
"0",
"]",
".",
"nombre",
")"
] | [
39,
4
] | [
50,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
doc_file_to_link | (doc_name, doc_file, path) | return f'<a href="{path + doc_file}" target="_blank">{doc_name}</a>' | **Función que liga el nombre de un documento con su archivo pdf**
:param doc_name: Nombre del documento
:type: str
:param doc_file: Nombre del archivo
:type: str
:param path: Path donde se encuentran los pdfs
:type: str
:return: Nombre del documento con la liga al pdf
:rtype: str
| **Función que liga el nombre de un documento con su archivo pdf** | def doc_file_to_link(doc_name, doc_file, path):
"""**Función que liga el nombre de un documento con su archivo pdf**
:param doc_name: Nombre del documento
:type: str
:param doc_file: Nombre del archivo
:type: str
:param path: Path donde se encuentran los pdfs
:type: str
:return: Nombre del documento con la liga al pdf
:rtype: str
"""
return f'<a href="{path + doc_file}" target="_blank">{doc_name}</a>' | [
"def",
"doc_file_to_link",
"(",
"doc_name",
",",
"doc_file",
",",
"path",
")",
":",
"return",
"f'<a href=\"{path + doc_file}\" target=\"_blank\">{doc_name}</a>'"
] | [
145,
0
] | [
157,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_funciones_math_esenciales | (t) | 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 | 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_instrucciones_funciones_math_esenciales(t) :
'''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_instrucciones_funciones_math_esenciales",
"(",
"t",
")",
":"
] | [
579,
0
] | [
582,
102
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ObjectTracker.run | (self) | Ejecuta el algoritmo de seguimiento y calcula el registro de seguimiento de los objetos.
| Ejecuta el algoritmo de seguimiento y calcula el registro de seguimiento de los objetos.
| def run(self) -> None:
"""Ejecuta el algoritmo de seguimiento y calcula el registro de seguimiento de los objetos.
"""
self._algorithm() | [
"def",
"run",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"_algorithm",
"(",
")"
] | [
60,
4
] | [
63,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Simulador.vel | (self) | return uniform(self.velocidad - 0.1, self.velocidad + 0.1) | Velocidad del avión en metros por segundo. | Velocidad del avión en metros por segundo. | def vel(self):
"""Velocidad del avión en metros por segundo."""
return uniform(self.velocidad - 0.1, self.velocidad + 0.1) | [
"def",
"vel",
"(",
"self",
")",
":",
"return",
"uniform",
"(",
"self",
".",
"velocidad",
"-",
"0.1",
",",
"self",
".",
"velocidad",
"+",
"0.1",
")"
] | [
115,
4
] | [
117,
66
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
InstantaneousVelocityWithKernelRegression.calculate_velocities | (self, tracked_object: TrackedObject) | return velocities | Realiza el cálculo de las velocidades y aplica un suavizado con regresión por kernels.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
| Realiza el cálculo de las velocidades y aplica un suavizado con regresión por kernels. | def calculate_velocities(self, tracked_object: TrackedObject) -> List[FloatVector2D]:
"""Realiza el cálculo de las velocidades y aplica un suavizado con regresión por kernels.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
"""
# Variables observadas.
frames = tracked_object.frames
positions = [self.get_object_point(detection) for detection in tracked_object.detections]
# Variables para el cálculo con el estimador de Nadaraya-Watson.
ts = np.array(frames)
xs = np.array(positions)
# Variables del modelo.
kernel = self.kernel
kernel_derivated = self.kernel_derivated
h = self.bandwidth
# Calcular los vectores de velocidad.
velocities = list()
for t in ts:
# i-índices.
indexes = range(0, len(ts))
# Calcular el numerador y denominador por partes.
ks = [kernel(t, ts[i], h) for i in indexes]
kds = [kernel_derivated(t, ts[i], h) for i in indexes]
n1 = np.array([kds[i] * xs[i] for i in indexes]).sum(axis=0)
n2 = np.array([ks[i] for i in indexes]).sum()
n3 = np.array([kds[i] for i in indexes]).sum()
n4 = np.array([ks[i] * xs[i] for i in indexes]).sum(axis=0)
# Cálculo del vector de velocidad.
v = (n1 * n2 - n3 * n4) / (n2 ** 2)
# Convertir las unidades a las indicadas al instanciar la c.ase
v = self.convert_velocity_from_pixels_frames(FloatVector2D(*v))
# Añadir a la lista.
velocities.append(v)
# Eliminar las estimaciones de los extremos producidos por la derivada de N-W.
num_estimations_to_remove = int(2 * np.sqrt(h))
velocities = velocities[num_estimations_to_remove:-num_estimations_to_remove+1]
return velocities | [
"def",
"calculate_velocities",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
")",
"->",
"List",
"[",
"FloatVector2D",
"]",
":",
"# Variables observadas.",
"frames",
"=",
"tracked_object",
".",
"frames",
"positions",
"=",
"[",
"self",
".",
"get_object_point",
"(",
"detection",
")",
"for",
"detection",
"in",
"tracked_object",
".",
"detections",
"]",
"# Variables para el cálculo con el estimador de Nadaraya-Watson.",
"ts",
"=",
"np",
".",
"array",
"(",
"frames",
")",
"xs",
"=",
"np",
".",
"array",
"(",
"positions",
")",
"# Variables del modelo.",
"kernel",
"=",
"self",
".",
"kernel",
"kernel_derivated",
"=",
"self",
".",
"kernel_derivated",
"h",
"=",
"self",
".",
"bandwidth",
"# Calcular los vectores de velocidad.",
"velocities",
"=",
"list",
"(",
")",
"for",
"t",
"in",
"ts",
":",
"# i-índices.",
"indexes",
"=",
"range",
"(",
"0",
",",
"len",
"(",
"ts",
")",
")",
"# Calcular el numerador y denominador por partes.",
"ks",
"=",
"[",
"kernel",
"(",
"t",
",",
"ts",
"[",
"i",
"]",
",",
"h",
")",
"for",
"i",
"in",
"indexes",
"]",
"kds",
"=",
"[",
"kernel_derivated",
"(",
"t",
",",
"ts",
"[",
"i",
"]",
",",
"h",
")",
"for",
"i",
"in",
"indexes",
"]",
"n1",
"=",
"np",
".",
"array",
"(",
"[",
"kds",
"[",
"i",
"]",
"*",
"xs",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
"axis",
"=",
"0",
")",
"n2",
"=",
"np",
".",
"array",
"(",
"[",
"ks",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
")",
"n3",
"=",
"np",
".",
"array",
"(",
"[",
"kds",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
")",
"n4",
"=",
"np",
".",
"array",
"(",
"[",
"ks",
"[",
"i",
"]",
"*",
"xs",
"[",
"i",
"]",
"for",
"i",
"in",
"indexes",
"]",
")",
".",
"sum",
"(",
"axis",
"=",
"0",
")",
"# Cálculo del vector de velocidad.",
"v",
"=",
"(",
"n1",
"*",
"n2",
"-",
"n3",
"*",
"n4",
")",
"/",
"(",
"n2",
"**",
"2",
")",
"# Convertir las unidades a las indicadas al instanciar la c.ase",
"v",
"=",
"self",
".",
"convert_velocity_from_pixels_frames",
"(",
"FloatVector2D",
"(",
"*",
"v",
")",
")",
"# Añadir a la lista.",
"velocities",
".",
"append",
"(",
"v",
")",
"# Eliminar las estimaciones de los extremos producidos por la derivada de N-W.",
"num_estimations_to_remove",
"=",
"int",
"(",
"2",
"*",
"np",
".",
"sqrt",
"(",
"h",
")",
")",
"velocities",
"=",
"velocities",
"[",
"num_estimations_to_remove",
":",
"-",
"num_estimations_to_remove",
"+",
"1",
"]",
"return",
"velocities"
] | [
66,
4
] | [
103,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DNARecord.get_kmers | (self, k) | Obtiene los kmers de una secuencia dada una longitud k. | Obtiene los kmers de una secuencia dada una longitud k. | def get_kmers(self, k):
"""Obtiene los kmers de una secuencia dada una longitud k."""
# Obtener k y longitud
k = str(k)
length = len(self.seq)
# Verificar si es digito
if k.isdigit():
k = int(k)
# Verificar si esta dentro de los limites
if 0 < k <= length:
# Obtener kmers
kmers = [self.seq[i: i + k] for i in range(0, len(self.seq) - k + 1)]
return kmers
else:
raise ValueError(f"La longitud de k = {k} es igual a cero o mayor a la longitud "
f"de la secuencia")
else:
raise TypeError(f"La longitud de k = '{k}' no es valida") | [
"def",
"get_kmers",
"(",
"self",
",",
"k",
")",
":",
"# Obtener k y longitud",
"k",
"=",
"str",
"(",
"k",
")",
"length",
"=",
"len",
"(",
"self",
".",
"seq",
")",
"# Verificar si es digito",
"if",
"k",
".",
"isdigit",
"(",
")",
":",
"k",
"=",
"int",
"(",
"k",
")",
"# Verificar si esta dentro de los limites",
"if",
"0",
"<",
"k",
"<=",
"length",
":",
"# Obtener kmers",
"kmers",
"=",
"[",
"self",
".",
"seq",
"[",
"i",
":",
"i",
"+",
"k",
"]",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"self",
".",
"seq",
")",
"-",
"k",
"+",
"1",
")",
"]",
"return",
"kmers",
"else",
":",
"raise",
"ValueError",
"(",
"f\"La longitud de k = {k} es igual a cero o mayor a la longitud \"",
"f\"de la secuencia\"",
")",
"else",
":",
"raise",
"TypeError",
"(",
"f\"La longitud de k = '{k}' no es valida\"",
")"
] | [
65,
4
] | [
82,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
planilla.abrir_datos | (self) | Abrir un archivo que tiene guardada la info [key], [Val[0]],[Val[1] ... ] | Abrir un archivo que tiene guardada la info [key], [Val[0]],[Val[1] ... ] | def abrir_datos(self): # nombre, alias, correo
"Abrir un archivo que tiene guardada la info [key], [Val[0]],[Val[1] ... ]"
vec =[]
dicc = {}
f = open(input("nombre")+'.txt', 'rt')
for line in f:
vec=line.strip('\n').split(', ')
dicc[str(vec[0])]=list(vec[1:])
f.close()
print(dicc)
self.Planilla_=dict(dicc) | [
"def",
"abrir_datos",
"(",
"self",
")",
":",
"# nombre, alias, correo",
"vec",
"=",
"[",
"]",
"dicc",
"=",
"{",
"}",
"f",
"=",
"open",
"(",
"input",
"(",
"\"nombre\"",
")",
"+",
"'.txt'",
",",
"'rt'",
")",
"for",
"line",
"in",
"f",
":",
"vec",
"=",
"line",
".",
"strip",
"(",
"'\\n'",
")",
".",
"split",
"(",
"', '",
")",
"dicc",
"[",
"str",
"(",
"vec",
"[",
"0",
"]",
")",
"]",
"=",
"list",
"(",
"vec",
"[",
"1",
":",
"]",
")",
"f",
".",
"close",
"(",
")",
"print",
"(",
"dicc",
")",
"self",
".",
"Planilla_",
"=",
"dict",
"(",
"dicc",
")"
] | [
57,
4
] | [
67,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BcraExchangeRateTestCase.test_exchange_rates_configuration_has_url | (self) | Validar la existencia de la clave url dentro de
la configuración de exchange-rates | Validar la existencia de la clave url dentro de
la configuración de exchange-rates | def test_exchange_rates_configuration_has_url(self):
"""Validar la existencia de la clave url dentro de
la configuración de exchange-rates"""
dict_config = {'exchange-rates': {'foo': 'bar'}}
with mock.patch(
'builtins.open',
return_value=io.StringIO(json.dumps(dict_config))
):
with self.assertRaises(InvalidConfigurationError):
config = read_config("config_general.json", "exchange-rates")
validate_url_config(config) | [
"def",
"test_exchange_rates_configuration_has_url",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'exchange-rates'",
":",
"{",
"'foo'",
":",
"'bar'",
"}",
"}",
"with",
"mock",
".",
"patch",
"(",
"'builtins.open'",
",",
"return_value",
"=",
"io",
".",
"StringIO",
"(",
"json",
".",
"dumps",
"(",
"dict_config",
")",
")",
")",
":",
"with",
"self",
".",
"assertRaises",
"(",
"InvalidConfigurationError",
")",
":",
"config",
"=",
"read_config",
"(",
"\"config_general.json\"",
",",
"\"exchange-rates\"",
")",
"validate_url_config",
"(",
"config",
")"
] | [
417,
4
] | [
429,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AccountPartialReconcile.create | (self, vals) | return super().create(vals) | ademas de mandar en el contexto en el metodo reconcile, hacemos
que el partial reconcile que crea el metodo auto_reconcile_lines
no tenga moneda en la misma situación (podriamos ).
Va de la mano de la modificacion de "def reconcile" en aml
| ademas de mandar en el contexto en el metodo reconcile, hacemos
que el partial reconcile que crea el metodo auto_reconcile_lines
no tenga moneda en la misma situación (podriamos ).
Va de la mano de la modificacion de "def reconcile" en aml
| def create(self, vals):
""" ademas de mandar en el contexto en el metodo reconcile, hacemos
que el partial reconcile que crea el metodo auto_reconcile_lines
no tenga moneda en la misma situación (podriamos ).
Va de la mano de la modificacion de "def reconcile" en aml
"""
if vals.get('currency_id'):
account = self.env['account.move.line'].browse(vals.get('debit_move_id')).account_id
if account.company_id.country_id == self.env.ref('base.ar') and not account.currency_id:
vals.update({'currency_id': False, 'amount_currency': 0.0})
return super().create(vals) | [
"def",
"create",
"(",
"self",
",",
"vals",
")",
":",
"if",
"vals",
".",
"get",
"(",
"'currency_id'",
")",
":",
"account",
"=",
"self",
".",
"env",
"[",
"'account.move.line'",
"]",
".",
"browse",
"(",
"vals",
".",
"get",
"(",
"'debit_move_id'",
")",
")",
".",
"account_id",
"if",
"account",
".",
"company_id",
".",
"country_id",
"==",
"self",
".",
"env",
".",
"ref",
"(",
"'base.ar'",
")",
"and",
"not",
"account",
".",
"currency_id",
":",
"vals",
".",
"update",
"(",
"{",
"'currency_id'",
":",
"False",
",",
"'amount_currency'",
":",
"0.0",
"}",
")",
"return",
"super",
"(",
")",
".",
"create",
"(",
"vals",
")"
] | [
7,
4
] | [
17,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
calcular_vulnerabilidad_urbana | (inicio, fin, min_casos=20, min_defunciones=0) | return modelos_df, resultados_df | Ajustar un modelo para los municipios urbanos y otro para los no urbanos | Ajustar un modelo para los municipios urbanos y otro para los no urbanos | def calcular_vulnerabilidad_urbana(inicio, fin, min_casos=20, min_defunciones=0):
''' Ajustar un modelo para los municipios urbanos y otro para los no urbanos '''
inicio = pd.to_datetime(inicio, yearfirst=True)
fin = pd.to_datetime(fin, yearfirst=True)
fechas = pd.date_range(inicio, fin)
resultados = []
modelos = []
asegura_archivos_covid_disponibles(fechas)
f = IntProgress(min=0, max=len(fechas) - 1) # instantiate the bar
display(f) # display the bar
urbanos = municipios_urbanos()
for count, fecha in enumerate(fechas):
covid_municipal = tabla_covid_indicadores_municipales(fecha.strftime("%y%m%d"))
covid_municipal = agregar_tasas_municipales(covid_municipal)
caracteristicas = caracteristicas_modelos_municipios(covid_municipal)
serie_urbanos = covid_municipal[covid_municipal.CLAVE_MUNICIPIO_RES.isin(urbanos.CLAVE_MUNICIPIO)]
pls_urbanos = ajustar_pls_letalidad(serie_urbanos, caracteristicas,
min_defunciones=min_defunciones, min_casos=min_casos)
df_urbanos = calificar_municipios_letalidad_formato_largo(serie_urbanos,
pls_urbanos,
caracteristicas,
modelo='PLS_URBANO',
dia_ajuste=fecha)
resultados.append(df_urbanos)
modelo = pd.DataFrame({'caracteristica': caracteristicas,
'coef': pls_urbanos.coef_})
modelo['dia_ajuste'] = fecha
modelo['modelo'] = 'PLS_URBANO'
modelos.append(modelo)
serie_no_urbanos = covid_municipal[~covid_municipal.CLAVE_MUNICIPIO_RES.isin(urbanos.CLAVE_MUNICIPIO)]
pls_no_urbanos = ajustar_pls_letalidad(serie_no_urbanos, caracteristicas,
min_defunciones=min_defunciones, min_casos=min_casos)
df_no_urbanos = calificar_municipios_letalidad_formato_largo(serie_no_urbanos,
pls_no_urbanos,
caracteristicas,
modelo='PLS_NO_URBANO',
dia_ajuste=fecha)
resultados.append(df_no_urbanos)
modelo = pd.DataFrame({'caracteristica': caracteristicas, 'coef': pls_no_urbanos.coef_})
modelo['dia_ajuste'] = fecha
modelo['modelo'] = 'PLS_NO_URBANO'
modelos.append(modelo)
f.value = count
resultados_df = pd.concat(resultados, ignore_index=True)
modelos_df = pd.concat(modelos, ignore_index=True)
return modelos_df, resultados_df | [
"def",
"calcular_vulnerabilidad_urbana",
"(",
"inicio",
",",
"fin",
",",
"min_casos",
"=",
"20",
",",
"min_defunciones",
"=",
"0",
")",
":",
"inicio",
"=",
"pd",
".",
"to_datetime",
"(",
"inicio",
",",
"yearfirst",
"=",
"True",
")",
"fin",
"=",
"pd",
".",
"to_datetime",
"(",
"fin",
",",
"yearfirst",
"=",
"True",
")",
"fechas",
"=",
"pd",
".",
"date_range",
"(",
"inicio",
",",
"fin",
")",
"resultados",
"=",
"[",
"]",
"modelos",
"=",
"[",
"]",
"asegura_archivos_covid_disponibles",
"(",
"fechas",
")",
"f",
"=",
"IntProgress",
"(",
"min",
"=",
"0",
",",
"max",
"=",
"len",
"(",
"fechas",
")",
"-",
"1",
")",
"# instantiate the bar",
"display",
"(",
"f",
")",
"# display the bar",
"urbanos",
"=",
"municipios_urbanos",
"(",
")",
"for",
"count",
",",
"fecha",
"in",
"enumerate",
"(",
"fechas",
")",
":",
"covid_municipal",
"=",
"tabla_covid_indicadores_municipales",
"(",
"fecha",
".",
"strftime",
"(",
"\"%y%m%d\"",
")",
")",
"covid_municipal",
"=",
"agregar_tasas_municipales",
"(",
"covid_municipal",
")",
"caracteristicas",
"=",
"caracteristicas_modelos_municipios",
"(",
"covid_municipal",
")",
"serie_urbanos",
"=",
"covid_municipal",
"[",
"covid_municipal",
".",
"CLAVE_MUNICIPIO_RES",
".",
"isin",
"(",
"urbanos",
".",
"CLAVE_MUNICIPIO",
")",
"]",
"pls_urbanos",
"=",
"ajustar_pls_letalidad",
"(",
"serie_urbanos",
",",
"caracteristicas",
",",
"min_defunciones",
"=",
"min_defunciones",
",",
"min_casos",
"=",
"min_casos",
")",
"df_urbanos",
"=",
"calificar_municipios_letalidad_formato_largo",
"(",
"serie_urbanos",
",",
"pls_urbanos",
",",
"caracteristicas",
",",
"modelo",
"=",
"'PLS_URBANO'",
",",
"dia_ajuste",
"=",
"fecha",
")",
"resultados",
".",
"append",
"(",
"df_urbanos",
")",
"modelo",
"=",
"pd",
".",
"DataFrame",
"(",
"{",
"'caracteristica'",
":",
"caracteristicas",
",",
"'coef'",
":",
"pls_urbanos",
".",
"coef_",
"}",
")",
"modelo",
"[",
"'dia_ajuste'",
"]",
"=",
"fecha",
"modelo",
"[",
"'modelo'",
"]",
"=",
"'PLS_URBANO'",
"modelos",
".",
"append",
"(",
"modelo",
")",
"serie_no_urbanos",
"=",
"covid_municipal",
"[",
"~",
"covid_municipal",
".",
"CLAVE_MUNICIPIO_RES",
".",
"isin",
"(",
"urbanos",
".",
"CLAVE_MUNICIPIO",
")",
"]",
"pls_no_urbanos",
"=",
"ajustar_pls_letalidad",
"(",
"serie_no_urbanos",
",",
"caracteristicas",
",",
"min_defunciones",
"=",
"min_defunciones",
",",
"min_casos",
"=",
"min_casos",
")",
"df_no_urbanos",
"=",
"calificar_municipios_letalidad_formato_largo",
"(",
"serie_no_urbanos",
",",
"pls_no_urbanos",
",",
"caracteristicas",
",",
"modelo",
"=",
"'PLS_NO_URBANO'",
",",
"dia_ajuste",
"=",
"fecha",
")",
"resultados",
".",
"append",
"(",
"df_no_urbanos",
")",
"modelo",
"=",
"pd",
".",
"DataFrame",
"(",
"{",
"'caracteristica'",
":",
"caracteristicas",
",",
"'coef'",
":",
"pls_no_urbanos",
".",
"coef_",
"}",
")",
"modelo",
"[",
"'dia_ajuste'",
"]",
"=",
"fecha",
"modelo",
"[",
"'modelo'",
"]",
"=",
"'PLS_NO_URBANO'",
"modelos",
".",
"append",
"(",
"modelo",
")",
"f",
".",
"value",
"=",
"count",
"resultados_df",
"=",
"pd",
".",
"concat",
"(",
"resultados",
",",
"ignore_index",
"=",
"True",
")",
"modelos_df",
"=",
"pd",
".",
"concat",
"(",
"modelos",
",",
"ignore_index",
"=",
"True",
")",
"return",
"modelos_df",
",",
"resultados_df"
] | [
387,
0
] | [
443,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Point.move_to | (self, x, y) | Reset x & y coordinates. | Reset x & y coordinates. | def move_to(self, x, y):
"""Reset x & y coordinates."""
self.x = x
self.y = y | [
"def",
"move_to",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"self",
".",
"x",
"=",
"x",
"self",
".",
"y",
"=",
"y"
] | [
488,
4
] | [
491,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
valuesAbove | (data, limit) | return res | Obtiene una lista con los valores mayores al límite.
Args:
data (list): Lista con todos los datos.
limit (same as list data type): Valor sobre el cual se buscan
los datos mayores.
Returns:
list: Valores en _data_ mayores a _limit_
| Obtiene una lista con los valores mayores al límite. | def valuesAbove(data, limit):
"""Obtiene una lista con los valores mayores al límite.
Args:
data (list): Lista con todos los datos.
limit (same as list data type): Valor sobre el cual se buscan
los datos mayores.
Returns:
list: Valores en _data_ mayores a _limit_
"""
res = list()
for i in data:
if i > limit:
res.append(i)
return res | [
"def",
"valuesAbove",
"(",
"data",
",",
"limit",
")",
":",
"res",
"=",
"list",
"(",
")",
"for",
"i",
"in",
"data",
":",
"if",
"i",
">",
"limit",
":",
"res",
".",
"append",
"(",
"i",
")",
"return",
"res"
] | [
109,
0
] | [
126,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
plot_comparativa | (
serie_inicial: List[float],
serie_final: List[float],
ancho_barras: float = 0.35,
) | Muestra una gráfica comparativa de obsolescencia.
:param serie_inicial: Lista de valores iniciales.
:param serie_final: Lista de valores finales.
:serie_inicial type: List[float]
:serie_final type: List[float]
:return: None
| Muestra una gráfica comparativa de obsolescencia. | def plot_comparativa(
serie_inicial: List[float],
serie_final: List[float],
ancho_barras: float = 0.35,
) -> None:
"""Muestra una gráfica comparativa de obsolescencia.
:param serie_inicial: Lista de valores iniciales.
:param serie_final: Lista de valores finales.
:serie_inicial type: List[float]
:serie_final type: List[float]
:return: None
"""
_xticks = tuple([f"Pieza {i}" for i in range(1, len(serie_inicial) + 1)])
numero_de_grupos = len(serie_inicial)
indice_barras = np.arange(numero_de_grupos)
plt.bar(
indice_barras,
serie_inicial,
width=ancho_barras,
label='Precio Inicial',
)
plt.bar(
indice_barras + ancho_barras, serie_final,
width=ancho_barras,
label='Precio final',
)
plt.legend(loc='best')
plt.xticks(indice_barras + ancho_barras, _xticks)
plt.ylabel('Precios')
plt.xlabel('Productos')
plt.title('Comparativa de Obsolescencia')
plt.show() | [
"def",
"plot_comparativa",
"(",
"serie_inicial",
":",
"List",
"[",
"float",
"]",
",",
"serie_final",
":",
"List",
"[",
"float",
"]",
",",
"ancho_barras",
":",
"float",
"=",
"0.35",
",",
")",
"->",
"None",
":",
"_xticks",
"=",
"tuple",
"(",
"[",
"f\"Pieza {i}\"",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"serie_inicial",
")",
"+",
"1",
")",
"]",
")",
"numero_de_grupos",
"=",
"len",
"(",
"serie_inicial",
")",
"indice_barras",
"=",
"np",
".",
"arange",
"(",
"numero_de_grupos",
")",
"plt",
".",
"bar",
"(",
"indice_barras",
",",
"serie_inicial",
",",
"width",
"=",
"ancho_barras",
",",
"label",
"=",
"'Precio Inicial'",
",",
")",
"plt",
".",
"bar",
"(",
"indice_barras",
"+",
"ancho_barras",
",",
"serie_final",
",",
"width",
"=",
"ancho_barras",
",",
"label",
"=",
"'Precio final'",
",",
")",
"plt",
".",
"legend",
"(",
"loc",
"=",
"'best'",
")",
"plt",
".",
"xticks",
"(",
"indice_barras",
"+",
"ancho_barras",
",",
"_xticks",
")",
"plt",
".",
"ylabel",
"(",
"'Precios'",
")",
"plt",
".",
"xlabel",
"(",
"'Productos'",
")",
"plt",
".",
"title",
"(",
"'Comparativa de Obsolescencia'",
")",
"plt",
".",
"show",
"(",
")"
] | [
26,
0
] | [
58,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
HolaViewSet.partial_update | (self, request, pk=None) | return Response({'http_method': 'PATCH'}) | Maneja la actualizacion parcial del objeto por un ID | Maneja la actualizacion parcial del objeto por un ID | def partial_update(self, request, pk=None):
"""Maneja la actualizacion parcial del objeto por un ID"""
return Response({'http_method': 'PATCH'}) | [
"def",
"partial_update",
"(",
"self",
",",
"request",
",",
"pk",
"=",
"None",
")",
":",
"return",
"Response",
"(",
"{",
"'http_method'",
":",
"'PATCH'",
"}",
")"
] | [
90,
4
] | [
92,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
search | (request) | **Realiza la búsqueda y muestra los resultados**
Vista encargada de construir el archivo ``json`` que será mandado al API
de ``Elasticsearch`` para ejecutar la *query*. Posteriorimente preprocesa
la respuesta del API y envía las variables para ser desplegadas en
el template ``sercher.html``. Además, reenvia el formulario con la
información previamente introducida para nuevas búsquedas.
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Resultados de búsqueda y formulario para nuevas búsquedas
| **Realiza la búsqueda y muestra los resultados** | def search(request):
"""**Realiza la búsqueda y muestra los resultados**
Vista encargada de construir el archivo ``json`` que será mandado al API
de ``Elasticsearch`` para ejecutar la *query*. Posteriorimente preprocesa
la respuesta del API y envía las variables para ser desplegadas en
el template ``sercher.html``. Además, reenvia el formulario con la
información previamente introducida para nuevas búsquedas.
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Resultados de búsqueda y formulario para nuevas búsquedas
"""
if request.method == "POST":
# Pasando información al formulario. Esta será reenviada al
# template
form = SearchPostForm(request.POST)
current_variants = get_variants()
if current_variants['status'] == 'success':
del current_variants['status']
if len(current_variants):
form.fields['variante'].choices = current_variants.items()
else:
form.fields['variante'].widget.attrs['disabled'] = True
else:
del current_variants['status']
if form.is_valid():
data_form = form.cleaned_data
user_query = data_form['busqueda']
LOGGER.info("Datos usuaria query={} idioma={} variantes={}".format(
user_query, data_form['idioma'],
', '.join(data_form['variante'])))
if len(data_form['variante']) != 0:
q_variant = data_form['variante']
variantes = " AND variant:" + variant_to_query(q_variant)
else:
variantes = ""
if data_form["idioma"] == "L1":
idioma = settings.L1.lower()
lang_query = "l1"
elif data_form["idioma"] == "L2":
idioma = settings.L2.lower()
lang_query = "l2"
query = query_kreator(f'{lang_query}:({user_query}){variantes}')
LOGGER.debug("Indice::" + settings.INDEX)
try:
r = es.search(index=settings.INDEX, body=query, scroll="1m")
data_response = r["hits"]
scroll_id = r["_scroll_id"]
all_documents = data_response["total"]["value"]
documents_count = len(data_response["hits"])
while documents_count != all_documents:
sub_response = es.scroll(scroll_id=scroll_id, scroll="1m")
data_response["hits"] += sub_response["hits"]["hits"]
documents_count += len(sub_response["hits"]["hits"])
scroll_id = sub_response["_scroll_id"]
except elasticsearch.exceptions.RequestError as e:
LOGGER.error("Error al buscar::{}".format(e))
LOGGER.error("Query::" + data_form["busqueda"])
notification = "Búsqueda inválida. Vuelve a intentarlo ¯\\_(ツ)_/¯"
messages.warning(request, notification)
documents_count = 0
except elasticsearch.exceptions.ConnectionError as e:
LOGGER.error("Error de conexión::{}".format(e))
LOGGER.error("No se pudo conectar al Indice de" +\
"Elasticsearch::" + settings.INDEX)
notification = "Error de conexión al servidor " + \
"Intentalo más tarde (；一_一)"
messages.error(request, notification)
# TODO: Mandar correos para notificar servers caidos
documents_count = 0
if documents_count != 0:
status = results_to_csv(data_response["hits"], current_variants)
LOGGER.info("Los resultados de la consulta se guardaron::"\
+ str(status))
data = data_processor(data_response, lang_query, user_query)
else:
data = []
# TODO: Make a function for this
mappings = es.indices.get_mapping(index=settings.INDEX)
del mappings[settings.INDEX]['mappings']['properties']['document_id']
del mappings[settings.INDEX]['mappings']['properties']['pdf_file']
fields = list(mappings[settings.INDEX]['mappings']['properties'].keys())
# Ordening fields
fields.insert(0, fields.pop(fields.index("l1")))
fields.insert(1, fields.pop(fields.index("l2")))
fields.insert(2, fields.pop(fields.index("variant")))
return render(request, "searcher/searcher.html",
{'form': form, 'data': data,
'total': documents_count,
'idioma': idioma,
'query_text': user_query,
'total_variants': len(current_variants),
'fields': fields
})
else:
user_data = form.cleaned_data
notification = "En la búsqueda no se adminten consultas vacías :|"
if "query" not in user_data.keys():
messages.warning(request, notification)
else:
messages.error(request, "Error en el formulario de consulta.")
return render(request, "searcher/searcher.html",
{"form": form, "total": 0, "form_error": True})
else:
# Si es metodo GET se redirige a la vista index
return HttpResponseRedirect('/') | [
"def",
"search",
"(",
"request",
")",
":",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"# Pasando información al formulario. Esta será reenviada al",
"# template",
"form",
"=",
"SearchPostForm",
"(",
"request",
".",
"POST",
")",
"current_variants",
"=",
"get_variants",
"(",
")",
"if",
"current_variants",
"[",
"'status'",
"]",
"==",
"'success'",
":",
"del",
"current_variants",
"[",
"'status'",
"]",
"if",
"len",
"(",
"current_variants",
")",
":",
"form",
".",
"fields",
"[",
"'variante'",
"]",
".",
"choices",
"=",
"current_variants",
".",
"items",
"(",
")",
"else",
":",
"form",
".",
"fields",
"[",
"'variante'",
"]",
".",
"widget",
".",
"attrs",
"[",
"'disabled'",
"]",
"=",
"True",
"else",
":",
"del",
"current_variants",
"[",
"'status'",
"]",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"data_form",
"=",
"form",
".",
"cleaned_data",
"user_query",
"=",
"data_form",
"[",
"'busqueda'",
"]",
"LOGGER",
".",
"info",
"(",
"\"Datos usuaria query={} idioma={} variantes={}\"",
".",
"format",
"(",
"user_query",
",",
"data_form",
"[",
"'idioma'",
"]",
",",
"', '",
".",
"join",
"(",
"data_form",
"[",
"'variante'",
"]",
")",
")",
")",
"if",
"len",
"(",
"data_form",
"[",
"'variante'",
"]",
")",
"!=",
"0",
":",
"q_variant",
"=",
"data_form",
"[",
"'variante'",
"]",
"variantes",
"=",
"\" AND variant:\"",
"+",
"variant_to_query",
"(",
"q_variant",
")",
"else",
":",
"variantes",
"=",
"\"\"",
"if",
"data_form",
"[",
"\"idioma\"",
"]",
"==",
"\"L1\"",
":",
"idioma",
"=",
"settings",
".",
"L1",
".",
"lower",
"(",
")",
"lang_query",
"=",
"\"l1\"",
"elif",
"data_form",
"[",
"\"idioma\"",
"]",
"==",
"\"L2\"",
":",
"idioma",
"=",
"settings",
".",
"L2",
".",
"lower",
"(",
")",
"lang_query",
"=",
"\"l2\"",
"query",
"=",
"query_kreator",
"(",
"f'{lang_query}:({user_query}){variantes}'",
")",
"LOGGER",
".",
"debug",
"(",
"\"Indice::\"",
"+",
"settings",
".",
"INDEX",
")",
"try",
":",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"query",
",",
"scroll",
"=",
"\"1m\"",
")",
"data_response",
"=",
"r",
"[",
"\"hits\"",
"]",
"scroll_id",
"=",
"r",
"[",
"\"_scroll_id\"",
"]",
"all_documents",
"=",
"data_response",
"[",
"\"total\"",
"]",
"[",
"\"value\"",
"]",
"documents_count",
"=",
"len",
"(",
"data_response",
"[",
"\"hits\"",
"]",
")",
"while",
"documents_count",
"!=",
"all_documents",
":",
"sub_response",
"=",
"es",
".",
"scroll",
"(",
"scroll_id",
"=",
"scroll_id",
",",
"scroll",
"=",
"\"1m\"",
")",
"data_response",
"[",
"\"hits\"",
"]",
"+=",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
"documents_count",
"+=",
"len",
"(",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
")",
"scroll_id",
"=",
"sub_response",
"[",
"\"_scroll_id\"",
"]",
"except",
"elasticsearch",
".",
"exceptions",
".",
"RequestError",
"as",
"e",
":",
"LOGGER",
".",
"error",
"(",
"\"Error al buscar::{}\"",
".",
"format",
"(",
"e",
")",
")",
"LOGGER",
".",
"error",
"(",
"\"Query::\"",
"+",
"data_form",
"[",
"\"busqueda\"",
"]",
")",
"notification",
"=",
"\"Búsqueda inválida. Vuelve a intentarlo ¯\\\\_(ツ)_/¯\"",
"messages",
".",
"warning",
"(",
"request",
",",
"notification",
")",
"documents_count",
"=",
"0",
"except",
"elasticsearch",
".",
"exceptions",
".",
"ConnectionError",
"as",
"e",
":",
"LOGGER",
".",
"error",
"(",
"\"Error de conexión::{}\".",
"f",
"ormat(",
"e",
")",
")",
"",
"LOGGER",
".",
"error",
"(",
"\"No se pudo conectar al Indice de\"",
"+",
"\"Elasticsearch::\"",
"+",
"settings",
".",
"INDEX",
")",
"notification",
"=",
"\"Error de conexión al servidor \" ",
" ",
"\"Intentalo más tarde (；一_一)\"",
"messages",
".",
"error",
"(",
"request",
",",
"notification",
")",
"# TODO: Mandar correos para notificar servers caidos",
"documents_count",
"=",
"0",
"if",
"documents_count",
"!=",
"0",
":",
"status",
"=",
"results_to_csv",
"(",
"data_response",
"[",
"\"hits\"",
"]",
",",
"current_variants",
")",
"LOGGER",
".",
"info",
"(",
"\"Los resultados de la consulta se guardaron::\"",
"+",
"str",
"(",
"status",
")",
")",
"data",
"=",
"data_processor",
"(",
"data_response",
",",
"lang_query",
",",
"user_query",
")",
"else",
":",
"data",
"=",
"[",
"]",
"# TODO: Make a function for this",
"mappings",
"=",
"es",
".",
"indices",
".",
"get_mapping",
"(",
"index",
"=",
"settings",
".",
"INDEX",
")",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'document_id'",
"]",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'pdf_file'",
"]",
"fields",
"=",
"list",
"(",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
".",
"keys",
"(",
")",
")",
"# Ordening fields",
"fields",
".",
"insert",
"(",
"0",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"l1\"",
")",
")",
")",
"fields",
".",
"insert",
"(",
"1",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"l2\"",
")",
")",
")",
"fields",
".",
"insert",
"(",
"2",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"variant\"",
")",
")",
")",
"return",
"render",
"(",
"request",
",",
"\"searcher/searcher.html\"",
",",
"{",
"'form'",
":",
"form",
",",
"'data'",
":",
"data",
",",
"'total'",
":",
"documents_count",
",",
"'idioma'",
":",
"idioma",
",",
"'query_text'",
":",
"user_query",
",",
"'total_variants'",
":",
"len",
"(",
"current_variants",
")",
",",
"'fields'",
":",
"fields",
"}",
")",
"else",
":",
"user_data",
"=",
"form",
".",
"cleaned_data",
"notification",
"=",
"\"En la búsqueda no se adminten consultas vacías :|\"",
"if",
"\"query\"",
"not",
"in",
"user_data",
".",
"keys",
"(",
")",
":",
"messages",
".",
"warning",
"(",
"request",
",",
"notification",
")",
"else",
":",
"messages",
".",
"error",
"(",
"request",
",",
"\"Error en el formulario de consulta.\"",
")",
"return",
"render",
"(",
"request",
",",
"\"searcher/searcher.html\"",
",",
"{",
"\"form\"",
":",
"form",
",",
"\"total\"",
":",
"0",
",",
"\"form_error\"",
":",
"True",
"}",
")",
"else",
":",
"# Si es metodo GET se redirige a la vista index",
"return",
"HttpResponseRedirect",
"(",
"'/'",
")"
] | [
23,
0
] | [
130,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solver | (f: Callable, s: str, n: int) | Evalua las palabras de una cadena de texto 's', si existe alguna
palabra cuya longuitud es mayor o igual a 'n' imprime 'Hay palabras
largas', de lo contrario imprime 'No hay palabras largas'
:param f: Función de evaluación
:f type: Callable
:param s: Cadena de texto a evaluar
:s type: str
:param n: Cantidad de caracteres
:n type: int
| Evalua las palabras de una cadena de texto 's', si existe alguna
palabra cuya longuitud es mayor o igual a 'n' imprime 'Hay palabras
largas', de lo contrario imprime 'No hay palabras largas' | def solver(f: Callable, s: str, n: int) -> None:
"""Evalua las palabras de una cadena de texto 's', si existe alguna
palabra cuya longuitud es mayor o igual a 'n' imprime 'Hay palabras
largas', de lo contrario imprime 'No hay palabras largas'
:param f: Función de evaluación
:f type: Callable
:param s: Cadena de texto a evaluar
:s type: str
:param n: Cantidad de caracteres
:n type: int
"""
print("Hay palabras largas" if f(s, n) else "No hay palabras largas") | [
"def",
"solver",
"(",
"f",
":",
"Callable",
",",
"s",
":",
"str",
",",
"n",
":",
"int",
")",
"->",
"None",
":",
"print",
"(",
"\"Hay palabras largas\"",
"if",
"f",
"(",
"s",
",",
"n",
")",
"else",
"\"No hay palabras largas\"",
")"
] | [
28,
0
] | [
40,
73
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
command | (as_module=False) | Linea de comandos para administración de la aplicacion. | Linea de comandos para administración de la aplicacion. | def command(as_module=False) -> None:
"""Linea de comandos para administración de la aplicacion."""
COMMAND_LINE_INTERFACE.main(args=sys.argv[1:], prog_name="python -m flask" if as_module else None) | [
"def",
"command",
"(",
"as_module",
"=",
"False",
")",
"->",
"None",
":",
"COMMAND_LINE_INTERFACE",
".",
"main",
"(",
"args",
"=",
"sys",
".",
"argv",
"[",
"1",
":",
"]",
",",
"prog_name",
"=",
"\"python -m flask\"",
"if",
"as_module",
"else",
"None",
")"
] | [
464,
0
] | [
466,
102
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cuad_pmedio_funcion | (a, b, f) | return aprox | Implementación de la regla del punto medio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del punto medio
Notes
-----
Este código es parte del curso "Computación", Famaf
| Implementación de la regla del punto medio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del punto medio
Notes
-----
Este código es parte del curso "Computación", Famaf
| def cuad_pmedio_funcion(a, b, f):
"""Implementación de la regla del punto medio
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla del punto medio
Notes
-----
Este código es parte del curso "Computación", Famaf
"""
if a > b:
raise ValueError("Oops! Debe ser a<b")
return None
try:
x0 = (a+b)/2
h = f(x0)
aprox = h*(b-a)
except:
print('Error: no fue posible calcular la función')
return aprox | [
"def",
"cuad_pmedio_funcion",
"(",
"a",
",",
"b",
",",
"f",
")",
":",
"if",
"a",
">",
"b",
":",
"raise",
"ValueError",
"(",
"\"Oops! Debe ser a<b\"",
")",
"return",
"None",
"try",
":",
"x0",
"=",
"(",
"a",
"+",
"b",
")",
"/",
"2",
"h",
"=",
"f",
"(",
"x0",
")",
"aprox",
"=",
"h",
"*",
"(",
"b",
"-",
"a",
")",
"except",
":",
"print",
"(",
"'Error: no fue posible calcular la función')",
"",
"return",
"aprox"
] | [
10,
0
] | [
36,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Frases.token_cumple | (self, token) | return True | Determina si token pasa los filtros.
Parameters
----------
token : spacy.tokens.Token
Token a evaluar.
Returns
-------
bool
Si token pasa los filtros o no.
| Determina si token pasa los filtros. | def token_cumple(self, token):
"""Determina si token pasa los filtros.
Parameters
----------
token : spacy.tokens.Token
Token a evaluar.
Returns
-------
bool
Si token pasa los filtros o no.
"""
if not self.filtros:
return True
if self.filtros.get("is_alpha"):
if not token.is_alpha:
return False
attr = ["lower_", "pos_", "dep_", "ent_type_"]
ok = [getattr(token, a) not in self.filtros.get(a, list()) for a in attr]
if not all(ok):
return False
chars = self.filtros.get("chars", 0)
if chars:
return len(token) > chars
return True | [
"def",
"token_cumple",
"(",
"self",
",",
"token",
")",
":",
"if",
"not",
"self",
".",
"filtros",
":",
"return",
"True",
"if",
"self",
".",
"filtros",
".",
"get",
"(",
"\"is_alpha\"",
")",
":",
"if",
"not",
"token",
".",
"is_alpha",
":",
"return",
"False",
"attr",
"=",
"[",
"\"lower_\"",
",",
"\"pos_\"",
",",
"\"dep_\"",
",",
"\"ent_type_\"",
"]",
"ok",
"=",
"[",
"getattr",
"(",
"token",
",",
"a",
")",
"not",
"in",
"self",
".",
"filtros",
".",
"get",
"(",
"a",
",",
"list",
"(",
")",
")",
"for",
"a",
"in",
"attr",
"]",
"if",
"not",
"all",
"(",
"ok",
")",
":",
"return",
"False",
"chars",
"=",
"self",
".",
"filtros",
".",
"get",
"(",
"\"chars\"",
",",
"0",
")",
"if",
"chars",
":",
"return",
"len",
"(",
"token",
")",
">",
"chars",
"return",
"True"
] | [
119,
4
] | [
148,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioAGTSP.generar_n | (self, n) | return sols | Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n listas, cada una representando
una posible solución al problema modelado por el objeto de dominio.
| Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n listas, cada una representando
una posible solución al problema modelado por el objeto de dominio.
| def generar_n(self, n):
"""Construye aleatoriamente una lista de listas que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n listas, cada una representando
una posible solución al problema modelado por el objeto de dominio.
"""
sols = []
for x in range(n):
nuevo = self.generar()
valido = self.validar(nuevo)
while(not valido):
nuevo = self.generar()
valido = self.validar(nuevo)
sols.append(nuevo)
return sols | [
"def",
"generar_n",
"(",
"self",
",",
"n",
")",
":",
"sols",
"=",
"[",
"]",
"for",
"x",
"in",
"range",
"(",
"n",
")",
":",
"nuevo",
"=",
"self",
".",
"generar",
"(",
")",
"valido",
"=",
"self",
".",
"validar",
"(",
"nuevo",
")",
"while",
"(",
"not",
"valido",
")",
":",
"nuevo",
"=",
"self",
".",
"generar",
"(",
")",
"valido",
"=",
"self",
".",
"validar",
"(",
"nuevo",
")",
"sols",
".",
"append",
"(",
"nuevo",
")",
"return",
"sols"
] | [
55,
4
] | [
75,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
tabla_mulitplos | (inicio: int, fin: int, base: int) | return suma | Imprime una secuencia comprendida entre "inicio" y "fin"
(ambos incluidos) con el texto "múltiplo de" si el número de la
secuencia es múltiplo de "base" y la suma acumulada de dichos
múltiplos.
:param inicio: Número inicial de la secuencia.
:inicio type: int
:param fin: Número final de la secuencia.
:fin type: int
:param base: Número base para el cálculo de los múltiplos.
:base type: int
:return: La suma acumulada de los múltiplos.
:return type: int
| Imprime una secuencia comprendida entre "inicio" y "fin"
(ambos incluidos) con el texto "múltiplo de" si el número de la
secuencia es múltiplo de "base" y la suma acumulada de dichos
múltiplos. | def tabla_mulitplos(inicio: int, fin: int, base: int) -> int:
"""Imprime una secuencia comprendida entre "inicio" y "fin"
(ambos incluidos) con el texto "múltiplo de" si el número de la
secuencia es múltiplo de "base" y la suma acumulada de dichos
múltiplos.
:param inicio: Número inicial de la secuencia.
:inicio type: int
:param fin: Número final de la secuencia.
:fin type: int
:param base: Número base para el cálculo de los múltiplos.
:base type: int
:return: La suma acumulada de los múltiplos.
:return type: int
"""
suma = 0
for numero in range(inicio, fin + 1):
if numero % base == 0:
suma += numero
print(f"{numero} múltiplo de {base} - suma acumulada: {suma}")
else:
print(numero)
return suma | [
"def",
"tabla_mulitplos",
"(",
"inicio",
":",
"int",
",",
"fin",
":",
"int",
",",
"base",
":",
"int",
")",
"->",
"int",
":",
"suma",
"=",
"0",
"for",
"numero",
"in",
"range",
"(",
"inicio",
",",
"fin",
"+",
"1",
")",
":",
"if",
"numero",
"%",
"base",
"==",
"0",
":",
"suma",
"+=",
"numero",
"print",
"(",
"f\"{numero} múltiplo de {base} - suma acumulada: {suma}\")",
"",
"else",
":",
"print",
"(",
"numero",
")",
"return",
"suma"
] | [
28,
0
] | [
50,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ingresar_notas | (min_: int = 0, max_: int = 20) | return notas | Pide al usuario las notas de las prácticas.
:param min_: Valor mínimo de la nota.
:min type: int
:param max_: Valor máximo de la nota.
:max type: int
:return: Lista con las notas.
:rtype: List[int]
| Pide al usuario las notas de las prácticas. | def ingresar_notas(min_: int = 0, max_: int = 20) -> List[int]:
"""Pide al usuario las notas de las prácticas.
:param min_: Valor mínimo de la nota.
:min type: int
:param max_: Valor máximo de la nota.
:max type: int
:return: Lista con las notas.
:rtype: List[int]
"""
notas = []
i = 1
while True:
try:
nota = int(input(f'Nota {i}: '))
if nota < 0:
break
if min_ <= nota <= max_:
notas.append(nota)
i += 1
else:
print('Nota fuera de rango')
except ValueError:
print('La nota debe ser un número.')
continue
return notas | [
"def",
"ingresar_notas",
"(",
"min_",
":",
"int",
"=",
"0",
",",
"max_",
":",
"int",
"=",
"20",
")",
"->",
"List",
"[",
"int",
"]",
":",
"notas",
"=",
"[",
"]",
"i",
"=",
"1",
"while",
"True",
":",
"try",
":",
"nota",
"=",
"int",
"(",
"input",
"(",
"f'Nota {i}: '",
")",
")",
"if",
"nota",
"<",
"0",
":",
"break",
"if",
"min_",
"<=",
"nota",
"<=",
"max_",
":",
"notas",
".",
"append",
"(",
"nota",
")",
"i",
"+=",
"1",
"else",
":",
"print",
"(",
"'Nota fuera de rango'",
")",
"except",
"ValueError",
":",
"print",
"(",
"'La nota debe ser un número.')",
"",
"continue",
"return",
"notas"
] | [
36,
0
] | [
61,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
imprimir_nombres | (lista) | imprime las diferentes listas que se van generando | imprime las diferentes listas que se van generando | def imprimir_nombres(lista):
""" imprime las diferentes listas que se van generando"""
print("\n".join(lista),"\n") | [
"def",
"imprimir_nombres",
"(",
"lista",
")",
":",
"print",
"(",
"\"\\n\"",
".",
"join",
"(",
"lista",
")",
",",
"\"\\n\"",
")"
] | [
54,
0
] | [
56,
32
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PlacesExtractor.recover | (self, provided_driver=None, place_id=None) | return result_to_return | Función auxiliar encargada de la recuperación de la información.
Llama la función scrap y actualiza el registro en la base de datos
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para realizar la extracción, en caso de no estar definido, se usará el que se haya
definido para la instancia de la clase
place_id : ínt
id del commercial_premise en la base de datos
Returns
-------
True
en caso de que se exporte correctamente los datos
False
en caso de que algo hubiera ocurrido durante la extracción o la exportación
dict
en caso de que no se haya writer definido
| Función auxiliar encargada de la recuperación de la información.
Llama la función scrap y actualiza el registro en la base de datos | def recover(self, provided_driver=None, place_id=None):
"""Función auxiliar encargada de la recuperación de la información.
Llama la función scrap y actualiza el registro en la base de datos
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para realizar la extracción, en caso de no estar definido, se usará el que se haya
definido para la instancia de la clase
place_id : ínt
id del commercial_premise en la base de datos
Returns
-------
True
en caso de que se exporte correctamente los datos
False
en caso de que algo hubiera ocurrido durante la extracción o la exportación
dict
en caso de que no se haya writer definido
"""
logging.info("-{name}-: recovery process for place with url -{url}- is starting".format(
name=self._place_name, url=self._url))
driver = provided_driver if provided_driver else self.get_driver()
init_time = time.time()
result_to_return = None
try:
place_info = self._scrap(driver)
place_info["commercial_premise_id"] = place_id
result_to_return = self.export_data(data=place_info, is_update=True)
except Exception as e:
self.logger.error("-{name}-: error during recovery process: {error}".format(name=self._place_name,
error=str(e)))
finally:
self.finish()
end_time = time.time()
elapsed = int(end_time - init_time)
self.logger.info("-{name}-: recovery process the url -{url}- has took: -{elapsed}- seconds".format(
name=self._place_name, elapsed=elapsed, url=self._url))
return result_to_return | [
"def",
"recover",
"(",
"self",
",",
"provided_driver",
"=",
"None",
",",
"place_id",
"=",
"None",
")",
":",
"logging",
".",
"info",
"(",
"\"-{name}-: recovery process for place with url -{url}- is starting\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"driver",
"=",
"provided_driver",
"if",
"provided_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"init_time",
"=",
"time",
".",
"time",
"(",
")",
"result_to_return",
"=",
"None",
"try",
":",
"place_info",
"=",
"self",
".",
"_scrap",
"(",
"driver",
")",
"place_info",
"[",
"\"commercial_premise_id\"",
"]",
"=",
"place_id",
"result_to_return",
"=",
"self",
".",
"export_data",
"(",
"data",
"=",
"place_info",
",",
"is_update",
"=",
"True",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{name}-: error during recovery process: {error}\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"error",
"=",
"str",
"(",
"e",
")",
")",
")",
"finally",
":",
"self",
".",
"finish",
"(",
")",
"end_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed",
"=",
"int",
"(",
"end_time",
"-",
"init_time",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{name}-: recovery process the url -{url}- has took: -{elapsed}- seconds\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"elapsed",
"=",
"elapsed",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"return",
"result_to_return"
] | [
637,
4
] | [
677,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_propiedades3 | (t) | propiedades : identity propiedades | propiedades : identity propiedades | def p_propiedades3(t):
'''propiedades : identity propiedades'''
node = grammer.nodoDireccion('propiedades')
node1 = grammer.nodoDireccion(t[1])
node.agregar(node1)
node.agregar(t[2])
t[0] = node | [
"def",
"p_propiedades3",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'propiedades'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"2",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
295,
0
] | [
301,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
doc_preview | (request, _id) | return render(request, "corpus-admin/doc-preview.html",
{
"doc_data": corpus, "doc_name": name,
"doc_file": file, "total": len(corpus),
"id": _id, "total_variants": len(current_variants),
"fields": fields
}) | **Vista que muestra el contenido de un documento particular**
Muestra los renglones alineados que componen un documento en
particular del corpus. Cada renglon tiene dos acciones, eliminar y
editar.
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
* `:param _id:` identificador del documento a visualizar
* `:type:` *str*
* `:return:` Contenido de un documento
| **Vista que muestra el contenido de un documento particular** | def doc_preview(request, _id):
"""**Vista que muestra el contenido de un documento particular**
Muestra los renglones alineados que componen un documento en
particular del corpus. Cada renglon tiene dos acciones, eliminar y
editar.
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
* `:param _id:` identificador del documento a visualizar
* `:type:` *str*
* `:return:` Contenido de un documento
"""
query = query_kreator("document_id:" + _id)
r = es.search(index=settings.INDEX, body=query)
corpus = data_processor(r['hits'], "NONE", "")
data = r['hits']['hits'][0]['_source']
name = data['document_name']
doc = get_document_info(_id)
file = doc['file']
# TODO: Refactor variants across the backend
current_variants = get_variants()
if len(current_variants) == 1:
current_variants = {}
# TODO: Make a function for this
mappings = es.indices.get_mapping(index=settings.INDEX)
del mappings[settings.INDEX]['mappings']['properties']['document_id']
del mappings[settings.INDEX]['mappings']['properties']['pdf_file']
del mappings[settings.INDEX]['mappings']['properties']['document_name']
fields = list(mappings[settings.INDEX]['mappings']['properties'].keys())
# Ordening fields
fields.insert(0, fields.pop(fields.index("l1")))
fields.insert(1, fields.pop(fields.index("l2")))
fields.insert(2, fields.pop(fields.index("variant")))
return render(request, "corpus-admin/doc-preview.html",
{
"doc_data": corpus, "doc_name": name,
"doc_file": file, "total": len(corpus),
"id": _id, "total_variants": len(current_variants),
"fields": fields
}) | [
"def",
"doc_preview",
"(",
"request",
",",
"_id",
")",
":",
"query",
"=",
"query_kreator",
"(",
"\"document_id:\"",
"+",
"_id",
")",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"query",
")",
"corpus",
"=",
"data_processor",
"(",
"r",
"[",
"'hits'",
"]",
",",
"\"NONE\"",
",",
"\"\"",
")",
"data",
"=",
"r",
"[",
"'hits'",
"]",
"[",
"'hits'",
"]",
"[",
"0",
"]",
"[",
"'_source'",
"]",
"name",
"=",
"data",
"[",
"'document_name'",
"]",
"doc",
"=",
"get_document_info",
"(",
"_id",
")",
"file",
"=",
"doc",
"[",
"'file'",
"]",
"# TODO: Refactor variants across the backend",
"current_variants",
"=",
"get_variants",
"(",
")",
"if",
"len",
"(",
"current_variants",
")",
"==",
"1",
":",
"current_variants",
"=",
"{",
"}",
"# TODO: Make a function for this",
"mappings",
"=",
"es",
".",
"indices",
".",
"get_mapping",
"(",
"index",
"=",
"settings",
".",
"INDEX",
")",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'document_id'",
"]",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'pdf_file'",
"]",
"del",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
"[",
"'document_name'",
"]",
"fields",
"=",
"list",
"(",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
".",
"keys",
"(",
")",
")",
"# Ordening fields",
"fields",
".",
"insert",
"(",
"0",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"l1\"",
")",
")",
")",
"fields",
".",
"insert",
"(",
"1",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"l2\"",
")",
")",
")",
"fields",
".",
"insert",
"(",
"2",
",",
"fields",
".",
"pop",
"(",
"fields",
".",
"index",
"(",
"\"variant\"",
")",
")",
")",
"return",
"render",
"(",
"request",
",",
"\"corpus-admin/doc-preview.html\"",
",",
"{",
"\"doc_data\"",
":",
"corpus",
",",
"\"doc_name\"",
":",
"name",
",",
"\"doc_file\"",
":",
"file",
",",
"\"total\"",
":",
"len",
"(",
"corpus",
")",
",",
"\"id\"",
":",
"_id",
",",
"\"total_variants\"",
":",
"len",
"(",
"current_variants",
")",
",",
"\"fields\"",
":",
"fields",
"}",
")"
] | [
118,
0
] | [
159,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
CubeShell.do_borrar_res | (self, arg) | Vaciar las carpetas de recursos (./res) | Vaciar las carpetas de recursos (./res) | def do_borrar_res(self, arg):
'''Vaciar las carpetas de recursos (./res)'''
utils.emptyFolder(utils.PATHS.get('image_folder')) | [
"def",
"do_borrar_res",
"(",
"self",
",",
"arg",
")",
":",
"utils",
".",
"emptyFolder",
"(",
"utils",
".",
"PATHS",
".",
"get",
"(",
"'image_folder'",
")",
")"
] | [
72,
4
] | [
74,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
adivinanza | (bot, replies) | Probabilidad y adivinanza para la bolita (lotería de la Florida) | Probabilidad y adivinanza para la bolita (lotería de la Florida) | def adivinanza(bot, replies) -> None:
"""Probabilidad y adivinanza para la bolita (lotería de la Florida)"""
with session.get("https://bolitacuba.com/probabilidad-y-adivinanza/") as resp:
resp.raise_for_status()
soup = bs4.BeautifulSoup(resp.text, "html5lib")
url = soup.find(class_="alm-reveal").a["href"]
base_url, resource = url.rstrip("/").rsplit("/", maxsplit=1)
resource = (
datetime.strptime(resource.split("pya-")[-1], "%m-%d-%Y") + timedelta(days=1)
).strftime("pya-%m-%d-%Y")
try:
with session.get(f"{base_url}/{resource}/") as resp:
resp.raise_for_status()
soup = bs4.BeautifulSoup(resp.text, "html5lib")
except requests.HTTPError as err:
bot.logger.exception(err)
with session.get(url) as resp:
resp.raise_for_status()
soup = bs4.BeautifulSoup(resp.text, "html5lib")
soup = soup.find(class_="entry-content")
for tag in soup(class_="code-block"):
tag.extract()
for tag in soup("i", class_="fa-sun"):
tag.replace_with("☀️")
for tag in soup("i", class_="fa-moon"):
tag.replace_with("🌙")
replies.add(text=_soup2text(soup)) | [
"def",
"adivinanza",
"(",
"bot",
",",
"replies",
")",
"->",
"None",
":",
"with",
"session",
".",
"get",
"(",
"\"https://bolitacuba.com/probabilidad-y-adivinanza/\"",
")",
"as",
"resp",
":",
"resp",
".",
"raise_for_status",
"(",
")",
"soup",
"=",
"bs4",
".",
"BeautifulSoup",
"(",
"resp",
".",
"text",
",",
"\"html5lib\"",
")",
"url",
"=",
"soup",
".",
"find",
"(",
"class_",
"=",
"\"alm-reveal\"",
")",
".",
"a",
"[",
"\"href\"",
"]",
"base_url",
",",
"resource",
"=",
"url",
".",
"rstrip",
"(",
"\"/\"",
")",
".",
"rsplit",
"(",
"\"/\"",
",",
"maxsplit",
"=",
"1",
")",
"resource",
"=",
"(",
"datetime",
".",
"strptime",
"(",
"resource",
".",
"split",
"(",
"\"pya-\"",
")",
"[",
"-",
"1",
"]",
",",
"\"%m-%d-%Y\"",
")",
"+",
"timedelta",
"(",
"days",
"=",
"1",
")",
")",
".",
"strftime",
"(",
"\"pya-%m-%d-%Y\"",
")",
"try",
":",
"with",
"session",
".",
"get",
"(",
"f\"{base_url}/{resource}/\"",
")",
"as",
"resp",
":",
"resp",
".",
"raise_for_status",
"(",
")",
"soup",
"=",
"bs4",
".",
"BeautifulSoup",
"(",
"resp",
".",
"text",
",",
"\"html5lib\"",
")",
"except",
"requests",
".",
"HTTPError",
"as",
"err",
":",
"bot",
".",
"logger",
".",
"exception",
"(",
"err",
")",
"with",
"session",
".",
"get",
"(",
"url",
")",
"as",
"resp",
":",
"resp",
".",
"raise_for_status",
"(",
")",
"soup",
"=",
"bs4",
".",
"BeautifulSoup",
"(",
"resp",
".",
"text",
",",
"\"html5lib\"",
")",
"soup",
"=",
"soup",
".",
"find",
"(",
"class_",
"=",
"\"entry-content\"",
")",
"for",
"tag",
"in",
"soup",
"(",
"class_",
"=",
"\"code-block\"",
")",
":",
"tag",
".",
"extract",
"(",
")",
"for",
"tag",
"in",
"soup",
"(",
"\"i\"",
",",
"class_",
"=",
"\"fa-sun\"",
")",
":",
"tag",
".",
"replace_with",
"(",
"\"☀️\")",
"",
"for",
"tag",
"in",
"soup",
"(",
"\"i\"",
",",
"class_",
"=",
"\"fa-moon\"",
")",
":",
"tag",
".",
"replace_with",
"(",
"\"🌙\")",
"",
"replies",
".",
"add",
"(",
"text",
"=",
"_soup2text",
"(",
"soup",
")",
")"
] | [
68,
0
] | [
94,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
separar_guiones | (texto) | return re.sub(r'([A-Za-zÀ-Üà-ü]+)–(\W)', r'\1 –\2', nuevo) | Separa guiones de primera y última palabra de fragmentos de texto.
Parameters
----------
texto : str
Returns
-------
str
Texto con guiones de fragmentos separados de las palabras.
| Separa guiones de primera y última palabra de fragmentos de texto. | def separar_guiones(texto):
"""Separa guiones de primera y última palabra de fragmentos de texto.
Parameters
----------
texto : str
Returns
-------
str
Texto con guiones de fragmentos separados de las palabras.
"""
# Asume ord 8211 ó 8212
nuevo = re.sub(r'[—–]{1,}', '–', texto)
nuevo = re.sub(r'(\W)–([A-Za-zÀ-Üà-ü]+)', r'\1– \2', nuevo)
return re.sub(r'([A-Za-zÀ-Üà-ü]+)–(\W)', r'\1 –\2', nuevo) | [
"def",
"separar_guiones",
"(",
"texto",
")",
":",
"# Asume ord 8211 ó 8212",
"nuevo",
"=",
"re",
".",
"sub",
"(",
"r'[—–]{1,}', '–",
"'",
" text",
"o",
"",
"",
"nuevo",
"=",
"re",
".",
"sub",
"(",
"r'(\\W)–([A-Za-zÀ-Üà-ü]+)', r'\\1",
"–",
"\\2', nuevo)",
"",
"",
"",
"return",
"re",
".",
"sub",
"(",
"r'([A-Za-zÀ-Üà-ü]+)–(\\W)', r'\\1",
" ",
"\\2', nuevo)",
"",
"",
""
] | [
44,
0
] | [
60,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UpdateOwnProfile.has_object_permission | (self, request, view, obj) | return obj.id == request.user.id | Chequea si el usuario quiere modificar su perfil | Chequea si el usuario quiere modificar su perfil | def has_object_permission(self, request, view, obj):
"""Chequea si el usuario quiere modificar su perfil"""
if request.method in permissions.SAFE_METHODS:
return True
return obj.id == request.user.id | [
"def",
"has_object_permission",
"(",
"self",
",",
"request",
",",
"view",
",",
"obj",
")",
":",
"if",
"request",
".",
"method",
"in",
"permissions",
".",
"SAFE_METHODS",
":",
"return",
"True",
"return",
"obj",
".",
"id",
"==",
"request",
".",
"user",
".",
"id"
] | [
6,
4
] | [
11,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
initResources | () | Inicializar las carpetas de imagenes y JSONs,
actualizar estado actual del cubo | Inicializar las carpetas de imagenes y JSONs,
actualizar estado actual del cubo | def initResources():
'''Inicializar las carpetas de imagenes y JSONs,
actualizar estado actual del cubo'''
utils.createFolder(utils.PATHS.get('image_folder'))
utils.createFolder(utils.PATHS.get('json_folder'))
cubo_actual.updateEstado() | [
"def",
"initResources",
"(",
")",
":",
"utils",
".",
"createFolder",
"(",
"utils",
".",
"PATHS",
".",
"get",
"(",
"'image_folder'",
")",
")",
"utils",
".",
"createFolder",
"(",
"utils",
".",
"PATHS",
".",
"get",
"(",
"'json_folder'",
")",
")",
"cubo_actual",
".",
"updateEstado",
"(",
")"
] | [
87,
0
] | [
92,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones_extras | (t) | funciones_extras : math_functions | funciones_extras : math_functions | def p_funciones_extras(t):
'funciones_extras : math_functions'
node= grammer.nodoDireccion('funciones_extras')
node.agregar(t[1])
t[0]= node | [
"def",
"p_funciones_extras",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'funciones_extras'",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1806,
0
] | [
1810,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ArticuloView.post | (self, request, *args, **kwargs) | Servicio para crear un nuevo articulo | Servicio para crear un nuevo articulo | def post(self, request, *args, **kwargs):
'''Servicio para crear un nuevo articulo'''
articulo_datos = request.data
try:
nuevo_articulo = Articulo(
codigo=articulo_datos['codigo'],
descripcion=articulo_datos['descripcion'],
precio=articulo_datos['precio']
)
nuevo_articulo.save()
serializer = ArticuloSerializer(nuevo_articulo)
except KeyError:
return Response({'detail': 'Una o mas llaves del objeto no coinciden.'}, status=status.HTTP_400_BAD_REQUEST)
except AttributeError:
return Response({'detail': 'Uno o mas atributos del objeto no coinciden.'}, status=status.HTTP_400_BAD_REQUEST)
except DataError:
return Response({'detail': 'Uno o mas atributos del objeto son muy largos'}, status=status.HTTP_400_BAD_REQUEST)
except TypeError:
return Response({'detail': 'No esta recibiendo argumentos validos'}, status=status.HTTP_400_BAD_REQUEST)
except Exception:
return Response({'detail': 'Objeto JSON desconcocido, ver documentación'}, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(serializer.data) | [
"def",
"post",
"(",
"self",
",",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"articulo_datos",
"=",
"request",
".",
"data",
"try",
":",
"nuevo_articulo",
"=",
"Articulo",
"(",
"codigo",
"=",
"articulo_datos",
"[",
"'codigo'",
"]",
",",
"descripcion",
"=",
"articulo_datos",
"[",
"'descripcion'",
"]",
",",
"precio",
"=",
"articulo_datos",
"[",
"'precio'",
"]",
")",
"nuevo_articulo",
".",
"save",
"(",
")",
"serializer",
"=",
"ArticuloSerializer",
"(",
"nuevo_articulo",
")",
"except",
"KeyError",
":",
"return",
"Response",
"(",
"{",
"'detail'",
":",
"'Una o mas llaves del objeto no coinciden.'",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")",
"except",
"AttributeError",
":",
"return",
"Response",
"(",
"{",
"'detail'",
":",
"'Uno o mas atributos del objeto no coinciden.'",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")",
"except",
"DataError",
":",
"return",
"Response",
"(",
"{",
"'detail'",
":",
"'Uno o mas atributos del objeto son muy largos'",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")",
"except",
"TypeError",
":",
"return",
"Response",
"(",
"{",
"'detail'",
":",
"'No esta recibiendo argumentos validos'",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")",
"except",
"Exception",
":",
"return",
"Response",
"(",
"{",
"'detail'",
":",
"'Objeto JSON desconcocido, ver documentación'}",
",",
" ",
"tatus=",
"s",
"tatus.",
"H",
"TTP_400_BAD_REQUEST)",
"",
"else",
":",
"return",
"Response",
"(",
"serializer",
".",
"data",
")"
] | [
248,
4
] | [
272,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cambiar_tipo_usario | () | return redirect(url_for("usuario", id_usuario=request.args.get("user"))) | Actualiza el tipo de usuario. | Actualiza el tipo de usuario. | def cambiar_tipo_usario():
"""Actualiza el tipo de usuario."""
cambia_tipo_de_usuario_por_id(
id_usuario=request.args.get("user"),
nuevo_tipo=request.args.get("type"),
)
return redirect(url_for("usuario", id_usuario=request.args.get("user"))) | [
"def",
"cambiar_tipo_usario",
"(",
")",
":",
"cambia_tipo_de_usuario_por_id",
"(",
"id_usuario",
"=",
"request",
".",
"args",
".",
"get",
"(",
"\"user\"",
")",
",",
"nuevo_tipo",
"=",
"request",
".",
"args",
".",
"get",
"(",
"\"type\"",
")",
",",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"\"usuario\"",
",",
"id_usuario",
"=",
"request",
".",
"args",
".",
"get",
"(",
"\"user\"",
")",
")",
")"
] | [
861,
0
] | [
867,
76
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
calculadora2 | (a,b) | Esta función recibe 2 parámetros, los números a y b.
Realiza operaciones elementales con a y b | Esta función recibe 2 parámetros, los números a y b.
Realiza operaciones elementales con a y b | def calculadora2(a,b):
'''Esta función recibe 2 parámetros, los números a y b.
Realiza operaciones elementales con a y b'''
# La 'f' antes de las comillas permite leer la variable que se encuentra en llaves '{}'.
print(f'{a} + {b} = {float(a)+float(b)}')
print(f'{a} - {b} = {float(a)-float(b)}')
print(f'{a} * {b} = {float(a)*float(b)}')
print(f'{b} / {a} = {float(b)/float(a)}') | [
"def",
"calculadora2",
"(",
"a",
",",
"b",
")",
":",
"# La 'f' antes de las comillas permite leer la variable que se encuentra en llaves '{}'.",
"print",
"(",
"f'{a} + {b} = {float(a)+float(b)}'",
")",
"print",
"(",
"f'{a} - {b} = {float(a)-float(b)}'",
")",
"print",
"(",
"f'{a} * {b} = {float(a)*float(b)}'",
")",
"print",
"(",
"f'{b} / {a} = {float(b)/float(a)}'",
")"
] | [
14,
0
] | [
21,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Codigo3d.asegurarIntruccion | (self, instruccion :str , goToMain : bool , quitarParentesisFinal = False) | Limpia de comentarios y se asegura que inicie con una palabra reservada de la fase 1 como USE , INSERT , SELECT , UPDATE | Limpia de comentarios y se asegura que inicie con una palabra reservada de la fase 1 como USE , INSERT , SELECT , UPDATE | def asegurarIntruccion(self, instruccion :str , goToMain : bool , quitarParentesisFinal = False):
'''Limpia de comentarios y se asegura que inicie con una palabra reservada de la fase 1 como USE , INSERT , SELECT , UPDATE '''
tn_previos = ''
instruccion += "\n"
instruccion = instruccion.lower()
instruccion = re.sub('\-\-(.*)\n|/\*(.|\n)*?\*/' ,"",instruccion)
instruccion = re.sub('create\s+(function|procedure)' ,"",instruccion)# quito unos create que podrian dar problemas
instruccion = instruccion[0:len(instruccion)-1]
instruccion = instruccion.replace("\n", " ")
lexema = ""
indiceInicial = 0
tipoFuncion = ''
for x in range(len(instruccion)):
if instruccion[x] == " ":
lexema = ""
else:
lexema += instruccion[x]
tipoFuncion = lexema.lower()
if lexema.lower() == "use":
indiceInicial = x-2
break
elif lexema.lower() == "select" or lexema.lower() == "insert" or lexema.lower() == "update" or lexema.lower() == "delete" or lexema.lower() == "create":
indiceInicial = x-5
break
elif lexema.lower() == "truncate":
indiceInicial = x-7
break
elif lexema.lower() == "(select":
indiceInicial = x-5
break
elif lexema.lower() == "alter":
indiceInicial = x-4
break
elif lexema.lower() == "show" or lexema.lower() == "drop":
indiceInicial = x-3
break
instruccionOK = ''
while(indiceInicial < len(instruccion)):
instruccionOK+=instruccion[indiceInicial]
indiceInicial +=1
lexema = ""
if tipoFuncion =="(select":
instruccionOK = quitarParentesisSubquery(instruccionOK)
quitarParentesisFinal = False
tipoFuncion ="select"
if tipoFuncion == "select":
if quitarParentesisFinal:
instruccionOK = quitarParentesisSubquery(instruccionOK)
aux = re.sub('select' ,"",instruccionOK)
aux = aux.strip()
auxParams = ''
for x in aux:
auxParams += x
if x == " ":
lexema = ""
else:
lexema += x.lower()
if lexema == "from" or lexema == ";": # paro de buscar con un from o un punto y coma
break
auxParams = re.sub('from' ,"",auxParams)
auxParams = re.sub(';' ,"",auxParams)
auxParams = auxParams.strip()
parametros = mi_split(auxParams)
parametros = quitarEspacios(parametros)
patron = '[a-zA-Z_][a-zA-Z_0-9]*\s*[(].*[)]'
for parametro in parametros:
if re.match(patron,parametro):
objPattern = re.search(patron , parametro)
coincidencia = objPattern.string[objPattern.span()[0] : objPattern.span()[1]]
# Y REEMPLAZO EL CODIGO 3D como un str(tn)
if coincidencia == 'count(*)':
continue
if getOnlyId(coincidencia).upper() in funcionesDefinidas:
# es de la fase 1 asi que se queda normal
pass
else:# REPLACE
tn = self.getNewTemporal()
salida = f'\t{coincidencia}\n\t{tn} = RETURN[0]'
if goToMain:
self.addToMain(salida)
else:
tn_previos+= salida+'\n'
instruccionOK = instruccionOK.replace(coincidencia,f'\"+str({tn})+\"')
elif tipoFuncion == "insert":
aux = instruccionOK
aux = aux.strip()
auxParams = ''
for x in aux:
if x == " ":
lexema = ""
elif x == ";":
break
else:
lexema += x.lower()
auxParams+=x
if lexema == "values":
auxParams = ""
elif auxParams =="values(":
auxParams=""+"("
auxParams = auxParams.strip()
auxParams = auxParams[1: len(auxParams)-1]# LE QUITO LOS PARENTESIS
parametros = mi_split(auxParams)
parametros = quitarEspacios(parametros)
patron = '[a-zA-Z_][a-zA-Z_0-9]*\s*[(].*[)]'
for parametro in parametros:
if re.match(patron,parametro):
objPattern = re.search(patron , parametro)
coincidencia = objPattern.string[objPattern.span()[0] : objPattern.span()[1]]
# VERIFICO SI EXISTE EN LA ESTRUCUTRA Y REEMPLAZO EL CODIGO 3D como un str(tn)
if getOnlyId(coincidencia).upper() in funcionesDefinidas:
pass # no se traduce
else:# REPLACE
# * SI SALE TODO BIEN
tn = self.getNewTemporal()
salida = f'\t{coincidencia}\n\t{tn} = RETURN[0]'
if goToMain:
self.addToMain(salida)
else:
tn_previos+= salida+'\n'
instruccionOK = instruccionOK.replace(coincidencia,f'\"+str({tn})+\"')
#va adentro de un procedure o funcion
if goToMain:
return instruccionOK
else:
tn = self.getNewTemporal()
tres = self.getNewTemporal()#TEMPORAL RESULTANTE
instruccionOK = tn_previos +f'\t{tn} = "{instruccionOK}"'
instruccionOK += f'\n\tstack.push({tn})'
instruccionOK += f"\n\t{tres} = funcionIntermedia()"
return [instruccionOK,tres] | [
"def",
"asegurarIntruccion",
"(",
"self",
",",
"instruccion",
":",
"str",
",",
"goToMain",
":",
"bool",
",",
"quitarParentesisFinal",
"=",
"False",
")",
":",
"tn_previos",
"=",
"''",
"instruccion",
"+=",
"\"\\n\"",
"instruccion",
"=",
"instruccion",
".",
"lower",
"(",
")",
"instruccion",
"=",
"re",
".",
"sub",
"(",
"'\\-\\-(.*)\\n|/\\*(.|\\n)*?\\*/'",
",",
"\"\"",
",",
"instruccion",
")",
"instruccion",
"=",
"re",
".",
"sub",
"(",
"'create\\s+(function|procedure)'",
",",
"\"\"",
",",
"instruccion",
")",
"# quito unos create que podrian dar problemas",
"instruccion",
"=",
"instruccion",
"[",
"0",
":",
"len",
"(",
"instruccion",
")",
"-",
"1",
"]",
"instruccion",
"=",
"instruccion",
".",
"replace",
"(",
"\"\\n\"",
",",
"\" \"",
")",
"lexema",
"=",
"\"\"",
"indiceInicial",
"=",
"0",
"tipoFuncion",
"=",
"''",
"for",
"x",
"in",
"range",
"(",
"len",
"(",
"instruccion",
")",
")",
":",
"if",
"instruccion",
"[",
"x",
"]",
"==",
"\" \"",
":",
"lexema",
"=",
"\"\"",
"else",
":",
"lexema",
"+=",
"instruccion",
"[",
"x",
"]",
"tipoFuncion",
"=",
"lexema",
".",
"lower",
"(",
")",
"if",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"use\"",
":",
"indiceInicial",
"=",
"x",
"-",
"2",
"break",
"elif",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"select\"",
"or",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"insert\"",
"or",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"update\"",
"or",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"delete\"",
"or",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"create\"",
":",
"indiceInicial",
"=",
"x",
"-",
"5",
"break",
"elif",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"truncate\"",
":",
"indiceInicial",
"=",
"x",
"-",
"7",
"break",
"elif",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"(select\"",
":",
"indiceInicial",
"=",
"x",
"-",
"5",
"break",
"elif",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"alter\"",
":",
"indiceInicial",
"=",
"x",
"-",
"4",
"break",
"elif",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"show\"",
"or",
"lexema",
".",
"lower",
"(",
")",
"==",
"\"drop\"",
":",
"indiceInicial",
"=",
"x",
"-",
"3",
"break",
"instruccionOK",
"=",
"''",
"while",
"(",
"indiceInicial",
"<",
"len",
"(",
"instruccion",
")",
")",
":",
"instruccionOK",
"+=",
"instruccion",
"[",
"indiceInicial",
"]",
"indiceInicial",
"+=",
"1",
"lexema",
"=",
"\"\"",
"if",
"tipoFuncion",
"==",
"\"(select\"",
":",
"instruccionOK",
"=",
"quitarParentesisSubquery",
"(",
"instruccionOK",
")",
"quitarParentesisFinal",
"=",
"False",
"tipoFuncion",
"=",
"\"select\"",
"if",
"tipoFuncion",
"==",
"\"select\"",
":",
"if",
"quitarParentesisFinal",
":",
"instruccionOK",
"=",
"quitarParentesisSubquery",
"(",
"instruccionOK",
")",
"aux",
"=",
"re",
".",
"sub",
"(",
"'select'",
",",
"\"\"",
",",
"instruccionOK",
")",
"aux",
"=",
"aux",
".",
"strip",
"(",
")",
"auxParams",
"=",
"''",
"for",
"x",
"in",
"aux",
":",
"auxParams",
"+=",
"x",
"if",
"x",
"==",
"\" \"",
":",
"lexema",
"=",
"\"\"",
"else",
":",
"lexema",
"+=",
"x",
".",
"lower",
"(",
")",
"if",
"lexema",
"==",
"\"from\"",
"or",
"lexema",
"==",
"\";\"",
":",
"# paro de buscar con un from o un punto y coma",
"break",
"auxParams",
"=",
"re",
".",
"sub",
"(",
"'from'",
",",
"\"\"",
",",
"auxParams",
")",
"auxParams",
"=",
"re",
".",
"sub",
"(",
"';'",
",",
"\"\"",
",",
"auxParams",
")",
"auxParams",
"=",
"auxParams",
".",
"strip",
"(",
")",
"parametros",
"=",
"mi_split",
"(",
"auxParams",
")",
"parametros",
"=",
"quitarEspacios",
"(",
"parametros",
")",
"patron",
"=",
"'[a-zA-Z_][a-zA-Z_0-9]*\\s*[(].*[)]'",
"for",
"parametro",
"in",
"parametros",
":",
"if",
"re",
".",
"match",
"(",
"patron",
",",
"parametro",
")",
":",
"objPattern",
"=",
"re",
".",
"search",
"(",
"patron",
",",
"parametro",
")",
"coincidencia",
"=",
"objPattern",
".",
"string",
"[",
"objPattern",
".",
"span",
"(",
")",
"[",
"0",
"]",
":",
"objPattern",
".",
"span",
"(",
")",
"[",
"1",
"]",
"]",
"# Y REEMPLAZO EL CODIGO 3D como un str(tn)",
"if",
"coincidencia",
"==",
"'count(*)'",
":",
"continue",
"if",
"getOnlyId",
"(",
"coincidencia",
")",
".",
"upper",
"(",
")",
"in",
"funcionesDefinidas",
":",
"# es de la fase 1 asi que se queda normal",
"pass",
"else",
":",
"# REPLACE",
"tn",
"=",
"self",
".",
"getNewTemporal",
"(",
")",
"salida",
"=",
"f'\\t{coincidencia}\\n\\t{tn} = RETURN[0]'",
"if",
"goToMain",
":",
"self",
".",
"addToMain",
"(",
"salida",
")",
"else",
":",
"tn_previos",
"+=",
"salida",
"+",
"'\\n'",
"instruccionOK",
"=",
"instruccionOK",
".",
"replace",
"(",
"coincidencia",
",",
"f'\\\"+str({tn})+\\\"'",
")",
"elif",
"tipoFuncion",
"==",
"\"insert\"",
":",
"aux",
"=",
"instruccionOK",
"aux",
"=",
"aux",
".",
"strip",
"(",
")",
"auxParams",
"=",
"''",
"for",
"x",
"in",
"aux",
":",
"if",
"x",
"==",
"\" \"",
":",
"lexema",
"=",
"\"\"",
"elif",
"x",
"==",
"\";\"",
":",
"break",
"else",
":",
"lexema",
"+=",
"x",
".",
"lower",
"(",
")",
"auxParams",
"+=",
"x",
"if",
"lexema",
"==",
"\"values\"",
":",
"auxParams",
"=",
"\"\"",
"elif",
"auxParams",
"==",
"\"values(\"",
":",
"auxParams",
"=",
"\"\"",
"+",
"\"(\"",
"auxParams",
"=",
"auxParams",
".",
"strip",
"(",
")",
"auxParams",
"=",
"auxParams",
"[",
"1",
":",
"len",
"(",
"auxParams",
")",
"-",
"1",
"]",
"# LE QUITO LOS PARENTESIS",
"parametros",
"=",
"mi_split",
"(",
"auxParams",
")",
"parametros",
"=",
"quitarEspacios",
"(",
"parametros",
")",
"patron",
"=",
"'[a-zA-Z_][a-zA-Z_0-9]*\\s*[(].*[)]'",
"for",
"parametro",
"in",
"parametros",
":",
"if",
"re",
".",
"match",
"(",
"patron",
",",
"parametro",
")",
":",
"objPattern",
"=",
"re",
".",
"search",
"(",
"patron",
",",
"parametro",
")",
"coincidencia",
"=",
"objPattern",
".",
"string",
"[",
"objPattern",
".",
"span",
"(",
")",
"[",
"0",
"]",
":",
"objPattern",
".",
"span",
"(",
")",
"[",
"1",
"]",
"]",
"# VERIFICO SI EXISTE EN LA ESTRUCUTRA Y REEMPLAZO EL CODIGO 3D como un str(tn)",
"if",
"getOnlyId",
"(",
"coincidencia",
")",
".",
"upper",
"(",
")",
"in",
"funcionesDefinidas",
":",
"pass",
"# no se traduce",
"else",
":",
"# REPLACE",
"# * SI SALE TODO BIEN",
"tn",
"=",
"self",
".",
"getNewTemporal",
"(",
")",
"salida",
"=",
"f'\\t{coincidencia}\\n\\t{tn} = RETURN[0]'",
"if",
"goToMain",
":",
"self",
".",
"addToMain",
"(",
"salida",
")",
"else",
":",
"tn_previos",
"+=",
"salida",
"+",
"'\\n'",
"instruccionOK",
"=",
"instruccionOK",
".",
"replace",
"(",
"coincidencia",
",",
"f'\\\"+str({tn})+\\\"'",
")",
"#va adentro de un procedure o funcion",
"if",
"goToMain",
":",
"return",
"instruccionOK",
"else",
":",
"tn",
"=",
"self",
".",
"getNewTemporal",
"(",
")",
"tres",
"=",
"self",
".",
"getNewTemporal",
"(",
")",
"#TEMPORAL RESULTANTE",
"instruccionOK",
"=",
"tn_previos",
"+",
"f'\\t{tn} = \"{instruccionOK}\"'",
"instruccionOK",
"+=",
"f'\\n\\tstack.push({tn})'",
"instruccionOK",
"+=",
"f\"\\n\\t{tres} = funcionIntermedia()\"",
"return",
"[",
"instruccionOK",
",",
"tres",
"]"
] | [
65,
4
] | [
207,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObject.index_frame | (self, frame: int) | Devuelve el índice dentro de los seguimientos del objeto en el que se detectó en el frame
indicado.
:param frame: número del frame en de la que se busca el índice del seguimiento del objeto.
:return: índice si es que está esa detección.
| Devuelve el índice dentro de los seguimientos del objeto en el que se detectó en el frame
indicado. | def index_frame(self, frame: int) -> Optional[int]:
"""Devuelve el índice dentro de los seguimientos del objeto en el que se detectó en el frame
indicado.
:param frame: número del frame en de la que se busca el índice del seguimiento del objeto.
:return: índice si es que está esa detección.
"""
try:
return self.frames.index(frame)
except ValueError:
return None | [
"def",
"index_frame",
"(",
"self",
",",
"frame",
":",
"int",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"try",
":",
"return",
"self",
".",
"frames",
".",
"index",
"(",
"frame",
")",
"except",
"ValueError",
":",
"return",
"None"
] | [
126,
4
] | [
136,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TextEditor.get_content | (self) | return self._content.strip() | Función que regresa el contenido de _content | Función que regresa el contenido de _content | def get_content(self):
"""Función que regresa el contenido de _content"""
return self._content.strip() | [
"def",
"get_content",
"(",
"self",
")",
":",
"return",
"self",
".",
"_content",
".",
"strip",
"(",
")"
] | [
14,
4
] | [
16,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Car.read_odometer | (self) | Imprima una declaración que muestre el millaje del automóvil. | Imprima una declaración que muestre el millaje del automóvil. | def read_odometer(self):
"""Imprima una declaración que muestre el millaje del automóvil."""
print("Este automóvil tiene" + str(self.odometer_reading) + " miles on it.") | [
"def",
"read_odometer",
"(",
"self",
")",
":",
"print",
"(",
"\"Este automóvil tiene\" ",
" ",
"tr(",
"s",
"elf.",
"o",
"dometer_reading)",
" ",
" ",
" miles on it.\")",
""
] | [
15,
4
] | [
17,
85
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProcControl.autoRemove | (self, item: Optional[str] = None) | Remueve los procesos/subprocesos finalizados pero no eliminados
Args:
item:
El nombre del proceso/subproceso
| Remueve los procesos/subprocesos finalizados pero no eliminados
Args:
item:
El nombre del proceso/subproceso
| def autoRemove(self, item: Optional[str] = None) -> None:
"""Remueve los procesos/subprocesos finalizados pero no eliminados
Args:
item:
El nombre del proceso/subproceso
"""
for procName in super().keys():
if (item is None):
items = copy.copy(super().__getitem__(procName))
for key in items.keys():
self._remove(procName, key)
else:
self._remove(procName, item) | [
"def",
"autoRemove",
"(",
"self",
",",
"item",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"None",
":",
"for",
"procName",
"in",
"super",
"(",
")",
".",
"keys",
"(",
")",
":",
"if",
"(",
"item",
"is",
"None",
")",
":",
"items",
"=",
"copy",
".",
"copy",
"(",
"super",
"(",
")",
".",
"__getitem__",
"(",
"procName",
")",
")",
"for",
"key",
"in",
"items",
".",
"keys",
"(",
")",
":",
"self",
".",
"_remove",
"(",
"procName",
",",
"key",
")",
"else",
":",
"self",
".",
"_remove",
"(",
"procName",
",",
"item",
")"
] | [
185,
4
] | [
201,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.string_regex_substitute | (self, field, regex_str_match,
regex_str_sub, sufix=None,
keep_original=True, inplace=False) | return replaced | Regla para manipular y reeemplazar datos de un campo con regex.
Args:
field (str): Campo a limpiar.
regex_str_match (str): Expresion regular a buscar
regex_str_sub (str): Expresion regular para el reemplazo.
Returns:
pandas.Series: Serie de strings limpios
| Regla para manipular y reeemplazar datos de un campo con regex. | def string_regex_substitute(self, field, regex_str_match,
regex_str_sub, sufix=None,
keep_original=True, inplace=False):
"""Regla para manipular y reeemplazar datos de un campo con regex.
Args:
field (str): Campo a limpiar.
regex_str_match (str): Expresion regular a buscar
regex_str_sub (str): Expresion regular para el reemplazo.
Returns:
pandas.Series: Serie de strings limpios
"""
sufix = sufix or self.DEFAULT_SUFIX
field = self._normalize_field(field)
series = self.df[field]
replaced = series.str.replace(regex_str_match, regex_str_sub)
if inplace:
self._update_series(field=field, sufix=sufix,
keep_original=keep_original,
new_series=replaced)
return replaced | [
"def",
"string_regex_substitute",
"(",
"self",
",",
"field",
",",
"regex_str_match",
",",
"regex_str_sub",
",",
"sufix",
"=",
"None",
",",
"keep_original",
"=",
"True",
",",
"inplace",
"=",
"False",
")",
":",
"sufix",
"=",
"sufix",
"or",
"self",
".",
"DEFAULT_SUFIX",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
"replaced",
"=",
"series",
".",
"str",
".",
"replace",
"(",
"regex_str_match",
",",
"regex_str_sub",
")",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"sufix",
"=",
"sufix",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"replaced",
")",
"return",
"replaced"
] | [
721,
4
] | [
744,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
create_index | (config) | Crea un índice de Elasticsearch con la configuración por defecto | Crea un índice de Elasticsearch con la configuración por defecto | def create_index(config):
"""Crea un índice de Elasticsearch con la configuración por defecto"""
es_client = Elasticsearch([config["URL"]])
with open('elastic-config.json', 'r', encoding="utf-8") as json_file:
es_config = json.loads(json_file.read())
print("\t⚙ Creando el índice con configuraciones por defecto ⚙")
try:
es_client.indices.create(index=config['INDEX'], body=es_config)
except elasticsearch.exceptions.ConnectionError:
print("[ERROR]: No se pudo conectar a la instancia de Elasticsearch :(")
print("¿Instalaste elasticsearch?")
print("Guia de instalación: https://www.elastic.co/guide/en/elasticsearch/reference/7.9/install-elasticsearch.html")
sys.exit(1)
except elasticsearch.exceptions.RequestError as e:
print(f"[ERROR]: No se pudo crear el índice {config['INDEX']}")
print(f"[REASON]: {e.error} [STATUS_CODE]: {e.status_code}")
print("Intentalo de nuevo cambiando el nombre del índice")
sys.exit(1)
print("\t⚙ Creado ⚙") | [
"def",
"create_index",
"(",
"config",
")",
":",
"es_client",
"=",
"Elasticsearch",
"(",
"[",
"config",
"[",
"\"URL\"",
"]",
"]",
")",
"with",
"open",
"(",
"'elastic-config.json'",
",",
"'r'",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"as",
"json_file",
":",
"es_config",
"=",
"json",
".",
"loads",
"(",
"json_file",
".",
"read",
"(",
")",
")",
"print",
"(",
"\"\\t⚙ Creando el índice con configuraciones por defecto ⚙\")",
"",
"try",
":",
"es_client",
".",
"indices",
".",
"create",
"(",
"index",
"=",
"config",
"[",
"'INDEX'",
"]",
",",
"body",
"=",
"es_config",
")",
"except",
"elasticsearch",
".",
"exceptions",
".",
"ConnectionError",
":",
"print",
"(",
"\"[ERROR]: No se pudo conectar a la instancia de Elasticsearch :(\"",
")",
"print",
"(",
"\"¿Instalaste elasticsearch?\")",
"",
"print",
"(",
"\"Guia de instalación: https://www.elastic.co/guide/en/elasticsearch/reference/7.9/install-elasticsearch.html\")",
"",
"sys",
".",
"exit",
"(",
"1",
")",
"except",
"elasticsearch",
".",
"exceptions",
".",
"RequestError",
"as",
"e",
":",
"print",
"(",
"f\"[ERROR]: No se pudo crear el índice {config['INDEX']}\")",
"",
"print",
"(",
"f\"[REASON]: {e.error} [STATUS_CODE]: {e.status_code}\"",
")",
"print",
"(",
"\"Intentalo de nuevo cambiando el nombre del índice\")",
"",
"sys",
".",
"exit",
"(",
"1",
")",
"print",
"(",
"\"\\t⚙ Creado ⚙\")",
""
] | [
98,
0
] | [
116,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
scrape_postal_code_url | (parameters) | return scraped_info | Función que crea una instancia de `UrlsExtractor` y ejecuta su función scrap. Esta función es llamada por el
pool de procesos para paralelizar la extracción de las urls por código postal.
Parameters
----------
parameters : dict
diccionario que contiene los campos para instanciar un objecto de la clase `UrlsExtractor`.
| Función que crea una instancia de `UrlsExtractor` y ejecuta su función scrap. Esta función es llamada por el
pool de procesos para paralelizar la extracción de las urls por código postal. | def scrape_postal_code_url(parameters):
""" Función que crea una instancia de `UrlsExtractor` y ejecuta su función scrap. Esta función es llamada por el
pool de procesos para paralelizar la extracción de las urls por código postal.
Parameters
----------
parameters : dict
diccionario que contiene los campos para instanciar un objecto de la clase `UrlsExtractor`.
"""
scraper = UrlsExtractor(driver_location=parameters.get("driver_location"),
country=parameters.get("country"),
postal_code=parameters.get("postal_code"),
output_config=parameters.get("output_config"))
scraped_info = scraper.scrap()
return scraped_info | [
"def",
"scrape_postal_code_url",
"(",
"parameters",
")",
":",
"scraper",
"=",
"UrlsExtractor",
"(",
"driver_location",
"=",
"parameters",
".",
"get",
"(",
"\"driver_location\"",
")",
",",
"country",
"=",
"parameters",
".",
"get",
"(",
"\"country\"",
")",
",",
"postal_code",
"=",
"parameters",
".",
"get",
"(",
"\"postal_code\"",
")",
",",
"output_config",
"=",
"parameters",
".",
"get",
"(",
"\"output_config\"",
")",
")",
"scraped_info",
"=",
"scraper",
".",
"scrap",
"(",
")",
"return",
"scraped_info"
] | [
15,
0
] | [
29,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
perfil_requerido | (perfil_id) | return decorator_verifica_acceso | Comprueba si un usuario tiene acceso a un recurso determinado en base a su tipo. | Comprueba si un usuario tiene acceso a un recurso determinado en base a su tipo. | def perfil_requerido(perfil_id):
"""Comprueba si un usuario tiene acceso a un recurso determinado en base a su tipo."""
def decorator_verifica_acceso(func):
@wraps(func)
def wrapper(*args, **kwargs):
if (current_user.is_authenticated and current_user.tipo == perfil_id) or current_user.tipo == "admin":
return func(*args, **kwargs)
else:
flash("No se encuentra autorizado a acceder al recurso solicitado.")
return abort(403)
return wrapper
return decorator_verifica_acceso | [
"def",
"perfil_requerido",
"(",
"perfil_id",
")",
":",
"def",
"decorator_verifica_acceso",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"(",
"current_user",
".",
"is_authenticated",
"and",
"current_user",
".",
"tipo",
"==",
"perfil_id",
")",
"or",
"current_user",
".",
"tipo",
"==",
"\"admin\"",
":",
"return",
"func",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"else",
":",
"flash",
"(",
"\"No se encuentra autorizado a acceder al recurso solicitado.\"",
")",
"return",
"abort",
"(",
"403",
")",
"return",
"wrapper",
"return",
"decorator_verifica_acceso"
] | [
533,
0
] | [
549,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioTSP.fcosto | (self, sol) | return costo_ruta | Calcula el costo asociado con una solución dada.
Entradas:
sol (list)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
| Calcula el costo asociado con una solución dada.
Entradas:
sol (list)
Solución cuyo costo se debe calcular | def fcosto(self, sol):
"""Calcula el costo asociado con una solución dada.
Entradas:
sol (list)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
"""
primera_visitada = self.ciudades[sol[0]]["km/min"]
costo_ruta = float(self.ciudades[self.i_ciudad_inicio][primera_visitada])
for i_ciudad in range(self.n_ciudades-2):
ciudad_sig = self.ciudades[sol[i_ciudad+1]]['km/min']
costo_ruta += float(self.ciudades[sol[i_ciudad]][ciudad_sig])
ultima_ciudad = self.i_ciudades[ciudad_sig]
costo_ruta += float(self.ciudades[ultima_ciudad][self.nombre_ciudad_inicio])
return costo_ruta | [
"def",
"fcosto",
"(",
"self",
",",
"sol",
")",
":",
"primera_visitada",
"=",
"self",
".",
"ciudades",
"[",
"sol",
"[",
"0",
"]",
"]",
"[",
"\"km/min\"",
"]",
"costo_ruta",
"=",
"float",
"(",
"self",
".",
"ciudades",
"[",
"self",
".",
"i_ciudad_inicio",
"]",
"[",
"primera_visitada",
"]",
")",
"for",
"i_ciudad",
"in",
"range",
"(",
"self",
".",
"n_ciudades",
"-",
"2",
")",
":",
"ciudad_sig",
"=",
"self",
".",
"ciudades",
"[",
"sol",
"[",
"i_ciudad",
"+",
"1",
"]",
"]",
"[",
"'km/min'",
"]",
"costo_ruta",
"+=",
"float",
"(",
"self",
".",
"ciudades",
"[",
"sol",
"[",
"i_ciudad",
"]",
"]",
"[",
"ciudad_sig",
"]",
")",
"ultima_ciudad",
"=",
"self",
".",
"i_ciudades",
"[",
"ciudad_sig",
"]",
"costo_ruta",
"+=",
"float",
"(",
"self",
".",
"ciudades",
"[",
"ultima_ciudad",
"]",
"[",
"self",
".",
"nombre_ciudad_inicio",
"]",
")",
"return",
"costo_ruta"
] | [
118,
4
] | [
138,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioAG.mutar | (self, sol) | Produce una nueva solución aplicando un ligero cambio a la solución dada por
parámetro.
Entradas:
sol (estructura de datos)
La solución a mutar.
Salidas:
(estructura de datos) Una nueva solución que refleja un ligero cambio con respecto
a la solución dada por parámetro
| Produce una nueva solución aplicando un ligero cambio a la solución dada por
parámetro. | def mutar(self, sol):
"""Produce una nueva solución aplicando un ligero cambio a la solución dada por
parámetro.
Entradas:
sol (estructura de datos)
La solución a mutar.
Salidas:
(estructura de datos) Una nueva solución que refleja un ligero cambio con respecto
a la solución dada por parámetro
"""
pass | [
"def",
"mutar",
"(",
"self",
",",
"sol",
")",
":",
"pass"
] | [
56,
4
] | [
69,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Tipo.tipoDecimal | (self) | devueleve el tipo indicado de tipo decimal | devueleve el tipo indicado de tipo decimal | def tipoDecimal(self):
'devueleve el tipo indicado de tipo decimal'
size=sys.getsizeof(self.valor)
if size<= 4:
return 'real'
elif size<=8:
if self.val>=-92233720368547758.08 and self.val <=92233720368547758.07:
return 'money'
return 'double'
else:
return 'decimal' | [
"def",
"tipoDecimal",
"(",
"self",
")",
":",
"size",
"=",
"sys",
".",
"getsizeof",
"(",
"self",
".",
"valor",
")",
"if",
"size",
"<=",
"4",
":",
"return",
"'real'",
"elif",
"size",
"<=",
"8",
":",
"if",
"self",
".",
"val",
">=",
"-",
"92233720368547758.08",
"and",
"self",
".",
"val",
"<=",
"92233720368547758.07",
":",
"return",
"'money'",
"return",
"'double'",
"else",
":",
"return",
"'decimal'"
] | [
21,
4
] | [
31,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AbstractGMapsExtractor._build_driver | (self, provided_driver_location=None, driver_options=None) | Función que genera y devuelve una instancia de selenium chromedriver. Hace llamada al
Parameters
----------
provided_driver_location: str
path donde ubicar el artefacto de selenium chromedriver. Si no está definida usará la que tenga deinfida la
clase en self._driver_location
driver_options: webdriver.ChromeOptions
instancia de opciones que se usará para generar el driver. Si no está definida llamará a la función
_get_driver_config para obtener las opciones por defecto
Returns
-------
chrome_options : webdriver.Chrome
| Función que genera y devuelve una instancia de selenium chromedriver. Hace llamada al | def _build_driver(self, provided_driver_location=None, driver_options=None):
"""Función que genera y devuelve una instancia de selenium chromedriver. Hace llamada al
Parameters
----------
provided_driver_location: str
path donde ubicar el artefacto de selenium chromedriver. Si no está definida usará la que tenga deinfida la
clase en self._driver_location
driver_options: webdriver.ChromeOptions
instancia de opciones que se usará para generar el driver. Si no está definida llamará a la función
_get_driver_config para obtener las opciones por defecto
Returns
-------
chrome_options : webdriver.Chrome
"""
driver_location = provided_driver_location if provided_driver_location else self._driver_location
options = driver_options if driver_options else self._get_driver_config()
# initialize the driver
driver = None
try:
driver = webdriver.Chrome(
executable_path=driver_location,
chrome_options=options)
driver.wait = WebDriverWait(driver, self._driver_wait)
driver.implicitly_wait(self._driver_implicit_wait)
except selenium.common.exceptions.WebDriverException as driverException:
if self._driver_build_intent == self._max_driver_build_intent:
self.logger.error("maximum retries to build driver reached. Aborting to generate driver")
self.logger.error(str(driverException))
else:
self.logger.warning("{exception_name} detected, trying to rebuild driver after short sleep time".format(
exception_name="selenium.common.exceptions.WebDriverException"))
self.force_sleep(self.sleep_xs)
self._driver_build_intent += 1
driver = self._build_driver(provided_driver_location=provided_driver_location,
driver_options=driver_options)
except Exception as e:
self.logger.error("not controlled error detected: {exception}".format(exception=str(e)))
finally:
return driver | [
"def",
"_build_driver",
"(",
"self",
",",
"provided_driver_location",
"=",
"None",
",",
"driver_options",
"=",
"None",
")",
":",
"driver_location",
"=",
"provided_driver_location",
"if",
"provided_driver_location",
"else",
"self",
".",
"_driver_location",
"options",
"=",
"driver_options",
"if",
"driver_options",
"else",
"self",
".",
"_get_driver_config",
"(",
")",
"# initialize the driver",
"driver",
"=",
"None",
"try",
":",
"driver",
"=",
"webdriver",
".",
"Chrome",
"(",
"executable_path",
"=",
"driver_location",
",",
"chrome_options",
"=",
"options",
")",
"driver",
".",
"wait",
"=",
"WebDriverWait",
"(",
"driver",
",",
"self",
".",
"_driver_wait",
")",
"driver",
".",
"implicitly_wait",
"(",
"self",
".",
"_driver_implicit_wait",
")",
"except",
"selenium",
".",
"common",
".",
"exceptions",
".",
"WebDriverException",
"as",
"driverException",
":",
"if",
"self",
".",
"_driver_build_intent",
"==",
"self",
".",
"_max_driver_build_intent",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"maximum retries to build driver reached. Aborting to generate driver\"",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"driverException",
")",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"{exception_name} detected, trying to rebuild driver after short sleep time\"",
".",
"format",
"(",
"exception_name",
"=",
"\"selenium.common.exceptions.WebDriverException\"",
")",
")",
"self",
".",
"force_sleep",
"(",
"self",
".",
"sleep_xs",
")",
"self",
".",
"_driver_build_intent",
"+=",
"1",
"driver",
"=",
"self",
".",
"_build_driver",
"(",
"provided_driver_location",
"=",
"provided_driver_location",
",",
"driver_options",
"=",
"driver_options",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"not controlled error detected: {exception}\"",
".",
"format",
"(",
"exception",
"=",
"str",
"(",
"e",
")",
")",
")",
"finally",
":",
"return",
"driver"
] | [
177,
4
] | [
219,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TwoPositionsSpeedAverage.calculate_speed | (self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) | return FloatVector2D(*speed) | Calcula la velocidad media entre las dos detecciones introducidas por parámetro.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: velocidad media.
| Calcula la velocidad media entre las dos detecciones introducidas por parámetro. | def calculate_speed(self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) -> FloatVector2D:
"""Calcula la velocidad media entre las dos detecciones introducidas por parámetro.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: velocidad media.
"""
distance = self.calculate_distance(tracked_object, index_initial, index_final)
time = self.calculate_time(tracked_object, index_initial, index_final)
speed = distance.x / time, distance.y / time
return FloatVector2D(*speed) | [
"def",
"calculate_speed",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
",",
"index_initial",
":",
"int",
"=",
"0",
",",
"index_final",
":",
"int",
"=",
"-",
"1",
")",
"->",
"FloatVector2D",
":",
"distance",
"=",
"self",
".",
"calculate_distance",
"(",
"tracked_object",
",",
"index_initial",
",",
"index_final",
")",
"time",
"=",
"self",
".",
"calculate_time",
"(",
"tracked_object",
",",
"index_initial",
",",
"index_final",
")",
"speed",
"=",
"distance",
".",
"x",
"/",
"time",
",",
"distance",
".",
"y",
"/",
"time",
"return",
"FloatVector2D",
"(",
"*",
"speed",
")"
] | [
60,
4
] | [
74,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Simulador.calc_tiempo_fin | (self) | Tiempo de finalización del vuelo. | Tiempo de finalización del vuelo. | def calc_tiempo_fin(self):
"""Tiempo de finalización del vuelo."""
tiempo = self.calc_tiempo()
tiempo_fin = self.tiempo_inicio + timedelta(seconds=tiempo)
self.tiempo_fin = tiempo_fin | [
"def",
"calc_tiempo_fin",
"(",
"self",
")",
":",
"tiempo",
"=",
"self",
".",
"calc_tiempo",
"(",
")",
"tiempo_fin",
"=",
"self",
".",
"tiempo_inicio",
"+",
"timedelta",
"(",
"seconds",
"=",
"tiempo",
")",
"self",
".",
"tiempo_fin",
"=",
"tiempo_fin"
] | [
50,
4
] | [
54,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
centro_de_salud_habilitado_form | (function) | return _inner | Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para los CREATE.
| Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para los CREATE.
| def centro_de_salud_habilitado_form(function):
'''Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para los CREATE.
'''
def _inner(request, *args, **kwargs):
centro = Servicio.objects.get(id=json.loads(request.body)['servicio']).centro
if request.user.centros_de_salud_permitidos.filter(centro_de_salud=centro).exists():
return function(request, *args, **kwargs)
else:
raise PermissionDenied("No tiene permiso para actuar en este centro de salud")
return _inner | [
"def",
"centro_de_salud_habilitado_form",
"(",
"function",
")",
":",
"def",
"_inner",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"centro",
"=",
"Servicio",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"json",
".",
"loads",
"(",
"request",
".",
"body",
")",
"[",
"'servicio'",
"]",
")",
".",
"centro",
"if",
"request",
".",
"user",
".",
"centros_de_salud_permitidos",
".",
"filter",
"(",
"centro_de_salud",
"=",
"centro",
")",
".",
"exists",
"(",
")",
":",
"return",
"function",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"else",
":",
"raise",
"PermissionDenied",
"(",
"\"No tiene permiso para actuar en este centro de salud\"",
")",
"return",
"_inner"
] | [
6,
0
] | [
17,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ServiceCallback.service2net | (
self,
service_name: str,
show_ids: bool = False, *,
cursor
) | Obtiene todas las redes que tienen un servicio específico
Args:
service_name:
El nombre del servicio
show_ids:
**True** para mostrar además la dirección de la red, el identificador de éste;
**False** para mostrar solo la dirección.
Returns:
Un iterador asincrónico con las redes obtenidas
| Obtiene todas las redes que tienen un servicio específico
Args:
service_name:
El nombre del servicio | async def service2net(
self,
service_name: str,
show_ids: bool = False, *,
cursor
) -> AsyncIterator[Union[Tuple[int, str], Tuple[str]]]:
"""Obtiene todas las redes que tienen un servicio específico
Args:
service_name:
El nombre del servicio
show_ids:
**True** para mostrar además la dirección de la red, el identificador de éste;
**False** para mostrar solo la dirección.
Returns:
Un iterador asincrónico con las redes obtenidas
"""
ids = self.service2id(
service_name, cursor=cursor
)
async for networkid in ids:
network = await self.id2network(*networkid, cursor=cursor)
if (show_ids):
yield networkid + network
else:
yield network | [
"async",
"def",
"service2net",
"(",
"self",
",",
"service_name",
":",
"str",
",",
"show_ids",
":",
"bool",
"=",
"False",
",",
"*",
",",
"cursor",
")",
"->",
"AsyncIterator",
"[",
"Union",
"[",
"Tuple",
"[",
"int",
",",
"str",
"]",
",",
"Tuple",
"[",
"str",
"]",
"]",
"]",
":",
"ids",
"=",
"self",
".",
"service2id",
"(",
"service_name",
",",
"cursor",
"=",
"cursor",
")",
"async",
"for",
"networkid",
"in",
"ids",
":",
"network",
"=",
"await",
"self",
".",
"id2network",
"(",
"*",
"networkid",
",",
"cursor",
"=",
"cursor",
")",
"if",
"(",
"show_ids",
")",
":",
"yield",
"networkid",
"+",
"network",
"else",
":",
"yield",
"network"
] | [
698,
4
] | [
731,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_declaraciones2 | (t) | declaraciones : declaracion | declaraciones : declaracion | def p_declaraciones2(t):
'declaraciones : declaracion'
t[0] = [t[1]] | [
"def",
"p_declaraciones2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
314,
0
] | [
316,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
sueldo | (cargo: str) | return dinero | Devuelve el sueldo acorde al cargo del trabajador.
:param cargo: Cargo del trabajador.
:cargo type: str
:return: Sueldo del trabajador
:rtype: int
>>> sueldo("Externo")
50
| Devuelve el sueldo acorde al cargo del trabajador. | def sueldo(cargo: str) -> int:
"""Devuelve el sueldo acorde al cargo del trabajador.
:param cargo: Cargo del trabajador.
:cargo type: str
:return: Sueldo del trabajador
:rtype: int
>>> sueldo("Externo")
50
"""
dinero = 0
cargo = cargo.capitalize()
if cargo == "Externo":
dinero = 50
elif cargo == "Ejecutivo":
dinero = 90
elif cargo == "Jefe":
dinero = 100
return dinero | [
"def",
"sueldo",
"(",
"cargo",
":",
"str",
")",
"->",
"int",
":",
"dinero",
"=",
"0",
"cargo",
"=",
"cargo",
".",
"capitalize",
"(",
")",
"if",
"cargo",
"==",
"\"Externo\"",
":",
"dinero",
"=",
"50",
"elif",
"cargo",
"==",
"\"Ejecutivo\"",
":",
"dinero",
"=",
"90",
"elif",
"cargo",
"==",
"\"Jefe\"",
":",
"dinero",
"=",
"100",
"return",
"dinero"
] | [
17,
0
] | [
36,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
IIterator.has_more | (self) | Regresa True si hay mas elementos en el iterable, False si no | Regresa True si hay mas elementos en el iterable, False si no | def has_more(self):
""" Regresa True si hay mas elementos en el iterable, False si no """
pass | [
"def",
"has_more",
"(",
"self",
")",
":",
"pass"
] | [
12,
4
] | [
14,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
hacer_gris | (imagen_original) | return imagen_gris | pone la foto en escala de grises
toma el valor maximo del rgb de cada pixel
| pone la foto en escala de grises
toma el valor maximo del rgb de cada pixel
| def hacer_gris(imagen_original):
"""pone la foto en escala de grises
toma el valor maximo del rgb de cada pixel
"""
x, y = imagen_original.size
imagen_gris = Image.new("RGB", (x,y))
pixeles = []
for a in range(y):
for b in range(x):
r, g, b = imagen_original.getpixel((b, a))
rgb = (r, g, b)
#se elige el valor mas grande
maximo = max(rgb)
data = (maximo, maximo, maximo)
pixeles.append(data)
imagen_gris.putdata(pixeles)
imagen_gris.save("imagen_gris.png")
return imagen_gris | [
"def",
"hacer_gris",
"(",
"imagen_original",
")",
":",
"x",
",",
"y",
"=",
"imagen_original",
".",
"size",
"imagen_gris",
"=",
"Image",
".",
"new",
"(",
"\"RGB\"",
",",
"(",
"x",
",",
"y",
")",
")",
"pixeles",
"=",
"[",
"]",
"for",
"a",
"in",
"range",
"(",
"y",
")",
":",
"for",
"b",
"in",
"range",
"(",
"x",
")",
":",
"r",
",",
"g",
",",
"b",
"=",
"imagen_original",
".",
"getpixel",
"(",
"(",
"b",
",",
"a",
")",
")",
"rgb",
"=",
"(",
"r",
",",
"g",
",",
"b",
")",
"#se elige el valor mas grande",
"maximo",
"=",
"max",
"(",
"rgb",
")",
"data",
"=",
"(",
"maximo",
",",
"maximo",
",",
"maximo",
")",
"pixeles",
".",
"append",
"(",
"data",
")",
"imagen_gris",
".",
"putdata",
"(",
"pixeles",
")",
"imagen_gris",
".",
"save",
"(",
"\"imagen_gris.png\"",
")",
"return",
"imagen_gris"
] | [
76,
0
] | [
93,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlacesExtractor._force_scrap | (self, provided_driver=None) | Función auxiliar que contiene la lógica de realizar el scrapping en caso de que la url de de búsqueda nos
redirija a una página de resultados en lugar de la página del local comercial.
Arguments
---------
provided_driver : webdriver.Chrome
driver sobre el que se usará para realizar la extracción. En caso de no estar definido se usará el de que
tenga definida la clase
Returns
-------
dict
devuelve el contenido de la información extraída en un diccionario python
| Función auxiliar que contiene la lógica de realizar el scrapping en caso de que la url de de búsqueda nos
redirija a una página de resultados en lugar de la página del local comercial. | def _force_scrap(self, provided_driver=None):
"""Función auxiliar que contiene la lógica de realizar el scrapping en caso de que la url de de búsqueda nos
redirija a una página de resultados en lugar de la página del local comercial.
Arguments
---------
provided_driver : webdriver.Chrome
driver sobre el que se usará para realizar la extracción. En caso de no estar definido se usará el de que
tenga definida la clase
Returns
-------
dict
devuelve el contenido de la información extraída en un diccionario python
"""
driver = provided_driver if provided_driver else self.get_driver()
# inicialización de la información que ya se conoce del local comercial
place_info = {
"name": self._place_name,
"zip_code": self._postal_code,
"date": self._extraction_date,
"address": self._place_address,
"execution_places_types": self._places_types,
"extractor_url": self._url
}
try:
# self.force_sleep(self.sleep_xs)
# búsqueda del local comercial en el listado de resultados: `self.shared_result_elements_xpath_query`
driver.wait.until(
ec.visibility_of_all_elements_located((By.XPATH, self.shared_result_elements_xpath_query)))
page_elements = driver.find_elements_by_xpath(self.shared_result_elements_xpath_query)
place_obj = self.found_place_in_list(page_elements)
# places_objs = {place.text.split("\n")[0]: place for place in page_elements}
# if self._place_name in places_objs.keys():
if place_obj:
# el nombre del local comercial se encuentra en los resultados y se procede a clickar sobre él y extraer
# la información una vez se haya cargado la página del local comercial
self.logger.info("-{place}-: found in search list due to ambiguous name nearby".format(
place=self._place_name))
# found_place = places_objs.get(self._place_name)
found_place = place_obj
driver.execute_script("arguments[0].click();", found_place)
driver.wait.until(ec.url_changes(self._url))
self.logger.debug("-{place}-: place clicked, current url: {url}".format(place=self._place_name,
url=driver.current_url))
# self.force_sleep(self.sleep_m)
place_info = self._get_place_info(provided_driver=driver)
else:
self.logger.warning("-{place}-: was not found in search list".format(place=self._place_name))
new_url_parts = self._url.split("/")
new_url_prefix = "/".join(new_url_parts[0:-2])
name_formatted = self._place_name.replace(" ", "+")
address_formatted = self._place_address.replace(" ", "+")
new_url = "{prefix}/{address}+{name}/{coords}".format(
prefix=new_url_prefix,
address=address_formatted,
name=name_formatted,
coords=new_url_parts[-1]
)
self.logger.warning("-{place}-: will be forced to url: {url}".format(place=self._place_name, url=new_url))
driver.get(new_url)
try:
driver.wait.until(
ec.visibility_of_all_elements_located((By.XPATH, self.shared_result_elements_xpath_query)))
page_elements = driver.find_elements_by_xpath(self.shared_result_elements_xpath_query)
place_obj = self.found_place_in_list(page_elements)
if place_obj:
# el nombre del local comercial se encuentra en los resultados y se procede a clickar sobre él y extraer
# la información una vez se haya cargado la página del local comercial
self.logger.debug("-{place}-: found in search list in -{url}-".format(
place=self._place_name, url=new_url))
# found_place = places_objs.get(self._place_name)
found_place = place_obj
driver.execute_script("arguments[0].click();", found_place)
driver.wait.until(ec.url_changes(driver.current_url))
self.force_sleep(self.sleep_m)
place_info = self._get_place_info(provided_driver=driver)
except TimeoutException as te:
current_url = driver.current_url
if new_url != current_url:
self.logger.warning("-{place}-: search url -{url}- has changed to {c_url}"
.format(place=self._place_name, url=new_url, c_url=current_url))
place_info = self._get_place_info(provided_driver=driver)
except StaleElementReferenceException as sere:
# se ha detectado un error tratando de acceder a algún elemento del DOM de la página y se vuelve a intentar
# extraer la información sin volver a procesar ninguna URL. Llamada recursiva a _scrap
self.logger.error(str(sere))
self.logger.warning("-{place}-: StaleElementReferenceException detected: accessing to ambiguous results: -{url}-".format(
place=self._place_name, url=driver.current_url))
if self._retries < self._max_retries:
self._retries += 1
place_info = self._force_scrap(driver)
else:
self.logger.warning("-{place}-: aborting retrying to force scraping due to max retries reached".format(
place=self._place_name))
except TimeoutException as te:
# se ha detectado de timeout esprando a que la página termine de cargar y se vuelve a intentar a
# extraer la información sin volver a procesar ninguna URL. Llamada recursiva a _scrap
self.logger.error(str(te))
self.logger.warning("-{place}-: TimeoutException detected: accessing to ambiguous results: -{url}-".format(
place=self._place_name, url=driver.current_url))
current_url = driver.current_url
if 'place' in current_url or current_url != self._url:
self.logger.warning(
"-{place}-: place url -{url}- is not the same to -{c_url}-".format(
place=self._place_name, url=self._url, c_url=driver.current_url))
place_info = self._get_place_info(provided_driver=driver)
else:
if self._retries < self._max_retries:
self._retries += 1
place_info = self._force_scrap(driver)
else:
self.logger.warning("-{place}-: aborting retrying to force scraping due to max retries reached".format(
place=self._place_name))
except Exception as e:
# error no controlado durante la extracción de la información. Se sale de la ejecución sin forzar la
# extracción de la información
self.logger.error(str(e))
self.logger.warning("-{place}-: uncaught Exception detected: accesing to ambiguous results: -{url}-".format(
place=self._place_name, url=driver.current_url))
finally:
return place_info | [
"def",
"_force_scrap",
"(",
"self",
",",
"provided_driver",
"=",
"None",
")",
":",
"driver",
"=",
"provided_driver",
"if",
"provided_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"# inicialización de la información que ya se conoce del local comercial",
"place_info",
"=",
"{",
"\"name\"",
":",
"self",
".",
"_place_name",
",",
"\"zip_code\"",
":",
"self",
".",
"_postal_code",
",",
"\"date\"",
":",
"self",
".",
"_extraction_date",
",",
"\"address\"",
":",
"self",
".",
"_place_address",
",",
"\"execution_places_types\"",
":",
"self",
".",
"_places_types",
",",
"\"extractor_url\"",
":",
"self",
".",
"_url",
"}",
"try",
":",
"# self.force_sleep(self.sleep_xs)",
"# búsqueda del local comercial en el listado de resultados: `self.shared_result_elements_xpath_query`",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"visibility_of_all_elements_located",
"(",
"(",
"By",
".",
"XPATH",
",",
"self",
".",
"shared_result_elements_xpath_query",
")",
")",
")",
"page_elements",
"=",
"driver",
".",
"find_elements_by_xpath",
"(",
"self",
".",
"shared_result_elements_xpath_query",
")",
"place_obj",
"=",
"self",
".",
"found_place_in_list",
"(",
"page_elements",
")",
"# places_objs = {place.text.split(\"\\n\")[0]: place for place in page_elements}",
"# if self._place_name in places_objs.keys():",
"if",
"place_obj",
":",
"# el nombre del local comercial se encuentra en los resultados y se procede a clickar sobre él y extraer",
"# la información una vez se haya cargado la página del local comercial",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: found in search list due to ambiguous name nearby\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
")",
")",
"# found_place = places_objs.get(self._place_name)",
"found_place",
"=",
"place_obj",
"driver",
".",
"execute_script",
"(",
"\"arguments[0].click();\"",
",",
"found_place",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"url_changes",
"(",
"self",
".",
"_url",
")",
")",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{place}-: place clicked, current url: {url}\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"driver",
".",
"current_url",
")",
")",
"# self.force_sleep(self.sleep_m)",
"place_info",
"=",
"self",
".",
"_get_place_info",
"(",
"provided_driver",
"=",
"driver",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: was not found in search list\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
")",
")",
"new_url_parts",
"=",
"self",
".",
"_url",
".",
"split",
"(",
"\"/\"",
")",
"new_url_prefix",
"=",
"\"/\"",
".",
"join",
"(",
"new_url_parts",
"[",
"0",
":",
"-",
"2",
"]",
")",
"name_formatted",
"=",
"self",
".",
"_place_name",
".",
"replace",
"(",
"\" \"",
",",
"\"+\"",
")",
"address_formatted",
"=",
"self",
".",
"_place_address",
".",
"replace",
"(",
"\" \"",
",",
"\"+\"",
")",
"new_url",
"=",
"\"{prefix}/{address}+{name}/{coords}\"",
".",
"format",
"(",
"prefix",
"=",
"new_url_prefix",
",",
"address",
"=",
"address_formatted",
",",
"name",
"=",
"name_formatted",
",",
"coords",
"=",
"new_url_parts",
"[",
"-",
"1",
"]",
")",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: will be forced to url: {url}\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"new_url",
")",
")",
"driver",
".",
"get",
"(",
"new_url",
")",
"try",
":",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"visibility_of_all_elements_located",
"(",
"(",
"By",
".",
"XPATH",
",",
"self",
".",
"shared_result_elements_xpath_query",
")",
")",
")",
"page_elements",
"=",
"driver",
".",
"find_elements_by_xpath",
"(",
"self",
".",
"shared_result_elements_xpath_query",
")",
"place_obj",
"=",
"self",
".",
"found_place_in_list",
"(",
"page_elements",
")",
"if",
"place_obj",
":",
"# el nombre del local comercial se encuentra en los resultados y se procede a clickar sobre él y extraer",
"# la información una vez se haya cargado la página del local comercial",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{place}-: found in search list in -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"new_url",
")",
")",
"# found_place = places_objs.get(self._place_name)",
"found_place",
"=",
"place_obj",
"driver",
".",
"execute_script",
"(",
"\"arguments[0].click();\"",
",",
"found_place",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"url_changes",
"(",
"driver",
".",
"current_url",
")",
")",
"self",
".",
"force_sleep",
"(",
"self",
".",
"sleep_m",
")",
"place_info",
"=",
"self",
".",
"_get_place_info",
"(",
"provided_driver",
"=",
"driver",
")",
"except",
"TimeoutException",
"as",
"te",
":",
"current_url",
"=",
"driver",
".",
"current_url",
"if",
"new_url",
"!=",
"current_url",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: search url -{url}- has changed to {c_url}\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"new_url",
",",
"c_url",
"=",
"current_url",
")",
")",
"place_info",
"=",
"self",
".",
"_get_place_info",
"(",
"provided_driver",
"=",
"driver",
")",
"except",
"StaleElementReferenceException",
"as",
"sere",
":",
"# se ha detectado un error tratando de acceder a algún elemento del DOM de la página y se vuelve a intentar",
"# extraer la información sin volver a procesar ninguna URL. Llamada recursiva a _scrap",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"sere",
")",
")",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: StaleElementReferenceException detected: accessing to ambiguous results: -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"driver",
".",
"current_url",
")",
")",
"if",
"self",
".",
"_retries",
"<",
"self",
".",
"_max_retries",
":",
"self",
".",
"_retries",
"+=",
"1",
"place_info",
"=",
"self",
".",
"_force_scrap",
"(",
"driver",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: aborting retrying to force scraping due to max retries reached\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
")",
")",
"except",
"TimeoutException",
"as",
"te",
":",
"# se ha detectado de timeout esprando a que la página termine de cargar y se vuelve a intentar a",
"# extraer la información sin volver a procesar ninguna URL. Llamada recursiva a _scrap",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"te",
")",
")",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: TimeoutException detected: accessing to ambiguous results: -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"driver",
".",
"current_url",
")",
")",
"current_url",
"=",
"driver",
".",
"current_url",
"if",
"'place'",
"in",
"current_url",
"or",
"current_url",
"!=",
"self",
".",
"_url",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: place url -{url}- is not the same to -{c_url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"self",
".",
"_url",
",",
"c_url",
"=",
"driver",
".",
"current_url",
")",
")",
"place_info",
"=",
"self",
".",
"_get_place_info",
"(",
"provided_driver",
"=",
"driver",
")",
"else",
":",
"if",
"self",
".",
"_retries",
"<",
"self",
".",
"_max_retries",
":",
"self",
".",
"_retries",
"+=",
"1",
"place_info",
"=",
"self",
".",
"_force_scrap",
"(",
"driver",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: aborting retrying to force scraping due to max retries reached\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"# error no controlado durante la extracción de la información. Se sale de la ejecución sin forzar la",
"# extracción de la información",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: uncaught Exception detected: accesing to ambiguous results: -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"driver",
".",
"current_url",
")",
")",
"finally",
":",
"return",
"place_info"
] | [
461,
4
] | [
582,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_Bom_Production._get_tracking_move_raw_ids | (self) | Toma las lineas de la orden de producción. | Toma las lineas de la orden de producción. | def _get_tracking_move_raw_ids(self):
""" Toma las lineas de la orden de producción. """
lines_name = ''
for line in self.move_raw_ids:
if line.fab_product:
if line.product_id.product_template_attribute_value_ids.name:
lines_name += line.fab_product.name +','+ line.product_id.name +','+ line.product_id.product_template_attribute_value_ids.name +','+ str(line.product_uom_qty) +','+ line.product_uom.name + '/'
else:
lines_name += line.fab_product.name +','+ line.product_id.name +','+ str(line.product_uom_qty) +','+ line.product_uom.name + '/'
else:
if line.product_id.product_template_attribute_value_ids.name:
lines_name += line.product_id.name +','+ line.product_id.product_template_attribute_value_ids.name +','+ str(line.product_uom_qty) +','+ line.product_uom.name + '/'
else:
lines_name += line.product_id.name +','+ str(line.product_uom_qty) +','+ line.product_uom.name + '/'
self.trancking_move_raw_ids = lines_name | [
"def",
"_get_tracking_move_raw_ids",
"(",
"self",
")",
":",
"lines_name",
"=",
"''",
"for",
"line",
"in",
"self",
".",
"move_raw_ids",
":",
"if",
"line",
".",
"fab_product",
":",
"if",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
":",
"lines_name",
"+=",
"line",
".",
"fab_product",
".",
"name",
"+",
"','",
"+",
"line",
".",
"product_id",
".",
"name",
"+",
"','",
"+",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_uom_qty",
")",
"+",
"','",
"+",
"line",
".",
"product_uom",
".",
"name",
"+",
"'/'",
"else",
":",
"lines_name",
"+=",
"line",
".",
"fab_product",
".",
"name",
"+",
"','",
"+",
"line",
".",
"product_id",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_uom_qty",
")",
"+",
"','",
"+",
"line",
".",
"product_uom",
".",
"name",
"+",
"'/'",
"else",
":",
"if",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
":",
"lines_name",
"+=",
"line",
".",
"product_id",
".",
"name",
"+",
"','",
"+",
"line",
".",
"product_id",
".",
"product_template_attribute_value_ids",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_uom_qty",
")",
"+",
"','",
"+",
"line",
".",
"product_uom",
".",
"name",
"+",
"'/'",
"else",
":",
"lines_name",
"+=",
"line",
".",
"product_id",
".",
"name",
"+",
"','",
"+",
"str",
"(",
"line",
".",
"product_uom_qty",
")",
"+",
"','",
"+",
"line",
".",
"product_uom",
".",
"name",
"+",
"'/'",
"self",
".",
"trancking_move_raw_ids",
"=",
"lines_name"
] | [
75,
4
] | [
89,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner._get_api_response | (entity_level, data) | return results | Realiza búsquedas sobre un listado de entidades en simultáneo
utilizando el método bulk de la API de normalización Georef.
Args:
entity_level (str): Nivel de la unidad territorial a consultar.
data (dict): Diccionario que contiene un listado de unidades
territoriales.
Returns:
results (list): Lista con resultados de la búsqueda.
| Realiza búsquedas sobre un listado de entidades en simultáneo
utilizando el método bulk de la API de normalización Georef. | def _get_api_response(entity_level, data):
"""Realiza búsquedas sobre un listado de entidades en simultáneo
utilizando el método bulk de la API de normalización Georef.
Args:
entity_level (str): Nivel de la unidad territorial a consultar.
data (dict): Diccionario que contiene un listado de unidades
territoriales.
Returns:
results (list): Lista con resultados de la búsqueda.
"""
wrapper = GeorefWrapper()
if entity_level in PROV:
results = wrapper.search_province(data)
elif entity_level in DEPT:
results = wrapper.search_departament(data)
elif entity_level in MUN:
results = wrapper.search_municipality(data)
else:
results = wrapper.search_locality(data)
return results | [
"def",
"_get_api_response",
"(",
"entity_level",
",",
"data",
")",
":",
"wrapper",
"=",
"GeorefWrapper",
"(",
")",
"if",
"entity_level",
"in",
"PROV",
":",
"results",
"=",
"wrapper",
".",
"search_province",
"(",
"data",
")",
"elif",
"entity_level",
"in",
"DEPT",
":",
"results",
"=",
"wrapper",
".",
"search_departament",
"(",
"data",
")",
"elif",
"entity_level",
"in",
"MUN",
":",
"results",
"=",
"wrapper",
".",
"search_municipality",
"(",
"data",
")",
"else",
":",
"results",
"=",
"wrapper",
".",
"search_locality",
"(",
"data",
")",
"return",
"results"
] | [
936,
4
] | [
957,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_argument_funciones_matematicas | (t) | argument : funcionesmatematicas | argument : funcionesmatematicas | def p_argument_funciones_matematicas(t):
'''argument : funcionesmatematicas''' | [
"def",
"p_argument_funciones_matematicas",
"(",
"t",
")",
":"
] | [
443,
0
] | [
444,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
crearPiezas | () | Crea las imagenes de las piezas en un tamaño 19x19 y de un color específico | Crea las imagenes de las piezas en un tamaño 19x19 y de un color específico | def crearPiezas():
'''Crea las imagenes de las piezas en un tamaño 19x19 y de un color específico'''
img = Image.new('RGBA', (19, 19), "red")
img.save('./res/FormarCubo/red1.png')
img = Image.new('RGBA', (19, 19), "blue")
img.save('./res/FormarCubo/blue.png')
img = Image.new('RGBA', (19, 19), "white")
img.save('./res/FormarCubo/white.png')
img = Image.new('RGBA', (19, 19), "green")
img.save('./res/FormarCubo/green.png')
img = Image.new('RGBA', (19, 19), "orange")
img.save('./res/FormarCubo/orange.png')
img = Image.new('RGBA', (19, 19), "yellow")
img.save('./res/FormarCubo/yellow.png') | [
"def",
"crearPiezas",
"(",
")",
":",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"red\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/red1.png'",
")",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"blue\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/blue.png'",
")",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"white\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/white.png'",
")",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"green\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/green.png'",
")",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"orange\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/orange.png'",
")",
"img",
"=",
"Image",
".",
"new",
"(",
"'RGBA'",
",",
"(",
"19",
",",
"19",
")",
",",
"\"yellow\"",
")",
"img",
".",
"save",
"(",
"'./res/FormarCubo/yellow.png'",
")"
] | [
109,
0
] | [
129,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DominioTSP.validar | (self, sol) | return True | Valida que la solución dada cumple con los requisitos del problema.
Si n es el número de ciudades en el grafo, la solución debe:
- Tener tamaño (n-1)
- Contener sólo números enteros menores que n (las ciudades se numeran de 0 a (n-1))
- No contener elementos repetidos
- No contener la ciudad de inicio/fin del circuito
Entradas:
sol (list)
La solución a validar.
Salidas:
(bool) True si la solución es válida, False en cualquier otro caso
| Valida que la solución dada cumple con los requisitos del problema.
Si n es el número de ciudades en el grafo, la solución debe:
- Tener tamaño (n-1)
- Contener sólo números enteros menores que n (las ciudades se numeran de 0 a (n-1))
- No contener elementos repetidos
- No contener la ciudad de inicio/fin del circuito | def validar(self, sol):
"""Valida que la solución dada cumple con los requisitos del problema.
Si n es el número de ciudades en el grafo, la solución debe:
- Tener tamaño (n-1)
- Contener sólo números enteros menores que n (las ciudades se numeran de 0 a (n-1))
- No contener elementos repetidos
- No contener la ciudad de inicio/fin del circuito
Entradas:
sol (list)
La solución a validar.
Salidas:
(bool) True si la solución es válida, False en cualquier otro caso
"""
repetidos = [x for x, y in collections.Counter(sol).items() if y > 1]
if len(sol) != self.n_ciudades-1:
return False
if repetidos != []:
return False
for entero in sol:
if entero > len(sol):
return False
if self.i_ciudad_inicio == entero:
return False
return True | [
"def",
"validar",
"(",
"self",
",",
"sol",
")",
":",
"repetidos",
"=",
"[",
"x",
"for",
"x",
",",
"y",
"in",
"collections",
".",
"Counter",
"(",
"sol",
")",
".",
"items",
"(",
")",
"if",
"y",
">",
"1",
"]",
"if",
"len",
"(",
"sol",
")",
"!=",
"self",
".",
"n_ciudades",
"-",
"1",
":",
"return",
"False",
"if",
"repetidos",
"!=",
"[",
"]",
":",
"return",
"False",
"for",
"entero",
"in",
"sol",
":",
"if",
"entero",
">",
"len",
"(",
"sol",
")",
":",
"return",
"False",
"if",
"self",
".",
"i_ciudad_inicio",
"==",
"entero",
":",
"return",
"False",
"return",
"True"
] | [
54,
4
] | [
80,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
primos_gemelos | (n1: int, n2: int) | return [(i, i + 2) for i in primos if es_primo(i + 2)] | Devuelve una lista de tuplas con los primos gemelos entre n1 y n2.
:param n1: Primer número
:type n1: int
:param n2: Segundo número
:type n2: int
:return: Lista de tuplas de primos gemelos
:rtype: list
| Devuelve una lista de tuplas con los primos gemelos entre n1 y n2. | def primos_gemelos(n1: int, n2: int) -> List[Tuple[int, int]]:
"""Devuelve una lista de tuplas con los primos gemelos entre n1 y n2.
:param n1: Primer número
:type n1: int
:param n2: Segundo número
:type n2: int
:return: Lista de tuplas de primos gemelos
:rtype: list
"""
primos: Iterable = (i for i in range(n1, n2 + 1) if es_primo(i))
return [(i, i + 2) for i in primos if es_primo(i + 2)] | [
"def",
"primos_gemelos",
"(",
"n1",
":",
"int",
",",
"n2",
":",
"int",
")",
"->",
"List",
"[",
"Tuple",
"[",
"int",
",",
"int",
"]",
"]",
":",
"primos",
":",
"Iterable",
"=",
"(",
"i",
"for",
"i",
"in",
"range",
"(",
"n1",
",",
"n2",
"+",
"1",
")",
"if",
"es_primo",
"(",
"i",
")",
")",
"return",
"[",
"(",
"i",
",",
"i",
"+",
"2",
")",
"for",
"i",
"in",
"primos",
"if",
"es_primo",
"(",
"i",
"+",
"2",
")",
"]"
] | [
36,
0
] | [
47,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ProductModelSerializer.validate_code | (self, data) | return data | Verificamos si el producto existe. | Verificamos si el producto existe. | def validate_code(self, data):
"""Verificamos si el producto existe."""
product = Product.objects.filter(code=data, is_active=True)
if product.exists():
raise serializers.ValidationError('Producto ya existe.')
return data | [
"def",
"validate_code",
"(",
"self",
",",
"data",
")",
":",
"product",
"=",
"Product",
".",
"objects",
".",
"filter",
"(",
"code",
"=",
"data",
",",
"is_active",
"=",
"True",
")",
"if",
"product",
".",
"exists",
"(",
")",
":",
"raise",
"serializers",
".",
"ValidationError",
"(",
"'Producto ya existe.'",
")",
"return",
"data"
] | [
44,
4
] | [
49,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
participants | (request) | return render(request, "participants.html") | **Muestra la página de participantes**
Vista encargada de mostrar la sección de participantes con los nombres de
los participantes y ligas de contacto con la comunidad Elotl
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Vista de participantes
| **Muestra la página de participantes** | def participants(request):
"""**Muestra la página de participantes**
Vista encargada de mostrar la sección de participantes con los nombres de
los participantes y ligas de contacto con la comunidad Elotl
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Vista de participantes
"""
LOGGER.info("Entrando a participants")
return render(request, "participants.html") | [
"def",
"participants",
"(",
"request",
")",
":",
"LOGGER",
".",
"info",
"(",
"\"Entrando a participants\"",
")",
"return",
"render",
"(",
"request",
",",
"\"participants.html\"",
")"
] | [
106,
0
] | [
118,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
boundingBox | (img) | return x,y,w,h | Función para calcular la caja englobante del carácter
representado en la imagen que se pasa como parámetro
Args:
img: imagen en la que se quiere calcular la caja englobante
Returns:
x,y: coordenadas de la esquina superior izquierda de la caja
w: ancho de la caja
h: altura de la caja
| Función para calcular la caja englobante del carácter
representado en la imagen que se pasa como parámetro
Args:
img: imagen en la que se quiere calcular la caja englobante
Returns:
x,y: coordenadas de la esquina superior izquierda de la caja
w: ancho de la caja
h: altura de la caja
| def boundingBox(img):
""" Función para calcular la caja englobante del carácter
representado en la imagen que se pasa como parámetro
Args:
img: imagen en la que se quiere calcular la caja englobante
Returns:
x,y: coordenadas de la esquina superior izquierda de la caja
w: ancho de la caja
h: altura de la caja
"""
#Referencias:
#https://learnopencv.com/otsu-thresholding-with-opencv/
#https://docs.opencv.org/master/d7/d4d/tutorial_py_thresholding.html
#https://docs.opencv.org/master/d9/d61/tutorial_py_morphological_ops.html
kernel = np.ones((3,3),np.uint8) #Kernel de 1's y tamaño 3x3
closing = cv2.morphologyEx(img,cv2.MORPH_CLOSE,kernel) #Calculamos el closing de la imagen para rellenar huecos
_,thresh = cv2.threshold(closing,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU) #Método de Otsu para calcular el threashold de la imagen automáticamente
x,y,w,h = 2,2,thresh.shape[0]-2,thresh.shape[1]-2 #Le restamos 2 para quitarle el padding que tienen las imágenes en el dataset
#Acotamos los límites del BB hasta encontrar un píxel blanco (que forme parte del trazo del carácter)
while not any(thresh[y:y+h,x]>0):
x += 1
w -= 1
while not any(thresh[y,x:x+w]>0):
y += 1
h -= 1
while not any(thresh[y:y+h,x+w-1]>0):
w -= 1
while not any(thresh[y+h-1,x:x+w]>0):
h -= 1
return x,y,w,h | [
"def",
"boundingBox",
"(",
"img",
")",
":",
"#Referencias:",
"#https://learnopencv.com/otsu-thresholding-with-opencv/",
"#https://docs.opencv.org/master/d7/d4d/tutorial_py_thresholding.html",
"#https://docs.opencv.org/master/d9/d61/tutorial_py_morphological_ops.html",
"kernel",
"=",
"np",
".",
"ones",
"(",
"(",
"3",
",",
"3",
")",
",",
"np",
".",
"uint8",
")",
"#Kernel de 1's y tamaño 3x3",
"closing",
"=",
"cv2",
".",
"morphologyEx",
"(",
"img",
",",
"cv2",
".",
"MORPH_CLOSE",
",",
"kernel",
")",
"#Calculamos el closing de la imagen para rellenar huecos ",
"_",
",",
"thresh",
"=",
"cv2",
".",
"threshold",
"(",
"closing",
",",
"0",
",",
"255",
",",
"cv2",
".",
"THRESH_BINARY",
"+",
"cv2",
".",
"THRESH_OTSU",
")",
"#Método de Otsu para calcular el threashold de la imagen automáticamente",
"x",
",",
"y",
",",
"w",
",",
"h",
"=",
"2",
",",
"2",
",",
"thresh",
".",
"shape",
"[",
"0",
"]",
"-",
"2",
",",
"thresh",
".",
"shape",
"[",
"1",
"]",
"-",
"2",
"#Le restamos 2 para quitarle el padding que tienen las imágenes en el dataset",
"#Acotamos los límites del BB hasta encontrar un píxel blanco (que forme parte del trazo del carácter)",
"while",
"not",
"any",
"(",
"thresh",
"[",
"y",
":",
"y",
"+",
"h",
",",
"x",
"]",
">",
"0",
")",
":",
"x",
"+=",
"1",
"w",
"-=",
"1",
"while",
"not",
"any",
"(",
"thresh",
"[",
"y",
",",
"x",
":",
"x",
"+",
"w",
"]",
">",
"0",
")",
":",
"y",
"+=",
"1",
"h",
"-=",
"1",
"while",
"not",
"any",
"(",
"thresh",
"[",
"y",
":",
"y",
"+",
"h",
",",
"x",
"+",
"w",
"-",
"1",
"]",
">",
"0",
")",
":",
"w",
"-=",
"1",
"while",
"not",
"any",
"(",
"thresh",
"[",
"y",
"+",
"h",
"-",
"1",
",",
"x",
":",
"x",
"+",
"w",
"]",
">",
"0",
")",
":",
"h",
"-=",
"1",
"return",
"x",
",",
"y",
",",
"w",
",",
"h"
] | [
163,
0
] | [
195,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
User.describe_user | (self) | Informacion del usuario | Informacion del usuario | def describe_user(self):
"""Informacion del usuario"""
print("\n" + self.first_name + " " + self.last_name)
print(" Username: " + self.username)
print(" Email: " + self.email)
print(" Location: " + self.location) | [
"def",
"describe_user",
"(",
"self",
")",
":",
"print",
"(",
"\"\\n\"",
"+",
"self",
".",
"first_name",
"+",
"\" \"",
"+",
"self",
".",
"last_name",
")",
"print",
"(",
"\" Username: \"",
"+",
"self",
".",
"username",
")",
"print",
"(",
"\" Email: \"",
"+",
"self",
".",
"email",
")",
"print",
"(",
"\" Location: \"",
"+",
"self",
".",
"location",
")"
] | [
17,
4
] | [
22,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UserCallback.hash2user | (hash: str, *, cursor) | return user | Obtiene el nombre de usuario a partir del usuario real (o identificador) | Obtiene el nombre de usuario a partir del usuario real (o identificador) | async def hash2user(hash: str, *, cursor) -> Tuple[str]:
"""Obtiene el nombre de usuario a partir del usuario real (o identificador)"""
await cursor.execute(
"SELECT user FROM users WHERE user_hash = %s LIMIT 1", (hash,)
)
user = await cursor.fetchone()
return user | [
"async",
"def",
"hash2user",
"(",
"hash",
":",
"str",
",",
"*",
",",
"cursor",
")",
"->",
"Tuple",
"[",
"str",
"]",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT user FROM users WHERE user_hash = %s LIMIT 1\"",
",",
"(",
"hash",
",",
")",
")",
"user",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"user"
] | [
108,
4
] | [
118,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
help_usuarios | () | guia rapida para el conocimiento de la aplicacion | guia rapida para el conocimiento de la aplicacion | def help_usuarios():
"""guia rapida para el conocimiento de la aplicacion"""
msg = messagebox.showinfo( "help", "ayuda rapida para el usuario \n * \n * \n * \n * \n * \n * \n *") | [
"def",
"help_usuarios",
"(",
")",
":",
"msg",
"=",
"messagebox",
".",
"showinfo",
"(",
"\"help\"",
",",
"\"ayuda rapida para el usuario \\n * \\n * \\n * \\n * \\n * \\n * \\n *\"",
")"
] | [
4,
0
] | [
6,
105
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Food.__str__ | (self) | return '{}\n{}\n{}\n{}\n{}'.format(self.pan, self.carne, self.verduras, self.condimentos, self.combo) | Regresamos los ingredientes | Regresamos los ingredientes | def __str__(self):
"""Regresamos los ingredientes"""
return '{}\n{}\n{}\n{}\n{}'.format(self.pan, self.carne, self.verduras, self.condimentos, self.combo) | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"'{}\\n{}\\n{}\\n{}\\n{}'",
".",
"format",
"(",
"self",
".",
"pan",
",",
"self",
".",
"carne",
",",
"self",
".",
"verduras",
",",
"self",
".",
"condimentos",
",",
"self",
".",
"combo",
")"
] | [
103,
4
] | [
105,
109
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Molecule.get_limits | (self) | return [min_x, max_x, min_y, max_y, min_z, max_z] | Metodo para obtener los extremos (en tamanio)
de la molecula. | Metodo para obtener los extremos (en tamanio)
de la molecula. | def get_limits(self):
""" Metodo para obtener los extremos (en tamanio)
de la molecula. """
coords = self.get_coords()
fin = len(coords) - 1
coords.sort(key=lambda s: s[1])
min_x, max_x = coords[0][1], coords[fin][1]
coords.sort(key=lambda s: s[2])
min_y, max_y = coords[0][2], coords[fin][2]
coords.sort(key=lambda s: s[3])
min_z, max_z = coords[0][3], coords[fin][3]
return [min_x, max_x, min_y, max_y, min_z, max_z] | [
"def",
"get_limits",
"(",
"self",
")",
":",
"coords",
"=",
"self",
".",
"get_coords",
"(",
")",
"fin",
"=",
"len",
"(",
"coords",
")",
"-",
"1",
"coords",
".",
"sort",
"(",
"key",
"=",
"lambda",
"s",
":",
"s",
"[",
"1",
"]",
")",
"min_x",
",",
"max_x",
"=",
"coords",
"[",
"0",
"]",
"[",
"1",
"]",
",",
"coords",
"[",
"fin",
"]",
"[",
"1",
"]",
"coords",
".",
"sort",
"(",
"key",
"=",
"lambda",
"s",
":",
"s",
"[",
"2",
"]",
")",
"min_y",
",",
"max_y",
"=",
"coords",
"[",
"0",
"]",
"[",
"2",
"]",
",",
"coords",
"[",
"fin",
"]",
"[",
"2",
"]",
"coords",
".",
"sort",
"(",
"key",
"=",
"lambda",
"s",
":",
"s",
"[",
"3",
"]",
")",
"min_z",
",",
"max_z",
"=",
"coords",
"[",
"0",
"]",
"[",
"3",
"]",
",",
"coords",
"[",
"fin",
"]",
"[",
"3",
"]",
"return",
"[",
"min_x",
",",
"max_x",
",",
"min_y",
",",
"max_y",
",",
"min_z",
",",
"max_z",
"]"
] | [
173,
4
] | [
184,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
organize_data | (list_data: list) | Función para organizar los archivos XML.
Args:
list_data (list): Recibe una lista con los nombres de los archivos XML.
Returns:
dict: Retorna un diccionario con los datos organizados por:
{key = Número de la carpeta : value = Lista con los archivos XML }
| Función para organizar los archivos XML. | def organize_data(list_data: list) -> dict:
""" Función para organizar los archivos XML.
Args:
list_data (list): Recibe una lista con los nombres de los archivos XML.
Returns:
dict: Retorna un diccionario con los datos organizados por:
{key = Número de la carpeta : value = Lista con los archivos XML }
"""
try:
length_list: int = len(list_data)
if length_list <= 0:
print(print_color(
text="No hay archivos XML en el directorio o ya están organizados.",
color=color_yellow_console))
exit()
start: int = 0
number_of_files_first_folder: int = 5
number_of_files_in_other_folders: int = 4
folder: int = number_of_files_first_folder
folder_counter: int = 0
root_dictionary: dict = {}
while True:
folder_counter += 1
formula: int = start + folder
split_list: list = list_data[start:formula]
if formula <= length_list:
root_dictionary.update({folder_counter: split_list})
else:
end_length: int = len(split_list)
if end_length >= 1:
root_dictionary.update({folder_counter: split_list})
break
if folder == number_of_files_first_folder:
folder = number_of_files_in_other_folders
start = formula
return root_dictionary
except Exception as error_in_organize_data:
print(print_color(
text="Error al organizar los archivos XML",
color=color_red_console,
message_exception=error_in_organize_data)) | [
"def",
"organize_data",
"(",
"list_data",
":",
"list",
")",
"->",
"dict",
":",
"try",
":",
"length_list",
":",
"int",
"=",
"len",
"(",
"list_data",
")",
"if",
"length_list",
"<=",
"0",
":",
"print",
"(",
"print_color",
"(",
"text",
"=",
"\"No hay archivos XML en el directorio o ya están organizados.\",",
"",
"color",
"=",
"color_yellow_console",
")",
")",
"exit",
"(",
")",
"start",
":",
"int",
"=",
"0",
"number_of_files_first_folder",
":",
"int",
"=",
"5",
"number_of_files_in_other_folders",
":",
"int",
"=",
"4",
"folder",
":",
"int",
"=",
"number_of_files_first_folder",
"folder_counter",
":",
"int",
"=",
"0",
"root_dictionary",
":",
"dict",
"=",
"{",
"}",
"while",
"True",
":",
"folder_counter",
"+=",
"1",
"formula",
":",
"int",
"=",
"start",
"+",
"folder",
"split_list",
":",
"list",
"=",
"list_data",
"[",
"start",
":",
"formula",
"]",
"if",
"formula",
"<=",
"length_list",
":",
"root_dictionary",
".",
"update",
"(",
"{",
"folder_counter",
":",
"split_list",
"}",
")",
"else",
":",
"end_length",
":",
"int",
"=",
"len",
"(",
"split_list",
")",
"if",
"end_length",
">=",
"1",
":",
"root_dictionary",
".",
"update",
"(",
"{",
"folder_counter",
":",
"split_list",
"}",
")",
"break",
"if",
"folder",
"==",
"number_of_files_first_folder",
":",
"folder",
"=",
"number_of_files_in_other_folders",
"start",
"=",
"formula",
"return",
"root_dictionary",
"except",
"Exception",
"as",
"error_in_organize_data",
":",
"print",
"(",
"print_color",
"(",
"text",
"=",
"\"Error al organizar los archivos XML\"",
",",
"color",
"=",
"color_red_console",
",",
"message_exception",
"=",
"error_in_organize_data",
")",
")"
] | [
30,
0
] | [
72,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Anuncio.__str__ | (self) | return self.titulo_anuncio | Retornar el titulo del anuncio como string | Retornar el titulo del anuncio como string | def __str__(self):
"""Retornar el titulo del anuncio como string"""
return self.titulo_anuncio | [
"def",
"__str__",
"(",
"self",
")",
":",
"return",
"self",
".",
"titulo_anuncio"
] | [
185,
4
] | [
187,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_expresion | (t) | expresion : cualquiercadena
| funcion_matematica_ws
| expresionaritmetica
| func_bin_strings_1
| func_bin_strings_2
| vallogico | expresion : cualquiercadena
| funcion_matematica_ws
| expresionaritmetica
| func_bin_strings_1
| func_bin_strings_2
| vallogico | def p_expresion(t) :
'''expresion : cualquiercadena
| funcion_matematica_ws
| expresionaritmetica
| func_bin_strings_1
| func_bin_strings_2
| vallogico'''
t[0] = t[1] | [
"def",
"p_expresion",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
1135,
0
] | [
1142,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_corpus | (file_name, path='corpora/') | Obtiene el corpus con el nombre indicado
Cada renglon del archivo es una oración codificada con glosa por cada
fragmento de palabras y con su etiqueta POS por oración.
El formato por renglon puede ser el siguiente:
`[[[letras, glosa], [letras, glosa], ..., POS],...]`
o
`[[[[letras, glosa], [letras, glosa]], ..., POS],...]`
:param path: Carpeta donde se encuentra el corpus
:type: str
:param file_name: Nombre del archivo que contiene el corpus
:type: str
:return: Lista donde cada elemento es un renglon el corpus
:rtype: list
| Obtiene el corpus con el nombre indicado | def get_corpus(file_name, path='corpora/'):
""" Obtiene el corpus con el nombre indicado
Cada renglon del archivo es una oración codificada con glosa por cada
fragmento de palabras y con su etiqueta POS por oración.
El formato por renglon puede ser el siguiente:
`[[[letras, glosa], [letras, glosa], ..., POS],...]`
o
`[[[[letras, glosa], [letras, glosa]], ..., POS],...]`
:param path: Carpeta donde se encuentra el corpus
:type: str
:param file_name: Nombre del archivo que contiene el corpus
:type: str
:return: Lista donde cada elemento es un renglon el corpus
:rtype: list
"""
corpus_path = os.path.join(path, file_name)
with open(corpus_path, encoding='utf-8', mode='r') as f:
plain_text = f.read()
if 'mod' in file_name:
raw_data = plain_text.split('\n')
return [eval(row) for row in raw_data if row]
elif 'hard' in file_name:
data = eval(plain_text)
for frase in data:
for i, chunk in enumerate(frase):
pos_tag = chunk.pop(-1)
chunk = chunk[0]
chunk.append(pos_tag)
frase[i] = chunk
return data | [
"def",
"get_corpus",
"(",
"file_name",
",",
"path",
"=",
"'corpora/'",
")",
":",
"corpus_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"file_name",
")",
"with",
"open",
"(",
"corpus_path",
",",
"encoding",
"=",
"'utf-8'",
",",
"mode",
"=",
"'r'",
")",
"as",
"f",
":",
"plain_text",
"=",
"f",
".",
"read",
"(",
")",
"if",
"'mod'",
"in",
"file_name",
":",
"raw_data",
"=",
"plain_text",
".",
"split",
"(",
"'\\n'",
")",
"return",
"[",
"eval",
"(",
"row",
")",
"for",
"row",
"in",
"raw_data",
"if",
"row",
"]",
"elif",
"'hard'",
"in",
"file_name",
":",
"data",
"=",
"eval",
"(",
"plain_text",
")",
"for",
"frase",
"in",
"data",
":",
"for",
"i",
",",
"chunk",
"in",
"enumerate",
"(",
"frase",
")",
":",
"pos_tag",
"=",
"chunk",
".",
"pop",
"(",
"-",
"1",
")",
"chunk",
"=",
"chunk",
"[",
"0",
"]",
"chunk",
".",
"append",
"(",
"pos_tag",
")",
"frase",
"[",
"i",
"]",
"=",
"chunk",
"return",
"data"
] | [
12,
0
] | [
42,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
dichotomicSearch | (model, param_name, x_train, y_train, a, b, a_score=-1, b_score=-1,
tol=0.001, integer=False, tuple_param=False, n_jobs_cv=None) | return np.array(params), np.array(scores) | Función que aplica búsqueda dicotómica sobre un modelo para estimar
el mejor valor del hiperparámetro especificado como argumento
Args:
model: modelo cuyo hiperparámetro se quiere ajustar
param_name: nombre del hiperparámetro a ajustar
x_train: conjunto de entrenamiento
y_train: vector de etiquetas asociado al conjunto de entrenamiento
a: extremo inferior del intervalo de búsqueda
b: extremo superior del intervalo de búsqueda
a_score: score cuando el hiperparámetro toma el valor a.
Será -1 si no se conoce el score.
b_score: score cuando el hiperparámetro toma el valor b.
Será -1 si no se conoce el score.
tol: tolerancia para el criterio de parada
integer: booleano que determina si el hiperparámetro
es de tipo entero o no. En caso negativo se asume que es float.
tuple_param: booleano que determina si el hiperparámetro es una tupla
n_jobs_cv: número de procesadores usados en paralelo en validación cruzada
Return:
params: lista de valores probados para el hiperparámetro
score: lista de scores para los valores probados
| Función que aplica búsqueda dicotómica sobre un modelo para estimar
el mejor valor del hiperparámetro especificado como argumento | def dichotomicSearch(model, param_name, x_train, y_train, a, b, a_score=-1, b_score=-1,
tol=0.001, integer=False, tuple_param=False, n_jobs_cv=None):
""" Función que aplica búsqueda dicotómica sobre un modelo para estimar
el mejor valor del hiperparámetro especificado como argumento
Args:
model: modelo cuyo hiperparámetro se quiere ajustar
param_name: nombre del hiperparámetro a ajustar
x_train: conjunto de entrenamiento
y_train: vector de etiquetas asociado al conjunto de entrenamiento
a: extremo inferior del intervalo de búsqueda
b: extremo superior del intervalo de búsqueda
a_score: score cuando el hiperparámetro toma el valor a.
Será -1 si no se conoce el score.
b_score: score cuando el hiperparámetro toma el valor b.
Será -1 si no se conoce el score.
tol: tolerancia para el criterio de parada
integer: booleano que determina si el hiperparámetro
es de tipo entero o no. En caso negativo se asume que es float.
tuple_param: booleano que determina si el hiperparámetro es una tupla
n_jobs_cv: número de procesadores usados en paralelo en validación cruzada
Return:
params: lista de valores probados para el hiperparámetro
score: lista de scores para los valores probados
"""
print("Búsqueda dicotómica para "+ param_name)
if a_score == -1:
if tuple_param:
model.set_params(**{param_name:(a,a)})
else:
model.set_params(**{param_name:a})
#Aplicamos cross_validation con K_FOLDS particiones para determinar el accuracy del modelo
a_score = np.mean(cross_val_score(model,x_train,y_train,cv=K_FOLDS,n_jobs=n_jobs_cv))
print(a,":",a_score)
if b_score == -1:
if tuple_param:
model.set_params(**{param_name:(b,b)})
else:
model.set_params(**{param_name:b})
#Aplicamos cross_validation con K_FOLDS particiones para determinar el accuracy del modelo
b_score = np.mean(cross_val_score(model,x_train,y_train,cv=K_FOLDS,n_jobs=n_jobs_cv))
print(b,":",b_score)
params = [a, b]
scores = [a_score, b_score]
while b-a > tol:
if a_score < b_score:
a = (a+b)/2
if integer:
a = int(a)
if tuple_param:
model.set_params(**{param_name:(a,a)})
else:
model.set_params(**{param_name:a})
a_score = np.mean(cross_val_score(model,x_train,y_train,cv=K_FOLDS,n_jobs=n_jobs_cv))
params.append(a)
scores.append(a_score)
print(a,":",a_score)
else:
b = (a+b)/2
if integer:
b = int(b)
if tuple_param:
model.set_params(**{param_name:(b,b)})
else:
model.set_params(**{param_name:b})
b_score = np.mean(cross_val_score(model,x_train,y_train,cv=K_FOLDS,n_jobs=n_jobs_cv))
params.append(b)
scores.append(b_score)
print(b,":",b_score)
return np.array(params), np.array(scores) | [
"def",
"dichotomicSearch",
"(",
"model",
",",
"param_name",
",",
"x_train",
",",
"y_train",
",",
"a",
",",
"b",
",",
"a_score",
"=",
"-",
"1",
",",
"b_score",
"=",
"-",
"1",
",",
"tol",
"=",
"0.001",
",",
"integer",
"=",
"False",
",",
"tuple_param",
"=",
"False",
",",
"n_jobs_cv",
"=",
"None",
")",
":",
"print",
"(",
"\"Búsqueda dicotómica para \"+ ",
"p",
"ram_name)",
"",
"if",
"a_score",
"==",
"-",
"1",
":",
"if",
"tuple_param",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"(",
"a",
",",
"a",
")",
"}",
")",
"else",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"a",
"}",
")",
"#Aplicamos cross_validation con K_FOLDS particiones para determinar el accuracy del modelo",
"a_score",
"=",
"np",
".",
"mean",
"(",
"cross_val_score",
"(",
"model",
",",
"x_train",
",",
"y_train",
",",
"cv",
"=",
"K_FOLDS",
",",
"n_jobs",
"=",
"n_jobs_cv",
")",
")",
"print",
"(",
"a",
",",
"\":\"",
",",
"a_score",
")",
"if",
"b_score",
"==",
"-",
"1",
":",
"if",
"tuple_param",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"(",
"b",
",",
"b",
")",
"}",
")",
"else",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"b",
"}",
")",
"#Aplicamos cross_validation con K_FOLDS particiones para determinar el accuracy del modelo",
"b_score",
"=",
"np",
".",
"mean",
"(",
"cross_val_score",
"(",
"model",
",",
"x_train",
",",
"y_train",
",",
"cv",
"=",
"K_FOLDS",
",",
"n_jobs",
"=",
"n_jobs_cv",
")",
")",
"print",
"(",
"b",
",",
"\":\"",
",",
"b_score",
")",
"params",
"=",
"[",
"a",
",",
"b",
"]",
"scores",
"=",
"[",
"a_score",
",",
"b_score",
"]",
"while",
"b",
"-",
"a",
">",
"tol",
":",
"if",
"a_score",
"<",
"b_score",
":",
"a",
"=",
"(",
"a",
"+",
"b",
")",
"/",
"2",
"if",
"integer",
":",
"a",
"=",
"int",
"(",
"a",
")",
"if",
"tuple_param",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"(",
"a",
",",
"a",
")",
"}",
")",
"else",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"a",
"}",
")",
"a_score",
"=",
"np",
".",
"mean",
"(",
"cross_val_score",
"(",
"model",
",",
"x_train",
",",
"y_train",
",",
"cv",
"=",
"K_FOLDS",
",",
"n_jobs",
"=",
"n_jobs_cv",
")",
")",
"params",
".",
"append",
"(",
"a",
")",
"scores",
".",
"append",
"(",
"a_score",
")",
"print",
"(",
"a",
",",
"\":\"",
",",
"a_score",
")",
"else",
":",
"b",
"=",
"(",
"a",
"+",
"b",
")",
"/",
"2",
"if",
"integer",
":",
"b",
"=",
"int",
"(",
"b",
")",
"if",
"tuple_param",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"(",
"b",
",",
"b",
")",
"}",
")",
"else",
":",
"model",
".",
"set_params",
"(",
"*",
"*",
"{",
"param_name",
":",
"b",
"}",
")",
"b_score",
"=",
"np",
".",
"mean",
"(",
"cross_val_score",
"(",
"model",
",",
"x_train",
",",
"y_train",
",",
"cv",
"=",
"K_FOLDS",
",",
"n_jobs",
"=",
"n_jobs_cv",
")",
")",
"params",
".",
"append",
"(",
"b",
")",
"scores",
".",
"append",
"(",
"b_score",
")",
"print",
"(",
"b",
",",
"\":\"",
",",
"b_score",
")",
"return",
"np",
".",
"array",
"(",
"params",
")",
",",
"np",
".",
"array",
"(",
"scores",
")"
] | [
342,
0
] | [
415,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
variant_to_query | (variantes) | return query | **Toma las variantes seleccionadas y regresa una cadena que filtra
resultados de búsqueda por variantes**
:param variantes: Lista de keys de las variantes seleccionadas
:type: list
:return: Cadena aceptada por el API de elasticsearch para filtrar
:rtype: str
| **Toma las variantes seleccionadas y regresa una cadena que filtra
resultados de búsqueda por variantes** | def variant_to_query(variantes):
"""**Toma las variantes seleccionadas y regresa una cadena que filtra
resultados de búsqueda por variantes**
:param variantes: Lista de keys de las variantes seleccionadas
:type: list
:return: Cadena aceptada por el API de elasticsearch para filtrar
:rtype: str
"""
query = "("
for i, variante in enumerate(variantes):
# TODO: Mejorar la busqueda de variantes
query += f"*{variante}*"
if i == len(variantes) - 1:
query += ")"
else:
query += " OR "
return query | [
"def",
"variant_to_query",
"(",
"variantes",
")",
":",
"query",
"=",
"\"(\"",
"for",
"i",
",",
"variante",
"in",
"enumerate",
"(",
"variantes",
")",
":",
"# TODO: Mejorar la busqueda de variantes",
"query",
"+=",
"f\"*{variante}*\"",
"if",
"i",
"==",
"len",
"(",
"variantes",
")",
"-",
"1",
":",
"query",
"+=",
"\")\"",
"else",
":",
"query",
"+=",
"\" OR \"",
"return",
"query"
] | [
162,
0
] | [
179,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
nombres_repetidos_nivel | (lista1,lista2) | return lista_rep | genera una lista con los nombres repetidos dentro de un mismo nivel de enseñanza | genera una lista con los nombres repetidos dentro de un mismo nivel de enseñanza | def nombres_repetidos_nivel(lista1,lista2):
"""genera una lista con los nombres repetidos dentro de un mismo nivel de enseñanza"""
lista_rep=[]
for i in lista1:
if lista2.count(i)>1:
lista_rep.append(i)
return lista_rep | [
"def",
"nombres_repetidos_nivel",
"(",
"lista1",
",",
"lista2",
")",
":",
"lista_rep",
"=",
"[",
"]",
"for",
"i",
"in",
"lista1",
":",
"if",
"lista2",
".",
"count",
"(",
"i",
")",
">",
"1",
":",
"lista_rep",
".",
"append",
"(",
"i",
")",
"return",
"lista_rep"
] | [
78,
0
] | [
84,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_futuros | (limit=5, de_registrantes_etiquetados=False, etiqueta=None) | return ultimos | Dominios que vencen más en el futuro | Dominios que vencen más en el futuro | def get_futuros(limit=5, de_registrantes_etiquetados=False, etiqueta=None):
""" Dominios que vencen más en el futuro """
starts = timezone.now() + timedelta(days=366)
ultimos = Dominio.objects.filter(expire__isnull=False).order_by('-expire').filter(expire__gt=starts)[:limit]
return ultimos | [
"def",
"get_futuros",
"(",
"limit",
"=",
"5",
",",
"de_registrantes_etiquetados",
"=",
"False",
",",
"etiqueta",
"=",
"None",
")",
":",
"starts",
"=",
"timezone",
".",
"now",
"(",
")",
"+",
"timedelta",
"(",
"days",
"=",
"366",
")",
"ultimos",
"=",
"Dominio",
".",
"objects",
".",
"filter",
"(",
"expire__isnull",
"=",
"False",
")",
".",
"order_by",
"(",
"'-expire'",
")",
".",
"filter",
"(",
"expire__gt",
"=",
"starts",
")",
"[",
":",
"limit",
"]",
"return",
"ultimos"
] | [
50,
0
] | [
54,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioTSP.generar | (self) | return sol | Construye aleatoriamente una lista que representa una posible solución al problema.
Entradas:
ninguna
Salidas:
(list) Una lista que representa una solución válida para esta instancia del vendedor viajero
| Construye aleatoriamente una lista que representa una posible solución al problema. | def generar(self):
"""Construye aleatoriamente una lista que representa una posible solución al problema.
Entradas:
ninguna
Salidas:
(list) Una lista que representa una solución válida para esta instancia del vendedor viajero
"""
sol = list(range(0,self.n_ciudades))
del sol[self.i_ciudad_inicio]
rd.shuffle(sol)
return sol | [
"def",
"generar",
"(",
"self",
")",
":",
"sol",
"=",
"list",
"(",
"range",
"(",
"0",
",",
"self",
".",
"n_ciudades",
")",
")",
"del",
"sol",
"[",
"self",
".",
"i_ciudad_inicio",
"]",
"rd",
".",
"shuffle",
"(",
"sol",
")",
"return",
"sol"
] | [
104,
4
] | [
116,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
RequiredArgument.__init__ | (self, key, *args, **kwargs) | Cuando un argumento es requerido y no está ajustado | Cuando un argumento es requerido y no está ajustado | def __init__(self, key, *args, **kwargs):
""" Cuando un argumento es requerido y no está ajustado """
super().__init__(*args, **kwargs)
self.key = key | [
"def",
"__init__",
"(",
"self",
",",
"key",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
")",
".",
"__init__",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"key",
"=",
"key"
] | [
35,
4
] | [
40,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
drop_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de borrar las tablas de la base de datos. Puede ser llamada en caso de recibir en la
configuración: `operation: drop` o `operation: reset`
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 la base de datos. Puede ser llamada en caso de recibir en la
configuración: `operation: drop` o `operation: reset` | def drop_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de borrar las tablas de la base de datos. Puede ser llamada en caso de recibir en la
configuración: `operation: drop` o `operation: reset`
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 public.commercial_premise_index",
"DROP TABLE IF EXISTS execution_info",
"DROP TABLE IF EXISTS zip_code_info",
"DROP TABLE IF EXISTS premise_type_info"
]
_exec_drop(host=host, user=user, passwd=passwd, db_name=db_name, queries=drop_sql) | [
"def",
"drop_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 public.commercial_premise_index\"",
",",
"\"DROP TABLE IF EXISTS execution_info\"",
",",
"\"DROP TABLE IF EXISTS zip_code_info\"",
",",
"\"DROP TABLE IF EXISTS premise_type_info\"",
"]",
"_exec_drop",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"drop_sql",
")"
] | [
228,
0
] | [
253,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cuad_simpson_funcion | (a, b, f) | return aprox | Implementación de la regla de Simpson
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
| Implementación de la regla de Simpson
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
| def cuad_simpson_funcion(a, b, f):
"""Implementación de la regla de Simpson
Parameters
----------
f: La función a integrar
a: Límite inferior del intervalo
b: Límite superior del intervalo
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
"""
if a > b:
raise ValueError("Oops! Debe ser a<b")
return None
try:
x0 = (a+b)/2
h = f(a) + f(b) + 4*f(x0)
aprox = (b-a)/6*h
except:
print('Error: no fue posible calcular la función')
return aprox | [
"def",
"cuad_simpson_funcion",
"(",
"a",
",",
"b",
",",
"f",
")",
":",
"if",
"a",
">",
"b",
":",
"raise",
"ValueError",
"(",
"\"Oops! Debe ser a<b\"",
")",
"return",
"None",
"try",
":",
"x0",
"=",
"(",
"a",
"+",
"b",
")",
"/",
"2",
"h",
"=",
"f",
"(",
"a",
")",
"+",
"f",
"(",
"b",
")",
"+",
"4",
"*",
"f",
"(",
"x0",
")",
"aprox",
"=",
"(",
"b",
"-",
"a",
")",
"/",
"6",
"*",
"h",
"except",
":",
"print",
"(",
"'Error: no fue posible calcular la función')",
"",
"return",
"aprox"
] | [
65,
0
] | [
91,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UTeslaConnector.return_first_result | (self, *args, **kwargs) | return await _execute_async_gen(
self.execute_command(*args, **kwargs)
) | Retorna el primer y sólo el primer resultado
Este método es igual que `execute_command()` pero sólo retorna el
primer resultado.
| Retorna el primer y sólo el primer resultado | async def return_first_result(self, *args, **kwargs):
"""Retorna el primer y sólo el primer resultado
Este método es igual que `execute_command()` pero sólo retorna el
primer resultado.
"""
return await _execute_async_gen(
self.execute_command(*args, **kwargs)
) | [
"async",
"def",
"return_first_result",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"await",
"_execute_async_gen",
"(",
"self",
".",
"execute_command",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
")"
] | [
868,
4
] | [
878,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Connection | () | Comprueba la disponibilidad de Internet | Comprueba la disponibilidad de Internet | def Connection():
"""Comprueba la disponibilidad de Internet"""
global cookies, data, s
s = requests.Session()
url = 'https://www.itvcita.com/Welcome.do'
data = {}
try:
response = s.get(url, headers=headers)
cookies = s.cookies.get_dict()
data['t'] = re.findall(r'value="\w{32}"', response.content.decode())[0][7:-1]
return True
except requests.ConnectionError:
return False | [
"def",
"Connection",
"(",
")",
":",
"global",
"cookies",
",",
"data",
",",
"s",
"s",
"=",
"requests",
".",
"Session",
"(",
")",
"url",
"=",
"'https://www.itvcita.com/Welcome.do'",
"data",
"=",
"{",
"}",
"try",
":",
"response",
"=",
"s",
".",
"get",
"(",
"url",
",",
"headers",
"=",
"headers",
")",
"cookies",
"=",
"s",
".",
"cookies",
".",
"get_dict",
"(",
")",
"data",
"[",
"'t'",
"]",
"=",
"re",
".",
"findall",
"(",
"r'value=\"\\w{32}\"'",
",",
"response",
".",
"content",
".",
"decode",
"(",
")",
")",
"[",
"0",
"]",
"[",
"7",
":",
"-",
"1",
"]",
"return",
"True",
"except",
"requests",
".",
"ConnectionError",
":",
"return",
"False"
] | [
99,
0
] | [
111,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
extraer_todos | (dirin, dirout, recursivo=False, exts=None, basura=None, chars=0) | return n | Extrae y guarda texto y metadata de archivos.
Parameters
----------
dirin : str | Path
Directorio donde están los documentos originales.
dirout : str | Path
Directorio donde se quiere guardar texto extraído.
recursivo: bool
Iterar recursivamente.
exts: Iterable
Solo considerar archivos con estas extensiones.
basura : Iterable
Caracteres a eliminar.
chars : int
Mínimo número de caracteres en una línea de texto.
Returns
-------
int
Número de documentos procesados.
| Extrae y guarda texto y metadata de archivos. | def extraer_todos(dirin, dirout, recursivo=False, exts=None, basura=None, chars=0):
"""Extrae y guarda texto y metadata de archivos.
Parameters
----------
dirin : str | Path
Directorio donde están los documentos originales.
dirout : str | Path
Directorio donde se quiere guardar texto extraído.
recursivo: bool
Iterar recursivamente.
exts: Iterable
Solo considerar archivos con estas extensiones.
basura : Iterable
Caracteres a eliminar.
chars : int
Mínimo número de caracteres en una línea de texto.
Returns
-------
int
Número de documentos procesados.
"""
dirdocs = Path(dirin).resolve()
dirtextos = Path(dirout).resolve()
dirmeta = crear_carpeta(dirtextos.joinpath("metadata"))
nparts = len(dirdocs.parts)
n = 0
for ruta in iterar_rutas(dirdocs, recursivo=recursivo, exts=exts):
partes = ruta.parent.parts[nparts:]
dirtexto = dirtextos.joinpath(*partes)
if not dirtexto.exists():
dirtexto = crear_carpeta(dirtexto)
archivo = dirtexto.joinpath(f"{ruta.stem}.txt")
if not archivo.exists():
content, metadata = extraer_info(ruta)
texto = procesar_xhtml(content, chars=chars, basura=basura)
if texto:
guardar_texto(texto, archivo)
metaout = dirmeta.joinpath(*partes)
if not metaout.exists():
metaout = crear_carpeta(metaout)
metafile = metaout.joinpath(f"{ruta.stem}.json")
with open(metafile, "w", encoding="utf-8") as out:
json.dump(metadata, out, ensure_ascii=False)
n += 1
return n | [
"def",
"extraer_todos",
"(",
"dirin",
",",
"dirout",
",",
"recursivo",
"=",
"False",
",",
"exts",
"=",
"None",
",",
"basura",
"=",
"None",
",",
"chars",
"=",
"0",
")",
":",
"dirdocs",
"=",
"Path",
"(",
"dirin",
")",
".",
"resolve",
"(",
")",
"dirtextos",
"=",
"Path",
"(",
"dirout",
")",
".",
"resolve",
"(",
")",
"dirmeta",
"=",
"crear_carpeta",
"(",
"dirtextos",
".",
"joinpath",
"(",
"\"metadata\"",
")",
")",
"nparts",
"=",
"len",
"(",
"dirdocs",
".",
"parts",
")",
"n",
"=",
"0",
"for",
"ruta",
"in",
"iterar_rutas",
"(",
"dirdocs",
",",
"recursivo",
"=",
"recursivo",
",",
"exts",
"=",
"exts",
")",
":",
"partes",
"=",
"ruta",
".",
"parent",
".",
"parts",
"[",
"nparts",
":",
"]",
"dirtexto",
"=",
"dirtextos",
".",
"joinpath",
"(",
"*",
"partes",
")",
"if",
"not",
"dirtexto",
".",
"exists",
"(",
")",
":",
"dirtexto",
"=",
"crear_carpeta",
"(",
"dirtexto",
")",
"archivo",
"=",
"dirtexto",
".",
"joinpath",
"(",
"f\"{ruta.stem}.txt\"",
")",
"if",
"not",
"archivo",
".",
"exists",
"(",
")",
":",
"content",
",",
"metadata",
"=",
"extraer_info",
"(",
"ruta",
")",
"texto",
"=",
"procesar_xhtml",
"(",
"content",
",",
"chars",
"=",
"chars",
",",
"basura",
"=",
"basura",
")",
"if",
"texto",
":",
"guardar_texto",
"(",
"texto",
",",
"archivo",
")",
"metaout",
"=",
"dirmeta",
".",
"joinpath",
"(",
"*",
"partes",
")",
"if",
"not",
"metaout",
".",
"exists",
"(",
")",
":",
"metaout",
"=",
"crear_carpeta",
"(",
"metaout",
")",
"metafile",
"=",
"metaout",
".",
"joinpath",
"(",
"f\"{ruta.stem}.json\"",
")",
"with",
"open",
"(",
"metafile",
",",
"\"w\"",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"as",
"out",
":",
"json",
".",
"dump",
"(",
"metadata",
",",
"out",
",",
"ensure_ascii",
"=",
"False",
")",
"n",
"+=",
"1",
"return",
"n"
] | [
73,
0
] | [
125,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DNARecord.at_content | (self) | return at_cont/(at_cont+gc_cont) | Obtiene el contenido de AT. | Obtiene el contenido de AT. | def at_content(self):
"""Obtiene el contenido de AT."""
# Obtener cantidad de AT y GC
at_cont = self.seq.count('A') + self.seq.count('T')
gc_cont = self.seq.count('G') + self.seq.count('C')
return at_cont/(at_cont+gc_cont) | [
"def",
"at_content",
"(",
"self",
")",
":",
"# Obtener cantidad de AT y GC",
"at_cont",
"=",
"self",
".",
"seq",
".",
"count",
"(",
"'A'",
")",
"+",
"self",
".",
"seq",
".",
"count",
"(",
"'T'",
")",
"gc_cont",
"=",
"self",
".",
"seq",
".",
"count",
"(",
"'G'",
")",
"+",
"self",
".",
"seq",
".",
"count",
"(",
"'C'",
")",
"return",
"at_cont",
"/",
"(",
"at_cont",
"+",
"gc_cont",
")"
] | [
118,
4
] | [
123,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_crear | (t) | crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C | crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C | def p_crear(t):
'''crear : CREATE reemplazar DATABASE verificacion ID propietario modo
| CREATE TABLE ID PAR_A columnas PAR_C herencia
| CREATE TYPE ID AS ENUM PAR_A lista_exp PAR_C''' | [
"def",
"p_crear",
"(",
"t",
")",
":"
] | [
502,
0
] | [
505,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProcesarEntradaPDF | (rutarecursos, archivo, ambiente) | return salida | Lee los datos de un pdf, y los envia al ambiente. | Lee los datos de un pdf, y los envia al ambiente. | def ProcesarEntradaPDF(rutarecursos, archivo, ambiente):
'''Lee los datos de un pdf, y los envia al ambiente. '''
from SimpleSoft.F2S_ExtraerPDF2 import ObjPDF
ob=ObjPDF( archpdf = archivo,
ruta_recursos=rutarecursos,
ambiente = ambiente,
ruta_app=request.folder,
debug= False
)
if ob.error:
print ('eeeeeerrrrrooooorrr')
return
ob.VistaPdf()
print ('*'*50)
salida =ob.Procesar()
# print (ob.Procesar())
salida=[]
for i in ob.documentos:
#print (ob.documentos[i]['camposweb2py'])
salida.append(ob.documentos[i]['camposweb2py'])
# print (ob.documentos['1']['datos'].campos)
# print (ob.documentos['10']['datos'].campos)
return salida | [
"def",
"ProcesarEntradaPDF",
"(",
"rutarecursos",
",",
"archivo",
",",
"ambiente",
")",
":",
"from",
"SimpleSoft",
".",
"F2S_ExtraerPDF2",
"import",
"ObjPDF",
"ob",
"=",
"ObjPDF",
"(",
"archpdf",
"=",
"archivo",
",",
"ruta_recursos",
"=",
"rutarecursos",
",",
"ambiente",
"=",
"ambiente",
",",
"ruta_app",
"=",
"request",
".",
"folder",
",",
"debug",
"=",
"False",
")",
"if",
"ob",
".",
"error",
":",
"print",
"(",
"'eeeeeerrrrrooooorrr'",
")",
"return",
"ob",
".",
"VistaPdf",
"(",
")",
"print",
"(",
"'*'",
"*",
"50",
")",
"salida",
"=",
"ob",
".",
"Procesar",
"(",
")",
"# print (ob.Procesar())",
"salida",
"=",
"[",
"]",
"for",
"i",
"in",
"ob",
".",
"documentos",
":",
"#print (ob.documentos[i]['camposweb2py'])",
"salida",
".",
"append",
"(",
"ob",
".",
"documentos",
"[",
"i",
"]",
"[",
"'camposweb2py'",
"]",
")",
"# print (ob.documentos['1']['datos'].campos)",
"# print (ob.documentos['10']['datos'].campos)",
"return",
"salida"
] | [
384,
0
] | [
407,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
esiterable | (objeto) | return isinstance(objeto, Iterable) and not isinstance(objeto, str) | Retorna True si el objeto es un iterador pero no es una cadena. | Retorna True si el objeto es un iterador pero no es una cadena. | def esiterable(objeto):
"""Retorna True si el objeto es un iterador pero no es una cadena."""
return isinstance(objeto, Iterable) and not isinstance(objeto, str) | [
"def",
"esiterable",
"(",
"objeto",
")",
":",
"return",
"isinstance",
"(",
"objeto",
",",
"Iterable",
")",
"and",
"not",
"isinstance",
"(",
"objeto",
",",
"str",
")"
] | [
31,
0
] | [
33,
71
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
extract_features_vgg16 | (archivo_scr) | return(data) | ## Registramos (recortamos/orientamos) el documento | ## Registramos (recortamos/orientamos) el documento | def extract_features_vgg16(archivo_scr):
# Cargamos la imagen
image = PIL.Image.open(archivo_scr).convert("RGB")
image = np.array(image)
"""## Registramos (recortamos/orientamos) el documento"""
# convert the warped image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#gray = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)[:,:,0] # cuadro chico
#gray = cv2.equalizeHist(gray) # segunda vuelta
blur = cv2.medianBlur(gray, 5)
# sharpen image
sharpen = cv2.GaussianBlur(gray, (7,7), 0)
#Get the best value for T with otsu thresholding
(T, threshInv) = cv2.threshold(sharpen, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
threshInv = cv2.erode(threshInv, None, iterations=2)
threshInv = cv2.dilate(threshInv, None, iterations=2)
# Detectamos los perfiles del documento segmentado
profile_h = threshInv.sum(0)
profile_v = threshInv.sum(1)
eje_x = np.where(profile_h > 200000)[0]
eje_y = np.where(profile_v > 200000)[0]
if eje_x.size == 0:
coor_x0 = 0
coor_xf = len(profile_h)
else:
coor_x0 = eje_x[0]
coor_xf = eje_x[len(eje_x)-1]
if eje_y.size == 0:
coor_y0 = 0
coor_yf = len(profile_v)
else:
coor_y0 = eje_y[0]
coor_yf = eje_y[len(eje_y)-1]
image = image[coor_y0:coor_yf,coor_x0:coor_xf,:]
"""## Detectamos la orientacion del documento"""
"""## Limpieza de la Imagen"""
# convert the warped image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# sharpen image
sharpen = cv2.GaussianBlur(gray, (0,0), 3)
#sharpen = cv2.medianBlur(gray,5)
sharpen = cv2.addWeighted(gray, 1.5, sharpen, -0.5, 0)
# apply adaptive threshold to get black and white effect
thresh = cv2.adaptiveThreshold(sharpen, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 71, 21) # buena 2
"""## Analysis of connected components"""
label_im, nb_labels = ndimage.label(thresh)
nb_labels # how many regions?
sizes = ndimage.sum(thresh, label_im, range(nb_labels + 1))
mask_size = sizes < 2000
remove_pixel = mask_size[label_im]
remove_pixel.shape
label_im[remove_pixel] = 0
"""element = np.ones((5,5))
dilate = cv2.dilate(np.array(label_im>0,dtype=np.uint8),element)
dilate = cv2.erode(dilate,element)
# Visualizamos la imagen
plt.figure(figsize=(15,10))
plt.imshow(dilate)
plt.show()
## Calculamos los bounding box
"""
#label_im, nb_labels = ndimage.label(dilate)
# Calculamos las Measure region properties de cada region
props = regionprops(label_im)
"""
image2 = image.copy()
label = np.zeros(image.shape[:2], dtype=np.uint8)
# Recorremos cada region segmentada en la imagen
cont = 1
for prop in props:
# Boundig Box
minr, minc, maxr, maxc = prop['bbox']
# region de interes
roi = label[minr:maxr,minc:maxc]
# asignamos label
if roi.sum() == 0:
label[minr:maxr,minc:maxc] = cont
else:
uni = np.unique(roi)
# si comparte bounding box con otra region le asignamos su etiqueta
if uni[0] != 0:
label[minr:maxr,minc:maxc] = uni[0]
else:
label[minr:maxr,minc:maxc] = uni[1]
cont += 1
#cv2.rectangle(image2, (minc0, np.min([minr0, minr]) ), (maxc, np.max([maxr0,maxr]) ), (0, 255, 0), 2)
plt.figure(figsize=(15,10))
plt.imshow(label)
plt.show()
"""
#label_im2, nb_labels2 = ndimage.label(label>0)
#props = regionprops(label_im2)
"""## Calculamos las caracterÃsticas con un VGG16"""
data = []
# Recorremos cada region segmentada en la imagen
for prop in props:
# Boundig Box
minr, minc, maxr, maxc = prop['bbox']
if prop['bbox_area'] < 100:
continue
a = 0 if minr-5<0 else minr-5
b = maxr+5
c = 0 if minc-5<0 else minc-5
d = maxc+5
# region de interes
roi = image[a:b,c:d,:]
#roi = cv2.resize(roi, (93,93), interpolation = cv2.INTER_AREA)
roi = cv2.resize(roi, (61,61), interpolation = cv2.INTER_AREA)
# Preprocesamos la imagen
x = np.expand_dims(roi, axis=0)
x = preprocess_input(x)
# Calculamos las features
features = model.predict(x)
# Guardamos en modo one-hot las caracteristicas
data.append([archivo_scr]+[a,b,c,d]+features.flatten().tolist())
return(data) | [
"def",
"extract_features_vgg16",
"(",
"archivo_scr",
")",
":",
"# Cargamos la imagen",
"image",
"=",
"PIL",
".",
"Image",
".",
"open",
"(",
"archivo_scr",
")",
".",
"convert",
"(",
"\"RGB\"",
")",
"image",
"=",
"np",
".",
"array",
"(",
"image",
")",
"# convert the warped image to grayscale",
"gray",
"=",
"cv2",
".",
"cvtColor",
"(",
"image",
",",
"cv2",
".",
"COLOR_BGR2GRAY",
")",
"#gray = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)[:,:,0] # cuadro chico",
"#gray = cv2.equalizeHist(gray) # segunda vuelta",
"blur",
"=",
"cv2",
".",
"medianBlur",
"(",
"gray",
",",
"5",
")",
"# sharpen image",
"sharpen",
"=",
"cv2",
".",
"GaussianBlur",
"(",
"gray",
",",
"(",
"7",
",",
"7",
")",
",",
"0",
")",
"#Get the best value for T with otsu thresholding",
"(",
"T",
",",
"threshInv",
")",
"=",
"cv2",
".",
"threshold",
"(",
"sharpen",
",",
"0",
",",
"255",
",",
"cv2",
".",
"THRESH_BINARY",
"|",
"cv2",
".",
"THRESH_OTSU",
")",
"threshInv",
"=",
"cv2",
".",
"erode",
"(",
"threshInv",
",",
"None",
",",
"iterations",
"=",
"2",
")",
"threshInv",
"=",
"cv2",
".",
"dilate",
"(",
"threshInv",
",",
"None",
",",
"iterations",
"=",
"2",
")",
"# Detectamos los perfiles del documento segmentado",
"profile_h",
"=",
"threshInv",
".",
"sum",
"(",
"0",
")",
"profile_v",
"=",
"threshInv",
".",
"sum",
"(",
"1",
")",
"eje_x",
"=",
"np",
".",
"where",
"(",
"profile_h",
">",
"200000",
")",
"[",
"0",
"]",
"eje_y",
"=",
"np",
".",
"where",
"(",
"profile_v",
">",
"200000",
")",
"[",
"0",
"]",
"if",
"eje_x",
".",
"size",
"==",
"0",
":",
"coor_x0",
"=",
"0",
"coor_xf",
"=",
"len",
"(",
"profile_h",
")",
"else",
":",
"coor_x0",
"=",
"eje_x",
"[",
"0",
"]",
"coor_xf",
"=",
"eje_x",
"[",
"len",
"(",
"eje_x",
")",
"-",
"1",
"]",
"if",
"eje_y",
".",
"size",
"==",
"0",
":",
"coor_y0",
"=",
"0",
"coor_yf",
"=",
"len",
"(",
"profile_v",
")",
"else",
":",
"coor_y0",
"=",
"eje_y",
"[",
"0",
"]",
"coor_yf",
"=",
"eje_y",
"[",
"len",
"(",
"eje_y",
")",
"-",
"1",
"]",
"image",
"=",
"image",
"[",
"coor_y0",
":",
"coor_yf",
",",
"coor_x0",
":",
"coor_xf",
",",
":",
"]",
"\"\"\"## Detectamos la orientacion del documento\"\"\"",
"\"\"\"## Limpieza de la Imagen\"\"\"",
"# convert the warped image to grayscale",
"gray",
"=",
"cv2",
".",
"cvtColor",
"(",
"image",
",",
"cv2",
".",
"COLOR_RGB2GRAY",
")",
"# sharpen image",
"sharpen",
"=",
"cv2",
".",
"GaussianBlur",
"(",
"gray",
",",
"(",
"0",
",",
"0",
")",
",",
"3",
")",
"#sharpen = cv2.medianBlur(gray,5)",
"sharpen",
"=",
"cv2",
".",
"addWeighted",
"(",
"gray",
",",
"1.5",
",",
"sharpen",
",",
"-",
"0.5",
",",
"0",
")",
"# apply adaptive threshold to get black and white effect",
"thresh",
"=",
"cv2",
".",
"adaptiveThreshold",
"(",
"sharpen",
",",
"255",
",",
"cv2",
".",
"ADAPTIVE_THRESH_GAUSSIAN_C",
",",
"cv2",
".",
"THRESH_BINARY_INV",
",",
"71",
",",
"21",
")",
"# buena 2",
"\"\"\"## Analysis of connected components\"\"\"",
"label_im",
",",
"nb_labels",
"=",
"ndimage",
".",
"label",
"(",
"thresh",
")",
"nb_labels",
"# how many regions?",
"sizes",
"=",
"ndimage",
".",
"sum",
"(",
"thresh",
",",
"label_im",
",",
"range",
"(",
"nb_labels",
"+",
"1",
")",
")",
"mask_size",
"=",
"sizes",
"<",
"2000",
"remove_pixel",
"=",
"mask_size",
"[",
"label_im",
"]",
"remove_pixel",
".",
"shape",
"label_im",
"[",
"remove_pixel",
"]",
"=",
"0",
"\"\"\"element = np.ones((5,5))\n dilate = cv2.dilate(np.array(label_im>0,dtype=np.uint8),element)\n dilate = cv2.erode(dilate,element)\n\n # Visualizamos la imagen\n plt.figure(figsize=(15,10))\n plt.imshow(dilate)\n plt.show()\n\n ## Calculamos los bounding box\n \"\"\"",
"#label_im, nb_labels = ndimage.label(dilate)",
"# Calculamos las Measure region properties de cada region",
"props",
"=",
"regionprops",
"(",
"label_im",
")",
"\"\"\"\n image2 = image.copy()\n label = np.zeros(image.shape[:2], dtype=np.uint8)\n\n # Recorremos cada region segmentada en la imagen\n cont = 1\n for prop in props:\n # Boundig Box\n minr, minc, maxr, maxc = prop['bbox']\n\n # region de interes\n roi = label[minr:maxr,minc:maxc]\n\n # asignamos label\n if roi.sum() == 0:\n label[minr:maxr,minc:maxc] = cont\n else:\n uni = np.unique(roi)\n # si comparte bounding box con otra region le asignamos su etiqueta\n if uni[0] != 0:\n label[minr:maxr,minc:maxc] = uni[0]\n else:\n label[minr:maxr,minc:maxc] = uni[1]\n\n cont += 1\n #cv2.rectangle(image2, (minc0, np.min([minr0, minr]) ), (maxc, np.max([maxr0,maxr]) ), (0, 255, 0), 2)\n\n plt.figure(figsize=(15,10))\n plt.imshow(label)\n plt.show()\n \"\"\"",
"#label_im2, nb_labels2 = ndimage.label(label>0)",
"#props = regionprops(label_im2)",
"\"\"\"## Calculamos las caracterÃsticas con un VGG16\"\"\"",
"data",
"=",
"[",
"]",
"# Recorremos cada region segmentada en la imagen",
"for",
"prop",
"in",
"props",
":",
"# Boundig Box",
"minr",
",",
"minc",
",",
"maxr",
",",
"maxc",
"=",
"prop",
"[",
"'bbox'",
"]",
"if",
"prop",
"[",
"'bbox_area'",
"]",
"<",
"100",
":",
"continue",
"a",
"=",
"0",
"if",
"minr",
"-",
"5",
"<",
"0",
"else",
"minr",
"-",
"5",
"b",
"=",
"maxr",
"+",
"5",
"c",
"=",
"0",
"if",
"minc",
"-",
"5",
"<",
"0",
"else",
"minc",
"-",
"5",
"d",
"=",
"maxc",
"+",
"5",
"# region de interes",
"roi",
"=",
"image",
"[",
"a",
":",
"b",
",",
"c",
":",
"d",
",",
":",
"]",
"#roi = cv2.resize(roi, (93,93), interpolation = cv2.INTER_AREA)",
"roi",
"=",
"cv2",
".",
"resize",
"(",
"roi",
",",
"(",
"61",
",",
"61",
")",
",",
"interpolation",
"=",
"cv2",
".",
"INTER_AREA",
")",
"# Preprocesamos la imagen",
"x",
"=",
"np",
".",
"expand_dims",
"(",
"roi",
",",
"axis",
"=",
"0",
")",
"x",
"=",
"preprocess_input",
"(",
"x",
")",
"# Calculamos las features",
"features",
"=",
"model",
".",
"predict",
"(",
"x",
")",
"# Guardamos en modo one-hot las caracteristicas",
"data",
".",
"append",
"(",
"[",
"archivo_scr",
"]",
"+",
"[",
"a",
",",
"b",
",",
"c",
",",
"d",
"]",
"+",
"features",
".",
"flatten",
"(",
")",
".",
"tolist",
"(",
")",
")",
"return",
"(",
"data",
")"
] | [
25,
0
] | [
178,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
iterable | (objeto) | return iter([objeto]) if not esiterable(objeto) else objeto | Retorna un iterador del objeto (una cadena no debe ser iterable). | Retorna un iterador del objeto (una cadena no debe ser iterable). | def iterable(objeto):
"""Retorna un iterador del objeto (una cadena no debe ser iterable)."""
return iter([objeto]) if not esiterable(objeto) else objeto | [
"def",
"iterable",
"(",
"objeto",
")",
":",
"return",
"iter",
"(",
"[",
"objeto",
"]",
")",
"if",
"not",
"esiterable",
"(",
"objeto",
")",
"else",
"objeto"
] | [
36,
0
] | [
38,
63
] | 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.