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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ArregloDinamico.remove | (self, obj: py_object) | Remueve la primera ocurrencia de un elemento del arreglo
:param obj: elemento a remover
:obj type: py_object
| Remueve la primera ocurrencia de un elemento del arreglo | def remove(self, obj: py_object) -> None:
"""Remueve la primera ocurrencia de un elemento del arreglo
:param obj: elemento a remover
:obj type: py_object
"""
for k in range(self._n):
if self._A[k] == obj:
for i in range(k, self._n - 1):
self._A[i] = self._A[i + 1]
self._n -= 1
self._reducir()
return
raise ValueError("El elemento no existe") | [
"def",
"remove",
"(",
"self",
",",
"obj",
":",
"py_object",
")",
"->",
"None",
":",
"for",
"k",
"in",
"range",
"(",
"self",
".",
"_n",
")",
":",
"if",
"self",
".",
"_A",
"[",
"k",
"]",
"==",
"obj",
":",
"for",
"i",
"in",
"range",
"(",
"k",
",",
"self",
".",
"_n",
"-",
"1",
")",
":",
"self",
".",
"_A",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"i",
"+",
"1",
"]",
"self",
".",
"_n",
"-=",
"1",
"self",
".",
"_reducir",
"(",
")",
"return",
"raise",
"ValueError",
"(",
"\"El elemento no existe\"",
")"
] | [
83,
4
] | [
96,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cuad_simpson_compuesta_II | (f, I, eps) | return aprox | Implementación de la regla de Simpson
Parameters
----------
I: list
Intervalo de integración, ingresado como lista de dos elementos
f: function (1 parameter)
La función a integrar
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson_compuesta_II(f, I)
cuad_simpson_compuesta_II(f, I)
| Implementación de la regla de Simpson
Parameters
----------
I: list
Intervalo de integración, ingresado como lista de dos elementos
f: function (1 parameter)
La función a integrar
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson_compuesta_II(f, I)
cuad_simpson_compuesta_II(f, I)
| def cuad_simpson_compuesta_II(f, I, eps):
"""Implementación de la regla de Simpson
Parameters
----------
I: list
Intervalo de integración, ingresado como lista de dos elementos
f: function (1 parameter)
La función a integrar
Returns
-------
aprox: Aproximación de la integral por la regla de Simpson
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_simpson_compuesta_II(f, I)
cuad_simpson_compuesta_II(f, I)
"""
import numpy as np
delta = 2*eps
n = 2
aprox_old = (I[1]-I[0])*f((I[1]+I[0])/2)
while delta > eps:
x = np.linspace(I[0], I[1], n)
aprox = cuad_simpson_compuesta(x, f=f)
delta = abs(aprox - aprox_old)
aprox_old = aprox
n += 10
if n>5000:
break
return aprox | [
"def",
"cuad_simpson_compuesta_II",
"(",
"f",
",",
"I",
",",
"eps",
")",
":",
"import",
"numpy",
"as",
"np",
"delta",
"=",
"2",
"*",
"eps",
"n",
"=",
"2",
"aprox_old",
"=",
"(",
"I",
"[",
"1",
"]",
"-",
"I",
"[",
"0",
"]",
")",
"*",
"f",
"(",
"(",
"I",
"[",
"1",
"]",
"+",
"I",
"[",
"0",
"]",
")",
"/",
"2",
")",
"while",
"delta",
">",
"eps",
":",
"x",
"=",
"np",
".",
"linspace",
"(",
"I",
"[",
"0",
"]",
",",
"I",
"[",
"1",
"]",
",",
"n",
")",
"aprox",
"=",
"cuad_simpson_compuesta",
"(",
"x",
",",
"f",
"=",
"f",
")",
"delta",
"=",
"abs",
"(",
"aprox",
"-",
"aprox_old",
")",
"aprox_old",
"=",
"aprox",
"n",
"+=",
"10",
"if",
"n",
">",
"5000",
":",
"break",
"return",
"aprox"
] | [
449,
0
] | [
485,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Expediente.comitentes | (self) | return self.expedientepersona_set.filter(comitente=True) | Devuelve las personas que figuran como comitentes. | Devuelve las personas que figuran como comitentes. | def comitentes(self):
"""Devuelve las personas que figuran como comitentes."""
return self.expedientepersona_set.filter(comitente=True) | [
"def",
"comitentes",
"(",
"self",
")",
":",
"return",
"self",
".",
"expedientepersona_set",
".",
"filter",
"(",
"comitente",
"=",
"True",
")"
] | [
301,
4
] | [
303,
64
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_opcion_from_1_0_0_0_0_0_0_0 | (t) | opcion_from : ID opcion_sobrenombre | opcion_from : ID opcion_sobrenombre | def p_opcion_from_1_0_0_0_0_0_0_0(t):
'opcion_from : ID opcion_sobrenombre' | [
"def",
"p_opcion_from_1_0_0_0_0_0_0_0",
"(",
"t",
")",
":"
] | [
1829,
0
] | [
1830,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AbstractGMapsExtractor.extract_current_address | (self, name, address_str) | return address | Función encargada de extraer la dirección de la descripción del elemento web de la sección de resultados
Arguments
---------
name : str
nombre del lugar a extraer
address_str : str
descripción del resultado de la búsqueda
Returns
-------
str :
dirección o dirección parcial del local comercial encontrado en el elemento web de la sección de resultados
| Función encargada de extraer la dirección de la descripción del elemento web de la sección de resultados | def extract_current_address(self, name, address_str):
"""Función encargada de extraer la dirección de la descripción del elemento web de la sección de resultados
Arguments
---------
name : str
nombre del lugar a extraer
address_str : str
descripción del resultado de la búsqueda
Returns
-------
str :
dirección o dirección parcial del local comercial encontrado en el elemento web de la sección de resultados
"""
self.logger.debug("-{postal_code}-: place -{name}- have been detected with address: {address}".format(
postal_code=self._postal_code, name=name, address=address_str
))
info_separator = "·"
address = address_str
if address_str:
if info_separator in address_str:
compressed_address = [item.strip() for item in address_str.split(info_separator)]
if len(compressed_address) == 3:
price_range = compressed_address[0]
style = compressed_address[1]
address = compressed_address[2]
else:
price_range = None
style = compressed_address[0]
address = compressed_address[1]
self.logger.debug("-{postal_code}-: place -{name}- have formatted address: {address}".format(
postal_code=self._postal_code, name=name, address=address
))
return address | [
"def",
"extract_current_address",
"(",
"self",
",",
"name",
",",
"address_str",
")",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: place -{name}- have been detected with address: {address}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"name",
"=",
"name",
",",
"address",
"=",
"address_str",
")",
")",
"info_separator",
"=",
"\"·\"",
"address",
"=",
"address_str",
"if",
"address_str",
":",
"if",
"info_separator",
"in",
"address_str",
":",
"compressed_address",
"=",
"[",
"item",
".",
"strip",
"(",
")",
"for",
"item",
"in",
"address_str",
".",
"split",
"(",
"info_separator",
")",
"]",
"if",
"len",
"(",
"compressed_address",
")",
"==",
"3",
":",
"price_range",
"=",
"compressed_address",
"[",
"0",
"]",
"style",
"=",
"compressed_address",
"[",
"1",
"]",
"address",
"=",
"compressed_address",
"[",
"2",
"]",
"else",
":",
"price_range",
"=",
"None",
"style",
"=",
"compressed_address",
"[",
"0",
"]",
"address",
"=",
"compressed_address",
"[",
"1",
"]",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}-: place -{name}- have formatted address: {address}\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"name",
"=",
"name",
",",
"address",
"=",
"address",
")",
")",
"return",
"address"
] | [
139,
4
] | [
175,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sumatorio | (lista) | return suma | función de determina el sumatorio de una lista de números | función de determina el sumatorio de una lista de números | def sumatorio(lista):
"""función de determina el sumatorio de una lista de números"""
suma=0
for i in range(len(lista)):
suma+=lista[i]
return suma | [
"def",
"sumatorio",
"(",
"lista",
")",
":",
"suma",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"lista",
")",
")",
":",
"suma",
"+=",
"lista",
"[",
"i",
"]",
"return",
"suma"
] | [
34,
0
] | [
39,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Obj_EstadoCuenta.setEncabezado | (self,fecha,linea,cuenta) | Procesa el Encabezado y inicializa las varibles | Procesa el Encabezado y inicializa las varibles | def setEncabezado(self,fecha,linea,cuenta):
'''Procesa el Encabezado y inicializa las varibles'''
self.encabezado.fecha={"texto":fecha,
"letra":"Ubuntu",
"alto":10,
"alinear":0,
"posx":100,
"posy":100,
"rotar":0}
self.encabezado.cuenta={"texto":cuenta,
"letra":"Ubuntu",
"alto":10,
"alinear":0,
"posx":100,
"posy":100,
"rotar":0}
selector=[
Storage({"campo":"nit",
"col_ini":0,
"col_fin":17,
"letra":"Ubuntu",
"alto":10,
"alinear":0,
"posx":100,
"posy":100,
"rotar":0
}),
Storage({"campo":"nombre",
"col_ini":17,
"col_fin":53,
"letra":"Ubuntu",
"alto":12,
"alinear":1,
"posx":200,
"posy":200,
"rotar":0
}),
]
for item in selector:
self.encabezado[item.campo]={"texto":linea[item.col_ini:item.col_fin].strip(),
"letra":item.letra,
"alto":item.alto,
"alinear":item.alinear,
"posx":item.posx,
"posy":item.posy,
"rotar":item.rotar,
}
print (self.encabezado.fecha["texto"], self.encabezado.fecha["letra"]) | [
"def",
"setEncabezado",
"(",
"self",
",",
"fecha",
",",
"linea",
",",
"cuenta",
")",
":",
"self",
".",
"encabezado",
".",
"fecha",
"=",
"{",
"\"texto\"",
":",
"fecha",
",",
"\"letra\"",
":",
"\"Ubuntu\"",
",",
"\"alto\"",
":",
"10",
",",
"\"alinear\"",
":",
"0",
",",
"\"posx\"",
":",
"100",
",",
"\"posy\"",
":",
"100",
",",
"\"rotar\"",
":",
"0",
"}",
"self",
".",
"encabezado",
".",
"cuenta",
"=",
"{",
"\"texto\"",
":",
"cuenta",
",",
"\"letra\"",
":",
"\"Ubuntu\"",
",",
"\"alto\"",
":",
"10",
",",
"\"alinear\"",
":",
"0",
",",
"\"posx\"",
":",
"100",
",",
"\"posy\"",
":",
"100",
",",
"\"rotar\"",
":",
"0",
"}",
"selector",
"=",
"[",
"Storage",
"(",
"{",
"\"campo\"",
":",
"\"nit\"",
",",
"\"col_ini\"",
":",
"0",
",",
"\"col_fin\"",
":",
"17",
",",
"\"letra\"",
":",
"\"Ubuntu\"",
",",
"\"alto\"",
":",
"10",
",",
"\"alinear\"",
":",
"0",
",",
"\"posx\"",
":",
"100",
",",
"\"posy\"",
":",
"100",
",",
"\"rotar\"",
":",
"0",
"}",
")",
",",
"Storage",
"(",
"{",
"\"campo\"",
":",
"\"nombre\"",
",",
"\"col_ini\"",
":",
"17",
",",
"\"col_fin\"",
":",
"53",
",",
"\"letra\"",
":",
"\"Ubuntu\"",
",",
"\"alto\"",
":",
"12",
",",
"\"alinear\"",
":",
"1",
",",
"\"posx\"",
":",
"200",
",",
"\"posy\"",
":",
"200",
",",
"\"rotar\"",
":",
"0",
"}",
")",
",",
"]",
"for",
"item",
"in",
"selector",
":",
"self",
".",
"encabezado",
"[",
"item",
".",
"campo",
"]",
"=",
"{",
"\"texto\"",
":",
"linea",
"[",
"item",
".",
"col_ini",
":",
"item",
".",
"col_fin",
"]",
".",
"strip",
"(",
")",
",",
"\"letra\"",
":",
"item",
".",
"letra",
",",
"\"alto\"",
":",
"item",
".",
"alto",
",",
"\"alinear\"",
":",
"item",
".",
"alinear",
",",
"\"posx\"",
":",
"item",
".",
"posx",
",",
"\"posy\"",
":",
"item",
".",
"posy",
",",
"\"rotar\"",
":",
"item",
".",
"rotar",
",",
"}",
"print",
"(",
"self",
".",
"encabezado",
".",
"fecha",
"[",
"\"texto\"",
"]",
",",
"self",
".",
"encabezado",
".",
"fecha",
"[",
"\"letra\"",
"]",
")"
] | [
14,
4
] | [
65,
78
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
planilla.abrir_planilla | (self) | Abrir el archivo .txt que se guardo el diccionario | Abrir el archivo .txt que se guardo el diccionario | def abrir_planilla(self):
"Abrir el archivo .txt que se guardo el diccionario"
self.Planilla_ = dict
f = open(input("nombre")+'.txt', 'rt')
self.Planilla_ = eval(f.read())
f.close() | [
"def",
"abrir_planilla",
"(",
"self",
")",
":",
"self",
".",
"Planilla_",
"=",
"dict",
"f",
"=",
"open",
"(",
"input",
"(",
"\"nombre\"",
")",
"+",
"'.txt'",
",",
"'rt'",
")",
"self",
".",
"Planilla_",
"=",
"eval",
"(",
"f",
".",
"read",
"(",
")",
")",
"f",
".",
"close",
"(",
")"
] | [
50,
4
] | [
55,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RatTube.descargar | (self) | Este método es para confirmar que si deseamos introducir la url del video.
Si no nos hemos equivocado, confirmaremos que pondremos la url, en caso que no
podremos dar en volver, ejecutando el método limpiar_Mostrar_Banner
y llamando al menú inicial nuevamente | Este método es para confirmar que si deseamos introducir la url del video.
Si no nos hemos equivocado, confirmaremos que pondremos la url, en caso que no
podremos dar en volver, ejecutando el método limpiar_Mostrar_Banner
y llamando al menú inicial nuevamente | def descargar(self):
self.limpiar_Mostrar_Banner()
print("""\n\n1. Ingresar URL del video
2. Volver""")
opcion = input("\nElija una opción: ")
if opcion == "1":
self.confirmar_Descargar()
else:
self.limpiar_Mostrar_Banner()
self.mostrar_Menu(self.descargar, self.salir)
'''Este método es para confirmar que si deseamos introducir la url del video.
Si no nos hemos equivocado, confirmaremos que pondremos la url, en caso que no
podremos dar en volver, ejecutando el método limpiar_Mostrar_Banner
y llamando al menú inicial nuevamente'''
| [
"def",
"descargar",
"(",
"self",
")",
":",
"self",
".",
"limpiar_Mostrar_Banner",
"(",
")",
"print",
"(",
"\"\"\"\\n\\n1. Ingresar URL del video\r\n2. Volver\"\"\"",
")",
"opcion",
"=",
"input",
"(",
"\"\\nElija una opción: \")",
"\r",
"if",
"opcion",
"==",
"\"1\"",
":",
"self",
".",
"confirmar_Descargar",
"(",
")",
"else",
":",
"self",
".",
"limpiar_Mostrar_Banner",
"(",
")",
"self",
".",
"mostrar_Menu",
"(",
"self",
".",
"descargar",
",",
"self",
".",
"salir",
")"
] | [
73,
1
] | [
89,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
shellSort | (v) | Metodo de ordenamiento shell | Metodo de ordenamiento shell | def shellSort(v):
"""Metodo de ordenamiento shell"""
length = len(v)
gap = int(length/2)
while(gap >= 1):
i = gap
while(i < length):
value = v[i]
j = i
while(j-gap >= 0 and value < v[j - gap]):
v[j] = v[j - gap]
j -= gap
v[j] = value
i+=1
gap = int(gap/2) | [
"def",
"shellSort",
"(",
"v",
")",
":",
"length",
"=",
"len",
"(",
"v",
")",
"gap",
"=",
"int",
"(",
"length",
"/",
"2",
")",
"while",
"(",
"gap",
">=",
"1",
")",
":",
"i",
"=",
"gap",
"while",
"(",
"i",
"<",
"length",
")",
":",
"value",
"=",
"v",
"[",
"i",
"]",
"j",
"=",
"i",
"while",
"(",
"j",
"-",
"gap",
">=",
"0",
"and",
"value",
"<",
"v",
"[",
"j",
"-",
"gap",
"]",
")",
":",
"v",
"[",
"j",
"]",
"=",
"v",
"[",
"j",
"-",
"gap",
"]",
"j",
"-=",
"gap",
"v",
"[",
"j",
"]",
"=",
"value",
"i",
"+=",
"1",
"gap",
"=",
"int",
"(",
"gap",
"/",
"2",
")"
] | [
106,
0
] | [
120,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_varias_funciones1 | (t) | varias_funciones : funcion | varias_funciones : funcion | def p_varias_funciones1(t):
'varias_funciones : funcion'
reporte_bnf.append("<varias_funciones> ::= <funcion>")
t[0] = [t[1]] | [
"def",
"p_varias_funciones1",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<varias_funciones> ::= <funcion>\"",
")",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
1828,
0
] | [
1831,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
plotScores | (params,scores,color,title,xlabel, log=False,xlimits=None,ylimits=None) | Función para visualizar las medidas de accuracy
obtenidas por distintos valores de un parámetro concreto
Args:
params: array de numpy con los valores del parámetro
scores: array de numpy con los valores de accuracy obtenidos para cada
valor del parámetro que se encuentra en params
color: color para los puntos que se visualizarán
title: título del gráfico generado
xlabel: etiqueta para el eje x
log: booleano que determina si se usa escala logarítmica en el eje x
xlimits: límites para el eje x. Será None si no se
quiere etablecer los límites manualmente
ylimits: límites para el eje y. Será None si no se
quiere etablecer los límites manualmente
| Función para visualizar las medidas de accuracy
obtenidas por distintos valores de un parámetro concreto | def plotScores(params,scores,color,title,xlabel, log=False,xlimits=None,ylimits=None):
""" Función para visualizar las medidas de accuracy
obtenidas por distintos valores de un parámetro concreto
Args:
params: array de numpy con los valores del parámetro
scores: array de numpy con los valores de accuracy obtenidos para cada
valor del parámetro que se encuentra en params
color: color para los puntos que se visualizarán
title: título del gráfico generado
xlabel: etiqueta para el eje x
log: booleano que determina si se usa escala logarítmica en el eje x
xlimits: límites para el eje x. Será None si no se
quiere etablecer los límites manualmente
ylimits: límites para el eje y. Será None si no se
quiere etablecer los límites manualmente
"""
plt.scatter(params,scores, c=color)
if xlimits!=None:
plt.xlim(xlimits)
if ylimits!=None:
plt.ylim(ylimits)
if log:
plt.xscale('log')
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel('Accuracy')
plt.grid(True)
plt.show() | [
"def",
"plotScores",
"(",
"params",
",",
"scores",
",",
"color",
",",
"title",
",",
"xlabel",
",",
"log",
"=",
"False",
",",
"xlimits",
"=",
"None",
",",
"ylimits",
"=",
"None",
")",
":",
"plt",
".",
"scatter",
"(",
"params",
",",
"scores",
",",
"c",
"=",
"color",
")",
"if",
"xlimits",
"!=",
"None",
":",
"plt",
".",
"xlim",
"(",
"xlimits",
")",
"if",
"ylimits",
"!=",
"None",
":",
"plt",
".",
"ylim",
"(",
"ylimits",
")",
"if",
"log",
":",
"plt",
".",
"xscale",
"(",
"'log'",
")",
"plt",
".",
"title",
"(",
"title",
")",
"plt",
".",
"xlabel",
"(",
"xlabel",
")",
"plt",
".",
"ylabel",
"(",
"'Accuracy'",
")",
"plt",
".",
"grid",
"(",
"True",
")",
"plt",
".",
"show",
"(",
")"
] | [
146,
0
] | [
175,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Child.component_function | (self) | Imrpime el nombre de nuestro child item | Imrpime el nombre de nuestro child item | def component_function(self):
"""Imrpime el nombre de nuestro child item"""
print("{}".format(self.name)) | [
"def",
"component_function",
"(",
"self",
")",
":",
"print",
"(",
"\"{}\"",
".",
"format",
"(",
"self",
".",
"name",
")",
")"
] | [
24,
4
] | [
26,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PlacesExtractor._get_place_info | (self, provided_driver=None) | return place_info | Función que extrae la información general del local comercial. Así también se llama a las funciones para
obtener la ocupación y los comentarios
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para extraer la información del local comercial
Returns
-------
dict
devuelve la información completa del local comercial en un diccionario de python
| Función que extrae la información general del local comercial. Así también se llama a las funciones para
obtener la ocupación y los comentarios | def _get_place_info(self, provided_driver=None):
"""Función que extrae la información general del local comercial. Así también se llama a las funciones para
obtener la ocupación y los comentarios
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para extraer la información del local comercial
Returns
-------
dict
devuelve la información completa del local comercial en un diccionario de python
"""
driver = provided_driver if provided_driver else self.get_driver()
elements = self._get_elements_match(provided_driver=driver)
# extract basic info
name_obj = self.get_obj_text(xpath_query=self._place_name_xpath, external_driver=driver)
name_val = name_obj if name_obj else self._place_name
score_obj = self.get_obj_text(xpath_query=self._place_score_xpath, external_driver=driver)
total_score_obj = self.get_obj_text(xpath_query=self._total_votes_xpath, external_driver=driver)
total_score_val = total_score_obj.replace("(", "").replace(")", "") if total_score_obj else total_score_obj
# address_obj = self.get_obj_text(xpath_query=self._address_xpath, external_driver=driver)
# address_obj_val = address_obj if address_obj else self._place_address
# coords_obj = self.get_obj_text(xpath_query=self._coords_xpath_selector, external_driver=driver)
# telephone_obj = self.get_obj_text(xpath_query=self._telephone_xpath_selector, external_driver=driver)
opening_obj_el = self.get_info_obj(xpath_query=self._openning_hours_xpath_selector, external_driver=driver)
opening_obj = opening_obj_el if opening_obj_el else self.get_info_obj(xpath_query=self._openning_hours_xpath_selector_aux, external_driver=driver)
price_range = self.get_obj_text(xpath_query=self._price_range, external_driver=driver)
style = self.get_obj_text(xpath_query=self._style, external_driver=driver)
premise_type = self.get_obj_text(xpath_query=self._premise_type, external_driver=driver)
opening_value = opening_obj.get_attribute("aria-label").split(",") if opening_obj else []
occupancy_obj = self._get_occupancy(external_driver=driver)
# se checkea si el local ya existe
# is_registered = self._writer.is_registered({"name": self._place_name, "date": self._extraction_date,
# "address": address_obj})
comments_list = self._get_comments(self._place_name, self.sleep_m, external_driver=driver)
# if is_registered:
# self.logger.warning("the place: -{name}- for date: -{date}- located in -{addr}-is already processed"
# .format(name=self._place_name, date=self._extraction_date, addr=address_obj))
# else:
# comments_list = self._get_comments(self._place_name, self.sleep_m, external_driver=driver)
place_info = {
"name": name_val,
"score": score_obj,
"total_scores": total_score_val,
# "address": address_obj_val,
"occupancy": occupancy_obj,
# "coordinates": coords_obj,
# "telephone_number": telephone_obj,
"opening_hours": opening_value,
"comments": comments_list,
"zip_code": self._postal_code,
"date": self._extraction_date,
"execution_places_types": self._places_types,
"price_range": price_range,
"style": style,
"premise_type": premise_type,
"extractor_url": self._url,
"current_url": driver.current_url
}
place_info.update(elements)
self.logger.info("-{place}-: info retrieved for place".format(place=self._place_name))
return place_info | [
"def",
"_get_place_info",
"(",
"self",
",",
"provided_driver",
"=",
"None",
")",
":",
"driver",
"=",
"provided_driver",
"if",
"provided_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"elements",
"=",
"self",
".",
"_get_elements_match",
"(",
"provided_driver",
"=",
"driver",
")",
"# extract basic info",
"name_obj",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_place_name_xpath",
",",
"external_driver",
"=",
"driver",
")",
"name_val",
"=",
"name_obj",
"if",
"name_obj",
"else",
"self",
".",
"_place_name",
"score_obj",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_place_score_xpath",
",",
"external_driver",
"=",
"driver",
")",
"total_score_obj",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_total_votes_xpath",
",",
"external_driver",
"=",
"driver",
")",
"total_score_val",
"=",
"total_score_obj",
".",
"replace",
"(",
"\"(\"",
",",
"\"\"",
")",
".",
"replace",
"(",
"\")\"",
",",
"\"\"",
")",
"if",
"total_score_obj",
"else",
"total_score_obj",
"# address_obj = self.get_obj_text(xpath_query=self._address_xpath, external_driver=driver)",
"# address_obj_val = address_obj if address_obj else self._place_address",
"# coords_obj = self.get_obj_text(xpath_query=self._coords_xpath_selector, external_driver=driver)",
"# telephone_obj = self.get_obj_text(xpath_query=self._telephone_xpath_selector, external_driver=driver)",
"opening_obj_el",
"=",
"self",
".",
"get_info_obj",
"(",
"xpath_query",
"=",
"self",
".",
"_openning_hours_xpath_selector",
",",
"external_driver",
"=",
"driver",
")",
"opening_obj",
"=",
"opening_obj_el",
"if",
"opening_obj_el",
"else",
"self",
".",
"get_info_obj",
"(",
"xpath_query",
"=",
"self",
".",
"_openning_hours_xpath_selector_aux",
",",
"external_driver",
"=",
"driver",
")",
"price_range",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_price_range",
",",
"external_driver",
"=",
"driver",
")",
"style",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_style",
",",
"external_driver",
"=",
"driver",
")",
"premise_type",
"=",
"self",
".",
"get_obj_text",
"(",
"xpath_query",
"=",
"self",
".",
"_premise_type",
",",
"external_driver",
"=",
"driver",
")",
"opening_value",
"=",
"opening_obj",
".",
"get_attribute",
"(",
"\"aria-label\"",
")",
".",
"split",
"(",
"\",\"",
")",
"if",
"opening_obj",
"else",
"[",
"]",
"occupancy_obj",
"=",
"self",
".",
"_get_occupancy",
"(",
"external_driver",
"=",
"driver",
")",
"# se checkea si el local ya existe",
"# is_registered = self._writer.is_registered({\"name\": self._place_name, \"date\": self._extraction_date,",
"# \"address\": address_obj})",
"comments_list",
"=",
"self",
".",
"_get_comments",
"(",
"self",
".",
"_place_name",
",",
"self",
".",
"sleep_m",
",",
"external_driver",
"=",
"driver",
")",
"# if is_registered:",
"# self.logger.warning(\"the place: -{name}- for date: -{date}- located in -{addr}-is already processed\"",
"# .format(name=self._place_name, date=self._extraction_date, addr=address_obj))",
"# else:",
"# comments_list = self._get_comments(self._place_name, self.sleep_m, external_driver=driver)",
"place_info",
"=",
"{",
"\"name\"",
":",
"name_val",
",",
"\"score\"",
":",
"score_obj",
",",
"\"total_scores\"",
":",
"total_score_val",
",",
"# \"address\": address_obj_val,",
"\"occupancy\"",
":",
"occupancy_obj",
",",
"# \"coordinates\": coords_obj,",
"# \"telephone_number\": telephone_obj,",
"\"opening_hours\"",
":",
"opening_value",
",",
"\"comments\"",
":",
"comments_list",
",",
"\"zip_code\"",
":",
"self",
".",
"_postal_code",
",",
"\"date\"",
":",
"self",
".",
"_extraction_date",
",",
"\"execution_places_types\"",
":",
"self",
".",
"_places_types",
",",
"\"price_range\"",
":",
"price_range",
",",
"\"style\"",
":",
"style",
",",
"\"premise_type\"",
":",
"premise_type",
",",
"\"extractor_url\"",
":",
"self",
".",
"_url",
",",
"\"current_url\"",
":",
"driver",
".",
"current_url",
"}",
"place_info",
".",
"update",
"(",
"elements",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: info retrieved for place\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
")",
")",
"return",
"place_info"
] | [
330,
4
] | [
394,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
fibonacci_while | (n: int) | Genera la secuencia de Fibonacci de 'n' elementos.
:param n: cantidad de elementos de la secuencia
:n type: int
:return: secuencia de Fibonacci
:rtype: Generator[int, None, None]
| Genera la secuencia de Fibonacci de 'n' elementos. | def fibonacci_while(n: int) -> Generator[int, None, None]:
"""Genera la secuencia de Fibonacci de 'n' elementos.
:param n: cantidad de elementos de la secuencia
:n type: int
:return: secuencia de Fibonacci
:rtype: Generator[int, None, None]
"""
a, b = 0, 1
while n > 0:
yield a
a, b = b, a + b
n -= 1 | [
"def",
"fibonacci_while",
"(",
"n",
":",
"int",
")",
"->",
"Generator",
"[",
"int",
",",
"None",
",",
"None",
"]",
":",
"a",
",",
"b",
"=",
"0",
",",
"1",
"while",
"n",
">",
"0",
":",
"yield",
"a",
"a",
",",
"b",
"=",
"b",
",",
"a",
"+",
"b",
"n",
"-=",
"1"
] | [
16,
0
] | [
29,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
loglikelihood | (x_obs, y_obs, sigma_y_obs, param) | return d | Logaritmo natural de la verosimilitud construida con los datos observacionales y los
parametros que describen el modelo.
| Logaritmo natural de la verosimilitud construida con los datos observacionales y los
parametros que describen el modelo.
| def loglikelihood(x_obs, y_obs, sigma_y_obs, param):
"""Logaritmo natural de la verosimilitud construida con los datos observacionales y los
parametros que describen el modelo.
"""
d = y_obs - model(x_obs, param)
d = d/sigma_y_obs
d = -0.5 * np.sum(d**2)
return d | [
"def",
"loglikelihood",
"(",
"x_obs",
",",
"y_obs",
",",
"sigma_y_obs",
",",
"param",
")",
":",
"d",
"=",
"y_obs",
"-",
"model",
"(",
"x_obs",
",",
"param",
")",
"d",
"=",
"d",
"/",
"sigma_y_obs",
"d",
"=",
"-",
"0.5",
"*",
"np",
".",
"sum",
"(",
"d",
"**",
"2",
")",
"return",
"d"
] | [
13,
0
] | [
20,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Molecule.set_bonds | (self, *bonds) | return True | Metodo para agregar enlaces a la molecula. | Metodo para agregar enlaces a la molecula. | def set_bonds(self, *bonds):
""" Metodo para agregar enlaces a la molecula. """
if len(bonds) == 0:
raise TypeError, "Molecule: The object added is empty."
elif len(bonds) == 1:
if isinstance(bonds[0], list):
bonds = bonds[0]
todos = len(self.atoms)
self.bonds = [[0] * todos for i in xrange(todos)]
for b in bonds:
if not isinstance(b, list) and not isinstance(b, tuple):
raise TypeError, "Molecule: The given argument is not a list."
if len(b) != 3:
raise ValueError, "Molecule: The given argument is incomplete - atom[1], atom[2], number of bonds."
if (b[0] > todos) or (b[1] > todos) or (b[0] < 0) or \
(b[1] < 0) or (not isinstance(b[0], int)) or \
(not isinstance(b[1], int)):
raise ValueError, "Molecule: The atom referenced does not exist."
self.bonds[b[0]][b[1]] = b[2]
self.bonds[b[1]][b[0]] = b[2]
self.bonds = Matrix(self.bonds)
return True | [
"def",
"set_bonds",
"(",
"self",
",",
"*",
"bonds",
")",
":",
"if",
"len",
"(",
"bonds",
")",
"==",
"0",
":",
"raise",
"TypeError",
",",
"\"Molecule: The object added is empty.\"",
"elif",
"len",
"(",
"bonds",
")",
"==",
"1",
":",
"if",
"isinstance",
"(",
"bonds",
"[",
"0",
"]",
",",
"list",
")",
":",
"bonds",
"=",
"bonds",
"[",
"0",
"]",
"todos",
"=",
"len",
"(",
"self",
".",
"atoms",
")",
"self",
".",
"bonds",
"=",
"[",
"[",
"0",
"]",
"*",
"todos",
"for",
"i",
"in",
"xrange",
"(",
"todos",
")",
"]",
"for",
"b",
"in",
"bonds",
":",
"if",
"not",
"isinstance",
"(",
"b",
",",
"list",
")",
"and",
"not",
"isinstance",
"(",
"b",
",",
"tuple",
")",
":",
"raise",
"TypeError",
",",
"\"Molecule: The given argument is not a list.\"",
"if",
"len",
"(",
"b",
")",
"!=",
"3",
":",
"raise",
"ValueError",
",",
"\"Molecule: The given argument is incomplete - atom[1], atom[2], number of bonds.\"",
"if",
"(",
"b",
"[",
"0",
"]",
">",
"todos",
")",
"or",
"(",
"b",
"[",
"1",
"]",
">",
"todos",
")",
"or",
"(",
"b",
"[",
"0",
"]",
"<",
"0",
")",
"or",
"(",
"b",
"[",
"1",
"]",
"<",
"0",
")",
"or",
"(",
"not",
"isinstance",
"(",
"b",
"[",
"0",
"]",
",",
"int",
")",
")",
"or",
"(",
"not",
"isinstance",
"(",
"b",
"[",
"1",
"]",
",",
"int",
")",
")",
":",
"raise",
"ValueError",
",",
"\"Molecule: The atom referenced does not exist.\"",
"self",
".",
"bonds",
"[",
"b",
"[",
"0",
"]",
"]",
"[",
"b",
"[",
"1",
"]",
"]",
"=",
"b",
"[",
"2",
"]",
"self",
".",
"bonds",
"[",
"b",
"[",
"1",
"]",
"]",
"[",
"b",
"[",
"0",
"]",
"]",
"=",
"b",
"[",
"2",
"]",
"self",
".",
"bonds",
"=",
"Matrix",
"(",
"self",
".",
"bonds",
")",
"return",
"True"
] | [
104,
4
] | [
125,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects.insert_empty_object | (self, id_: int) | Añade un objeto vacío en la posición indicada.
:param id_: índice donde añadirlo.
:return: None.
| Añade un objeto vacío en la posición indicada. | def insert_empty_object(self, id_: int) -> None:
"""Añade un objeto vacío en la posición indicada.
:param id_: índice donde añadirlo.
:return: None.
"""
empty_object = TrackedObject(id_, False, None, None)
# Insertar el objeto vacío.
self._tracked_objects.insert(id_, empty_object)
# Reajustar los ids de todos los objetos siguientes.
for tracked_object in self._tracked_objects[id_+1:]:
tracked_object.id += 1 | [
"def",
"insert_empty_object",
"(",
"self",
",",
"id_",
":",
"int",
")",
"->",
"None",
":",
"empty_object",
"=",
"TrackedObject",
"(",
"id_",
",",
"False",
",",
"None",
",",
"None",
")",
"# Insertar el objeto vacío.",
"self",
".",
"_tracked_objects",
".",
"insert",
"(",
"id_",
",",
"empty_object",
")",
"# Reajustar los ids de todos los objetos siguientes.",
"for",
"tracked_object",
"in",
"self",
".",
"_tracked_objects",
"[",
"id_",
"+",
"1",
":",
"]",
":",
"tracked_object",
".",
"id",
"+=",
"1"
] | [
307,
4
] | [
318,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
promedio | (a: List[int], b: List[int], c: List[int]) | return list(map(avg, zip_longest(a, b, c))) | Calcula el promedio de los elementos de tres listas de
diferentes tamaños.
:param a: Lista de números enteros
:a type: List[int]
:param b: Lista de números enteros
:b type: List[int]
:param c: Lista de numeros enteros
:c type: List[int]
:return: Lista con el promedio de los elementos de las tres listas
:rtype: List[int]
| Calcula el promedio de los elementos de tres listas de
diferentes tamaños.
:param a: Lista de números enteros
:a type: List[int]
:param b: Lista de números enteros
:b type: List[int]
:param c: Lista de numeros enteros
:c type: List[int]
:return: Lista con el promedio de los elementos de las tres listas
:rtype: List[int]
| def promedio(a: List[int], b: List[int], c: List[int]) -> List[int]:
"""Calcula el promedio de los elementos de tres listas de
diferentes tamaños.
:param a: Lista de números enteros
:a type: List[int]
:param b: Lista de números enteros
:b type: List[int]
:param c: Lista de numeros enteros
:c type: List[int]
:return: Lista con el promedio de los elementos de las tres listas
:rtype: List[int]
"""
def avg(x: int) -> int:
x = [n for n in x if n is not None]
return floor((sum(x) / len(x)) + 0.5)
return list(map(avg, zip_longest(a, b, c))) | [
"def",
"promedio",
"(",
"a",
":",
"List",
"[",
"int",
"]",
",",
"b",
":",
"List",
"[",
"int",
"]",
",",
"c",
":",
"List",
"[",
"int",
"]",
")",
"->",
"List",
"[",
"int",
"]",
":",
"def",
"avg",
"(",
"x",
":",
"int",
")",
"->",
"int",
":",
"x",
"=",
"[",
"n",
"for",
"n",
"in",
"x",
"if",
"n",
"is",
"not",
"None",
"]",
"return",
"floor",
"(",
"(",
"sum",
"(",
"x",
")",
"/",
"len",
"(",
"x",
")",
")",
"+",
"0.5",
")",
"return",
"list",
"(",
"map",
"(",
"avg",
",",
"zip_longest",
"(",
"a",
",",
"b",
",",
"c",
")",
")",
")"
] | [
17,
0
] | [
32,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraLiborScraperTestCase.test_fetch_contents_with_valid_dates | (self) | comprueba, dependiendo de un rango de fechas,
la cantidad de contenidos | comprueba, dependiendo de un rango de fechas,
la cantidad de contenidos | def test_fetch_contents_with_valid_dates(self):
"""comprueba, dependiendo de un rango de fechas,
la cantidad de contenidos"""
url = "http://www.bcra.gov.ar/PublicacionesEstadisticas/libor.asp"
rates = {
"30": "libor_30_dias",
"60": "libor_60_dias",
"90": "libor_90_dias",
"180": "libor_180_dias",
"360": "libor_360_dias"
}
with patch.object(
BCRALiborScraper,
'fetch_day_content',
return_value=['a', 'b', 'c', 'd', 'e', 'f', 'g']
):
scraper = BCRALiborScraper(url, rates, intermediate_panel_path=None, use_intermediate_panel=False)
start_day = date(2019, 3, 4)
end_day = date(2019, 3, 10)
contents = scraper.fetch_contents(start_day, end_day)
assert len(contents) == 7 | [
"def",
"test_fetch_contents_with_valid_dates",
"(",
"self",
")",
":",
"url",
"=",
"\"http://www.bcra.gov.ar/PublicacionesEstadisticas/libor.asp\"",
"rates",
"=",
"{",
"\"30\"",
":",
"\"libor_30_dias\"",
",",
"\"60\"",
":",
"\"libor_60_dias\"",
",",
"\"90\"",
":",
"\"libor_90_dias\"",
",",
"\"180\"",
":",
"\"libor_180_dias\"",
",",
"\"360\"",
":",
"\"libor_360_dias\"",
"}",
"with",
"patch",
".",
"object",
"(",
"BCRALiborScraper",
",",
"'fetch_day_content'",
",",
"return_value",
"=",
"[",
"'a'",
",",
"'b'",
",",
"'c'",
",",
"'d'",
",",
"'e'",
",",
"'f'",
",",
"'g'",
"]",
")",
":",
"scraper",
"=",
"BCRALiborScraper",
"(",
"url",
",",
"rates",
",",
"intermediate_panel_path",
"=",
"None",
",",
"use_intermediate_panel",
"=",
"False",
")",
"start_day",
"=",
"date",
"(",
"2019",
",",
"3",
",",
"4",
")",
"end_day",
"=",
"date",
"(",
"2019",
",",
"3",
",",
"10",
")",
"contents",
"=",
"scraper",
".",
"fetch_contents",
"(",
"start_day",
",",
"end_day",
")",
"assert",
"len",
"(",
"contents",
")",
"==",
"7"
] | [
35,
4
] | [
59,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Chimp.send | (self, id) | Este método es para enviar la campaña a todos los contactos de cierta campaña,
para saber cuál, este método recibe como parametro el id de la campaña | Este método es para enviar la campaña a todos los contactos de cierta campaña,
para saber cuál, este método recibe como parametro el id de la campaña | def send(self, id):
"""Este método es para enviar la campaña a todos los contactos de cierta campaña,
para saber cuál, este método recibe como parametro el id de la campaña"""
self.client.campaigns.actions.send(campaign_id=id) | [
"def",
"send",
"(",
"self",
",",
"id",
")",
":",
"self",
".",
"client",
".",
"campaigns",
".",
"actions",
".",
"send",
"(",
"campaign_id",
"=",
"id",
")"
] | [
168,
4
] | [
171,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
getRegisterStatus | (
apiclient: ApiClient, token: str
) | Este servicio retorna el resultado del registro de la tarjeta de
crédito de un cliente.
| Este servicio retorna el resultado del registro de la tarjeta de
crédito de un cliente.
| def getRegisterStatus(
apiclient: ApiClient, token: str
) -> Union[CustomerRegisterStatusResponse, Error]:
"""Este servicio retorna el resultado del registro de la tarjeta de
crédito de un cliente.
"""
url = f"{apiclient.api_url}/customer/getRegisterStatus"
params: Dict[str, Any] = {
"apiKey": apiclient.api_key,
"token": token,
}
signature = apiclient.make_signature(params)
params["s"] = signature
logging.debug("Before Request:" + str(params))
response = apiclient.get(url, params)
if response.status_code == 200:
return CustomerRegisterStatusResponse.from_dict(
cast(Dict[str, Any], response.json())
)
if response.status_code == 400:
return Error.from_dict(cast(Dict[str, Any], response.json()))
if response.status_code == 401:
return Error.from_dict(cast(Dict[str, Any], response.json()))
else:
raise Exception(response=response) | [
"def",
"getRegisterStatus",
"(",
"apiclient",
":",
"ApiClient",
",",
"token",
":",
"str",
")",
"->",
"Union",
"[",
"CustomerRegisterStatusResponse",
",",
"Error",
"]",
":",
"url",
"=",
"f\"{apiclient.api_url}/customer/getRegisterStatus\"",
"params",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"\"apiKey\"",
":",
"apiclient",
".",
"api_key",
",",
"\"token\"",
":",
"token",
",",
"}",
"signature",
"=",
"apiclient",
".",
"make_signature",
"(",
"params",
")",
"params",
"[",
"\"s\"",
"]",
"=",
"signature",
"logging",
".",
"debug",
"(",
"\"Before Request:\"",
"+",
"str",
"(",
"params",
")",
")",
"response",
"=",
"apiclient",
".",
"get",
"(",
"url",
",",
"params",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"CustomerRegisterStatusResponse",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"400",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"401",
":",
"return",
"Error",
".",
"from_dict",
"(",
"cast",
"(",
"Dict",
"[",
"str",
",",
"Any",
"]",
",",
"response",
".",
"json",
"(",
")",
")",
")",
"else",
":",
"raise",
"Exception",
"(",
"response",
"=",
"response",
")"
] | [
191,
0
] | [
219,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Car.increment_odometer | (self, miles) | Agregue la cantidad dada a la lectura del odómetro. | Agregue la cantidad dada a la lectura del odómetro. | def increment_odometer(self, miles):
"""Agregue la cantidad dada a la lectura del odómetro."""
self.odometer_reading += miles | [
"def",
"increment_odometer",
"(",
"self",
",",
"miles",
")",
":",
"self",
".",
"odometer_reading",
"+=",
"miles"
] | [
29,
4
] | [
31,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
CapitalizerIntegrationTestCase.test_capitalizer_methods_together | (self) | Testea el método principal de normalizecion. | Testea el método principal de normalizecion. | def test_capitalizer_methods_together(self):
"""Testea el método principal de normalizecion."""
test_strings = [
("JUAN PEREZ", "Juan Perez"),
("juAn PErez", "Juan Perez"),
(u"juán PErez", u'Ju\xe1n Perez'),
(u"o'higgins", u"O'Higgins"),
(u"o'higgins mc Donald", u"O'Higgins Mc Donald"),
("Juan De La Vaca", 'Juan de la Vaca'),
(u"Calle PúBlica S/N", u"Calle Pública S/N"),
(1, "1"),
(1.5, "1.5"),
]
for (inp, outp) in test_strings:
self.assertEqual(capitalize(inp), outp) | [
"def",
"test_capitalizer_methods_together",
"(",
"self",
")",
":",
"test_strings",
"=",
"[",
"(",
"\"JUAN PEREZ\"",
",",
"\"Juan Perez\"",
")",
",",
"(",
"\"juAn PErez\"",
",",
"\"Juan Perez\"",
")",
",",
"(",
"u\"juán PErez\",",
" ",
"'Ju\\xe1n Perez')",
",",
"",
"(",
"u\"o'higgins\"",
",",
"u\"O'Higgins\"",
")",
",",
"(",
"u\"o'higgins mc Donald\"",
",",
"u\"O'Higgins Mc Donald\"",
")",
",",
"(",
"\"Juan De La Vaca\"",
",",
"'Juan de la Vaca'",
")",
",",
"(",
"u\"Calle PúBlica S/N\",",
" ",
"\"Calle Pública S/N\"),",
"",
"",
"(",
"1",
",",
"\"1\"",
")",
",",
"(",
"1.5",
",",
"\"1.5\"",
")",
",",
"]",
"for",
"(",
"inp",
",",
"outp",
")",
"in",
"test_strings",
":",
"self",
".",
"assertEqual",
"(",
"capitalize",
"(",
"inp",
")",
",",
"outp",
")"
] | [
21,
4
] | [
35,
51
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Text.clean_person_name | (cls, text: str) | return out | Valida el texto para utilizarlo como nombre válido de persona. | Valida el texto para utilizarlo como nombre válido de persona. | def clean_person_name(cls, text: str) -> str:
"""Valida el texto para utilizarlo como nombre válido de persona."""
out = cls.strip(text).title()
if not cls.is_possible_name(out):
raise TextError("El texto indicado no parece ser el nombre válido "
"de una persona.")
return out | [
"def",
"clean_person_name",
"(",
"cls",
",",
"text",
":",
"str",
")",
"->",
"str",
":",
"out",
"=",
"cls",
".",
"strip",
"(",
"text",
")",
".",
"title",
"(",
")",
"if",
"not",
"cls",
".",
"is_possible_name",
"(",
"out",
")",
":",
"raise",
"TextError",
"(",
"\"El texto indicado no parece ser el nombre válido \"\r",
"\"de una persona.\"",
")",
"return",
"out"
] | [
368,
4
] | [
374,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Dominio.texto | (self, sol) | Construye una representación en hilera legible por humanos de la solución
con el fin de reportar resultados al usuario final.
Entradas:
sol (estructura de datos)
La solución a transformar en texto legible
Salidas:
(str) El texto legible que representa a la solución.
| Construye una representación en hilera legible por humanos de la solución
con el fin de reportar resultados al usuario final. | def texto(self, sol):
"""Construye una representación en hilera legible por humanos de la solución
con el fin de reportar resultados al usuario final.
Entradas:
sol (estructura de datos)
La solución a transformar en texto legible
Salidas:
(str) El texto legible que representa a la solución.
"""
pass | [
"def",
"texto",
"(",
"self",
",",
"sol",
")",
":",
"pass"
] | [
89,
4
] | [
101,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_propiedades4 | (t) | propiedades : primary key propiedades | propiedades : primary key propiedades | def p_propiedades4(t):
'''propiedades : primary key propiedades '''
node = grammer.nodoDireccion('propiedades')
node1 = grammer.nodoDireccion(t[1])
node2 = grammer.nodoDireccion(t[2])
node.agregar(node1)
node.agregar(node2)
node.agregar(t[3])
t[0] = node | [
"def",
"p_propiedades4",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'propiedades'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node2",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"2",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"node",
".",
"agregar",
"(",
"node2",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"3",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
302,
0
] | [
310,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResults.ignore_object | (self, id_: int) | Se ignorará el objeto indicado en los métodos de cálculo sobre las estimaciones, como por
ejemplo el cálculo del MSE.
:param id_: índice del objeto.
:return: None.
| Se ignorará el objeto indicado en los métodos de cálculo sobre las estimaciones, como por
ejemplo el cálculo del MSE. | def ignore_object(self, id_: int) -> None:
"""Se ignorará el objeto indicado en los métodos de cálculo sobre las estimaciones, como por
ejemplo el cálculo del MSE.
:param id_: índice del objeto.
:return: None.
"""
self._ignored_ids.append(id_) | [
"def",
"ignore_object",
"(",
"self",
",",
"id_",
":",
"int",
")",
"->",
"None",
":",
"self",
".",
"_ignored_ids",
".",
"append",
"(",
"id_",
")"
] | [
107,
4
] | [
114,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResults.__getitem__ | (self, item: int) | return self._estimations_results[item] | Devuelve la estimación item-ésima.
:param item: índice de la estimación.
:return: resultado de la estimación.
| Devuelve la estimación item-ésima. | def __getitem__(self, item: int) -> EstimationResult:
"""Devuelve la estimación item-ésima.
:param item: índice de la estimación.
:return: resultado de la estimación.
"""
if item >= len(self._estimations_results):
raise IndexError(f'El índice {item} está fuera del límite.')
return self._estimations_results[item] | [
"def",
"__getitem__",
"(",
"self",
",",
"item",
":",
"int",
")",
"->",
"EstimationResult",
":",
"if",
"item",
">=",
"len",
"(",
"self",
".",
"_estimations_results",
")",
":",
"raise",
"IndexError",
"(",
"f'El índice {item} está fuera del límite.')",
"",
"return",
"self",
".",
"_estimations_results",
"[",
"item",
"]"
] | [
78,
4
] | [
86,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObject.append | (self, frame: int, obj: Object) | Añade un registro al seguimiento del objeto.
:param frame: frame en el que fue visto.
:param obj: objeto detectado.
:return: None
| Añade un registro al seguimiento del objeto. | def append(self, frame: int, obj: Object) -> None:
"""Añade un registro al seguimiento del objeto.
:param frame: frame en el que fue visto.
:param obj: objeto detectado.
:return: None
"""
self.frames.append(frame)
self.detections.append(obj) | [
"def",
"append",
"(",
"self",
",",
"frame",
":",
"int",
",",
"obj",
":",
"Object",
")",
"->",
"None",
":",
"self",
".",
"frames",
".",
"append",
"(",
"frame",
")",
"self",
".",
"detections",
".",
"append",
"(",
"obj",
")"
] | [
63,
4
] | [
71,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackingVideo._draw_object_trace | (self, fid: int, frame: Image, tracked_object: TrackedObject) | return frame | Dibuja los trazados de un objeto hasta el frame en el que se encuentra.
:param fid: número del frame.
:param frame: frame.
:param tracked_object: estructura del seguimiento del objeto.
:return: imagen con el seguimiento del objeto.
| Dibuja los trazados de un objeto hasta el frame en el que se encuentra. | def _draw_object_trace(self, fid: int, frame: Image, tracked_object: TrackedObject) -> Image:
"""Dibuja los trazados de un objeto hasta el frame en el que se encuentra.
:param fid: número del frame.
:param frame: frame.
:param tracked_object: estructura del seguimiento del objeto.
:return: imagen con el seguimiento del objeto.
"""
positions_centroid = [t_obj.object.center for t_obj in tracked_object if t_obj.frame <= fid]
# Comprobación de que se ha obtenido al menos una posición.
if len(positions_centroid) == 0:
return frame
# Dibujar centroides.
prev_position = positions_centroid[0]
# Dibujar las líneas.
color = self._objects_colors[tracked_object.id]
prev_position = positions_centroid[0]
for position in positions_centroid:
cv2.line(frame, position, prev_position, color, 2, cv2.LINE_AA)
prev_position = position
# Dibujar los puntos.
color = (color[0] * 1/2, color[1] * 2/3, 3/4 * color[2])
prev_position = positions_centroid[0]
for position in positions_centroid:
cv2.circle(frame, position, 0, color, 5, cv2.LINE_AA)
prev_position = position
return frame | [
"def",
"_draw_object_trace",
"(",
"self",
",",
"fid",
":",
"int",
",",
"frame",
":",
"Image",
",",
"tracked_object",
":",
"TrackedObject",
")",
"->",
"Image",
":",
"positions_centroid",
"=",
"[",
"t_obj",
".",
"object",
".",
"center",
"for",
"t_obj",
"in",
"tracked_object",
"if",
"t_obj",
".",
"frame",
"<=",
"fid",
"]",
"# Comprobación de que se ha obtenido al menos una posición.",
"if",
"len",
"(",
"positions_centroid",
")",
"==",
"0",
":",
"return",
"frame",
"# Dibujar centroides.",
"prev_position",
"=",
"positions_centroid",
"[",
"0",
"]",
"# Dibujar las líneas.",
"color",
"=",
"self",
".",
"_objects_colors",
"[",
"tracked_object",
".",
"id",
"]",
"prev_position",
"=",
"positions_centroid",
"[",
"0",
"]",
"for",
"position",
"in",
"positions_centroid",
":",
"cv2",
".",
"line",
"(",
"frame",
",",
"position",
",",
"prev_position",
",",
"color",
",",
"2",
",",
"cv2",
".",
"LINE_AA",
")",
"prev_position",
"=",
"position",
"# Dibujar los puntos.",
"color",
"=",
"(",
"color",
"[",
"0",
"]",
"*",
"1",
"/",
"2",
",",
"color",
"[",
"1",
"]",
"*",
"2",
"/",
"3",
",",
"3",
"/",
"4",
"*",
"color",
"[",
"2",
"]",
")",
"prev_position",
"=",
"positions_centroid",
"[",
"0",
"]",
"for",
"position",
"in",
"positions_centroid",
":",
"cv2",
".",
"circle",
"(",
"frame",
",",
"position",
",",
"0",
",",
"color",
",",
"5",
",",
"cv2",
".",
"LINE_AA",
")",
"prev_position",
"=",
"position",
"return",
"frame"
] | [
258,
4
] | [
284,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo._draw_frame_number | (self, fid: int, frame: Image) | return frame | Escribe el número del frame en el que se encuentra en cada instante.
:param fid: número del frame.
:param frame: frame.
:return: frame con el número de frame.
| Escribe el número del frame en el que se encuentra en cada instante. | def _draw_frame_number(self, fid: int, frame: Image) -> Image:
"""Escribe el número del frame en el que se encuentra en cada instante.
:param fid: número del frame.
:param frame: frame.
:return: frame con el número de frame.
"""
# Propiedades del texto.
text_format = self.get_property(TrackingVideoProperty.TEXT_FRAME_INFORMATION)
font, color, linetype, thickness, font_scale, _ = text_format
# Dibujar texto.
text = f'Frame {fid}'
position = (30, self.input_sequence.properties().height - 30)
cv2.putText(frame, text, position, font, font_scale, color, thickness, linetype)
return frame | [
"def",
"_draw_frame_number",
"(",
"self",
",",
"fid",
":",
"int",
",",
"frame",
":",
"Image",
")",
"->",
"Image",
":",
"# Propiedades del texto.",
"text_format",
"=",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"TEXT_FRAME_INFORMATION",
")",
"font",
",",
"color",
",",
"linetype",
",",
"thickness",
",",
"font_scale",
",",
"_",
"=",
"text_format",
"# Dibujar texto.",
"text",
"=",
"f'Frame {fid}'",
"position",
"=",
"(",
"30",
",",
"self",
".",
"input_sequence",
".",
"properties",
"(",
")",
".",
"height",
"-",
"30",
")",
"cv2",
".",
"putText",
"(",
"frame",
",",
"text",
",",
"position",
",",
"font",
",",
"font_scale",
",",
"color",
",",
"thickness",
",",
"linetype",
")",
"return",
"frame"
] | [
225,
4
] | [
239,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
traer_usuarios_a_lista | (diccionario) | return list(diccionario.keys()) | Recibe el json de los usuario y devuelve las keys en formato de lista | Recibe el json de los usuario y devuelve las keys en formato de lista | def traer_usuarios_a_lista(diccionario):
"""Recibe el json de los usuario y devuelve las keys en formato de lista"""
return list(diccionario.keys()) | [
"def",
"traer_usuarios_a_lista",
"(",
"diccionario",
")",
":",
"return",
"list",
"(",
"diccionario",
".",
"keys",
"(",
")",
")"
] | [
9,
0
] | [
11,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Select.ejecutar | (self) | Metodo Abstracto para ejecutar la instruccion | Metodo Abstracto para ejecutar la instruccion | def ejecutar(self):
'Metodo Abstracto para ejecutar la instruccion'
if self.distinct is None and self.froms is None and self.where is None and self.group is None and self.having is None and self.order is None and self.combinig is None:
for exp in self.exps:
print(exp.getval())
return exp.getval() | [
"def",
"ejecutar",
"(",
"self",
")",
":",
"if",
"self",
".",
"distinct",
"is",
"None",
"and",
"self",
".",
"froms",
"is",
"None",
"and",
"self",
".",
"where",
"is",
"None",
"and",
"self",
".",
"group",
"is",
"None",
"and",
"self",
".",
"having",
"is",
"None",
"and",
"self",
".",
"order",
"is",
"None",
"and",
"self",
".",
"combinig",
"is",
"None",
":",
"for",
"exp",
"in",
"self",
".",
"exps",
":",
"print",
"(",
"exp",
".",
"getval",
"(",
")",
")",
"return",
"exp",
".",
"getval",
"(",
")"
] | [
17,
4
] | [
22,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DominioTSP.vecino | (self, sol) | return sol | Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (list)
Solución a partir de la cual se originará una nueva solución vecina
Salidas:
(list) Solución vecina
| Calcula una solución vecina a partir de una solución dada. | def vecino(self, sol):
"""Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (list)
Solución a partir de la cual se originará una nueva solución vecina
Salidas:
(list) Solución vecina
"""
a=random.randint(0,len(sol)-2)
sol[a], sol[a+1] = sol[a+1], sol[a]
return sol | [
"def",
"vecino",
"(",
"self",
",",
"sol",
")",
":",
"a",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"len",
"(",
"sol",
")",
"-",
"2",
")",
"sol",
"[",
"a",
"]",
",",
"sol",
"[",
"a",
"+",
"1",
"]",
"=",
"sol",
"[",
"a",
"+",
"1",
"]",
",",
"sol",
"[",
"a",
"]",
"return",
"sol"
] | [
159,
4
] | [
177,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Matrix.__sub__ | (self, other) | Metodo para la resta de matrices. | Metodo para la resta de matrices. | def __sub__(self, other):
""" Metodo para la resta de matrices. """
if self.check("add", other):
new = [map(lambda r, s: r - s, i, j) for i, j in zip(self, other)]
return Matrix(new)
else:
raise TypeError("Matrix: Dimensions do not match.") | [
"def",
"__sub__",
"(",
"self",
",",
"other",
")",
":",
"if",
"self",
".",
"check",
"(",
"\"add\"",
",",
"other",
")",
":",
"new",
"=",
"[",
"map",
"(",
"lambda",
"r",
",",
"s",
":",
"r",
"-",
"s",
",",
"i",
",",
"j",
")",
"for",
"i",
",",
"j",
"in",
"zip",
"(",
"self",
",",
"other",
")",
"]",
"return",
"Matrix",
"(",
"new",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"Matrix: Dimensions do not match.\"",
")"
] | [
24,
4
] | [
30,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
drop_execution_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de borrar las tabla de ejecución en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de borrar las tabla de ejecución en la base de datos. | def drop_execution_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de borrar las tabla de ejecución en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
"""
drop_sql = ["DROP TABLE IF EXISTS execution_info"]
_exec_drop(host=host, user=user, passwd=passwd, db_name=db_name, queries=drop_sql) | [
"def",
"drop_execution_schema",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"drop_sql",
"=",
"[",
"\"DROP TABLE IF EXISTS execution_info\"",
"]",
"_exec_drop",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"drop_sql",
")"
] | [
324,
0
] | [
340,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ModelGraphs.plot_compare_losses | (history1, history2, name1="Red 1",
name2="Red 2", title="Graph title") | Compara losses de dos entrenamientos con nombres name1 y name2 | Compara losses de dos entrenamientos con nombres name1 y name2 | def plot_compare_losses(history1, history2, name1="Red 1",
name2="Red 2", title="Graph title"):
"""Compara losses de dos entrenamientos con nombres name1 y name2"""
plt.plot(history1.history['loss'], color="green")
plt.plot(history1.history['val_loss'], 'r--', color="green")
plt.plot(history2.history['loss'], color="blue")
plt.plot(history2.history['val_loss'], 'r--', color="blue")
plt.title(title)
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train ' + name1, 'Val ' + name1,
'Train ' + name2, 'Val ' + name2],
loc='upper right')
plt.show() | [
"def",
"plot_compare_losses",
"(",
"history1",
",",
"history2",
",",
"name1",
"=",
"\"Red 1\"",
",",
"name2",
"=",
"\"Red 2\"",
",",
"title",
"=",
"\"Graph title\"",
")",
":",
"plt",
".",
"plot",
"(",
"history1",
".",
"history",
"[",
"'loss'",
"]",
",",
"color",
"=",
"\"green\"",
")",
"plt",
".",
"plot",
"(",
"history1",
".",
"history",
"[",
"'val_loss'",
"]",
",",
"'r--'",
",",
"color",
"=",
"\"green\"",
")",
"plt",
".",
"plot",
"(",
"history2",
".",
"history",
"[",
"'loss'",
"]",
",",
"color",
"=",
"\"blue\"",
")",
"plt",
".",
"plot",
"(",
"history2",
".",
"history",
"[",
"'val_loss'",
"]",
",",
"'r--'",
",",
"color",
"=",
"\"blue\"",
")",
"plt",
".",
"title",
"(",
"title",
")",
"plt",
".",
"ylabel",
"(",
"'Loss'",
")",
"plt",
".",
"xlabel",
"(",
"'Epoch'",
")",
"plt",
".",
"legend",
"(",
"[",
"'Train '",
"+",
"name1",
",",
"'Val '",
"+",
"name1",
",",
"'Train '",
"+",
"name2",
",",
"'Val '",
"+",
"name2",
"]",
",",
"loc",
"=",
"'upper right'",
")",
"plt",
".",
"show",
"(",
")"
] | [
28,
4
] | [
41,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
es_primo | (n: int) | return not any(not n % i for i in impares) | Verifica si el número es primo o no.
:param n: Número a verificar
:type n: int
:return: True si es primo, False si no lo es
:rtype: bool
>>> es_primo_(2)
True
>>> es_primo_(1)
False
| Verifica si el número es primo o no. | def es_primo(n: int) -> bool:
"""Verifica si el número es primo o no.
:param n: Número a verificar
:type n: int
:return: True si es primo, False si no lo es
:rtype: bool
>>> es_primo_(2)
True
>>> es_primo_(1)
False
"""
if 1 < n < 4:
return True
elif n < 2 or not n % 2:
return False
impares: Iterable = range(3, int(sqrt(n) + 1), 2)
return not any(not n % i for i in impares) | [
"def",
"es_primo",
"(",
"n",
":",
"int",
")",
"->",
"bool",
":",
"if",
"1",
"<",
"n",
"<",
"4",
":",
"return",
"True",
"elif",
"n",
"<",
"2",
"or",
"not",
"n",
"%",
"2",
":",
"return",
"False",
"impares",
":",
"Iterable",
"=",
"range",
"(",
"3",
",",
"int",
"(",
"sqrt",
"(",
"n",
")",
"+",
"1",
")",
",",
"2",
")",
"return",
"not",
"any",
"(",
"not",
"n",
"%",
"i",
"for",
"i",
"in",
"impares",
")"
] | [
15,
0
] | [
33,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlacesExtractor._get_comments | (self, place_name=None, sleep_time=None, external_driver=None) | return comments | Función que extrae los comentarios para el local comercial.
Arguments
---------
place_name : str
nombre del local comercial
sleep_time : int
tiempo de espera para que el driver renderice los elementos de la web
external_driver : webdriver.Chrome
driver que se usará para hacer la extracción de los comentarios en caso de ser provisto, en caso contrario
se usará el asociado a la instancia de la clase
Returns
-------
list
lista de comentarios encontrados para el local comercial
| Función que extrae los comentarios para el local comercial. | def _get_comments(self, place_name=None, sleep_time=None, external_driver=None):
"""Función que extrae los comentarios para el local comercial.
Arguments
---------
place_name : str
nombre del local comercial
sleep_time : int
tiempo de espera para que el driver renderice los elementos de la web
external_driver : webdriver.Chrome
driver que se usará para hacer la extracción de los comentarios en caso de ser provisto, en caso contrario
se usará el asociado a la instancia de la clase
Returns
-------
list
lista de comentarios encontrados para el local comercial
"""
# get all reviews button
driver = external_driver if external_driver else self.get_driver()
self.logger.info("-{place}-: trying to retrieve comments".format(place=place_name))
button_see_all_reviews = self.get_info_obj(self._see_all_reviews_button)
reviews_elements_list = driver.find_elements_by_class_name(self._review_css_class)
if len(reviews_elements_list) < self._num_reviews and button_see_all_reviews:
self.logger.debug("-{place}-: all reviews button has been found".format(place=place_name))
# change page to next comments and iterate
driver.execute_script("arguments[0].click();", button_see_all_reviews)
driver.wait.until(ec.url_changes(driver.current_url))
self.force_sleep(sleep_time)
aux_reviews = driver.find_elements_by_class_name(self._review_css_class)
have_finished = False
while not have_finished:
# iterates appending comments until it reaches the `self._num_reviews` or the found comments don't
# change between iterations
previous_iteration_found = len(aux_reviews)
last_review = aux_reviews[-1]
driver.execute_script("arguments[0].scrollIntoView(true);", last_review)
self.force_sleep(sleep_time)
aux_reviews = driver.find_elements_by_class_name(self._review_css_class)
have_finished = previous_iteration_found == len(aux_reviews) or len(aux_reviews) >= self._num_reviews
# At this point the last `self._num_reviews` reviews must be shown
self.logger.debug("-{place}-: retrieving comment bucle has finished".format(place=place_name))
# extract content of each element
reviews_elements_list = driver.find_elements_by_class_name(self._review_css_class)
comments = [self._get_formatted_comments(elem.text) for elem in reviews_elements_list]
self.logger.info("-{place}-: found -{total_reviews}- comments.".format(total_reviews=len(comments),
place=place_name))
return comments | [
"def",
"_get_comments",
"(",
"self",
",",
"place_name",
"=",
"None",
",",
"sleep_time",
"=",
"None",
",",
"external_driver",
"=",
"None",
")",
":",
"# get all reviews button",
"driver",
"=",
"external_driver",
"if",
"external_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: trying to retrieve comments\"",
".",
"format",
"(",
"place",
"=",
"place_name",
")",
")",
"button_see_all_reviews",
"=",
"self",
".",
"get_info_obj",
"(",
"self",
".",
"_see_all_reviews_button",
")",
"reviews_elements_list",
"=",
"driver",
".",
"find_elements_by_class_name",
"(",
"self",
".",
"_review_css_class",
")",
"if",
"len",
"(",
"reviews_elements_list",
")",
"<",
"self",
".",
"_num_reviews",
"and",
"button_see_all_reviews",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{place}-: all reviews button has been found\"",
".",
"format",
"(",
"place",
"=",
"place_name",
")",
")",
"# change page to next comments and iterate",
"driver",
".",
"execute_script",
"(",
"\"arguments[0].click();\"",
",",
"button_see_all_reviews",
")",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"url_changes",
"(",
"driver",
".",
"current_url",
")",
")",
"self",
".",
"force_sleep",
"(",
"sleep_time",
")",
"aux_reviews",
"=",
"driver",
".",
"find_elements_by_class_name",
"(",
"self",
".",
"_review_css_class",
")",
"have_finished",
"=",
"False",
"while",
"not",
"have_finished",
":",
"# iterates appending comments until it reaches the `self._num_reviews` or the found comments don't",
"# change between iterations",
"previous_iteration_found",
"=",
"len",
"(",
"aux_reviews",
")",
"last_review",
"=",
"aux_reviews",
"[",
"-",
"1",
"]",
"driver",
".",
"execute_script",
"(",
"\"arguments[0].scrollIntoView(true);\"",
",",
"last_review",
")",
"self",
".",
"force_sleep",
"(",
"sleep_time",
")",
"aux_reviews",
"=",
"driver",
".",
"find_elements_by_class_name",
"(",
"self",
".",
"_review_css_class",
")",
"have_finished",
"=",
"previous_iteration_found",
"==",
"len",
"(",
"aux_reviews",
")",
"or",
"len",
"(",
"aux_reviews",
")",
">=",
"self",
".",
"_num_reviews",
"# At this point the last `self._num_reviews` reviews must be shown",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{place}-: retrieving comment bucle has finished\"",
".",
"format",
"(",
"place",
"=",
"place_name",
")",
")",
"# extract content of each element",
"reviews_elements_list",
"=",
"driver",
".",
"find_elements_by_class_name",
"(",
"self",
".",
"_review_css_class",
")",
"comments",
"=",
"[",
"self",
".",
"_get_formatted_comments",
"(",
"elem",
".",
"text",
")",
"for",
"elem",
"in",
"reviews_elements_list",
"]",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: found -{total_reviews}- comments.\"",
".",
"format",
"(",
"total_reviews",
"=",
"len",
"(",
"comments",
")",
",",
"place",
"=",
"place_name",
")",
")",
"return",
"comments"
] | [
411,
4
] | [
459,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Text.is_possible_name | (cls, text: str) | return True | Comprueba si el texto indicado puede ser un nombre. | Comprueba si el texto indicado puede ser un nombre. | def is_possible_name(cls, text: str) -> bool:
"""Comprueba si el texto indicado puede ser un nombre."""
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for n in numbers:
if str(n) in text:
return False
return True | [
"def",
"is_possible_name",
"(",
"cls",
",",
"text",
":",
"str",
")",
"->",
"bool",
":",
"numbers",
"=",
"[",
"0",
",",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
",",
"6",
",",
"7",
",",
"8",
",",
"9",
"]",
"for",
"n",
"in",
"numbers",
":",
"if",
"str",
"(",
"n",
")",
"in",
"text",
":",
"return",
"False",
"return",
"True"
] | [
299,
4
] | [
305,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sort_por_mana | () | return sorted(champions_in_csv(), reverse=True, key=lambda x: x[17]) | Champions que mas mana tienen en lvl 18 | Champions que mas mana tienen en lvl 18 | def sort_por_mana():
"""Champions que mas mana tienen en lvl 18"""
return sorted(champions_in_csv(), reverse=True, key=lambda x: x[17]) | [
"def",
"sort_por_mana",
"(",
")",
":",
"return",
"sorted",
"(",
"champions_in_csv",
"(",
")",
",",
"reverse",
"=",
"True",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"17",
"]",
")"
] | [
50,
0
] | [
52,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
verify | (verifyKey: bytes, *args, **kwargs) | return verifySignature.verify(*args, **kwargs) | Verificar los datos firmados
Args:
verifyKey:
La clave para verificar la firma
*args:
Argumentos variables para ``nacl.signing.VerifyKey.verify``
**kwargs:
Argumentos claves variables para ``nacl.signing.VerifyKey.verify``
Returns:
El mismo dato que se introdujo al firmar
| Verificar los datos firmados | def verify(verifyKey: bytes, *args, **kwargs) -> bytes:
"""Verificar los datos firmados
Args:
verifyKey:
La clave para verificar la firma
*args:
Argumentos variables para ``nacl.signing.VerifyKey.verify``
**kwargs:
Argumentos claves variables para ``nacl.signing.VerifyKey.verify``
Returns:
El mismo dato que se introdujo al firmar
"""
verifySignature = nacl.signing.VerifyKey(verifyKey)
return verifySignature.verify(*args, **kwargs) | [
"def",
"verify",
"(",
"verifyKey",
":",
"bytes",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"bytes",
":",
"verifySignature",
"=",
"nacl",
".",
"signing",
".",
"VerifyKey",
"(",
"verifyKey",
")",
"return",
"verifySignature",
".",
"verify",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | [
117,
0
] | [
137,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_llamasFuncion1 | (t) | llamadafunciones : SELECT ID PARIZQ listaexpresiones PARDER PTCOMA | llamadafunciones : SELECT ID PARIZQ listaexpresiones PARDER PTCOMA | def p_llamasFuncion1(t):
'llamadafunciones : SELECT ID PARIZQ listaexpresiones PARDER PTCOMA'
g = '<llamadafunciones> : SELECT ID PARIZQ <listaexpresiones> PARDER PTCOMA'
t[0] = Nodo('SELECT FUNC', t[2], t[4], t.lexer.lineno, 0, g) | [
"def",
"p_llamasFuncion1",
"(",
"t",
")",
":",
"g",
"=",
"'<llamadafunciones> : SELECT ID PARIZQ <listaexpresiones> PARDER PTCOMA'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'SELECT FUNC'",
",",
"t",
"[",
"2",
"]",
",",
"t",
"[",
"4",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"g",
")"
] | [
534,
0
] | [
537,
64
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Annotation.parse_json_arr | (data) | return annotations | parsea el array con los json para construir una instancia valida de Annotation @see #parseJson | parsea el array con los json para construir una instancia valida de Annotation | def parse_json_arr(data) -> list:
""" parsea el array con los json para construir una instancia valida de Annotation @see #parseJson"""
annotations = []
for entry in data:
annotations.append(Annotation.parse_json(entry))
return annotations | [
"def",
"parse_json_arr",
"(",
"data",
")",
"->",
"list",
":",
"annotations",
"=",
"[",
"]",
"for",
"entry",
"in",
"data",
":",
"annotations",
".",
"append",
"(",
"Annotation",
".",
"parse_json",
"(",
"entry",
")",
")",
"return",
"annotations"
] | [
53,
4
] | [
58,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_renovaciones | (limit=50, solo_fallados=False, solo_hacia_atras=False) | return cambios[:limit] | Dominios que cambia la fecha en que expira | Dominios que cambia la fecha en que expira | def get_renovaciones(limit=50, solo_fallados=False, solo_hacia_atras=False):
""" Dominios que cambia la fecha en que expira """
cambios = CampoCambio.objects\
.filter(campo='dominio_expire')\
.exclude(anterior__exact="")\
.exclude(nuevo__exact="")\
.annotate(dnuevo=Cast('nuevo', DateTimeField()))\
.annotate(danterior=Cast('anterior', DateTimeField()))\
.annotate(tdiff=ExpressionWrapper(F('dnuevo') - F('danterior'), output_field=DurationField()))
if solo_fallados:
cambios = cambios.filter(
Q(tdiff__gt=timedelta(days=370)) | Q(tdiff__lt=timedelta(days=360))
)
if solo_hacia_atras:
cambios = cambios.filter(
Q(nuevo__lt=F('anterior'))
)
cambios = cambios.order_by('-cambio__momento')
return cambios[:limit] | [
"def",
"get_renovaciones",
"(",
"limit",
"=",
"50",
",",
"solo_fallados",
"=",
"False",
",",
"solo_hacia_atras",
"=",
"False",
")",
":",
"cambios",
"=",
"CampoCambio",
".",
"objects",
".",
"filter",
"(",
"campo",
"=",
"'dominio_expire'",
")",
".",
"exclude",
"(",
"anterior__exact",
"=",
"\"\"",
")",
".",
"exclude",
"(",
"nuevo__exact",
"=",
"\"\"",
")",
".",
"annotate",
"(",
"dnuevo",
"=",
"Cast",
"(",
"'nuevo'",
",",
"DateTimeField",
"(",
")",
")",
")",
".",
"annotate",
"(",
"danterior",
"=",
"Cast",
"(",
"'anterior'",
",",
"DateTimeField",
"(",
")",
")",
")",
".",
"annotate",
"(",
"tdiff",
"=",
"ExpressionWrapper",
"(",
"F",
"(",
"'dnuevo'",
")",
"-",
"F",
"(",
"'danterior'",
")",
",",
"output_field",
"=",
"DurationField",
"(",
")",
")",
")",
"if",
"solo_fallados",
":",
"cambios",
"=",
"cambios",
".",
"filter",
"(",
"Q",
"(",
"tdiff__gt",
"=",
"timedelta",
"(",
"days",
"=",
"370",
")",
")",
"|",
"Q",
"(",
"tdiff__lt",
"=",
"timedelta",
"(",
"days",
"=",
"360",
")",
")",
")",
"if",
"solo_hacia_atras",
":",
"cambios",
"=",
"cambios",
".",
"filter",
"(",
"Q",
"(",
"nuevo__lt",
"=",
"F",
"(",
"'anterior'",
")",
")",
")",
"cambios",
"=",
"cambios",
".",
"order_by",
"(",
"'-cambio__momento'",
")",
"return",
"cambios",
"[",
":",
"limit",
"]"
] | [
41,
0
] | [
63,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NetworkCallback.get_network_token | (networkid: int, *, cursor) | return token | Obtiene el token del nodo | Obtiene el token del nodo | async def get_network_token(networkid: int, *, cursor) -> Tuple[str]:
"""Obtiene el token del nodo"""
await cursor.execute(
"SELECT token FROM networks WHERE id_network = %s LIMIT 1",
(networkid,)
)
token = await cursor.fetchone()
return token | [
"async",
"def",
"get_network_token",
"(",
"networkid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"Tuple",
"[",
"str",
"]",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT token FROM networks WHERE id_network = %s LIMIT 1\"",
",",
"(",
"networkid",
",",
")",
")",
"token",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"token"
] | [
514,
4
] | [
525,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraExchangeRateTestCase.test_exchange_rates_configuration_has_coins | (self) | Validar la existencia de la clave coins dentro de
la configuración de exchange rates | Validar la existencia de la clave coins dentro de
la configuración de exchange rates | def test_exchange_rates_configuration_has_coins(self):
"""Validar la existencia de la clave coins 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_coins_key_config(config) | [
"def",
"test_exchange_rates_configuration_has_coins",
"(",
"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_coins_key_config",
"(",
"config",
")"
] | [
444,
4
] | [
456,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
create_results_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de crear las tablas de resultados en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de crear las tablas de resultados en la base de datos. | def create_results_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de crear las tablas de resultados en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
"""
tables = [sql_main_table, sql_comments, sql_ocupation, sql_index_creation]
_exec_create(host=host, user=user, passwd=passwd, db_name=db_name, queries=tables) | [
"def",
"create_results_schema",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"tables",
"=",
"[",
"sql_main_table",
",",
"sql_comments",
",",
"sql_ocupation",
",",
"sql_index_creation",
"]",
"_exec_create",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"tables",
")"
] | [
305,
0
] | [
321,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PointTracker._unregister_step | (self, frame_actual: int) | Paso de desregistro de los objetos.
Aquellos objetos que llevan sin verse un número de frames indicado en el modelo de
seguimiento, se cambiará su estado a *desregistrado* para así no tenerlos en cuenta en la
fase del emparejamiento.
:param frame_actual: identificador del frame actual.
:return: None.
| Paso de desregistro de los objetos. | def _unregister_step(self, frame_actual: int) -> None:
"""Paso de desregistro de los objetos.
Aquellos objetos que llevan sin verse un número de frames indicado en el modelo de
seguimiento, se cambiará su estado a *desregistrado* para así no tenerlos en cuenta en la
fase del emparejamiento.
:param frame_actual: identificador del frame actual.
:return: None.
"""
max_frames_missing = self.frames_to_unregister_missing_objects
self.objects.unregister_missing_objects(frame_actual, max_frames_missing) | [
"def",
"_unregister_step",
"(",
"self",
",",
"frame_actual",
":",
"int",
")",
"->",
"None",
":",
"max_frames_missing",
"=",
"self",
".",
"frames_to_unregister_missing_objects",
"self",
".",
"objects",
".",
"unregister_missing_objects",
"(",
"frame_actual",
",",
"max_frames_missing",
")"
] | [
121,
4
] | [
132,
81
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TraductorReceipt.printComanda | (self, comanda, setHeader=None, setTrailer=None) | return self.comando.printComanda(comanda, setHeader, setTrailer) | Imprime una Comanda, comando de accion valido solo para Comandos de Receipt | Imprime una Comanda, comando de accion valido solo para Comandos de Receipt | def printComanda(self, comanda, setHeader=None, setTrailer=None):
"Imprime una Comanda, comando de accion valido solo para Comandos de Receipt"
return self.comando.printComanda(comanda, setHeader, setTrailer) | [
"def",
"printComanda",
"(",
"self",
",",
"comanda",
",",
"setHeader",
"=",
"None",
",",
"setTrailer",
"=",
"None",
")",
":",
"return",
"self",
".",
"comando",
".",
"printComanda",
"(",
"comanda",
",",
"setHeader",
",",
"setTrailer",
")"
] | [
21,
4
] | [
23,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Pitch._draw_juego_de_posicion | (self, ax) | Draw Juego de Posición | Draw Juego de Posición | def _draw_juego_de_posicion(self, ax):
"""Draw Juego de Posición"""
line_prop = {'linewidth': self.positional_linewidth, 'color': self.positional_color,
'linestyle': self.positional_linestyle, 'zorder': self.positional_zorder}
if self.orientation == 'horizontal':
# x lines
xline1 = lines.Line2D([self.x2, self.x2], [self.bottom, self.top], **line_prop)
xline2 = lines.Line2D([self.x3, self.x3], [self.bottom, self.top], **line_prop)
xline3 = lines.Line2D([self.x4, self.x4], [self.bottom, self.top], **line_prop)
xline4 = lines.Line2D([self.x5, self.x5], [self.bottom, self.top], **line_prop)
xline5 = lines.Line2D([self.x6, self.x6], [self.bottom, self.top], **line_prop)
# y lines
yline1 = lines.Line2D([self.left, self.right], [self.y2, self.y2], **line_prop)
yline2 = lines.Line2D([self.left + self.penalty_area_length, self.right - self.penalty_area_length],
[self.y3, self.y3], **line_prop)
yline3 = lines.Line2D([self.left + self.penalty_area_length, self.right - self.penalty_area_length],
[self.y4, self.y4], **line_prop)
yline4 = lines.Line2D([self.left, self.right], [self.y5, self.y5], **line_prop)
elif self.orientation == 'vertical':
# x lines
xline1 = lines.Line2D([self.bottom, self.top], [self.x2, self.x2], **line_prop)
xline2 = lines.Line2D([self.bottom, self.top], [self.x3, self.x3], **line_prop)
xline3 = lines.Line2D([self.bottom, self.top], [self.x4, self.x4], **line_prop)
xline4 = lines.Line2D([self.bottom, self.top], [self.x5, self.x5], **line_prop)
xline5 = lines.Line2D([self.bottom, self.top], [self.x6, self.x6], **line_prop)
# y lines
yline1 = lines.Line2D([self.y2, self.y2], [self.left, self.right], **line_prop)
yline2 = lines.Line2D([self.y3, self.y3],
[self.left + self.penalty_area_length, self.right - self.penalty_area_length],
**line_prop)
yline3 = lines.Line2D([self.y4, self.y4],
[self.left + self.penalty_area_length, self.right - self.penalty_area_length],
**line_prop)
yline4 = lines.Line2D([self.y5, self.y5], [self.left, self.right], **line_prop)
for artist in [xline1, xline2, xline3, xline4, xline5, yline1, yline2, yline3, yline4]:
ax.add_artist(artist) | [
"def",
"_draw_juego_de_posicion",
"(",
"self",
",",
"ax",
")",
":",
"line_prop",
"=",
"{",
"'linewidth'",
":",
"self",
".",
"positional_linewidth",
",",
"'color'",
":",
"self",
".",
"positional_color",
",",
"'linestyle'",
":",
"self",
".",
"positional_linestyle",
",",
"'zorder'",
":",
"self",
".",
"positional_zorder",
"}",
"if",
"self",
".",
"orientation",
"==",
"'horizontal'",
":",
"# x lines",
"xline1",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"x2",
",",
"self",
".",
"x2",
"]",
",",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline2",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"x3",
",",
"self",
".",
"x3",
"]",
",",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline3",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"x4",
",",
"self",
".",
"x4",
"]",
",",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline4",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"x5",
",",
"self",
".",
"x5",
"]",
",",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline5",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"x6",
",",
"self",
".",
"x6",
"]",
",",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"*",
"*",
"line_prop",
")",
"# y lines",
"yline1",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"left",
",",
"self",
".",
"right",
"]",
",",
"[",
"self",
".",
"y2",
",",
"self",
".",
"y2",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline2",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"left",
"+",
"self",
".",
"penalty_area_length",
",",
"self",
".",
"right",
"-",
"self",
".",
"penalty_area_length",
"]",
",",
"[",
"self",
".",
"y3",
",",
"self",
".",
"y3",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline3",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"left",
"+",
"self",
".",
"penalty_area_length",
",",
"self",
".",
"right",
"-",
"self",
".",
"penalty_area_length",
"]",
",",
"[",
"self",
".",
"y4",
",",
"self",
".",
"y4",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline4",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"left",
",",
"self",
".",
"right",
"]",
",",
"[",
"self",
".",
"y5",
",",
"self",
".",
"y5",
"]",
",",
"*",
"*",
"line_prop",
")",
"elif",
"self",
".",
"orientation",
"==",
"'vertical'",
":",
"# x lines",
"xline1",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"[",
"self",
".",
"x2",
",",
"self",
".",
"x2",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline2",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"[",
"self",
".",
"x3",
",",
"self",
".",
"x3",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline3",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"[",
"self",
".",
"x4",
",",
"self",
".",
"x4",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline4",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"[",
"self",
".",
"x5",
",",
"self",
".",
"x5",
"]",
",",
"*",
"*",
"line_prop",
")",
"xline5",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"bottom",
",",
"self",
".",
"top",
"]",
",",
"[",
"self",
".",
"x6",
",",
"self",
".",
"x6",
"]",
",",
"*",
"*",
"line_prop",
")",
"# y lines",
"yline1",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"y2",
",",
"self",
".",
"y2",
"]",
",",
"[",
"self",
".",
"left",
",",
"self",
".",
"right",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline2",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"y3",
",",
"self",
".",
"y3",
"]",
",",
"[",
"self",
".",
"left",
"+",
"self",
".",
"penalty_area_length",
",",
"self",
".",
"right",
"-",
"self",
".",
"penalty_area_length",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline3",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"y4",
",",
"self",
".",
"y4",
"]",
",",
"[",
"self",
".",
"left",
"+",
"self",
".",
"penalty_area_length",
",",
"self",
".",
"right",
"-",
"self",
".",
"penalty_area_length",
"]",
",",
"*",
"*",
"line_prop",
")",
"yline4",
"=",
"lines",
".",
"Line2D",
"(",
"[",
"self",
".",
"y5",
",",
"self",
".",
"y5",
"]",
",",
"[",
"self",
".",
"left",
",",
"self",
".",
"right",
"]",
",",
"*",
"*",
"line_prop",
")",
"for",
"artist",
"in",
"[",
"xline1",
",",
"xline2",
",",
"xline3",
",",
"xline4",
",",
"xline5",
",",
"yline1",
",",
"yline2",
",",
"yline3",
",",
"yline4",
"]",
":",
"ax",
".",
"add_artist",
"(",
"artist",
")"
] | [
853,
4
] | [
894,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
create_execution_schema | (host=None, user=None, passwd=None, db_name=None) | Función encargada de crear las tabla de ejecución en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de crear las tabla de ejecución en la base de datos. | def create_execution_schema(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de crear las tabla de ejecución en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
"""
tables = [sql_execution_table]
_exec_create(host=host, user=user, passwd=passwd, db_name=db_name, queries=tables) | [
"def",
"create_execution_schema",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"tables",
"=",
"[",
"sql_execution_table",
"]",
"_exec_create",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"passwd",
"=",
"passwd",
",",
"db_name",
"=",
"db_name",
",",
"queries",
"=",
"tables",
")"
] | [
343,
0
] | [
359,
86
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_shapefile_files | (filename) | return files | Verifica las dependencias para un shapefile y devuelve un diccionario
con todas las dependencias
| Verifica las dependencias para un shapefile y devuelve un diccionario
con todas las dependencias
| def get_shapefile_files(filename):
"""Verifica las dependencias para un shapefile y devuelve un diccionario
con todas las dependencias
"""
# print 'get_shapefile_files: '+filename
files = {'base': filename}
base_name, extension = os.path.splitext(filename)
# Replace special characters in filenames - []{}()
glob_name = re.sub(r'([\[\]\(\)\{\}])', r'[\g<1>]', base_name)
if extension.lower() == '.shp':
required_extensions = dict(
shp='.[sS][hH][pP]', dbf='.[dD][bB][fF]', shx='.[sS][hH][xX]')
for ext, pattern in required_extensions.iteritems():
matches = glob.glob(glob_name + pattern)
if len(matches) == 0:
msg = ('Se esperaba un archivo "%s" que no existe; un Shapefile '
'requiere archivos con las siguientes extensiones: '
'%s') % (os.path.basename(base_name) + "." + ext,
required_extensions.keys())
# print msg
raise MapGroundException(msg)
elif len(matches) > 1:
msg = ('Existen múltiples archivos %s; tienen que llamarse distinto '
'y no solo diferenciarse en mayúsculas y minúsculas.') % filename
raise MapGroundException(msg)
# print msg
else:
files[ext] = matches[0]
matches = glob.glob(glob_name + ".[pP][rR][jJ]")
if len(matches) == 1:
files['prj'] = matches[0]
elif len(matches) > 1:
msg = ('Existen múltiples archivos %s; tienen que llamarse distinto '
'y no solo diferenciarse en mayúsculas y minúsculas.') % filename
raise MapGroundException(msg)
# print msg
matches = glob.glob(glob_name + ".[sS][lL][dD]")
if len(matches) == 1:
files['sld'] = matches[0]
elif len(matches) > 1:
msg = ('Existen múltiples archivos de estilo para %s; tienen que llamarse '
'distinto y no solo diferenciarse en mayúsculas y minúsculas.') % filename
raise MapGroundException(msg)
# print msg
matches = glob.glob(base_name + ".[xX][mM][lL]")
# shapefile XML metadata is sometimes named base_name.shp.xml
# try looking for filename.xml if base_name.xml does not exist
if len(matches) == 0:
matches = glob.glob(filename + ".[xX][mM][lL]")
if len(matches) == 1:
files['xml'] = matches[0]
elif len(matches) > 1:
msg = ('Existen múltiples archivos XML para %s; tienen que llamarse '
'distinto y no solo diferenciarse en mayúsculas y minúsculas.') % filename
raise MapGroundException(msg)
# print msg
return files | [
"def",
"get_shapefile_files",
"(",
"filename",
")",
":",
"# print 'get_shapefile_files: '+filename",
"files",
"=",
"{",
"'base'",
":",
"filename",
"}",
"base_name",
",",
"extension",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"filename",
")",
"# Replace special characters in filenames - []{}()",
"glob_name",
"=",
"re",
".",
"sub",
"(",
"r'([\\[\\]\\(\\)\\{\\}])'",
",",
"r'[\\g<1>]'",
",",
"base_name",
")",
"if",
"extension",
".",
"lower",
"(",
")",
"==",
"'.shp'",
":",
"required_extensions",
"=",
"dict",
"(",
"shp",
"=",
"'.[sS][hH][pP]'",
",",
"dbf",
"=",
"'.[dD][bB][fF]'",
",",
"shx",
"=",
"'.[sS][hH][xX]'",
")",
"for",
"ext",
",",
"pattern",
"in",
"required_extensions",
".",
"iteritems",
"(",
")",
":",
"matches",
"=",
"glob",
".",
"glob",
"(",
"glob_name",
"+",
"pattern",
")",
"if",
"len",
"(",
"matches",
")",
"==",
"0",
":",
"msg",
"=",
"(",
"'Se esperaba un archivo \"%s\" que no existe; un Shapefile '",
"'requiere archivos con las siguientes extensiones: '",
"'%s'",
")",
"%",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"base_name",
")",
"+",
"\".\"",
"+",
"ext",
",",
"required_extensions",
".",
"keys",
"(",
")",
")",
"# print msg",
"raise",
"MapGroundException",
"(",
"msg",
")",
"elif",
"len",
"(",
"matches",
")",
">",
"1",
":",
"msg",
"=",
"(",
"'Existen múltiples archivos %s; tienen que llamarse distinto '",
"'y no solo diferenciarse en mayúsculas y minúsculas.') ",
"%",
"f",
"lename",
"raise",
"MapGroundException",
"(",
"msg",
")",
"# print msg",
"else",
":",
"files",
"[",
"ext",
"]",
"=",
"matches",
"[",
"0",
"]",
"matches",
"=",
"glob",
".",
"glob",
"(",
"glob_name",
"+",
"\".[pP][rR][jJ]\"",
")",
"if",
"len",
"(",
"matches",
")",
"==",
"1",
":",
"files",
"[",
"'prj'",
"]",
"=",
"matches",
"[",
"0",
"]",
"elif",
"len",
"(",
"matches",
")",
">",
"1",
":",
"msg",
"=",
"(",
"'Existen múltiples archivos %s; tienen que llamarse distinto '",
"'y no solo diferenciarse en mayúsculas y minúsculas.') ",
"%",
"f",
"lename",
"raise",
"MapGroundException",
"(",
"msg",
")",
"# print msg",
"matches",
"=",
"glob",
".",
"glob",
"(",
"glob_name",
"+",
"\".[sS][lL][dD]\"",
")",
"if",
"len",
"(",
"matches",
")",
"==",
"1",
":",
"files",
"[",
"'sld'",
"]",
"=",
"matches",
"[",
"0",
"]",
"elif",
"len",
"(",
"matches",
")",
">",
"1",
":",
"msg",
"=",
"(",
"'Existen múltiples archivos de estilo para %s; tienen que llamarse '",
"'distinto y no solo diferenciarse en mayúsculas y minúsculas.') ",
"%",
"f",
"lename",
"raise",
"MapGroundException",
"(",
"msg",
")",
"# print msg",
"matches",
"=",
"glob",
".",
"glob",
"(",
"base_name",
"+",
"\".[xX][mM][lL]\"",
")",
"# shapefile XML metadata is sometimes named base_name.shp.xml",
"# try looking for filename.xml if base_name.xml does not exist",
"if",
"len",
"(",
"matches",
")",
"==",
"0",
":",
"matches",
"=",
"glob",
".",
"glob",
"(",
"filename",
"+",
"\".[xX][mM][lL]\"",
")",
"if",
"len",
"(",
"matches",
")",
"==",
"1",
":",
"files",
"[",
"'xml'",
"]",
"=",
"matches",
"[",
"0",
"]",
"elif",
"len",
"(",
"matches",
")",
">",
"1",
":",
"msg",
"=",
"(",
"'Existen múltiples archivos XML para %s; tienen que llamarse '",
"'distinto y no solo diferenciarse en mayúsculas y minúsculas.') ",
"%",
"f",
"lename",
"raise",
"MapGroundException",
"(",
"msg",
")",
"# print msg",
"return",
"files"
] | [
89,
0
] | [
153,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
main | () | Hace un profiling del scraping de una distribución. | Hace un profiling del scraping de una distribución. | def main():
"""Hace un profiling del scraping de una distribución."""
tce(ctx, config, start_date, end_date, skip_intermediate_panel_data, dolar_csv_path,
euro_csv_path, intermediate_panel_path) | [
"def",
"main",
"(",
")",
":",
"tce",
"(",
"ctx",
",",
"config",
",",
"start_date",
",",
"end_date",
",",
"skip_intermediate_panel_data",
",",
"dolar_csv_path",
",",
"euro_csv_path",
",",
"intermediate_panel_path",
")"
] | [
61,
0
] | [
65,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BcraLiborScraperTestCase.test_libor_configuration_has_url | (self) | Validar la existencia de la clave url dentro de
la configuración de libor | Validar la existencia de la clave url dentro de
la configuración de libor | def test_libor_configuration_has_url(self):
"""Validar la existencia de la clave url dentro de
la configuración de libor"""
dict_config = {'libor': {'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", "libor")
validate_url_config(config) | [
"def",
"test_libor_configuration_has_url",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'libor'",
":",
"{",
"'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\"",
",",
"\"libor\"",
")",
"validate_url_config",
"(",
"config",
")"
] | [
597,
4
] | [
609,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TransactionViewSet.pass_go | (self, request, pk=None) | Método que permite al banquero dar pass go ($200) automáticamente a un usuario
Nota: solo el usuario banquero tiene acceso a este método. | Método que permite al banquero dar pass go ($200) automáticamente a un usuario
Nota: solo el usuario banquero tiene acceso a este método. | def pass_go(self, request, pk=None):
""" Método que permite al banquero dar pass go ($200) automáticamente a un usuario
Nota: solo el usuario banquero tiene acceso a este método."""
banquero = self.request.user
serializer = TransactionSerializer(data=request.data)
if serializer.is_valid():
transaction = serializer.save(userTransmitter=banquero, amount=200)
jugador = serializer.validated_data['userReceiver']
jugador.amount += 200
jugador.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response({"errors": (serializer.errors,)}, status=status.HTTP_400_BAD_REQUEST) | [
"def",
"pass_go",
"(",
"self",
",",
"request",
",",
"pk",
"=",
"None",
")",
":",
"banquero",
"=",
"self",
".",
"request",
".",
"user",
"serializer",
"=",
"TransactionSerializer",
"(",
"data",
"=",
"request",
".",
"data",
")",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"transaction",
"=",
"serializer",
".",
"save",
"(",
"userTransmitter",
"=",
"banquero",
",",
"amount",
"=",
"200",
")",
"jugador",
"=",
"serializer",
".",
"validated_data",
"[",
"'userReceiver'",
"]",
"jugador",
".",
"amount",
"+=",
"200",
"jugador",
".",
"save",
"(",
")",
"return",
"Response",
"(",
"serializer",
".",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_201_CREATED",
")",
"else",
":",
"return",
"Response",
"(",
"{",
"\"errors\"",
":",
"(",
"serializer",
".",
"errors",
",",
")",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
89,
4
] | [
101,
97
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Atajo.get | (cls, slug = None, user = None, url = None) | Dado un slug, devuelve el atajo correspondiente.
Dado un usuario:
Si url es None, devuelve la lista de sus atajos
Si url no es None , devuelve *ese* atajo
| Dado un slug, devuelve el atajo correspondiente.
Dado un usuario:
Si url es None, devuelve la lista de sus atajos
Si url no es None , devuelve *ese* atajo
| def get(cls, slug = None, user = None, url = None):
''' Dado un slug, devuelve el atajo correspondiente.
Dado un usuario:
Si url es None, devuelve la lista de sus atajos
Si url no es None , devuelve *ese* atajo
'''
if slug is not None:
i = 0
for p,l in enumerate(slug):
i += 62 ** p * cls.validos.index(l)
return cls.store.find(cls, id = i, activo = True).one()
if user is not None:
if url is None:
return cls.store.find(cls, user = user, activo = True)
else:
return cls.store.find(cls, user = user,
url = url, activo = True).one() | [
"def",
"get",
"(",
"cls",
",",
"slug",
"=",
"None",
",",
"user",
"=",
"None",
",",
"url",
"=",
"None",
")",
":",
"if",
"slug",
"is",
"not",
"None",
":",
"i",
"=",
"0",
"for",
"p",
",",
"l",
"in",
"enumerate",
"(",
"slug",
")",
":",
"i",
"+=",
"62",
"**",
"p",
"*",
"cls",
".",
"validos",
".",
"index",
"(",
"l",
")",
"return",
"cls",
".",
"store",
".",
"find",
"(",
"cls",
",",
"id",
"=",
"i",
",",
"activo",
"=",
"True",
")",
".",
"one",
"(",
")",
"if",
"user",
"is",
"not",
"None",
":",
"if",
"url",
"is",
"None",
":",
"return",
"cls",
".",
"store",
".",
"find",
"(",
"cls",
",",
"user",
"=",
"user",
",",
"activo",
"=",
"True",
")",
"else",
":",
"return",
"cls",
".",
"store",
".",
"find",
"(",
"cls",
",",
"user",
"=",
"user",
",",
"url",
"=",
"url",
",",
"activo",
"=",
"True",
")",
".",
"one",
"(",
")"
] | [
156,
4
] | [
174,
51
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RBF.convert_to_one_hot | (self, x, num_of_classes) | return arr | Pasa las etiquetas categóricas del vector x
a vectores one hot | Pasa las etiquetas categóricas del vector x
a vectores one hot | def convert_to_one_hot(self, x, num_of_classes):
""" Pasa las etiquetas categóricas del vector x
a vectores one hot """
arr = np.zeros((len(x), num_of_classes))
for i in range(len(x)):
c = int(x[i])
arr[i][c] = 1
return arr | [
"def",
"convert_to_one_hot",
"(",
"self",
",",
"x",
",",
"num_of_classes",
")",
":",
"arr",
"=",
"np",
".",
"zeros",
"(",
"(",
"len",
"(",
"x",
")",
",",
"num_of_classes",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"x",
")",
")",
":",
"c",
"=",
"int",
"(",
"x",
"[",
"i",
"]",
")",
"arr",
"[",
"i",
"]",
"[",
"c",
"]",
"=",
"1",
"return",
"arr"
] | [
40,
4
] | [
47,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
csv_writer | (csv_file) | return True | **Escribe un archivo ``csv`` de forma temporal**
Esta función escribe el ``csv`` en disco para posteriormente
subirlo al indice de ``Elasticsearch``
:param csv_file: ``csv`` enviado por medio del objeto ``request``
:type: ``FileField``
:param file_name: Nombre del archivo ``csv``
:type: str
:return: ``True`` si se guardo correctamente
:rtype: bool
| **Escribe un archivo ``csv`` de forma temporal** | def csv_writer(csv_file):
"""**Escribe un archivo ``csv`` de forma temporal**
Esta función escribe el ``csv`` en disco para posteriormente
subirlo al indice de ``Elasticsearch``
:param csv_file: ``csv`` enviado por medio del objeto ``request``
:type: ``FileField``
:param file_name: Nombre del archivo ``csv``
:type: str
:return: ``True`` si se guardo correctamente
:rtype: bool
"""
LOGGER.debug(f"Guardando CSV temporal::{csv_file.name}")
# Guardando en disco ante de procesar los datos
with open(csv_file.name, 'wb+') as f:
for chunk in csv_file.chunks():
f.write(chunk)
return True | [
"def",
"csv_writer",
"(",
"csv_file",
")",
":",
"LOGGER",
".",
"debug",
"(",
"f\"Guardando CSV temporal::{csv_file.name}\"",
")",
"# Guardando en disco ante de procesar los datos",
"with",
"open",
"(",
"csv_file",
".",
"name",
",",
"'wb+'",
")",
"as",
"f",
":",
"for",
"chunk",
"in",
"csv_file",
".",
"chunks",
"(",
")",
":",
"f",
".",
"write",
"(",
"chunk",
")",
"return",
"True"
] | [
89,
0
] | [
107,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AdministrativosTest.test_permiso_administrativo_en_CS_unico | (self) | La autorización entre un usuario y el Centro de Salud
permitido debe existir solo una vez | La autorización entre un usuario y el Centro de Salud
permitido debe existir solo una vez | def test_permiso_administrativo_en_CS_unico(self):
''' La autorización entre un usuario y el Centro de Salud
permitido debe existir solo una vez '''
with self.assertRaises(IntegrityError):
UsuarioEnCentroDeSalud.objects.create(
usuario=self.user_admin_1,
centro_de_salud=CentroDeSalud.objects.get(nombre='Centro de Salud 1')
) | [
"def",
"test_permiso_administrativo_en_CS_unico",
"(",
"self",
")",
":",
"with",
"self",
".",
"assertRaises",
"(",
"IntegrityError",
")",
":",
"UsuarioEnCentroDeSalud",
".",
"objects",
".",
"create",
"(",
"usuario",
"=",
"self",
".",
"user_admin_1",
",",
"centro_de_salud",
"=",
"CentroDeSalud",
".",
"objects",
".",
"get",
"(",
"nombre",
"=",
"'Centro de Salud 1'",
")",
")"
] | [
98,
4
] | [
106,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
mayor_fila | (arr: List[List[int]], pos: int = 0) | return pos | Determina la fila con la mayor cantidad de números impares
usando recursion.
:param arr: Lista de números enteros.
:arr type: List[List[int]]
:param pos: Posición actual en la lista.
:pos type: int
:return: Fila con la mayor cantidad de números impares.
:rtype: int
| Determina la fila con la mayor cantidad de números impares
usando recursion. | def mayor_fila(arr: List[List[int]], pos: int = 0) -> int:
"""Determina la fila con la mayor cantidad de números impares
usando recursion.
:param arr: Lista de números enteros.
:arr type: List[List[int]]
:param pos: Posición actual en la lista.
:pos type: int
:return: Fila con la mayor cantidad de números impares.
:rtype: int
"""
if len(arr) - 1 == pos:
return pos
i = mayor_fila(arr, pos+1)
if contar_impares(arr[i]) > contar_impares(arr[pos]):
return i
return pos | [
"def",
"mayor_fila",
"(",
"arr",
":",
"List",
"[",
"List",
"[",
"int",
"]",
"]",
",",
"pos",
":",
"int",
"=",
"0",
")",
"->",
"int",
":",
"if",
"len",
"(",
"arr",
")",
"-",
"1",
"==",
"pos",
":",
"return",
"pos",
"i",
"=",
"mayor_fila",
"(",
"arr",
",",
"pos",
"+",
"1",
")",
"if",
"contar_impares",
"(",
"arr",
"[",
"i",
"]",
")",
">",
"contar_impares",
"(",
"arr",
"[",
"pos",
"]",
")",
":",
"return",
"i",
"return",
"pos"
] | [
42,
0
] | [
58,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
logger.__init__ | (self, ficherolog,loglevel) | indica si la clase escribe mensajes en pantalla o no | indica si la clase escribe mensajes en pantalla o no | def __init__(self, ficherolog,loglevel):
self.log=True
""" indica si la clase escribe mensajes en pantalla o no """
if not loglevel:
self.loglevel=1
else:
self.loglevel=loglevel
if not ficherolog:
self.ficherolog='salida_defecto.txt'
else:
self.ficherolog=ficherolog
self.fw= None | [
"def",
"__init__",
"(",
"self",
",",
"ficherolog",
",",
"loglevel",
")",
":",
"self",
".",
"log",
"=",
"True",
"if",
"not",
"loglevel",
":",
"self",
".",
"loglevel",
"=",
"1",
"else",
":",
"self",
".",
"loglevel",
"=",
"loglevel",
"if",
"not",
"ficherolog",
":",
"self",
".",
"ficherolog",
"=",
"'salida_defecto.txt'",
"else",
":",
"self",
".",
"ficherolog",
"=",
"ficherolog",
"self",
".",
"fw",
"=",
"None"
] | [
29,
4
] | [
41,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TranslateFactory.getLanguage | (self, lan) | Dado el nombre de un idioma, la siguiente función regresa un
objeto de cierto tipo dependiendo del idioma ingresado | Dado el nombre de un idioma, la siguiente función regresa un
objeto de cierto tipo dependiendo del idioma ingresado | def getLanguage(self, lan):
"""Dado el nombre de un idioma, la siguiente función regresa un
objeto de cierto tipo dependiendo del idioma ingresado"""
if lan == 'español':
return SpanishTranslator() # objeto regresado
if lan == 'griego':
return GreekTranslator() # objeto regresado
if lan == 'alemán':
return TranslatorAleman() | [
"def",
"getLanguage",
"(",
"self",
",",
"lan",
")",
":",
"if",
"lan",
"==",
"'español':",
"",
"return",
"SpanishTranslator",
"(",
")",
"# objeto regresado",
"if",
"lan",
"==",
"'griego'",
":",
"return",
"GreekTranslator",
"(",
")",
"# objeto regresado",
"if",
"lan",
"==",
"'alemán':",
"",
"return",
"TranslatorAleman",
"(",
")"
] | [
35,
4
] | [
43,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.cofactor_matrix | (self) | return new | Metodo para calcular la matriz de cofactores. | Metodo para calcular la matriz de cofactores. | def cofactor_matrix(self):
""" Metodo para calcular la matriz de cofactores. """
c = len(self)
r = len(self[0])
new = Matrix([[0] * r for t in xrange(c)])
for x in xrange(c):
for y in xrange(r):
new[x][y] = (-1) ** (x + y) * self.submat(x, y).det()
return new | [
"def",
"cofactor_matrix",
"(",
"self",
")",
":",
"c",
"=",
"len",
"(",
"self",
")",
"r",
"=",
"len",
"(",
"self",
"[",
"0",
"]",
")",
"new",
"=",
"Matrix",
"(",
"[",
"[",
"0",
"]",
"*",
"r",
"for",
"t",
"in",
"xrange",
"(",
"c",
")",
"]",
")",
"for",
"x",
"in",
"xrange",
"(",
"c",
")",
":",
"for",
"y",
"in",
"xrange",
"(",
"r",
")",
":",
"new",
"[",
"x",
"]",
"[",
"y",
"]",
"=",
"(",
"-",
"1",
")",
"**",
"(",
"x",
"+",
"y",
")",
"*",
"self",
".",
"submat",
"(",
"x",
",",
"y",
")",
".",
"det",
"(",
")",
"return",
"new"
] | [
152,
4
] | [
160,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlaceDbWriter.write | (self, element, is_update=False) | Escribe la información de element en la base de datos, en las distintas tablas.
Arguments
---------
element : dict
diccionario con la información necesaria para escribir en las tablas de la base de datos.
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
Returns
-------
True
si se ha insertado correctamente en la base de datos.
False
si no se ha insertado.
| Escribe la información de element en la base de datos, en las distintas tablas. | def write(self, element, is_update=False):
"""Escribe la información de element en la base de datos, en las distintas tablas.
Arguments
---------
element : dict
diccionario con la información necesaria para escribir en las tablas de la base de datos.
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
Returns
-------
True
si se ha insertado correctamente en la base de datos.
False
si no se ha insertado.
"""
cursor = self.db.cursor()
# Store element
op_values = element.get("opening_hours")[0] if len(element.get("opening_hours", [])) == 1 else element.get(
"opening_hours", [])
name = element.get("name", None)
zip_code = element.get("zip_code", None) # external added to element in extraction process
date = element.get("date", None) # external added to element in extraction process
address = element.get("address", None)
price_range = element.get("price_range", None) # to extract
style = element.get("style", None) # to extract
premise_type = element.get("premise_type", None) # to extract
coordinates = element.get("coordinates", None)
telephone = element.get("telephone_number", None)
opening_hours = ",".join(op_values) if op_values else None
score = float(element.get("score").replace(",", ".")) if element.get("score") else None
total_score = int(element.get("total_scores").replace(",", "").replace(".", "")) if element.get("total_scores") else None
execution_places_types = element.get("execution_places_types", None)
commercial_premise_gmaps_url = element.get("current_url", element.get("extractor_url"))
address_hash = hashlib.sha256((name+address).encode()).hexdigest() if address and name else None
updatable_id = element.get("commercial_premise_id") if is_update else None
gps_coords = commercial_premise_gmaps_url.split("!3d")[-1].split("!4d") if "/place/" in commercial_premise_gmaps_url else None
lat = str(gps_coords[0]).replace(".", ",") if gps_coords is not None else None
long = str(gps_coords[1]).replace(".", ",") if gps_coords is not None else None
inserted = False
try:
cursor.execute(self._find_place_query, (name, date, address))
db_element = cursor.fetchone()
element_id = None
self.logger.info("-{place}- is being registered in database with address -{address}- and date -{date}-"
.format(place=name, date=date, address=address))
if db_element and not is_update:
# si el local comercial ya existe en la base de datos para la fecha de ejecución, se marca como
# insertado: `inserted = True`
self.logger.info(
"-{place}- with address -{address}- and date -{date}- found in database with: -{dbelement}-".format(
place=name, date=date, address=address, dbelement=db_element))
inserted = True
else:
# si no está, se inserta primero en la tabla `commercial_premise` y se obtiene el id para el local
# insertado. Este id (`element_id`) se usará para hacer las insercciones en las tablas de
# `commercial_premise_comments` y `commercial_premise_occupation`
values = (
name, zip_code, coordinates, telephone, opening_hours, premise_type, score, total_score,
price_range, style, address, date, execution_places_types, commercial_premise_gmaps_url,
address_hash, lat, long, updatable_id
) if is_update else (
name, zip_code, coordinates, telephone, opening_hours, premise_type, score, total_score,
price_range, style, address, date, execution_places_types, commercial_premise_gmaps_url,
address_hash, lat, long
)
query = self._update_commercial_premise_query if is_update else self._commercial_premise_query
try:
self.logger.info("-{place}-: storing commercial premise in database".format(place=name))
cursor.execute(query, values)
element_id = cursor.fetchone()
self.db.commit()
except IntegrityError as ie:
self.db.rollback()
self.logger.error("-{place}-: integrity error while storing commercial premise".format(place=name))
if is_update:
self.logger.error("-{place}-: integrity error detected in recovery process".format(place=name))
self.logger.error("-{place}-: deleting commercial premise with id: {id}".format(
place=name, id=updatable_id))
cursor.execute(self._delete_place_query, (updatable_id,))
self.db.commit()
raise ie
except Exception as e:
self.db.rollback()
self.logger.error("-{place}-: error storing commercial premise".format(place=name))
if is_update:
print(e)
self.logger.error(str(e))
self.logger.error("-{place}-: wrong value: {values}".format(place=name, values=values))
raise Exception(
"-{place}-: avoid registration: commercial premise with name with wrong values".format(
place=name))
# Store comments
# (commercial_premise_id, author, publish_date, reviews_by_author, content, raw_content, date)
values = [(element_id[0],
comment.get("author", ""),
comment.get("publish_date", ""),
comment.get("reviews_by_author", ""),
comment.get("content", ""),
comment.get("raw_content", ""),
date,
address_hash) for comment in element.get("comments", [])]
self.logger.info("-{place}-: storing commercial premise comments in database".format(place=name))
try:
cursor.executemany(self._commercial_premise_comments_query, values)
self.db.commit()
except Exception as e:
self.db.rollback()
self.logger.error("-{place}-: error during storing comments".format(place=name))
self.logger.error(str(e))
self.logger.error("-{place}-: wrong values:".format(place=name))
self.logger.error(values)
# Store occupancy data
if element.get("occupancy"):
values = []
self.logger.info("-{place}-: storing commercial premise occupancy in database".format(place=name))
for week_day, content in self.decompose_occupancy_data(element["occupancy"]).items():
if content and content.items():
values += [(element_id, week_day, key, value, date, address_hash) for key, value in
content.items()]
try:
cursor.executemany(self._commercial_premise_occupation_query, values)
self.db.commit()
except Exception as e:
self.db.rollback()
self.logger.error("-{place}-: error during storing occupancy".format(place=name))
self.logger.error(str(e))
self.logger.error("-{place}-: wrong values:".format(place=name))
self.logger.error(values)
inserted = True
except Exception as e:
self.db.rollback()
self.logger.error("-{place}-: error during writing data for place".format(place=name))
self.logger.error(str(e))
self.logger.error("-{place}-: wrong values:".format(place=name))
self.logger.error(json.dumps(element))
finally:
cursor.close()
return inserted | [
"def",
"write",
"(",
"self",
",",
"element",
",",
"is_update",
"=",
"False",
")",
":",
"cursor",
"=",
"self",
".",
"db",
".",
"cursor",
"(",
")",
"# Store element",
"op_values",
"=",
"element",
".",
"get",
"(",
"\"opening_hours\"",
")",
"[",
"0",
"]",
"if",
"len",
"(",
"element",
".",
"get",
"(",
"\"opening_hours\"",
",",
"[",
"]",
")",
")",
"==",
"1",
"else",
"element",
".",
"get",
"(",
"\"opening_hours\"",
",",
"[",
"]",
")",
"name",
"=",
"element",
".",
"get",
"(",
"\"name\"",
",",
"None",
")",
"zip_code",
"=",
"element",
".",
"get",
"(",
"\"zip_code\"",
",",
"None",
")",
"# external added to element in extraction process",
"date",
"=",
"element",
".",
"get",
"(",
"\"date\"",
",",
"None",
")",
"# external added to element in extraction process",
"address",
"=",
"element",
".",
"get",
"(",
"\"address\"",
",",
"None",
")",
"price_range",
"=",
"element",
".",
"get",
"(",
"\"price_range\"",
",",
"None",
")",
"# to extract",
"style",
"=",
"element",
".",
"get",
"(",
"\"style\"",
",",
"None",
")",
"# to extract",
"premise_type",
"=",
"element",
".",
"get",
"(",
"\"premise_type\"",
",",
"None",
")",
"# to extract",
"coordinates",
"=",
"element",
".",
"get",
"(",
"\"coordinates\"",
",",
"None",
")",
"telephone",
"=",
"element",
".",
"get",
"(",
"\"telephone_number\"",
",",
"None",
")",
"opening_hours",
"=",
"\",\"",
".",
"join",
"(",
"op_values",
")",
"if",
"op_values",
"else",
"None",
"score",
"=",
"float",
"(",
"element",
".",
"get",
"(",
"\"score\"",
")",
".",
"replace",
"(",
"\",\"",
",",
"\".\"",
")",
")",
"if",
"element",
".",
"get",
"(",
"\"score\"",
")",
"else",
"None",
"total_score",
"=",
"int",
"(",
"element",
".",
"get",
"(",
"\"total_scores\"",
")",
".",
"replace",
"(",
"\",\"",
",",
"\"\"",
")",
".",
"replace",
"(",
"\".\"",
",",
"\"\"",
")",
")",
"if",
"element",
".",
"get",
"(",
"\"total_scores\"",
")",
"else",
"None",
"execution_places_types",
"=",
"element",
".",
"get",
"(",
"\"execution_places_types\"",
",",
"None",
")",
"commercial_premise_gmaps_url",
"=",
"element",
".",
"get",
"(",
"\"current_url\"",
",",
"element",
".",
"get",
"(",
"\"extractor_url\"",
")",
")",
"address_hash",
"=",
"hashlib",
".",
"sha256",
"(",
"(",
"name",
"+",
"address",
")",
".",
"encode",
"(",
")",
")",
".",
"hexdigest",
"(",
")",
"if",
"address",
"and",
"name",
"else",
"None",
"updatable_id",
"=",
"element",
".",
"get",
"(",
"\"commercial_premise_id\"",
")",
"if",
"is_update",
"else",
"None",
"gps_coords",
"=",
"commercial_premise_gmaps_url",
".",
"split",
"(",
"\"!3d\"",
")",
"[",
"-",
"1",
"]",
".",
"split",
"(",
"\"!4d\"",
")",
"if",
"\"/place/\"",
"in",
"commercial_premise_gmaps_url",
"else",
"None",
"lat",
"=",
"str",
"(",
"gps_coords",
"[",
"0",
"]",
")",
".",
"replace",
"(",
"\".\"",
",",
"\",\"",
")",
"if",
"gps_coords",
"is",
"not",
"None",
"else",
"None",
"long",
"=",
"str",
"(",
"gps_coords",
"[",
"1",
"]",
")",
".",
"replace",
"(",
"\".\"",
",",
"\",\"",
")",
"if",
"gps_coords",
"is",
"not",
"None",
"else",
"None",
"inserted",
"=",
"False",
"try",
":",
"cursor",
".",
"execute",
"(",
"self",
".",
"_find_place_query",
",",
"(",
"name",
",",
"date",
",",
"address",
")",
")",
"db_element",
"=",
"cursor",
".",
"fetchone",
"(",
")",
"element_id",
"=",
"None",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}- is being registered in database with address -{address}- and date -{date}-\"",
".",
"format",
"(",
"place",
"=",
"name",
",",
"date",
"=",
"date",
",",
"address",
"=",
"address",
")",
")",
"if",
"db_element",
"and",
"not",
"is_update",
":",
"# si el local comercial ya existe en la base de datos para la fecha de ejecución, se marca como",
"# insertado: `inserted = True`",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}- with address -{address}- and date -{date}- found in database with: -{dbelement}-\"",
".",
"format",
"(",
"place",
"=",
"name",
",",
"date",
"=",
"date",
",",
"address",
"=",
"address",
",",
"dbelement",
"=",
"db_element",
")",
")",
"inserted",
"=",
"True",
"else",
":",
"# si no está, se inserta primero en la tabla `commercial_premise` y se obtiene el id para el local",
"# insertado. Este id (`element_id`) se usará para hacer las insercciones en las tablas de",
"# `commercial_premise_comments` y `commercial_premise_occupation`",
"values",
"=",
"(",
"name",
",",
"zip_code",
",",
"coordinates",
",",
"telephone",
",",
"opening_hours",
",",
"premise_type",
",",
"score",
",",
"total_score",
",",
"price_range",
",",
"style",
",",
"address",
",",
"date",
",",
"execution_places_types",
",",
"commercial_premise_gmaps_url",
",",
"address_hash",
",",
"lat",
",",
"long",
",",
"updatable_id",
")",
"if",
"is_update",
"else",
"(",
"name",
",",
"zip_code",
",",
"coordinates",
",",
"telephone",
",",
"opening_hours",
",",
"premise_type",
",",
"score",
",",
"total_score",
",",
"price_range",
",",
"style",
",",
"address",
",",
"date",
",",
"execution_places_types",
",",
"commercial_premise_gmaps_url",
",",
"address_hash",
",",
"lat",
",",
"long",
")",
"query",
"=",
"self",
".",
"_update_commercial_premise_query",
"if",
"is_update",
"else",
"self",
".",
"_commercial_premise_query",
"try",
":",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: storing commercial premise in database\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"cursor",
".",
"execute",
"(",
"query",
",",
"values",
")",
"element_id",
"=",
"cursor",
".",
"fetchone",
"(",
")",
"self",
".",
"db",
".",
"commit",
"(",
")",
"except",
"IntegrityError",
"as",
"ie",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: integrity error while storing commercial premise\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"if",
"is_update",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: integrity error detected in recovery process\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: deleting commercial premise with id: {id}\"",
".",
"format",
"(",
"place",
"=",
"name",
",",
"id",
"=",
"updatable_id",
")",
")",
"cursor",
".",
"execute",
"(",
"self",
".",
"_delete_place_query",
",",
"(",
"updatable_id",
",",
")",
")",
"self",
".",
"db",
".",
"commit",
"(",
")",
"raise",
"ie",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: error storing commercial premise\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"if",
"is_update",
":",
"print",
"(",
"e",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: wrong value: {values}\"",
".",
"format",
"(",
"place",
"=",
"name",
",",
"values",
"=",
"values",
")",
")",
"raise",
"Exception",
"(",
"\"-{place}-: avoid registration: commercial premise with name with wrong values\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"# Store comments",
"# (commercial_premise_id, author, publish_date, reviews_by_author, content, raw_content, date)",
"values",
"=",
"[",
"(",
"element_id",
"[",
"0",
"]",
",",
"comment",
".",
"get",
"(",
"\"author\"",
",",
"\"\"",
")",
",",
"comment",
".",
"get",
"(",
"\"publish_date\"",
",",
"\"\"",
")",
",",
"comment",
".",
"get",
"(",
"\"reviews_by_author\"",
",",
"\"\"",
")",
",",
"comment",
".",
"get",
"(",
"\"content\"",
",",
"\"\"",
")",
",",
"comment",
".",
"get",
"(",
"\"raw_content\"",
",",
"\"\"",
")",
",",
"date",
",",
"address_hash",
")",
"for",
"comment",
"in",
"element",
".",
"get",
"(",
"\"comments\"",
",",
"[",
"]",
")",
"]",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: storing commercial premise comments in database\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"try",
":",
"cursor",
".",
"executemany",
"(",
"self",
".",
"_commercial_premise_comments_query",
",",
"values",
")",
"self",
".",
"db",
".",
"commit",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: error during storing comments\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: wrong values:\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"values",
")",
"# Store occupancy data",
"if",
"element",
".",
"get",
"(",
"\"occupancy\"",
")",
":",
"values",
"=",
"[",
"]",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{place}-: storing commercial premise occupancy in database\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"for",
"week_day",
",",
"content",
"in",
"self",
".",
"decompose_occupancy_data",
"(",
"element",
"[",
"\"occupancy\"",
"]",
")",
".",
"items",
"(",
")",
":",
"if",
"content",
"and",
"content",
".",
"items",
"(",
")",
":",
"values",
"+=",
"[",
"(",
"element_id",
",",
"week_day",
",",
"key",
",",
"value",
",",
"date",
",",
"address_hash",
")",
"for",
"key",
",",
"value",
"in",
"content",
".",
"items",
"(",
")",
"]",
"try",
":",
"cursor",
".",
"executemany",
"(",
"self",
".",
"_commercial_premise_occupation_query",
",",
"values",
")",
"self",
".",
"db",
".",
"commit",
"(",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: error during storing occupancy\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: wrong values:\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"values",
")",
"inserted",
"=",
"True",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: error during writing data for place\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{place}-: wrong values:\"",
".",
"format",
"(",
"place",
"=",
"name",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"json",
".",
"dumps",
"(",
"element",
")",
")",
"finally",
":",
"cursor",
".",
"close",
"(",
")",
"return",
"inserted"
] | [
197,
4
] | [
337,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_Bom.approve_list | (self) | Permite poner en estado aprobado una lista de materiales. | Permite poner en estado aprobado una lista de materiales. | def approve_list(self):
""" Permite poner en estado aprobado una lista de materiales. """
register = self.env['mrp.bom'].search([('id', '=', self.id)])
if register.state != 'Aprobado':
register.write({
'state': 'Aprobado',
'approval_user': self.env.user,
'approval_date': fields.Datetime.now()
}) | [
"def",
"approve_list",
"(",
"self",
")",
":",
"register",
"=",
"self",
".",
"env",
"[",
"'mrp.bom'",
"]",
".",
"search",
"(",
"[",
"(",
"'id'",
",",
"'='",
",",
"self",
".",
"id",
")",
"]",
")",
"if",
"register",
".",
"state",
"!=",
"'Aprobado'",
":",
"register",
".",
"write",
"(",
"{",
"'state'",
":",
"'Aprobado'",
",",
"'approval_user'",
":",
"self",
".",
"env",
".",
"user",
",",
"'approval_date'",
":",
"fields",
".",
"Datetime",
".",
"now",
"(",
")",
"}",
")"
] | [
58,
4
] | [
66,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_tiempo6 | (t) | tiempo : SECOND
| tiempo : SECOND
| def p_tiempo6(t):
''' tiempo : SECOND
''' | [
"def",
"p_tiempo6",
"(",
"t",
")",
":"
] | [
939,
0
] | [
941,
7
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones13 | (p) | funciones : AS PABRE expresion PCIERRA | funciones : AS PABRE expresion PCIERRA | def p_funciones13(p):
'funciones : AS PABRE expresion PCIERRA' | [
"def",
"p_funciones13",
"(",
"p",
")",
":"
] | [
337,
0
] | [
338,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackingVideo._apply_internal_drawings | (self, fid: int, frame: Image) | return frame | Aplica las funciones internas de dibujado.
Son aplicadas a través de las propiedades.
:param fid: número del frame.
:param frame: frame.
:return: frame con los dibujados.
| Aplica las funciones internas de dibujado. | def _apply_internal_drawings(self, fid: int, frame: Image) -> Image:
"""Aplica las funciones internas de dibujado.
Son aplicadas a través de las propiedades.
:param fid: número del frame.
:param frame: frame.
:return: frame con los dibujados.
"""
# DRAW_OBJECTS
if self.get_property(TrackingVideoProperty.DRAW_OBJECTS):
frame = self._draw_objects(fid, frame)
# DRAW_FRAME_NUMBER
if self.get_property(TrackingVideoProperty.DRAW_FRAME_NUMBER):
frame = self._draw_frame_number(fid, frame)
# DRAW_FRAME_TIMESTAMP
if self.get_property(TrackingVideoProperty.DRAW_FRAME_NUMBER):
frame = self._draw_frame_timestamp(fid, frame)
# Devolver frame con los dibujados.
return frame | [
"def",
"_apply_internal_drawings",
"(",
"self",
",",
"fid",
":",
"int",
",",
"frame",
":",
"Image",
")",
"->",
"Image",
":",
"# DRAW_OBJECTS",
"if",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"DRAW_OBJECTS",
")",
":",
"frame",
"=",
"self",
".",
"_draw_objects",
"(",
"fid",
",",
"frame",
")",
"# DRAW_FRAME_NUMBER",
"if",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"DRAW_FRAME_NUMBER",
")",
":",
"frame",
"=",
"self",
".",
"_draw_frame_number",
"(",
"fid",
",",
"frame",
")",
"# DRAW_FRAME_TIMESTAMP",
"if",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"DRAW_FRAME_NUMBER",
")",
":",
"frame",
"=",
"self",
".",
"_draw_frame_timestamp",
"(",
"fid",
",",
"frame",
")",
"# Devolver frame con los dibujados.",
"return",
"frame"
] | [
85,
4
] | [
104,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo._draw_object_informations | (self,
fid: int,
frame: Image,
tracked_object: TrackedObject,
tracked_object_detection: TrackedObjectDetection,
object_informations: List[str]) | return frame | Dibuja los textos de información del vehículo.
:param fid: identificador del frame.
:param frame: frame.
:param tracked_object: detección del objeto seguido.
:param tracked_object_detection:
:return: frame con las informaciones del objeto dibujadas.
| Dibuja los textos de información del vehículo. | def _draw_object_informations(self,
fid: int,
frame: Image,
tracked_object: TrackedObject,
tracked_object_detection: TrackedObjectDetection,
object_informations: List[str]) -> Image:
"""Dibuja los textos de información del vehículo.
:param fid: identificador del frame.
:param frame: frame.
:param tracked_object: detección del objeto seguido.
:param tracked_object_detection:
:return: frame con las informaciones del objeto dibujadas.
"""
# Propiedades del texto.
text_format = self.get_property(TrackingVideoProperty.TEXT_OBJECT_INFORMATION)
font, color, linetype, thickness, font_scale, blo = text_format
margin = 0, 8
# Posición inicial.
object_top_left = tracked_object_detection.object.bounding_box.top_left
next_position = object_top_left.x, object_top_left.y - margin[1]
# Dibujar textos.
for text in object_informations:
size, _ = cv2.getTextSize(text, font, font_scale, thickness)
cv2.putText(frame, text, next_position, font, font_scale, color, thickness, linetype, blo)
# Calcular la posición del siguiente texto.
next_position = next_position[0], next_position[1] - size[1] - margin[1]
# Devolver el frame con los dibujados.
return frame | [
"def",
"_draw_object_informations",
"(",
"self",
",",
"fid",
":",
"int",
",",
"frame",
":",
"Image",
",",
"tracked_object",
":",
"TrackedObject",
",",
"tracked_object_detection",
":",
"TrackedObjectDetection",
",",
"object_informations",
":",
"List",
"[",
"str",
"]",
")",
"->",
"Image",
":",
"# Propiedades del texto.",
"text_format",
"=",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"TEXT_OBJECT_INFORMATION",
")",
"font",
",",
"color",
",",
"linetype",
",",
"thickness",
",",
"font_scale",
",",
"blo",
"=",
"text_format",
"margin",
"=",
"0",
",",
"8",
"# Posición inicial.",
"object_top_left",
"=",
"tracked_object_detection",
".",
"object",
".",
"bounding_box",
".",
"top_left",
"next_position",
"=",
"object_top_left",
".",
"x",
",",
"object_top_left",
".",
"y",
"-",
"margin",
"[",
"1",
"]",
"# Dibujar textos.",
"for",
"text",
"in",
"object_informations",
":",
"size",
",",
"_",
"=",
"cv2",
".",
"getTextSize",
"(",
"text",
",",
"font",
",",
"font_scale",
",",
"thickness",
")",
"cv2",
".",
"putText",
"(",
"frame",
",",
"text",
",",
"next_position",
",",
"font",
",",
"font_scale",
",",
"color",
",",
"thickness",
",",
"linetype",
",",
"blo",
")",
"# Calcular la posición del siguiente texto.",
"next_position",
"=",
"next_position",
"[",
"0",
"]",
",",
"next_position",
"[",
"1",
"]",
"-",
"size",
"[",
"1",
"]",
"-",
"margin",
"[",
"1",
"]",
"# Devolver el frame con los dibujados.",
"return",
"frame"
] | [
195,
4
] | [
223,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
plot2D | (x,y,title) | Función para visualizar una muesta etiquetada en 2D
Args:
x: muestra de puntos a visualizar
y: vector de etiquetas asociado a la muestra x
title: título para el gráfico generado
| Función para visualizar una muesta etiquetada en 2D | def plot2D(x,y,title):
""" Función para visualizar una muesta etiquetada en 2D
Args:
x: muestra de puntos a visualizar
y: vector de etiquetas asociado a la muestra x
title: título para el gráfico generado
"""
num_classes = np.unique(y).size
plt.figure(figsize=(10,10))
plt.scatter(x[:,0],x[:,1],c=y, cmap='tab20', alpha=0.5)
cmap=cm.get_cmap('tab20')
proxys=[]
labels=[]
for l in range(num_classes):
proxys.append(Line2D([0],[0], linestyle='none', c=cmap(l/(num_classes-1)), marker='o'))
labels.append(str(l+1))
plt.legend(proxys, labels, numpoints = 1,framealpha=0.5)
plt.title(title)
plt.show() | [
"def",
"plot2D",
"(",
"x",
",",
"y",
",",
"title",
")",
":",
"num_classes",
"=",
"np",
".",
"unique",
"(",
"y",
")",
".",
"size",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"10",
",",
"10",
")",
")",
"plt",
".",
"scatter",
"(",
"x",
"[",
":",
",",
"0",
"]",
",",
"x",
"[",
":",
",",
"1",
"]",
",",
"c",
"=",
"y",
",",
"cmap",
"=",
"'tab20'",
",",
"alpha",
"=",
"0.5",
")",
"cmap",
"=",
"cm",
".",
"get_cmap",
"(",
"'tab20'",
")",
"proxys",
"=",
"[",
"]",
"labels",
"=",
"[",
"]",
"for",
"l",
"in",
"range",
"(",
"num_classes",
")",
":",
"proxys",
".",
"append",
"(",
"Line2D",
"(",
"[",
"0",
"]",
",",
"[",
"0",
"]",
",",
"linestyle",
"=",
"'none'",
",",
"c",
"=",
"cmap",
"(",
"l",
"/",
"(",
"num_classes",
"-",
"1",
")",
")",
",",
"marker",
"=",
"'o'",
")",
")",
"labels",
".",
"append",
"(",
"str",
"(",
"l",
"+",
"1",
")",
")",
"plt",
".",
"legend",
"(",
"proxys",
",",
"labels",
",",
"numpoints",
"=",
"1",
",",
"framealpha",
"=",
"0.5",
")",
"plt",
".",
"title",
"(",
"title",
")",
"plt",
".",
"show",
"(",
")"
] | [
107,
0
] | [
131,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_CONTENIDO8 | (t) | CONTENIDO : nueval
| CONTENIDO : nueval
| def p_CONTENIDO8(t):
'''CONTENIDO : nueval
'''
t[0] = t[1] | [
"def",
"p_CONTENIDO8",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
233,
0
] | [
236,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
set_services | (config) | return config | Escribe información de los servivios
Escribe en el diccionario de configuraciones el nombre del índice
y la url (ip y puerto) del servidor elasticsearch. Opcionalmente
el token de Google Analytics.
:param config: Diccionario con la configuración
:type: dict
:return: Diccionario de configuraciones con información del
de los servicios
:rtype: dict
| Escribe información de los servivios | def set_services(config):
"""Escribe información de los servivios
Escribe en el diccionario de configuraciones el nombre del índice
y la url (ip y puerto) del servidor elasticsearch. Opcionalmente
el token de Google Analytics.
:param config: Diccionario con la configuración
:type: dict
:return: Diccionario de configuraciones con información del
de los servicios
:rtype: dict
"""
config['INDEX'] = input('\t * Índice de Elasticsearch[default]>> ') or "default"
protocol = input("\t * Protocolo HTTP o HTTPS [http]>>")
ip = input("\t * Nombre o IP del servidor de Elasticsearch [localhost]>>")
port = input("\t * Puerto del servidor de Elasticsearch [9200]>>")
config['URL'] = set_url(protocol, ip, port)
index_flag = input("\t Deseas crear el índice [Y/n]>>")
config['GOOGLE_ANALYTICS'] = input('\t * Token Google Analytics []>> ')
if index_flag == "y" or index_flag == "Y" or index_flag == "":
create_index(config)
else:
print(f"\t⚙ Se Omitie la creación del indice {config['INDEX']} ⚙ ")
return config | [
"def",
"set_services",
"(",
"config",
")",
":",
"config",
"[",
"'INDEX'",
"]",
"=",
"input",
"(",
"'\\t * Índice de Elasticsearch[default]>> ')",
" ",
"r ",
"default\"",
"protocol",
"=",
"input",
"(",
"\"\\t * Protocolo HTTP o HTTPS [http]>>\"",
")",
"ip",
"=",
"input",
"(",
"\"\\t * Nombre o IP del servidor de Elasticsearch [localhost]>>\"",
")",
"port",
"=",
"input",
"(",
"\"\\t * Puerto del servidor de Elasticsearch [9200]>>\"",
")",
"config",
"[",
"'URL'",
"]",
"=",
"set_url",
"(",
"protocol",
",",
"ip",
",",
"port",
")",
"index_flag",
"=",
"input",
"(",
"\"\\t Deseas crear el índice [Y/n]>>\")",
"",
"config",
"[",
"'GOOGLE_ANALYTICS'",
"]",
"=",
"input",
"(",
"'\\t * Token Google Analytics []>> '",
")",
"if",
"index_flag",
"==",
"\"y\"",
"or",
"index_flag",
"==",
"\"Y\"",
"or",
"index_flag",
"==",
"\"\"",
":",
"create_index",
"(",
"config",
")",
"else",
":",
"print",
"(",
"f\"\\t⚙ Se Omitie la creación del indice {config['INDEX']} ⚙ \")",
"",
"return",
"config"
] | [
71,
0
] | [
95,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Battery.get_range | (self) | Imprime una declaración sobre el alcance que proporciona esta batería | Imprime una declaración sobre el alcance que proporciona esta batería | def get_range(self):
"""Imprime una declaración sobre el alcance que proporciona esta batería"""
if self.battery_size == 60:
range = 140
elif self.battery_size == 85:
range = 185
message = "Este automóvil puede ir aproximadamente " + str(range)
message += " millas con una carga completa."
print(message) | [
"def",
"get_range",
"(",
"self",
")",
":",
"if",
"self",
".",
"battery_size",
"==",
"60",
":",
"range",
"=",
"140",
"elif",
"self",
".",
"battery_size",
"==",
"85",
":",
"range",
"=",
"185",
"message",
"=",
"\"Este automóvil puede ir aproximadamente \" ",
" ",
"tr(",
"r",
"ange)",
"",
"message",
"+=",
"\" millas con una carga completa.\"",
"print",
"(",
"message",
")"
] | [
45,
4
] | [
54,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Procedure.ejecutar | (self, ent) | ejecucion de la definicion del procedimiento | ejecucion de la definicion del procedimiento | def ejecutar(self, ent):
'ejecucion de la definicion del procedimiento'
simbolo = Simbolo(Tipo('Procedure',None,-1,-1), '_P'+self.nombre, [self.params,self.instrucciones], -1)
s = ent.nuevoSimbolo(simbolo)
if s!='ok':
variables.consola.insert(INSERT,'La funcion '+self.nombre+' no se pudo crear porque ya existe\n') | [
"def",
"ejecutar",
"(",
"self",
",",
"ent",
")",
":",
"simbolo",
"=",
"Simbolo",
"(",
"Tipo",
"(",
"'Procedure'",
",",
"None",
",",
"-",
"1",
",",
"-",
"1",
")",
",",
"'_P'",
"+",
"self",
".",
"nombre",
",",
"[",
"self",
".",
"params",
",",
"self",
".",
"instrucciones",
"]",
",",
"-",
"1",
")",
"s",
"=",
"ent",
".",
"nuevoSimbolo",
"(",
"simbolo",
")",
"if",
"s",
"!=",
"'ok'",
":",
"variables",
".",
"consola",
".",
"insert",
"(",
"INSERT",
",",
"'La funcion '",
"+",
"self",
".",
"nombre",
"+",
"' no se pudo crear porque ya existe\\n'",
")"
] | [
14,
4
] | [
19,
109
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UserCallback.show_users | (
limit: int = 0,
asc: bool = True, *,
cursor
) | Obtiene los usuarios registrados
Args:
limit:
El límite de la cantidad de registrar
asc:
**True** para mostrarlos de formar ascendente; **False** para
mostrarlos de formar descendente.
Returns:
Un iterador asincrónico con los usuarios registrados
| Obtiene los usuarios registrados
Args:
limit:
El límite de la cantidad de registrar | async def show_users(
limit: int = 0,
asc: bool = True, *,
cursor
) -> AsyncIterator[Tuple[int, str, int, Union[int, bool]]]:
"""Obtiene los usuarios registrados
Args:
limit:
El límite de la cantidad de registrar
asc:
**True** para mostrarlos de formar ascendente; **False** para
mostrarlos de formar descendente.
Returns:
Un iterador asincrónico con los usuarios registrados
"""
sql = ["SELECT id, user, token_limit, guest_user FROM users ORDER BY id"]
args = []
if (asc):
sql.append("ASC")
else:
sql.append("DESC")
if (limit > 0):
sql.append("LIMIT %s")
args.append(limit)
await cursor.execute(
" ".join(sql), args
)
while (result := await cursor.fetchone()):
yield result | [
"async",
"def",
"show_users",
"(",
"limit",
":",
"int",
"=",
"0",
",",
"asc",
":",
"bool",
"=",
"True",
",",
"*",
",",
"cursor",
")",
"->",
"AsyncIterator",
"[",
"Tuple",
"[",
"int",
",",
"str",
",",
"int",
",",
"Union",
"[",
"int",
",",
"bool",
"]",
"]",
"]",
":",
"sql",
"=",
"[",
"\"SELECT id, user, token_limit, guest_user FROM users ORDER BY id\"",
"]",
"args",
"=",
"[",
"]",
"if",
"(",
"asc",
")",
":",
"sql",
".",
"append",
"(",
"\"ASC\"",
")",
"else",
":",
"sql",
".",
"append",
"(",
"\"DESC\"",
")",
"if",
"(",
"limit",
">",
"0",
")",
":",
"sql",
".",
"append",
"(",
"\"LIMIT %s\"",
")",
"args",
".",
"append",
"(",
"limit",
")",
"await",
"cursor",
".",
"execute",
"(",
"\" \"",
".",
"join",
"(",
"sql",
")",
",",
"args",
")",
"while",
"(",
"result",
":=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
")",
":",
"yield",
"result"
] | [
198,
4
] | [
239,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
CajeroHandler.next_succesor | (next) | siguiente handler en la cadena | siguiente handler en la cadena | def next_succesor(next):
"""siguiente handler en la cadena""" | [
"def",
"next_succesor",
"(",
"next",
")",
":"
] | [
5,
4
] | [
6,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
s3_pass | (message: Message, replies: Replies) | Obtén el password de tu sessión registrada. | Obtén el password de tu sessión registrada. | def s3_pass(message: Message, replies: Replies) -> None:
"""Obtén el password de tu sessión registrada."""
acc = db.get_account(message.get_sender_contact().addr)
if acc and acc["password"]:
replies.add(text=acc["password"])
else:
replies.add(text="❌ No estás registrado", quote=message) | [
"def",
"s3_pass",
"(",
"message",
":",
"Message",
",",
"replies",
":",
"Replies",
")",
"->",
"None",
":",
"acc",
"=",
"db",
".",
"get_account",
"(",
"message",
".",
"get_sender_contact",
"(",
")",
".",
"addr",
")",
"if",
"acc",
"and",
"acc",
"[",
"\"password\"",
"]",
":",
"replies",
".",
"add",
"(",
"text",
"=",
"acc",
"[",
"\"password\"",
"]",
")",
"else",
":",
"replies",
".",
"add",
"(",
"text",
"=",
"\"❌ No estás registrado\", q",
"u",
"te=me",
"s",
"sage)",
""
] | [
249,
0
] | [
255,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResults.speed_mse | (self, expected_speeds: List[float]) | return ((estimated_speeds - expected_speeds) ** 2).mean(axis=0) | Calcula el error cuadrático medio del módulo de las velocidades.
:param expected_speeds: lista con las velocidades esperadas.
:return: error cuadrático medio.
| Calcula el error cuadrático medio del módulo de las velocidades. | def speed_mse(self, expected_speeds: List[float]) -> float:
"""Calcula el error cuadrático medio del módulo de las velocidades.
:param expected_speeds: lista con las velocidades esperadas.
:return: error cuadrático medio.
"""
# Comprobar que tienen las mismas dimensiones.
if len(self._estimations_results) != len(expected_speeds):
raise VehicleSpeedEstimationException(
f'La lista de velocidades introducida no tiene la dimensión esperada. '
f'Se esperaban {len(self._estimations_results)} y se obtuvieron '
f'{len(expected_speeds)}')
# Filtrar los índices ignorados.
estimated_speeds = [result.mean_speed() for result in self._estimations_results
if not self.object_ignored(result.tracked_object.id)]
expected_speeds = [speed for id_, speed in enumerate(expected_speeds)
if not self.object_ignored(id_)]
# Calcular MSE.
estimated_speeds = np.array(estimated_speeds)
expected_speeds = np.array(expected_speeds)
return ((estimated_speeds - expected_speeds) ** 2).mean(axis=0) | [
"def",
"speed_mse",
"(",
"self",
",",
"expected_speeds",
":",
"List",
"[",
"float",
"]",
")",
"->",
"float",
":",
"# Comprobar que tienen las mismas dimensiones.",
"if",
"len",
"(",
"self",
".",
"_estimations_results",
")",
"!=",
"len",
"(",
"expected_speeds",
")",
":",
"raise",
"VehicleSpeedEstimationException",
"(",
"f'La lista de velocidades introducida no tiene la dimensión esperada. '",
"f'Se esperaban {len(self._estimations_results)} y se obtuvieron '",
"f'{len(expected_speeds)}'",
")",
"# Filtrar los índices ignorados.",
"estimated_speeds",
"=",
"[",
"result",
".",
"mean_speed",
"(",
")",
"for",
"result",
"in",
"self",
".",
"_estimations_results",
"if",
"not",
"self",
".",
"object_ignored",
"(",
"result",
".",
"tracked_object",
".",
"id",
")",
"]",
"expected_speeds",
"=",
"[",
"speed",
"for",
"id_",
",",
"speed",
"in",
"enumerate",
"(",
"expected_speeds",
")",
"if",
"not",
"self",
".",
"object_ignored",
"(",
"id_",
")",
"]",
"# Calcular MSE.",
"estimated_speeds",
"=",
"np",
".",
"array",
"(",
"estimated_speeds",
")",
"expected_speeds",
"=",
"np",
".",
"array",
"(",
"expected_speeds",
")",
"return",
"(",
"(",
"estimated_speeds",
"-",
"expected_speeds",
")",
"**",
"2",
")",
".",
"mean",
"(",
"axis",
"=",
"0",
")"
] | [
136,
4
] | [
156,
71
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioTSP.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
| Valida que la solución dada cumple con los requisitos del problema. | 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
"""
# Pendiente: implementar este método
for x in sol:
if isinstance(x,int):
print("La lista solo posee numeros enteros")
else:
print("La lista posee elementos que no son numeros enteros")
pass | [
"def",
"validar",
"(",
"self",
",",
"sol",
")",
":",
"# Pendiente: implementar este método",
"for",
"x",
"in",
"sol",
":",
"if",
"isinstance",
"(",
"x",
",",
"int",
")",
":",
"print",
"(",
"\"La lista solo posee numeros enteros\"",
")",
"else",
":",
"print",
"(",
"\"La lista posee elementos que no son numeros enteros\"",
")",
"pass"
] | [
61,
4
] | [
85,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ayuda | (request) | return render(request, "help.html") | **Muestra la página de ayuda**
Vista encargada de mostrar la sección de ayuda con las operaciones
soportadas, como realizar busquedas y recomendaciones generales.
:param request: Objeto ``HttpRequets`` para pasar el estado de la
app a través del sistema
:type: ``HttpRequest``
:return: Vista de ayuda
| **Muestra la página de ayuda** | def ayuda(request):
"""**Muestra la página de ayuda**
Vista encargada de mostrar la sección de ayuda con las operaciones
soportadas, como realizar busquedas y recomendaciones generales.
:param request: Objeto ``HttpRequets`` para pasar el estado de la
app a través del sistema
:type: ``HttpRequest``
:return: Vista de ayuda
"""
LOGGER.info("Entrando a ayuda")
return render(request, "help.html") | [
"def",
"ayuda",
"(",
"request",
")",
":",
"LOGGER",
".",
"info",
"(",
"\"Entrando a ayuda\"",
")",
"return",
"render",
"(",
"request",
",",
"\"help.html\"",
")"
] | [
43,
0
] | [
55,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
_exec_create | (host=None, user=None, passwd=None, db_name=None, queries=[]) | Función encargada de crear las tablas en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
queries: list
lista de queries de creación a ejecutar
| Función encargada de crear las tablas en la base de datos. | def _exec_create(host=None, user=None, passwd=None, db_name=None, queries=[]):
"""Función encargada de crear las tablas en la base de datos.
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
queries: list
lista de queries de creación a ejecutar
"""
db = psycopg2.connect(
host=host,
user=user,
password=passwd,
database=db_name
)
cursor = db.cursor()
for t in queries:
cursor.execute(t)
db.commit()
cursor.close()
db.close() | [
"def",
"_exec_create",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
",",
"queries",
"=",
"[",
"]",
")",
":",
"db",
"=",
"psycopg2",
".",
"connect",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"password",
"=",
"passwd",
",",
"database",
"=",
"db_name",
")",
"cursor",
"=",
"db",
".",
"cursor",
"(",
")",
"for",
"t",
"in",
"queries",
":",
"cursor",
".",
"execute",
"(",
"t",
")",
"db",
".",
"commit",
"(",
")",
"cursor",
".",
"close",
"(",
")",
"db",
".",
"close",
"(",
")"
] | [
142,
0
] | [
171,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Etl._load | (self) | Actualiza los metadatos del cubo. | Actualiza los metadatos del cubo. | def _load(self):
"""Actualiza los metadatos del cubo.""" | [
"def",
"_load",
"(",
"self",
")",
":"
] | [
67,
4
] | [
68,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProcControl.getInterval | (self) | return self.interval | Obtener el intervalo actual | Obtener el intervalo actual | def getInterval(self) -> float:
"""Obtener el intervalo actual"""
return self.interval | [
"def",
"getInterval",
"(",
"self",
")",
"->",
"float",
":",
"return",
"self",
".",
"interval"
] | [
96,
4
] | [
99,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_declaracion2 | (t) | declaracion : ID cualquieridentificador MODULO TYPE PTCOMA | declaracion : ID cualquieridentificador MODULO TYPE PTCOMA | def p_declaracion2(t):
'''declaracion : ID cualquieridentificador MODULO TYPE PTCOMA'''
t[0] = getdeclaraciones2(t) | [
"def",
"p_declaracion2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"getdeclaraciones2",
"(",
"t",
")"
] | [
606,
0
] | [
608,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
LearnerMedia.similarity_learning | (self, other_problem) | Implementar una espicie de encoding para los feature de los problemas
| Implementar una espicie de encoding para los feature de los problemas
| def similarity_learning(self, other_problem):
""" Implementar una espicie de encoding para los feature de los problemas
"""
raise NotImplementedError() | [
"def",
"similarity_learning",
"(",
"self",
",",
"other_problem",
")",
":",
"raise",
"NotImplementedError",
"(",
")"
] | [
254,
4
] | [
257,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.v_proj | (self, other) | Metodo para proyectar un vector sobre otro. | Metodo para proyectar un vector sobre otro. | def v_proj(self, other):
""" Metodo para proyectar un vector sobre otro. """
if len(self) == 1 and len(other) == 1 and self.check("add", other):
up = self.t() * other
down = other.t() * other
coef = float(up[0][0]) / down[0][0]
return other * coef
else:
raise TypeError("Matrix: Can only operate on vectors.") | [
"def",
"v_proj",
"(",
"self",
",",
"other",
")",
":",
"if",
"len",
"(",
"self",
")",
"==",
"1",
"and",
"len",
"(",
"other",
")",
"==",
"1",
"and",
"self",
".",
"check",
"(",
"\"add\"",
",",
"other",
")",
":",
"up",
"=",
"self",
".",
"t",
"(",
")",
"*",
"other",
"down",
"=",
"other",
".",
"t",
"(",
")",
"*",
"other",
"coef",
"=",
"float",
"(",
"up",
"[",
"0",
"]",
"[",
"0",
"]",
")",
"/",
"down",
"[",
"0",
"]",
"[",
"0",
"]",
"return",
"other",
"*",
"coef",
"else",
":",
"raise",
"TypeError",
"(",
"\"Matrix: Can only operate on vectors.\"",
")"
] | [
208,
4
] | [
216,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
set_header | (self, key: Any, value: Any, *args, **kwargs) | Ajusta las claves claves de los encabezados
Args:
key:
La clave
value:
El valor de dicha clave
*args, **kwargs:
- type:
El tipo de dato que se espera recibir
- index:
Si son muchos (como una lista o una tupla), esto es
útil para esclarecer explícitamente cuál es el
valor que se desea.
- convert:
Convertir el valor al tipo de dato ajustado en `type`
cuando no sea el correcto, o generar una excepción.
| Ajusta las claves claves de los encabezados
Args:
key:
La clave | def set_header(self, key: Any, value: Any, *args, **kwargs) -> None:
"""Ajusta las claves claves de los encabezados
Args:
key:
La clave
value:
El valor de dicha clave
*args, **kwargs:
- type:
El tipo de dato que se espera recibir
- index:
Si son muchos (como una lista o una tupla), esto es
útil para esclarecer explícitamente cuál es el
valor que se desea.
- convert:
Convertir el valor al tipo de dato ajustado en `type`
cuando no sea el correcto, o generar una excepción.
"""
value = self._check_type(value, *args, **kwargs)
self.headers[key] = value | [
"def",
"set_header",
"(",
"self",
",",
"key",
":",
"Any",
",",
"value",
":",
"Any",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"None",
":",
"value",
"=",
"self",
".",
"_check_type",
"(",
"value",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"headers",
"[",
"key",
"]",
"=",
"value"
] | [
69,
4
] | [
94,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
out | (cadena="", final="\n") | Envía una cadena a stdout y limpia el buffer (imprime más rápido). | Envía una cadena a stdout y limpia el buffer (imprime más rápido). | def out(cadena="", final="\n"):
"""Envía una cadena a stdout y limpia el buffer (imprime más rápido)."""
sys.stdout.write(str(cadena) + final)
sys.stdout.flush() | [
"def",
"out",
"(",
"cadena",
"=",
"\"\"",
",",
"final",
"=",
"\"\\n\"",
")",
":",
"sys",
".",
"stdout",
".",
"write",
"(",
"str",
"(",
"cadena",
")",
"+",
"final",
")",
"sys",
".",
"stdout",
".",
"flush",
"(",
")"
] | [
19,
0
] | [
22,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
query_kreator | (term) | return {
"version": True,
"size": 10000, # TODO: Variar para obetener mejor desempeño
"sort": [{"_score": {"order": "desc"}}],
"_source": {"excludes": []},
"stored_fields": ["*"],
"script_fields": {},
"docvalue_fields": [],
"query": {
"bool": {
"must": [
{
"query_string": {
"query": term,
"analyze_wildcard": True
}
}
],
"filter": [],
"should": [],
"must_not": []
}
},
"highlight": {
"pre_tags": [
"<em>"
],
"post_tags": [
"</em>"
],
"fields": {
"*": {}
},
"fragment_size": 2147483647
}
} | Crea la estructura para busquedas en Elasticsearch
Función encargada de devolver el objeto con los elementos
necesarios para realizar una búsqueda en Elasticsearch.
Esto beneficia la limpieza del código reemplazando una variable
estática
:param term: Consulta introducida por la usuaria desde el Frontend
:type: str
| Crea la estructura para busquedas en Elasticsearch | def query_kreator(term):
"""Crea la estructura para busquedas en Elasticsearch
Función encargada de devolver el objeto con los elementos
necesarios para realizar una búsqueda en Elasticsearch.
Esto beneficia la limpieza del código reemplazando una variable
estática
:param term: Consulta introducida por la usuaria desde el Frontend
:type: str
"""
# TODO: Refinar la estructura para busquedas
return {
"version": True,
"size": 10000, # TODO: Variar para obetener mejor desempeño
"sort": [{"_score": {"order": "desc"}}],
"_source": {"excludes": []},
"stored_fields": ["*"],
"script_fields": {},
"docvalue_fields": [],
"query": {
"bool": {
"must": [
{
"query_string": {
"query": term,
"analyze_wildcard": True
}
}
],
"filter": [],
"should": [],
"must_not": []
}
},
"highlight": {
"pre_tags": [
"<em>"
],
"post_tags": [
"</em>"
],
"fields": {
"*": {}
},
"fragment_size": 2147483647
}
} | [
"def",
"query_kreator",
"(",
"term",
")",
":",
"# TODO: Refinar la estructura para busquedas",
"return",
"{",
"\"version\"",
":",
"True",
",",
"\"size\"",
":",
"10000",
",",
"# TODO: Variar para obetener mejor desempeño",
"\"sort\"",
":",
"[",
"{",
"\"_score\"",
":",
"{",
"\"order\"",
":",
"\"desc\"",
"}",
"}",
"]",
",",
"\"_source\"",
":",
"{",
"\"excludes\"",
":",
"[",
"]",
"}",
",",
"\"stored_fields\"",
":",
"[",
"\"*\"",
"]",
",",
"\"script_fields\"",
":",
"{",
"}",
",",
"\"docvalue_fields\"",
":",
"[",
"]",
",",
"\"query\"",
":",
"{",
"\"bool\"",
":",
"{",
"\"must\"",
":",
"[",
"{",
"\"query_string\"",
":",
"{",
"\"query\"",
":",
"term",
",",
"\"analyze_wildcard\"",
":",
"True",
"}",
"}",
"]",
",",
"\"filter\"",
":",
"[",
"]",
",",
"\"should\"",
":",
"[",
"]",
",",
"\"must_not\"",
":",
"[",
"]",
"}",
"}",
",",
"\"highlight\"",
":",
"{",
"\"pre_tags\"",
":",
"[",
"\"<em>\"",
"]",
",",
"\"post_tags\"",
":",
"[",
"\"</em>\"",
"]",
",",
"\"fields\"",
":",
"{",
"\"*\"",
":",
"{",
"}",
"}",
",",
"\"fragment_size\"",
":",
"2147483647",
"}",
"}"
] | [
93,
0
] | [
140,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects.update_object | (self, obj: Object, obj_id: int, frame: int) | return True | Actualiza un objeto dada su identificador único (uid), el nuevo objeto detectado, y el
frame en el que fue visto.
:param obj: objeto detectado.
:param obj_id: identificador único del objeto.
:param frame: identificador del frame en el que fue visto.
:return: true si el objeto fue actualizado correctamente.
| Actualiza un objeto dada su identificador único (uid), el nuevo objeto detectado, y el
frame en el que fue visto. | def update_object(self, obj: Object, obj_id: int, frame: int) -> bool:
"""Actualiza un objeto dada su identificador único (uid), el nuevo objeto detectado, y el
frame en el que fue visto.
:param obj: objeto detectado.
:param obj_id: identificador único del objeto.
:param frame: identificador del frame en el que fue visto.
:return: true si el objeto fue actualizado correctamente.
"""
# Comprobar que el objeto está ya insertado.
if len(self._tracked_objects) < obj_id:
raise SimpleObjectTrackingException(f'The object uid {obj_id} is not registered.')
tracked_object = self._tracked_objects[obj_id]
tracked_object.append(frame, obj)
return True | [
"def",
"update_object",
"(",
"self",
",",
"obj",
":",
"Object",
",",
"obj_id",
":",
"int",
",",
"frame",
":",
"int",
")",
"->",
"bool",
":",
"# Comprobar que el objeto está ya insertado.",
"if",
"len",
"(",
"self",
".",
"_tracked_objects",
")",
"<",
"obj_id",
":",
"raise",
"SimpleObjectTrackingException",
"(",
"f'The object uid {obj_id} is not registered.'",
")",
"tracked_object",
"=",
"self",
".",
"_tracked_objects",
"[",
"obj_id",
"]",
"tracked_object",
".",
"append",
"(",
"frame",
",",
"obj",
")",
"return",
"True"
] | [
217,
4
] | [
231,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UserCallback.change_password | (password: str, userid: int, *, cursor) | Cambiar la contraseña | Cambiar la contraseña | async def change_password(password: str, userid: int, *, cursor) -> None:
"""Cambiar la contraseña"""
logging.warning(
_("¡Cambiando la contraseña del usuario con el identificador: ID:%d!"),
userid
)
await cursor.execute(
"UPDATE users SET password=%s WHERE id = %s LIMIT 1", (password, userid)
)
logging.debug(
_("Se ha cambiado satisfactoriamente la contraseña del usuario: ID:%d"),
userid
) | [
"async",
"def",
"change_password",
"(",
"password",
":",
"str",
",",
"userid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"None",
":",
"logging",
".",
"warning",
"(",
"_",
"(",
"\"¡Cambiando la contraseña del usuario con el identificador: ID:%d!\"),",
"",
"",
"userid",
")",
"await",
"cursor",
".",
"execute",
"(",
"\"UPDATE users SET password=%s WHERE id = %s LIMIT 1\"",
",",
"(",
"password",
",",
"userid",
")",
")",
"logging",
".",
"debug",
"(",
"_",
"(",
"\"Se ha cambiado satisfactoriamente la contraseña del usuario: ID:%d\")",
",",
"",
"userid",
")"
] | [
134,
4
] | [
152,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner._plural_entity_level | (entity_level) | return entity_level | Pluraliza el nombre de una unidad territorial.
Args:
entity_level (str): Nivel de la unidad territorial a pluralizar.
Return:
entity_level (str): Nombre pluralizado.
| Pluraliza el nombre de una unidad territorial. | def _plural_entity_level(entity_level):
"""Pluraliza el nombre de una unidad territorial.
Args:
entity_level (str): Nivel de la unidad territorial a pluralizar.
Return:
entity_level (str): Nombre pluralizado.
"""
if LOC not in entity_level:
entity_level = entity_level + 's'
else:
entity_level = entity_level + 'es'
return entity_level | [
"def",
"_plural_entity_level",
"(",
"entity_level",
")",
":",
"if",
"LOC",
"not",
"in",
"entity_level",
":",
"entity_level",
"=",
"entity_level",
"+",
"'s'",
"else",
":",
"entity_level",
"=",
"entity_level",
"+",
"'es'",
"return",
"entity_level"
] | [
983,
4
] | [
996,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
etiqueta_RIIA | (word) | Etiquetar palabras completas con cadenas posibles | Etiquetar palabras completas con cadenas posibles | def etiqueta_RIIA(word):
"""Etiquetar palabras completas con cadenas posibles"""
try:
expr = re.compile(".*{0}.*".format(word))
busca_coincidencia = lambda lista, expr: list(filter(lambda x: expr.match(x), lista))
newtag = []
for optiontag, lista in zip(["per", "per", "pla", "org"] , [listProsecuted, listcivilservs, listplaces, listorgs]):
if any(busca_coincidencia(lista, expr)) and optiontag not in newtag:
newtag.append(optiontag)
if len(newtag) == 0:
newtag = ["dato"]
except Exception as error:
print(error)
print("Causada por:", word)
newtag = ["Err"]
finally:
return "".join(newtag) | [
"def",
"etiqueta_RIIA",
"(",
"word",
")",
":",
"try",
":",
"expr",
"=",
"re",
".",
"compile",
"(",
"\".*{0}.*\"",
".",
"format",
"(",
"word",
")",
")",
"busca_coincidencia",
"=",
"lambda",
"lista",
",",
"expr",
":",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"expr",
".",
"match",
"(",
"x",
")",
",",
"lista",
")",
")",
"newtag",
"=",
"[",
"]",
"for",
"optiontag",
",",
"lista",
"in",
"zip",
"(",
"[",
"\"per\"",
",",
"\"per\"",
",",
"\"pla\"",
",",
"\"org\"",
"]",
",",
"[",
"listProsecuted",
",",
"listcivilservs",
",",
"listplaces",
",",
"listorgs",
"]",
")",
":",
"if",
"any",
"(",
"busca_coincidencia",
"(",
"lista",
",",
"expr",
")",
")",
"and",
"optiontag",
"not",
"in",
"newtag",
":",
"newtag",
".",
"append",
"(",
"optiontag",
")",
"if",
"len",
"(",
"newtag",
")",
"==",
"0",
":",
"newtag",
"=",
"[",
"\"dato\"",
"]",
"except",
"Exception",
"as",
"error",
":",
"print",
"(",
"error",
")",
"print",
"(",
"\"Causada por:\"",
",",
"word",
")",
"newtag",
"=",
"[",
"\"Err\"",
"]",
"finally",
":",
"return",
"\"\"",
".",
"join",
"(",
"newtag",
")"
] | [
32,
0
] | [
48,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
prob_E | (priori_H, prob_E_dado_H, prob_E_no_dado_H) | return (priori_H * prob_E_dado_H) + (no_priori_H * prob_E_no_dado_H) | Función que regresa la probabilidad de la evidencia.
Variables de entrada:
- priori_H = probabidad de la hipótesis
- prob_E_dado_H = probabidad de la evidencia dada la hipótesis
- prob_E_no_dado_H = probabilidad de la evidencia no dada la hipótesis
return (priori_H * prob_E_dado_H) + (no_priori_H * prob_E_no_dado_H)
| Función que regresa la probabilidad de la evidencia. | def prob_E(priori_H, prob_E_dado_H, prob_E_no_dado_H):
'''Función que regresa la probabilidad de la evidencia.
Variables de entrada:
- priori_H = probabidad de la hipótesis
- prob_E_dado_H = probabidad de la evidencia dada la hipótesis
- prob_E_no_dado_H = probabilidad de la evidencia no dada la hipótesis
return (priori_H * prob_E_dado_H) + (no_priori_H * prob_E_no_dado_H)
'''
no_priori_H = 1 - priori_H
return (priori_H * prob_E_dado_H) + (no_priori_H * prob_E_no_dado_H) | [
"def",
"prob_E",
"(",
"priori_H",
",",
"prob_E_dado_H",
",",
"prob_E_no_dado_H",
")",
":",
"no_priori_H",
"=",
"1",
"-",
"priori_H",
"return",
"(",
"priori_H",
"*",
"prob_E_dado_H",
")",
"+",
"(",
"no_priori_H",
"*",
"prob_E_no_dado_H",
")"
] | [
13,
0
] | [
24,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObject.remove_outliers | (self) | Elimina los valores extraños en las estimaciones.
TODO
:return:
| Elimina los valores extraños en las estimaciones. | def remove_outliers(self):
"""Elimina los valores extraños en las estimaciones.
TODO
:return:
""" | [
"def",
"remove_outliers",
"(",
"self",
")",
":"
] | [
146,
4
] | [
152,
11
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Lines._remove_ys | (self, event) | Remove a y. | Remove a y. | def _remove_ys(self, event):
"Remove a y."
# Update title and y_label when removing a y
if self._control_y_label:
self.y_label = self._default_y_label()
if self._control_title:
self.title = self._default_title()
y = event.item
for artist in self._ys_to_artists.pop(y):
artist.axes.discard(artist) | [
"def",
"_remove_ys",
"(",
"self",
",",
"event",
")",
":",
"# Update title and y_label when removing a y",
"if",
"self",
".",
"_control_y_label",
":",
"self",
".",
"y_label",
"=",
"self",
".",
"_default_y_label",
"(",
")",
"if",
"self",
".",
"_control_title",
":",
"self",
".",
"title",
"=",
"self",
".",
"_default_title",
"(",
")",
"y",
"=",
"event",
".",
"item",
"for",
"artist",
"in",
"self",
".",
"_ys_to_artists",
".",
"pop",
"(",
"y",
")",
":",
"artist",
".",
"axes",
".",
"discard",
"(",
"artist",
")"
] | [
296,
4
] | [
305,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UserProfileSerializer.create | (self, validated_data) | return user | Crea y retorna un nuevo usuario | Crea y retorna un nuevo usuario | def create(self, validated_data):
"""Crea y retorna un nuevo usuario"""
user = models.UserProfile.objects.create_user(
email=validated_data['email'],
name=validated_data['name'],
password=validated_data['password']
)
return user | [
"def",
"create",
"(",
"self",
",",
"validated_data",
")",
":",
"user",
"=",
"models",
".",
"UserProfile",
".",
"objects",
".",
"create_user",
"(",
"email",
"=",
"validated_data",
"[",
"'email'",
"]",
",",
"name",
"=",
"validated_data",
"[",
"'name'",
"]",
",",
"password",
"=",
"validated_data",
"[",
"'password'",
"]",
")",
"return",
"user"
] | [
22,
4
] | [
29,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_PROPIETARIO_4 | (t) | PROPIETARIO : owner cadena
| PROPIETARIO : owner cadena
| def p_PROPIETARIO_4(t):
'''PROPIETARIO : owner cadena
'''
t[0] = 'owner \'' + str(t[2]) + '\''
listaBNF.append("PROPIETARIO ::= owner " + str(t[2])) | [
"def",
"p_PROPIETARIO_4",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"'owner \\''",
"+",
"str",
"(",
"t",
"[",
"2",
"]",
")",
"+",
"'\\''",
"listaBNF",
".",
"append",
"(",
"\"PROPIETARIO ::= owner \"",
"+",
"str",
"(",
"t",
"[",
"2",
"]",
")",
")"
] | [
1258,
0
] | [
1262,
57
] | 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.