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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
recortar_nombres | (nombres: List[str]) | return [nombre[:n] for nombre in nombres] | Recorta los nombres de la lista a la longitud de la última
cadena de caracteres.
:param nombres: Lista de cadenas de caracteres.
:nombres type: List[str]
:return: Lista de cadenas de caracteres recortadas.
:rtype: List[str]
| Recorta los nombres de la lista a la longitud de la última
cadena de caracteres. | def recortar_nombres(nombres: List[str]) -> List[str]:
"""Recorta los nombres de la lista a la longitud de la última
cadena de caracteres.
:param nombres: Lista de cadenas de caracteres.
:nombres type: List[str]
:return: Lista de cadenas de caracteres recortadas.
:rtype: List[str]
"""
n = len(nombres[-1])
return [nombre[:n] for nombre in nombres] | [
"def",
"recortar_nombres",
"(",
"nombres",
":",
"List",
"[",
"str",
"]",
")",
"->",
"List",
"[",
"str",
"]",
":",
"n",
"=",
"len",
"(",
"nombres",
"[",
"-",
"1",
"]",
")",
"return",
"[",
"nombre",
"[",
":",
"n",
"]",
"for",
"nombre",
"in",
"nombres",
"]"
] | [
14,
0
] | [
24,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_condicionhavingagregacion | (t) | condicionhavingagregacion : agregacion PARIZQ cualquieridentificador PARDER | condicionhavingagregacion : agregacion PARIZQ cualquieridentificador PARDER | def p_condicionhavingagregacion(t):
'condicionhavingagregacion : agregacion PARIZQ cualquieridentificador PARDER'
gramatica = '<expresionhaving> ::= <condicionhavingagregacion>'
gramatica += '<condicionhavingagregacion> ::= <agregacion> \"PARIZQ\" <cualquieridentificador> \"PARDER\"'
t[0] = Nodo('Agregacion', t[1], [t[3]], t.lexer.lineno, 0, gramatica) | [
"def",
"p_condicionhavingagregacion",
"(",
"t",
")",
":",
"gramatica",
"=",
"'<expresionhaving> ::= <condicionhavingagregacion>'",
"gramatica",
"+=",
"'<condicionhavingagregacion> ::= <agregacion> \\\"PARIZQ\\\" <cualquieridentificador> \\\"PARDER\\\"'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'Agregacion'",
",",
"t",
"[",
"1",
"]",
",",
"[",
"t",
"[",
"3",
"]",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"gramatica",
")"
] | [
1046,
0
] | [
1050,
73
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
grado | (p: int) | return len(p)-1 | Calcula el grado de un polinomio
:param p: polinomio
:p type: list
:return: grado del polinomio
:rtype: int
| Calcula el grado de un polinomio
:param p: polinomio
:p type: list
:return: grado del polinomio
:rtype: int
| def grado(p: int) -> int:
"""Calcula el grado de un polinomio
:param p: polinomio
:p type: list
:return: grado del polinomio
:rtype: int
"""
return len(p)-1 | [
"def",
"grado",
"(",
"p",
":",
"int",
")",
"->",
"int",
":",
"return",
"len",
"(",
"p",
")",
"-",
"1"
] | [
6,
0
] | [
14,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones_extras | (t) | funciones_extras : math_functions
| trigonometricas
| binary_string | funciones_extras : math_functions
| trigonometricas
| binary_string | def p_funciones_extras(t):
'''funciones_extras : math_functions
| trigonometricas
| binary_string''' | [
"def",
"p_funciones_extras",
"(",
"t",
")",
":"
] | [
399,
0
] | [
402,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get | (
apiclient: ApiClient,
cust_id: str,
) | Permite obtener los datos de un cliente en base a su customerId. | Permite obtener los datos de un cliente en base a su customerId. | def get(
apiclient: ApiClient,
cust_id: str,
) -> Union[Customer, Error]:
"""Permite obtener los datos de un cliente en base a su customerId."""
url = f"{apiclient.api_url}/customer/get"
params: Dict[str, Any] = {"apiKey": apiclient.api_key, "customerId": cust_id}
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 Customer.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",
"get",
"(",
"apiclient",
":",
"ApiClient",
",",
"cust_id",
":",
"str",
",",
")",
"->",
"Union",
"[",
"Customer",
",",
"Error",
"]",
":",
"url",
"=",
"f\"{apiclient.api_url}/customer/get\"",
"params",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"{",
"\"apiKey\"",
":",
"apiclient",
".",
"api_key",
",",
"\"customerId\"",
":",
"cust_id",
"}",
"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",
"Customer",
".",
"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",
")"
] | [
99,
0
] | [
119,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
load_model_in_gpu | (IAModel) | return detect_fn | Función para cargar el modelo de IA en la GPU
Parameters
----------
IAModel: str
Ruta al directorio del modelo
Returns
-------
function
Función de detección del modelo
| Función para cargar el modelo de IA en la GPU | def load_model_in_gpu(IAModel):
"""Función para cargar el modelo de IA en la GPU
Parameters
----------
IAModel: str
Ruta al directorio del modelo
Returns
-------
function
Función de detección del modelo
"""
# Cargamos el fichero de configuración
pipeline_config = os.path.join(IAModel, 'model.config')
# Reservamos espacio en la gpu para el modelo
gpus = tf.config.experimental.list_physical_devices('GPU')
if gpus:
try:
tf.config.experimental.set_virtual_device_configuration(gpus[0], [
tf.config.experimental.VirtualDeviceConfiguration(memory_limit=6144)])
except RuntimeError as e:
print(e)
# Cargamos archivos de configuración del modelo
from object_detection.utils import config_util
from object_detection.builders import model_builder
configs = config_util.get_configs_from_pipeline_file(pipeline_config)
model_config = configs['model']
detection_model = model_builder.build(model_config=model_config, is_training=False)
# Restauramos el ckpt
ckpt = tf.compat.v2.train.Checkpoint(model=detection_model)
ckpt.restore(os.path.join(IAModel, 'ckpt-0')).expect_partial()
def get_model_detection_function(model):
"""Get a tf.function for detection."""
@tf.function
def detect_fn(image):
"""Detect objects in image."""
image, shapes = model.preprocess(image)
prediction_dict = model.predict(image, shapes)
detections = model.postprocess(prediction_dict, shapes)
return detections, prediction_dict, tf.reshape(shapes, [-1])
return detect_fn
detect_fn = get_model_detection_function(detection_model)
return detect_fn | [
"def",
"load_model_in_gpu",
"(",
"IAModel",
")",
":",
"# Cargamos el fichero de configuración",
"pipeline_config",
"=",
"os",
".",
"path",
".",
"join",
"(",
"IAModel",
",",
"'model.config'",
")",
"# Reservamos espacio en la gpu para el modelo",
"gpus",
"=",
"tf",
".",
"config",
".",
"experimental",
".",
"list_physical_devices",
"(",
"'GPU'",
")",
"if",
"gpus",
":",
"try",
":",
"tf",
".",
"config",
".",
"experimental",
".",
"set_virtual_device_configuration",
"(",
"gpus",
"[",
"0",
"]",
",",
"[",
"tf",
".",
"config",
".",
"experimental",
".",
"VirtualDeviceConfiguration",
"(",
"memory_limit",
"=",
"6144",
")",
"]",
")",
"except",
"RuntimeError",
"as",
"e",
":",
"print",
"(",
"e",
")",
"# Cargamos archivos de configuración del modelo",
"from",
"object_detection",
".",
"utils",
"import",
"config_util",
"from",
"object_detection",
".",
"builders",
"import",
"model_builder",
"configs",
"=",
"config_util",
".",
"get_configs_from_pipeline_file",
"(",
"pipeline_config",
")",
"model_config",
"=",
"configs",
"[",
"'model'",
"]",
"detection_model",
"=",
"model_builder",
".",
"build",
"(",
"model_config",
"=",
"model_config",
",",
"is_training",
"=",
"False",
")",
"# Restauramos el ckpt",
"ckpt",
"=",
"tf",
".",
"compat",
".",
"v2",
".",
"train",
".",
"Checkpoint",
"(",
"model",
"=",
"detection_model",
")",
"ckpt",
".",
"restore",
"(",
"os",
".",
"path",
".",
"join",
"(",
"IAModel",
",",
"'ckpt-0'",
")",
")",
".",
"expect_partial",
"(",
")",
"def",
"get_model_detection_function",
"(",
"model",
")",
":",
"\"\"\"Get a tf.function for detection.\"\"\"",
"@",
"tf",
".",
"function",
"def",
"detect_fn",
"(",
"image",
")",
":",
"\"\"\"Detect objects in image.\"\"\"",
"image",
",",
"shapes",
"=",
"model",
".",
"preprocess",
"(",
"image",
")",
"prediction_dict",
"=",
"model",
".",
"predict",
"(",
"image",
",",
"shapes",
")",
"detections",
"=",
"model",
".",
"postprocess",
"(",
"prediction_dict",
",",
"shapes",
")",
"return",
"detections",
",",
"prediction_dict",
",",
"tf",
".",
"reshape",
"(",
"shapes",
",",
"[",
"-",
"1",
"]",
")",
"return",
"detect_fn",
"detect_fn",
"=",
"get_model_detection_function",
"(",
"detection_model",
")",
"return",
"detect_fn"
] | [
8,
0
] | [
63,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
s3_status | (bot: DeltaBot, payload: str, message: Message, replies: Replies) | Muestra el estado de tu descarga. | Muestra el estado de tu descarga. | def s3_status(bot: DeltaBot, payload: str, message: Message, replies: Replies) -> None:
"""Muestra el estado de tu descarga."""
addr = message.get_sender_contact().addr
in_queue = addr in petitions
d = None
for download in list(downloading):
if download.addr == addr:
d = download
break
if d and d.parts:
step = max(int(d.step), 0)
percent = step / d.parts
progress = ("🟩" * round(10 * percent)).ljust(10, "⬜")
text = f"⬆️ Tu petición se está subiendo...\n\n{progress}\n**{step}/{d.parts} ({d.size//1024:,}KB)**"
elif d:
text = f"⬇️ Tu petición se está descargando..."
elif in_queue:
text = "⏳ Tu petición está pendiente en cola, espera tu turno."
else:
text = "❌ No tienes ninguna petición pendiente en cola."
replies.add(text=text) | [
"def",
"s3_status",
"(",
"bot",
":",
"DeltaBot",
",",
"payload",
":",
"str",
",",
"message",
":",
"Message",
",",
"replies",
":",
"Replies",
")",
"->",
"None",
":",
"addr",
"=",
"message",
".",
"get_sender_contact",
"(",
")",
".",
"addr",
"in_queue",
"=",
"addr",
"in",
"petitions",
"d",
"=",
"None",
"for",
"download",
"in",
"list",
"(",
"downloading",
")",
":",
"if",
"download",
".",
"addr",
"==",
"addr",
":",
"d",
"=",
"download",
"break",
"if",
"d",
"and",
"d",
".",
"parts",
":",
"step",
"=",
"max",
"(",
"int",
"(",
"d",
".",
"step",
")",
",",
"0",
")",
"percent",
"=",
"step",
"/",
"d",
".",
"parts",
"progress",
"=",
"(",
"\"🟩\" * ",
"o",
"nd(10",
" ",
"* ",
"e",
"cent)).",
"l",
"j",
"u",
"st(10",
",",
" \"",
"⬜",
")",
"",
"text",
"=",
"f\"⬆️ Tu petición se está subiendo...\\n\\n{progress}\\n**{step}/{d.parts} ({d.size//1024:,}KB)**\"",
"elif",
"d",
":",
"text",
"=",
"f\"⬇️ Tu petición se está descargando...\"",
"elif",
"in_queue",
":",
"text",
"=",
"\"⏳ Tu petición está pendiente en cola, espera tu turno.\"",
"else",
":",
"text",
"=",
"\"❌ No tienes ninguna petición pendiente en cola.\"",
"replies",
".",
"add",
"(",
"text",
"=",
"text",
")"
] | [
176,
0
] | [
196,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solver | (alumnos: List[str]) | return [s[0] for s in alumnos] | Devuelve las iniciales de cada nombre.
:param alumnos: Lista de nombres de alumnos
:alumnos type: List[str]
:return: Lista con las iniciales de cada nombre
:return type: List[str]
| Devuelve las iniciales de cada nombre. | def solver(alumnos: List[str]) -> List[str]:
"""Devuelve las iniciales de cada nombre.
:param alumnos: Lista de nombres de alumnos
:alumnos type: List[str]
:return: Lista con las iniciales de cada nombre
:return type: List[str]
"""
return [s[0] for s in alumnos] | [
"def",
"solver",
"(",
"alumnos",
":",
"List",
"[",
"str",
"]",
")",
"->",
"List",
"[",
"str",
"]",
":",
"return",
"[",
"s",
"[",
"0",
"]",
"for",
"s",
"in",
"alumnos",
"]"
] | [
21,
0
] | [
29,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_lista_condicion_salida | (t) | condiciones : condicion | condiciones : condicion | def p_lista_condicion_salida(t) :
'condiciones : condicion'
t[1].gramatica = '<condiciones> ::= <condicion>\n' + t[1].gramatica
t[0] = t[1] | [
"def",
"p_lista_condicion_salida",
"(",
"t",
")",
":",
"t",
"[",
"1",
"]",
".",
"gramatica",
"=",
"'<condiciones> ::= <condicion>\\n'",
"+",
"t",
"[",
"1",
"]",
".",
"gramatica",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
1120,
0
] | [
1123,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
_descuento | (cantidad: int, total: float) | return 0 | Calcula el descuento a aplicar. Si la cantidad de helados es
mayor a 7, el descuento es del 10% de lo que se compro; de lo
contrario no se aplica descuento.
:param cantidad: Cantidad de helados
:type cantidad: int
:param total: Total de la compra
:type total: float
:return: Descuento a aplicar
:rtype: float
| Calcula el descuento a aplicar. Si la cantidad de helados es
mayor a 7, el descuento es del 10% de lo que se compro; de lo
contrario no se aplica descuento.
:param cantidad: Cantidad de helados
:type cantidad: int
:param total: Total de la compra
:type total: float
:return: Descuento a aplicar
:rtype: float
| def _descuento(cantidad: int, total: float) -> float:
"""Calcula el descuento a aplicar. Si la cantidad de helados es
mayor a 7, el descuento es del 10% de lo que se compro; de lo
contrario no se aplica descuento.
:param cantidad: Cantidad de helados
:type cantidad: int
:param total: Total de la compra
:type total: float
:return: Descuento a aplicar
:rtype: float
"""
if cantidad >= 7:
return total * 0.1
return 0 | [
"def",
"_descuento",
"(",
"cantidad",
":",
"int",
",",
"total",
":",
"float",
")",
"->",
"float",
":",
"if",
"cantidad",
">=",
"7",
":",
"return",
"total",
"*",
"0.1",
"return",
"0"
] | [
25,
0
] | [
39,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
custom_cleaning_before_rules | (dc) | Script de limpieza custom para aplicar al objeto antes de las reglas.
Args:
dc (DataCleaner): Objeto data cleaner con datos cargados.
| Script de limpieza custom para aplicar al objeto antes de las reglas. | def custom_cleaning_before_rules(dc):
"""Script de limpieza custom para aplicar al objeto antes de las reglas.
Args:
dc (DataCleaner): Objeto data cleaner con datos cargados.
"""
pass | [
"def",
"custom_cleaning_before_rules",
"(",
"dc",
")",
":",
"pass"
] | [
49,
0
] | [
55,
8
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_parametro_fun | (t) | lista_parametros_funciones : valor_dato | lista_parametros_funciones : valor_dato | def p_instrucciones_parametro_fun(t) :
'lista_parametros_funciones : valor_dato '
t[0] = [t[1]]
gramatica = " | <valor_dato>"
no_terminal = ["<valor_dato>"]
terminal = []
reg_gramatical = "\nlista_parametros_funciones = [valor_dato]"
gramatical.agregarGramatical(gramatica,reg_gramatical,terminal,no_terminal,"lista_parametros_funciones") | [
"def",
"p_instrucciones_parametro_fun",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]",
"gramatica",
"=",
"\"\t\t\t\t\t\t\t\t| <valor_dato>\"",
"no_terminal",
"=",
"[",
"\"<valor_dato>\"",
"]",
"terminal",
"=",
"[",
"]",
"reg_gramatical",
"=",
"\"\\nlista_parametros_funciones = [valor_dato]\"",
"gramatical",
".",
"agregarGramatical",
"(",
"gramatica",
",",
"reg_gramatical",
",",
"terminal",
",",
"no_terminal",
",",
"\"lista_parametros_funciones\"",
")"
] | [
1625,
0
] | [
1632,
108
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
activar_usuario | (user_id) | return redirect(url_for("usuario", id_usuario=user_id)) | Estable el usuario como activo y redirecciona a la vista dada. | Estable el usuario como activo y redirecciona a la vista dada. | def activar_usuario(user_id):
"""Estable el usuario como activo y redirecciona a la vista dada."""
perfil_usuario = Usuario.query.filter_by(usuario=user_id).first()
perfil_usuario.activo = True
database.session.add(perfil_usuario)
database.session.commit()
return redirect(url_for("usuario", id_usuario=user_id)) | [
"def",
"activar_usuario",
"(",
"user_id",
")",
":",
"perfil_usuario",
"=",
"Usuario",
".",
"query",
".",
"filter_by",
"(",
"usuario",
"=",
"user_id",
")",
".",
"first",
"(",
")",
"perfil_usuario",
".",
"activo",
"=",
"True",
"database",
".",
"session",
".",
"add",
"(",
"perfil_usuario",
")",
"database",
".",
"session",
".",
"commit",
"(",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"\"usuario\"",
",",
"id_usuario",
"=",
"user_id",
")",
")"
] | [
826,
0
] | [
832,
59
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ethnologue_data | (request, iso_variant) | **Búsca información de la variante en Ethnologue**
Trae la información de la página de la variante de Ethnologue. Se scrappea
con ``BeautifulSoup``. Posteriormente se cra una tabla html con la función
``ethno_table_maker``.
:param request: Objeto ``HttpRequet`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:paran iso_variant: ISO de la variante
:type: str
:return: ``Html`` con la información disponible de *Ethnologue*
:rtype: str
| **Búsca información de la variante en Ethnologue** | def ethnologue_data(request, iso_variant):
"""**Búsca información de la variante en Ethnologue**
Trae la información de la página de la variante de Ethnologue. Se scrappea
con ``BeautifulSoup``. Posteriormente se cra una tabla html con la función
``ethno_table_maker``.
:param request: Objeto ``HttpRequet`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:paran iso_variant: ISO de la variante
:type: str
:return: ``Html`` con la información disponible de *Ethnologue*
:rtype: str
"""
LOGGER.info("Obteniendo información de Ethnologue")
try:
r = requests.get(f'https://www.ethnologue.com/language/{iso_variant}')
if r.status_code != 404:
html_doc = r.text
soup = BeautifulSoup(html_doc, 'html.parser')
return HttpResponse(ethno_table_maker(soup))
else:
return HttpResponse(f"<h3>No se encontraron datos :(</h3>")
except requests.exceptions.ConnectionError as e:
LOGGER.error("Error de conexión a Ethnologue::{}".format(e.request.body))
LOGGER.error("Url Ethnologue::" + e.request.url)
return HttpResponse("<h1>404 :(</h1>") | [
"def",
"ethnologue_data",
"(",
"request",
",",
"iso_variant",
")",
":",
"LOGGER",
".",
"info",
"(",
"\"Obteniendo información de Ethnologue\")",
"",
"try",
":",
"r",
"=",
"requests",
".",
"get",
"(",
"f'https://www.ethnologue.com/language/{iso_variant}'",
")",
"if",
"r",
".",
"status_code",
"!=",
"404",
":",
"html_doc",
"=",
"r",
".",
"text",
"soup",
"=",
"BeautifulSoup",
"(",
"html_doc",
",",
"'html.parser'",
")",
"return",
"HttpResponse",
"(",
"ethno_table_maker",
"(",
"soup",
")",
")",
"else",
":",
"return",
"HttpResponse",
"(",
"f\"<h3>No se encontraron datos :(</h3>\"",
")",
"except",
"requests",
".",
"exceptions",
".",
"ConnectionError",
"as",
"e",
":",
"LOGGER",
".",
"error",
"(",
"\"Error de conexión a Ethnologue::{}\".",
"f",
"ormat(",
"e",
".",
"r",
"equest.",
"b",
"ody)",
")",
"",
"LOGGER",
".",
"error",
"(",
"\"Url Ethnologue::\"",
"+",
"e",
".",
"request",
".",
"url",
")",
"return",
"HttpResponse",
"(",
"\"<h1>404 :(</h1>\"",
")"
] | [
133,
0
] | [
160,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solucion_b | (fuente: str, analizador: dict) | return "".join(
[analizador[x + y] for x, y in zip(fuente[::2], fuente[1::2])
if x+y in analizador]
) | Reemplaza pares de caracteres si son encontrados en el
analizador.
:param fuente: Texto fuente
:fuente type: str
:param analizador: Mapeo de caracteres a reemplazar
:analizador type: dict
:returns: Texto modificado
:rtype: str
.. Nota:
x: caracter en posicion impar del texto fuente
y: caracter en posicion par del texto fuente
| Reemplaza pares de caracteres si son encontrados en el
analizador. | def solucion_b(fuente: str, analizador: dict) -> str:
"""Reemplaza pares de caracteres si son encontrados en el
analizador.
:param fuente: Texto fuente
:fuente type: str
:param analizador: Mapeo de caracteres a reemplazar
:analizador type: dict
:returns: Texto modificado
:rtype: str
.. Nota:
x: caracter en posicion impar del texto fuente
y: caracter en posicion par del texto fuente
"""
return "".join(
[analizador[x + y] for x, y in zip(fuente[::2], fuente[1::2])
if x+y in analizador]
) | [
"def",
"solucion_b",
"(",
"fuente",
":",
"str",
",",
"analizador",
":",
"dict",
")",
"->",
"str",
":",
"return",
"\"\"",
".",
"join",
"(",
"[",
"analizador",
"[",
"x",
"+",
"y",
"]",
"for",
"x",
",",
"y",
"in",
"zip",
"(",
"fuente",
"[",
":",
":",
"2",
"]",
",",
"fuente",
"[",
"1",
":",
":",
"2",
"]",
")",
"if",
"x",
"+",
"y",
"in",
"analizador",
"]",
")"
] | [
43,
0
] | [
61,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
InitSession.destination | (self) | return self._pk_dst._public_key | La clave pública del destinatario | La clave pública del destinatario | def destination(self) -> bytes:
"""La clave pública del destinatario"""
return self._pk_dst._public_key | [
"def",
"destination",
"(",
"self",
")",
"->",
"bytes",
":",
"return",
"self",
".",
"_pk_dst",
".",
"_public_key"
] | [
88,
4
] | [
91,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_columna_2 | (p) | columna : ID tipo listaOpciones | columna : ID tipo listaOpciones | def p_columna_2(p):
'columna : ID tipo listaOpciones' | [
"def",
"p_columna_2",
"(",
"p",
")",
":"
] | [
689,
0
] | [
690,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TablaValores.Temp | (self) | return var | Retorna la nueva variable temporal t# y la incremeta | Retorna la nueva variable temporal t# y la incremeta | def Temp(self):
'''Retorna la nueva variable temporal t# y la incremeta'''
var = 't' + str(self.temp)
self.temp = self.temp + 1
return var | [
"def",
"Temp",
"(",
"self",
")",
":",
"var",
"=",
"'t'",
"+",
"str",
"(",
"self",
".",
"temp",
")",
"self",
".",
"temp",
"=",
"self",
".",
"temp",
"+",
"1",
"return",
"var"
] | [
5,
4
] | [
9,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
es_divisible_3_y_5 | (n: int) | return False | Comprueba si el número es divisible entre 3 y 5
:param n: Número a evaluar.
:n type: int
:return: True si es divisible entre 3 y 5, False de lo contrario
:rtype: bool
| Comprueba si el número es divisible entre 3 y 5 | def es_divisible_3_y_5(n: int) -> bool:
"""Comprueba si el número es divisible entre 3 y 5
:param n: Número a evaluar.
:n type: int
:return: True si es divisible entre 3 y 5, False de lo contrario
:rtype: bool
"""
if n % 3 == 0 and n % 5 == 0:
return True
return False | [
"def",
"es_divisible_3_y_5",
"(",
"n",
":",
"int",
")",
"->",
"bool",
":",
"if",
"n",
"%",
"3",
"==",
"0",
"and",
"n",
"%",
"5",
"==",
"0",
":",
"return",
"True",
"return",
"False"
] | [
24,
0
] | [
34,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ApiRequest.CargaJsonFichero | (self,archivo) | Lee un fichero json y lo carga en una variable
Parameters
----------
archivo: str
Fichero donde se encuentra un json
Returns
----------
json : _
objeto json con el fichero cargado
| Lee un fichero json y lo carga en una variable | def CargaJsonFichero(self,archivo):
"""Lee un fichero json y lo carga en una variable
Parameters
----------
archivo: str
Fichero donde se encuentra un json
Returns
----------
json : _
objeto json con el fichero cargado
"""
with open(archivo) as json_file:
return json.load(json_file) | [
"def",
"CargaJsonFichero",
"(",
"self",
",",
"archivo",
")",
":",
"with",
"open",
"(",
"archivo",
")",
"as",
"json_file",
":",
"return",
"json",
".",
"load",
"(",
"json_file",
")"
] | [
168,
4
] | [
182,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_con_drop | (t) | con_drop : column identificador
| constraint identificador | con_drop : column identificador
| constraint identificador | def p_con_drop(t):
'''con_drop : column identificador
| constraint identificador ''' | [
"def",
"p_con_drop",
"(",
"t",
")",
":"
] | [
156,
0
] | [
158,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
programa_formativo | (
N: int,
codigos: List[int],
M: List[int],
notas: List[List[int]],
) | Determina si se aprobó o desaprobó el Programa Formativo.
:param N: Cantidad de cursos
:type N: int
:param codigos: Códigos de los cursos.
:type codigos: List(int)
:param M: Cantidad de notas de los cursos con el código en la misma
posición.
:type M: List[int]
:param notas: Representación de las notas (matriz)
:type notas: List[List[int]]
:return: Mensaje indicando si aprobo o desaprobo. Si desaprueba, se
muestra la cantidad de cursos que se aprobo. Si existe un error
en los datos, indica el error.
:rtype: str
| Determina si se aprobó o desaprobó el Programa Formativo. | def programa_formativo(
N: int,
codigos: List[int],
M: List[int],
notas: List[List[int]],
) -> str:
"""Determina si se aprobó o desaprobó el Programa Formativo.
:param N: Cantidad de cursos
:type N: int
:param codigos: Códigos de los cursos.
:type codigos: List(int)
:param M: Cantidad de notas de los cursos con el código en la misma
posición.
:type M: List[int]
:param notas: Representación de las notas (matriz)
:type notas: List[List[int]]
:return: Mensaje indicando si aprobo o desaprobo. Si desaprueba, se
muestra la cantidad de cursos que se aprobo. Si existe un error
en los datos, indica el error.
:rtype: str
"""
if validar_numero(N):
return "Código de autodestrucción detectado." \
" Iniciando proceso en 3, 2, 1."
for m in M:
if validar_numero(m):
return "Error, no pueden existir cursos sin notas"
if validar_codigos(codigos):
return "Error, ha introducido el mismo curso 2 veces"
estado, resultado = calcular(notas, codigos)
if estado:
return "Felicitaciones. Te graduaste"
else:
return (
f"Has reprobado. Pero no te rindas, toma el Programa nuevamente."
f" Aprobaste {sum(resultado)} de los {N} cursos."
) | [
"def",
"programa_formativo",
"(",
"N",
":",
"int",
",",
"codigos",
":",
"List",
"[",
"int",
"]",
",",
"M",
":",
"List",
"[",
"int",
"]",
",",
"notas",
":",
"List",
"[",
"List",
"[",
"int",
"]",
"]",
",",
")",
"->",
"str",
":",
"if",
"validar_numero",
"(",
"N",
")",
":",
"return",
"\"Código de autodestrucción detectado.\" \\",
"\" Iniciando proceso en 3, 2, 1.\"",
"for",
"m",
"in",
"M",
":",
"if",
"validar_numero",
"(",
"m",
")",
":",
"return",
"\"Error, no pueden existir cursos sin notas\"",
"if",
"validar_codigos",
"(",
"codigos",
")",
":",
"return",
"\"Error, ha introducido el mismo curso 2 veces\"",
"estado",
",",
"resultado",
"=",
"calcular",
"(",
"notas",
",",
"codigos",
")",
"if",
"estado",
":",
"return",
"\"Felicitaciones. Te graduaste\"",
"else",
":",
"return",
"(",
"f\"Has reprobado. Pero no te rindas, toma el Programa nuevamente.\"",
"f\" Aprobaste {sum(resultado)} de los {N} cursos.\"",
")"
] | [
123,
0
] | [
160,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ingresar_datos | () | return datos | Ingresa los datos de las secciones | Ingresa los datos de las secciones | def ingresar_datos():
"""Ingresa los datos de las secciones"""
datos = {}
while True:
codigo = int_input('Ingrese el código de la sección: ')
if codigo < 0:
break
cantidad = int_input(
'Ingrese la cantidad de alumnos: ', min=MIN, max=MAX
)
datos[codigo] = cantidad
return datos | [
"def",
"ingresar_datos",
"(",
")",
":",
"datos",
"=",
"{",
"}",
"while",
"True",
":",
"codigo",
"=",
"int_input",
"(",
"'Ingrese el código de la sección: ')",
"",
"if",
"codigo",
"<",
"0",
":",
"break",
"cantidad",
"=",
"int_input",
"(",
"'Ingrese la cantidad de alumnos: '",
",",
"min",
"=",
"MIN",
",",
"max",
"=",
"MAX",
")",
"datos",
"[",
"codigo",
"]",
"=",
"cantidad",
"return",
"datos"
] | [
42,
0
] | [
53,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Usuario.has_perm | (self, perm, obj=None) | return True | ¿El usuario cuenta con los permisos en especificos? | ¿El usuario cuenta con los permisos en especificos? | def has_perm(self, perm, obj=None):
"¿El usuario cuenta con los permisos en especificos?"
return True | [
"def",
"has_perm",
"(",
"self",
",",
"perm",
",",
"obj",
"=",
"None",
")",
":",
"return",
"True"
] | [
67,
4
] | [
69,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
full_search | (request) | Endpoint para búsquedas completas de la API
Se pueden realizar búsquedas añadiendo el campo de variante a la query.
El limite de resultados es mayor al de las búsquedas básicas y los
resultados incluyen el campo de *highlight* automático. La cantidad de
request por hora y día será más amplia que en las búsquedas básicas.
| Endpoint para búsquedas completas de la API | def full_search(request):
"""Endpoint para búsquedas completas de la API
Se pueden realizar búsquedas añadiendo el campo de variante a la query.
El limite de resultados es mayor al de las búsquedas básicas y los
resultados incluyen el campo de *highlight* automático. La cantidad de
request por hora y día será más amplia que en las búsquedas básicas.
"""
user_limit = settings.API['limit_results']['user']
ip_client = get_source_ip(request)
client_type = "user"
fields = ["lang", "query", "index", "variants"]
if request.method == "POST":
entries = 0
variants = ""
data = request.data
if set(fields) - set(data.keys()) != set():
# Getting missing fields with set operation
missing_fields = set(fields) - (set(data.keys()))
return Response(
{
"detail": "Missing fields in JSON request",
"missing_fields": missing_fields,
"error": "bad_request"
}, status=status.HTTP_400_BAD_REQUEST)
if data["variants"]:
variants = " AND variant:" + variant_to_query(data["variants"])
lang = data["lang"]
# TODO: Create get_logger_msg()
LOGGER.info(f"lang:{lang}::query:{data['query']}::{ip_client}::{client_type}")
query = query_kreator(f"{lang}:{data['query']}{variants}")
try:
r = es.search(index=data['index'], body=query, scroll="1m")
data_response = r["hits"]
scroll_id = r["_scroll_id"]
total_entries = data_response["total"]["value"]
entries_count = len(data_response["hits"])
# Scroll over the index to get all entries
while entries_count != total_entries and entries_count <= user_limit:
sub_response = es.scroll(scroll_id=scroll_id, scroll="1m")
data_response["hits"] += sub_response["hits"]["hits"]
entries_count += len(sub_response["hits"]["hits"])
scroll_id = sub_response["_scroll_id"]
preprocess_data = api_data_processor(data_response, client_type,
user_limit=user_limit)
response = {"query": data["query"],
"index": data["index"],
"total_results": total_entries,
"showed_results": user_limit,
"results": preprocess_data,
}
status_code = status.HTTP_200_OK
except elasticsearch.exceptions.RequestError as e:
info = e.info['error']['root_cause'][0]
status_code = "status:" + str(e.status_code)
error_type = f"type:{info['type']}"
reason = f"reason:{info['reason']}"
index = f"index:{info['index']}"
LOGGER.error("::".join([error_type, reason, status_code, index,
ip_client, client_type]))
response = {"error": error_type,
"detail": "No se pudo concretar la búsqueda :("}
status_code = e.status_code
except elasticsearch.exceptions.ConnectionError as e:
error_type = "conection-timeout"
index_name = f"index:{settings.INDEX}"
url = f"url:{settings.URL}"
LOGGER.error("::".join([error_type, index_name, url, ip_client,
client_type]))
response = {"error": error_type,
"detail": "No se pudo conectar con el server :("}
status_code = e.status_code
except elasticsearch.exceptions.NotFoundError as e:
info = e.info['error']['root_cause'][0]
index = f"index:{data['index']}"
status_code = "status:" + str(e.status_code)
error_type = f"type:{info['type']}"
reason = f"reason:{info['reason']}"
error_type = "index_not_found"
LOGGER.error("::".join([error_type, index, ip_client,
client_type]))
response = {"error": error_type,
"detail": "No se encontró el índice de elasticsearch :("}
status_code = e.status_code
return Response(response, status=status_code) | [
"def",
"full_search",
"(",
"request",
")",
":",
"user_limit",
"=",
"settings",
".",
"API",
"[",
"'limit_results'",
"]",
"[",
"'user'",
"]",
"ip_client",
"=",
"get_source_ip",
"(",
"request",
")",
"client_type",
"=",
"\"user\"",
"fields",
"=",
"[",
"\"lang\"",
",",
"\"query\"",
",",
"\"index\"",
",",
"\"variants\"",
"]",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"entries",
"=",
"0",
"variants",
"=",
"\"\"",
"data",
"=",
"request",
".",
"data",
"if",
"set",
"(",
"fields",
")",
"-",
"set",
"(",
"data",
".",
"keys",
"(",
")",
")",
"!=",
"set",
"(",
")",
":",
"# Getting missing fields with set operation",
"missing_fields",
"=",
"set",
"(",
"fields",
")",
"-",
"(",
"set",
"(",
"data",
".",
"keys",
"(",
")",
")",
")",
"return",
"Response",
"(",
"{",
"\"detail\"",
":",
"\"Missing fields in JSON request\"",
",",
"\"missing_fields\"",
":",
"missing_fields",
",",
"\"error\"",
":",
"\"bad_request\"",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")",
"if",
"data",
"[",
"\"variants\"",
"]",
":",
"variants",
"=",
"\" AND variant:\"",
"+",
"variant_to_query",
"(",
"data",
"[",
"\"variants\"",
"]",
")",
"lang",
"=",
"data",
"[",
"\"lang\"",
"]",
"# TODO: Create get_logger_msg()",
"LOGGER",
".",
"info",
"(",
"f\"lang:{lang}::query:{data['query']}::{ip_client}::{client_type}\"",
")",
"query",
"=",
"query_kreator",
"(",
"f\"{lang}:{data['query']}{variants}\"",
")",
"try",
":",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"data",
"[",
"'index'",
"]",
",",
"body",
"=",
"query",
",",
"scroll",
"=",
"\"1m\"",
")",
"data_response",
"=",
"r",
"[",
"\"hits\"",
"]",
"scroll_id",
"=",
"r",
"[",
"\"_scroll_id\"",
"]",
"total_entries",
"=",
"data_response",
"[",
"\"total\"",
"]",
"[",
"\"value\"",
"]",
"entries_count",
"=",
"len",
"(",
"data_response",
"[",
"\"hits\"",
"]",
")",
"# Scroll over the index to get all entries",
"while",
"entries_count",
"!=",
"total_entries",
"and",
"entries_count",
"<=",
"user_limit",
":",
"sub_response",
"=",
"es",
".",
"scroll",
"(",
"scroll_id",
"=",
"scroll_id",
",",
"scroll",
"=",
"\"1m\"",
")",
"data_response",
"[",
"\"hits\"",
"]",
"+=",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
"entries_count",
"+=",
"len",
"(",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
")",
"scroll_id",
"=",
"sub_response",
"[",
"\"_scroll_id\"",
"]",
"preprocess_data",
"=",
"api_data_processor",
"(",
"data_response",
",",
"client_type",
",",
"user_limit",
"=",
"user_limit",
")",
"response",
"=",
"{",
"\"query\"",
":",
"data",
"[",
"\"query\"",
"]",
",",
"\"index\"",
":",
"data",
"[",
"\"index\"",
"]",
",",
"\"total_results\"",
":",
"total_entries",
",",
"\"showed_results\"",
":",
"user_limit",
",",
"\"results\"",
":",
"preprocess_data",
",",
"}",
"status_code",
"=",
"status",
".",
"HTTP_200_OK",
"except",
"elasticsearch",
".",
"exceptions",
".",
"RequestError",
"as",
"e",
":",
"info",
"=",
"e",
".",
"info",
"[",
"'error'",
"]",
"[",
"'root_cause'",
"]",
"[",
"0",
"]",
"status_code",
"=",
"\"status:\"",
"+",
"str",
"(",
"e",
".",
"status_code",
")",
"error_type",
"=",
"f\"type:{info['type']}\"",
"reason",
"=",
"f\"reason:{info['reason']}\"",
"index",
"=",
"f\"index:{info['index']}\"",
"LOGGER",
".",
"error",
"(",
"\"::\"",
".",
"join",
"(",
"[",
"error_type",
",",
"reason",
",",
"status_code",
",",
"index",
",",
"ip_client",
",",
"client_type",
"]",
")",
")",
"response",
"=",
"{",
"\"error\"",
":",
"error_type",
",",
"\"detail\"",
":",
"\"No se pudo concretar la búsqueda :(\"}",
"",
"status_code",
"=",
"e",
".",
"status_code",
"except",
"elasticsearch",
".",
"exceptions",
".",
"ConnectionError",
"as",
"e",
":",
"error_type",
"=",
"\"conection-timeout\"",
"index_name",
"=",
"f\"index:{settings.INDEX}\"",
"url",
"=",
"f\"url:{settings.URL}\"",
"LOGGER",
".",
"error",
"(",
"\"::\"",
".",
"join",
"(",
"[",
"error_type",
",",
"index_name",
",",
"url",
",",
"ip_client",
",",
"client_type",
"]",
")",
")",
"response",
"=",
"{",
"\"error\"",
":",
"error_type",
",",
"\"detail\"",
":",
"\"No se pudo conectar con el server :(\"",
"}",
"status_code",
"=",
"e",
".",
"status_code",
"except",
"elasticsearch",
".",
"exceptions",
".",
"NotFoundError",
"as",
"e",
":",
"info",
"=",
"e",
".",
"info",
"[",
"'error'",
"]",
"[",
"'root_cause'",
"]",
"[",
"0",
"]",
"index",
"=",
"f\"index:{data['index']}\"",
"status_code",
"=",
"\"status:\"",
"+",
"str",
"(",
"e",
".",
"status_code",
")",
"error_type",
"=",
"f\"type:{info['type']}\"",
"reason",
"=",
"f\"reason:{info['reason']}\"",
"error_type",
"=",
"\"index_not_found\"",
"LOGGER",
".",
"error",
"(",
"\"::\"",
".",
"join",
"(",
"[",
"error_type",
",",
"index",
",",
"ip_client",
",",
"client_type",
"]",
")",
")",
"response",
"=",
"{",
"\"error\"",
":",
"error_type",
",",
"\"detail\"",
":",
"\"No se encontró el índice de elasticsearch :(\"}",
"",
"status_code",
"=",
"e",
".",
"status_code",
"return",
"Response",
"(",
"response",
",",
"status",
"=",
"status_code",
")"
] | [
120,
0
] | [
204,
53
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
NDD_eval | (xi, dd, xd) | return y | Evaluar el polinomio interpolante.
Args:
dd : array
Diferencias divididas
xi : list or array
Valores donde quiero evaluar al polinomio
xd : list or array
Valores X interpolados
Returns:
y : list or array
Valores del polinomio en x
| Evaluar el polinomio interpolante. | def NDD_eval(xi, dd, xd):
"""Evaluar el polinomio interpolante.
Args:
dd : array
Diferencias divididas
xi : list or array
Valores donde quiero evaluar al polinomio
xd : list or array
Valores X interpolados
Returns:
y : list or array
Valores del polinomio en x
"""
#N = len(dd)
#print(f"P = a[{N-1}]")
#for i in range(N-2, -1, -1):
#print(f"P = a[{i}] + p*(x-x[{i}])")
N = len(dd)
y = []
for xx in xi:
p = dd[N-1]
for i in range(N-2, -1, -1):
p = dd[i] + p*(xx-xd[i])
y.append(p)
return y | [
"def",
"NDD_eval",
"(",
"xi",
",",
"dd",
",",
"xd",
")",
":",
"#N = len(dd)",
"#print(f\"P = a[{N-1}]\")",
"#for i in range(N-2, -1, -1):",
"#print(f\"P = a[{i}] + p*(x-x[{i}])\")",
"N",
"=",
"len",
"(",
"dd",
")",
"y",
"=",
"[",
"]",
"for",
"xx",
"in",
"xi",
":",
"p",
"=",
"dd",
"[",
"N",
"-",
"1",
"]",
"for",
"i",
"in",
"range",
"(",
"N",
"-",
"2",
",",
"-",
"1",
",",
"-",
"1",
")",
":",
"p",
"=",
"dd",
"[",
"i",
"]",
"+",
"p",
"*",
"(",
"xx",
"-",
"xd",
"[",
"i",
"]",
")",
"y",
".",
"append",
"(",
"p",
")",
"return",
"y"
] | [
48,
0
] | [
75,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraSmlScraperTestCase.test_sml_url_has_value | (self) | Validar que la url sea valida | Validar que la url sea valida | def test_sml_url_has_value(self):
"""Validar que la url sea valida"""
dict_config = {'sml': {'url': ''}}
with mock.patch(
'builtins.open',
return_value=io.StringIO(json.dumps(dict_config))
):
with self.assertRaises(InvalidConfigurationError):
config = read_config("config_general.json", "sml")
validate_url_has_value(config) | [
"def",
"test_sml_url_has_value",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'sml'",
":",
"{",
"'url'",
":",
"''",
"}",
"}",
"with",
"mock",
".",
"patch",
"(",
"'builtins.open'",
",",
"return_value",
"=",
"io",
".",
"StringIO",
"(",
"json",
".",
"dumps",
"(",
"dict_config",
")",
")",
")",
":",
"with",
"self",
".",
"assertRaises",
"(",
"InvalidConfigurationError",
")",
":",
"config",
"=",
"read_config",
"(",
"\"config_general.json\"",
",",
"\"sml\"",
")",
"validate_url_has_value",
"(",
"config",
")"
] | [
323,
4
] | [
334,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_cadenas | (t) | cadenastodas : cualquiercadena
| cualquieridentificador | cadenastodas : cualquiercadena
| cualquieridentificador | def p_cadenas(t):
'''cadenastodas : cualquiercadena
| cualquieridentificador'''
t[0] = t[1] | [
"def",
"p_cadenas",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
984,
0
] | [
987,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Subrayado_Decorador.render | (self) | return "<u>" + self.textodecorado.render() + "</u>" | Decora el texto agregándole las etiquetas <u></u> | Decora el texto agregándole las etiquetas <u></u> | def render(self):
"""Decora el texto agregándole las etiquetas <u></u>"""
return "<u>" + self.textodecorado.render() + "</u>" | [
"def",
"render",
"(",
"self",
")",
":",
"return",
"\"<u>\"",
"+",
"self",
".",
"textodecorado",
".",
"render",
"(",
")",
"+",
"\"</u>\""
] | [
52,
4
] | [
54,
59
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NewDomains.date_to_csvid | (self, dated) | return None | los CSVs estan enumerados. Cada fecha es un numero
1022 = 2020-12-15
del 303 pasa al 316 (?)
del 203 pasa al 312 y despues sigue con 204 (?)
NO SIRVE | los CSVs estan enumerados. Cada fecha es un numero
1022 = 2020-12-15 | def date_to_csvid(self, dated):
""" los CSVs estan enumerados. Cada fecha es un numero
1022 = 2020-12-15
del 303 pasa al 316 (?)
del 203 pasa al 312 y despues sigue con 204 (?)
NO SIRVE """
# base = date(2020, 12, 25)
# daydiff = (dated - base).days
# return 1022 + daydiff
# usar el filtro por fecha
filter_url = f'https://rdlist.nic.ar/rd_list/?date_filter={dated.strftime("%d-%m-%Y")}'
response = requests.get(filter_url)
rgx = re.search(r'/rd_list/download/(?P<csvid>[0-9]+)/csv/', response.text)
if rgx is not None:
return rgx.group('csvid')
logger.error(f'CSVID not found for {dated}')
return None | [
"def",
"date_to_csvid",
"(",
"self",
",",
"dated",
")",
":",
"# base = date(2020, 12, 25)",
"# daydiff = (dated - base).days",
"# return 1022 + daydiff",
"# usar el filtro por fecha",
"filter_url",
"=",
"f'https://rdlist.nic.ar/rd_list/?date_filter={dated.strftime(\"%d-%m-%Y\")}'",
"response",
"=",
"requests",
".",
"get",
"(",
"filter_url",
")",
"rgx",
"=",
"re",
".",
"search",
"(",
"r'/rd_list/download/(?P<csvid>[0-9]+)/csv/'",
",",
"response",
".",
"text",
")",
"if",
"rgx",
"is",
"not",
"None",
":",
"return",
"rgx",
".",
"group",
"(",
"'csvid'",
")",
"logger",
".",
"error",
"(",
"f'CSVID not found for {dated}'",
")",
"return",
"None"
] | [
80,
4
] | [
102,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
is_valid_stream | (stream: object, *, exception: bool = False) | Verifica si una función es válida
Verifica si una función es válida y contiene el método `close`,
además verifica si es invocable para proceder.
Args:
stream:
Un objeto, estilo `socket.socket()` o `open()`
exception:
Si es **True**, en caso de no ser válido el `stream` se llama una excepción
Returns:
Si `exception` es **False** se retornará un booleano. Si `stream` es válido se
retorna **True**, si no, **False**
Raises:
TypeError: Si `exception` es **True** y `stream` es inválido
| Verifica si una función es válida
Verifica si una función es válida y contiene el método `close`,
además verifica si es invocable para proceder. | def is_valid_stream(stream: object, *, exception: bool = False) -> bool:
"""Verifica si una función es válida
Verifica si una función es válida y contiene el método `close`,
además verifica si es invocable para proceder.
Args:
stream:
Un objeto, estilo `socket.socket()` o `open()`
exception:
Si es **True**, en caso de no ser válido el `stream` se llama una excepción
Returns:
Si `exception` es **False** se retornará un booleano. Si `stream` es válido se
retorna **True**, si no, **False**
Raises:
TypeError: Si `exception` es **True** y `stream` es inválido
"""
if not (hasattr(stream, "close")) or not (callable(stream.close)):
if (exception):
raise TypeError(_("'close' debe estar en el stream y debe poder ser invocado"))
else:
return False
else:
return True | [
"def",
"is_valid_stream",
"(",
"stream",
":",
"object",
",",
"*",
",",
"exception",
":",
"bool",
"=",
"False",
")",
"->",
"bool",
":",
"if",
"not",
"(",
"hasattr",
"(",
"stream",
",",
"\"close\"",
")",
")",
"or",
"not",
"(",
"callable",
"(",
"stream",
".",
"close",
")",
")",
":",
"if",
"(",
"exception",
")",
":",
"raise",
"TypeError",
"(",
"_",
"(",
"\"'close' debe estar en el stream y debe poder ser invocado\"",
")",
")",
"else",
":",
"return",
"False",
"else",
":",
"return",
"True"
] | [
9,
0
] | [
39,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_instruccion | (t) | instrucciones : instruccion
| instrucciones : instruccion
| def p_instrucciones_instruccion(t) :
'''instrucciones : instruccion
'''
t[0] = [t[1]] | [
"def",
"p_instrucciones_instruccion",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
302,
0
] | [
305,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
tagging | (phrase) | return result | Generar tags para palabras de una frase. | Generar tags para palabras de una frase. | def tagging(phrase):
"""Generar tags para palabras de una frase."""
limpiar = lambda x: re.sub("[*+/\-_\\\?\'\\\n\|]", "", x)
phrase = limpiar(phrase)
tokens = nltk.word_tokenize(phrase)
# limpiar palabras raras
norare = lambda x: re.search(r"[^a-zA-ZÀ-ÿ\d]", x) is None or len(x) > 3
# quitar stopwords
noincluir = stopwords.words("spanish")
seincluye = lambda x: ((x not in noincluir) or (x.isupper() or x.istitle())) and (norare(x))
tokens = list(filter(lambda x: seincluye(x), tokens))
tokens_low = list(map(lambda x: x.lower(), tokens))
tagged = sgt.pos_tag(tokens_low)
# filtrar los que resulten None
result = []
for (word, tag), word_unch in zip(tagged, tokens):
if (tag is None) or (tag == ""):
# compararlos con las entidades que se tienen de propuesta
newtag = etiqueta_entidades_RIIA(word, tag)
result.append((word_unch, word, newtag))
else:
result.append((word_unch, word, tag))
return result | [
"def",
"tagging",
"(",
"phrase",
")",
":",
"limpiar",
"=",
"lambda",
"x",
":",
"re",
".",
"sub",
"(",
"\"[*+/\\-_\\\\\\?\\'\\\\\\n\\|]\"",
",",
"\"\"",
",",
"x",
")",
"phrase",
"=",
"limpiar",
"(",
"phrase",
")",
"tokens",
"=",
"nltk",
".",
"word_tokenize",
"(",
"phrase",
")",
"# limpiar palabras raras",
"norare",
"=",
"lambda",
"x",
":",
"re",
".",
"search",
"(",
"r\"[^a-zA-ZÀ-ÿ\\d]\", ",
"x",
" ",
"i",
" N",
"ne o",
" l",
"n(x",
")",
" ",
">",
"3",
"",
"# quitar stopwords",
"noincluir",
"=",
"stopwords",
".",
"words",
"(",
"\"spanish\"",
")",
"seincluye",
"=",
"lambda",
"x",
":",
"(",
"(",
"x",
"not",
"in",
"noincluir",
")",
"or",
"(",
"x",
".",
"isupper",
"(",
")",
"or",
"x",
".",
"istitle",
"(",
")",
")",
")",
"and",
"(",
"norare",
"(",
"x",
")",
")",
"tokens",
"=",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"seincluye",
"(",
"x",
")",
",",
"tokens",
")",
")",
"tokens_low",
"=",
"list",
"(",
"map",
"(",
"lambda",
"x",
":",
"x",
".",
"lower",
"(",
")",
",",
"tokens",
")",
")",
"tagged",
"=",
"sgt",
".",
"pos_tag",
"(",
"tokens_low",
")",
"# filtrar los que resulten None",
"result",
"=",
"[",
"]",
"for",
"(",
"word",
",",
"tag",
")",
",",
"word_unch",
"in",
"zip",
"(",
"tagged",
",",
"tokens",
")",
":",
"if",
"(",
"tag",
"is",
"None",
")",
"or",
"(",
"tag",
"==",
"\"\"",
")",
":",
"# compararlos con las entidades que se tienen de propuesta",
"newtag",
"=",
"etiqueta_entidades_RIIA",
"(",
"word",
",",
"tag",
")",
"result",
".",
"append",
"(",
"(",
"word_unch",
",",
"word",
",",
"newtag",
")",
")",
"else",
":",
"result",
".",
"append",
"(",
"(",
"word_unch",
",",
"word",
",",
"tag",
")",
")",
"return",
"result"
] | [
76,
0
] | [
98,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationModel.get_object_point | (self, object_detection: Object) | return points[self.object_point] | Obtiene el punto del objeto especificado al instanciar la clase.
:param object_detection: detección del objeto.
:return: punto del objeto.
| Obtiene el punto del objeto especificado al instanciar la clase. | def get_object_point(self, object_detection: Object) -> Point2D:
"""Obtiene el punto del objeto especificado al instanciar la clase.
:param object_detection: detección del objeto.
:return: punto del objeto.
"""
points = {
self.ObjectPoint.CENTROID: object_detection.center,
self.ObjectPoint.TOP_LEFT_CORNER: object_detection.bounding_box[0],
self.ObjectPoint.TOP_RIGHT_CORNER: object_detection.bounding_box[1],
self.ObjectPoint.BOTTOM_RIGHT_CORNER: object_detection.bounding_box[2],
self.ObjectPoint.BOTTOM_LEFT_CORNER: object_detection.bounding_box[3]
}
return points[self.object_point] | [
"def",
"get_object_point",
"(",
"self",
",",
"object_detection",
":",
"Object",
")",
"->",
"Point2D",
":",
"points",
"=",
"{",
"self",
".",
"ObjectPoint",
".",
"CENTROID",
":",
"object_detection",
".",
"center",
",",
"self",
".",
"ObjectPoint",
".",
"TOP_LEFT_CORNER",
":",
"object_detection",
".",
"bounding_box",
"[",
"0",
"]",
",",
"self",
".",
"ObjectPoint",
".",
"TOP_RIGHT_CORNER",
":",
"object_detection",
".",
"bounding_box",
"[",
"1",
"]",
",",
"self",
".",
"ObjectPoint",
".",
"BOTTOM_RIGHT_CORNER",
":",
"object_detection",
".",
"bounding_box",
"[",
"2",
"]",
",",
"self",
".",
"ObjectPoint",
".",
"BOTTOM_LEFT_CORNER",
":",
"object_detection",
".",
"bounding_box",
"[",
"3",
"]",
"}",
"return",
"points",
"[",
"self",
".",
"object_point",
"]"
] | [
255,
4
] | [
268,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
riemann | (a: int, b: int, n: int) | return s | Calcula el area de una región de una función
en el intervalo [a, b] con n subintervalos.
| Calcula el area de una región de una función
en el intervalo [a, b] con n subintervalos.
| def riemann(a: int, b: int, n: int) -> float:
"""Calcula el area de una región de una función
en el intervalo [a, b] con n subintervalos.
"""
h = (b - a) / n
s = 0
for i in range(n):
s += f(a + i*h)*h
return s | [
"def",
"riemann",
"(",
"a",
":",
"int",
",",
"b",
":",
"int",
",",
"n",
":",
"int",
")",
"->",
"float",
":",
"h",
"=",
"(",
"b",
"-",
"a",
")",
"/",
"n",
"s",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"s",
"+=",
"f",
"(",
"a",
"+",
"i",
"*",
"h",
")",
"*",
"h",
"return",
"s"
] | [
7,
0
] | [
15,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
print_color | (text: str, color: str, message_exception: Exception = '') | Función para imprimir en la terminal en el color que le indiquen.
Args:
text (str): Recibe el texto que se va a convertir en color.
color (str): Recibe el color que al que se va a aplicar al texto.
message_exception (Exception)<-(optional): Recibe el mensaje de error que lance el script.
Returns:
str: Retorna el texto en color que hayan indicado.
| Función para imprimir en la terminal en el color que le indiquen. | def print_color(text: str, color: str, message_exception: Exception = '') -> str:
""" Función para imprimir en la terminal en el color que le indiquen.
Args:
text (str): Recibe el texto que se va a convertir en color.
color (str): Recibe el color que al que se va a aplicar al texto.
message_exception (Exception)<-(optional): Recibe el mensaje de error que lance el script.
Returns:
str: Retorna el texto en color que hayan indicado.
"""
if message_exception != '':
return f"{color}{text_bold_console}{text}: {message_exception}{color_end_console}"
else:
return f"{color}{text_bold_console}{text}{color_end_console}" | [
"def",
"print_color",
"(",
"text",
":",
"str",
",",
"color",
":",
"str",
",",
"message_exception",
":",
"Exception",
"=",
"''",
")",
"->",
"str",
":",
"if",
"message_exception",
"!=",
"''",
":",
"return",
"f\"{color}{text_bold_console}{text}: {message_exception}{color_end_console}\"",
"else",
":",
"return",
"f\"{color}{text_bold_console}{text}{color_end_console}\""
] | [
13,
0
] | [
27,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ejercicio_K_L | (df, columna) | Items K y L
K)
Divida la población en dos grupos de acuerdo con el peso entre los que
pesan menos de 70 Kg y los de peso igual o mayor. En cada grupo determine
el porcentaje de los que tienen IMC mayor que 25.
L)
Realice dos diagramas de dispersión superpuestos donde se represente PGC
en función de la variable elegida en el ítem i para los dos grupos del
ítem anterior. Represente cada serie con un símbolo diferente. Haga algún
comentario de lo que observe.
Args:
df (pandas data frame): Conjunto de datos del archivo 'grasacorp.txt'
columna (string): Encabezado de la columna con la variable de mayor
correlación con el PGC.
| Items K y L | def ejercicio_K_L(df, columna):
"""Items K y L
K)
Divida la población en dos grupos de acuerdo con el peso entre los que
pesan menos de 70 Kg y los de peso igual o mayor. En cada grupo determine
el porcentaje de los que tienen IMC mayor que 25.
L)
Realice dos diagramas de dispersión superpuestos donde se represente PGC
en función de la variable elegida en el ítem i para los dos grupos del
ítem anterior. Represente cada serie con un símbolo diferente. Haga algún
comentario de lo que observe.
Args:
df (pandas data frame): Conjunto de datos del archivo 'grasacorp.txt'
columna (string): Encabezado de la columna con la variable de mayor
correlación con el PGC.
"""
printHeader('K y L')
# Datos
pgc_all = df["PGC"].tolist()
variable_elegida_all = df[columna].tolist()
imc = df["IMC"].tolist()
peso_lb = df["Peso"]
# Convertimos el peso a kilogramos, manteniendo el número de orden (n)
peso_kg = [(n, libraKilogramo(p)) for n, p in peso_lb.iteritems()]
datos_grupo = {
'pgc': list(), # PGC de cada individuo del grupo
'var': list(), # Variable elegida
'imc>25': [int(), float()], # Cant y % de individuos con IMC > 25
}
peso_por_grupo = {
# datos_grupo es un template para crear este diccionario.
# Lo copiamos para que ambos elementos no hagan referencia a la misma
# porción en memoria (cosas de Python)
'< 70': copy.deepcopy(datos_grupo),
'>= 70': copy.deepcopy(datos_grupo),
}
for n, w in peso_kg:
if w < 70:
grupo = '< 70'
else:
grupo = '>= 70'
peso_por_grupo[grupo]['pgc'].append(pgc_all[n])
peso_por_grupo[grupo]['var'].append(variable_elegida_all[n])
if (pgc_all[n] > 25):
peso_por_grupo[grupo]['imc>25'][0] += 1
# Se calcula el porcentaje de individuos con IMC > 25, en cada grupo
for grupo, _ in peso_por_grupo.items():
peso_por_grupo[grupo]['imc>25'][1] = \
peso_por_grupo[grupo]['imc>25'][0] \
/ len(peso_por_grupo[grupo]['pgc'])
# Preparamos e imprimomos una tabla
encabezado = [
'Peso [kg]',
'Personas en\neste grupo',
'Personas con\nIMC mayor a 25',
'Proporción [%]'
]
datos_tabla = list()
for grupo, _ in peso_por_grupo.items():
datos_tabla.append(
[
grupo,
len(peso_por_grupo[grupo]['pgc']),
peso_por_grupo[grupo]['imc>25'][0],
peso_por_grupo[grupo]['imc>25'][1] * 100
]
)
printTable(encabezado, datos_tabla)
# Gráficos
# Para crear dos gráficos superpuestos, en el primero se crea una
# plt.figure y en el segundo no, de forma tal que el segundo plt.plot se
# haga sobre la misma figura que el primero.
diagrama_puntos(
peso_por_grupo['< 70']['var'],
peso_por_grupo['< 70']['pgc'],
nombre_leyenda='Peso menor a 70 kg',
crear_figure=True,
)
diagrama_puntos(
peso_por_grupo['>= 70']['var'],
peso_por_grupo['>= 70']['pgc'],
marker_color='g',
marker_style='*',
nombre_leyenda='Peso mayor o igual a 70 kg',
titulo_figura='Diagramas de dispersión',
titulo_ejes=[columna + ' [cm]', 'PGC'],
mostrar_leyenda=True,
crear_figure=False
) | [
"def",
"ejercicio_K_L",
"(",
"df",
",",
"columna",
")",
":",
"printHeader",
"(",
"'K y L'",
")",
"# Datos",
"pgc_all",
"=",
"df",
"[",
"\"PGC\"",
"]",
".",
"tolist",
"(",
")",
"variable_elegida_all",
"=",
"df",
"[",
"columna",
"]",
".",
"tolist",
"(",
")",
"imc",
"=",
"df",
"[",
"\"IMC\"",
"]",
".",
"tolist",
"(",
")",
"peso_lb",
"=",
"df",
"[",
"\"Peso\"",
"]",
"# Convertimos el peso a kilogramos, manteniendo el número de orden (n)",
"peso_kg",
"=",
"[",
"(",
"n",
",",
"libraKilogramo",
"(",
"p",
")",
")",
"for",
"n",
",",
"p",
"in",
"peso_lb",
".",
"iteritems",
"(",
")",
"]",
"datos_grupo",
"=",
"{",
"'pgc'",
":",
"list",
"(",
")",
",",
"# PGC de cada individuo del grupo",
"'var'",
":",
"list",
"(",
")",
",",
"# Variable elegida",
"'imc>25'",
":",
"[",
"int",
"(",
")",
",",
"float",
"(",
")",
"]",
",",
"# Cant y % de individuos con IMC > 25",
"}",
"peso_por_grupo",
"=",
"{",
"# datos_grupo es un template para crear este diccionario.",
"# Lo copiamos para que ambos elementos no hagan referencia a la misma",
"# porción en memoria (cosas de Python)",
"'< 70'",
":",
"copy",
".",
"deepcopy",
"(",
"datos_grupo",
")",
",",
"'>= 70'",
":",
"copy",
".",
"deepcopy",
"(",
"datos_grupo",
")",
",",
"}",
"for",
"n",
",",
"w",
"in",
"peso_kg",
":",
"if",
"w",
"<",
"70",
":",
"grupo",
"=",
"'< 70'",
"else",
":",
"grupo",
"=",
"'>= 70'",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'pgc'",
"]",
".",
"append",
"(",
"pgc_all",
"[",
"n",
"]",
")",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'var'",
"]",
".",
"append",
"(",
"variable_elegida_all",
"[",
"n",
"]",
")",
"if",
"(",
"pgc_all",
"[",
"n",
"]",
">",
"25",
")",
":",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'imc>25'",
"]",
"[",
"0",
"]",
"+=",
"1",
"# Se calcula el porcentaje de individuos con IMC > 25, en cada grupo",
"for",
"grupo",
",",
"_",
"in",
"peso_por_grupo",
".",
"items",
"(",
")",
":",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'imc>25'",
"]",
"[",
"1",
"]",
"=",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'imc>25'",
"]",
"[",
"0",
"]",
"/",
"len",
"(",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'pgc'",
"]",
")",
"# Preparamos e imprimomos una tabla",
"encabezado",
"=",
"[",
"'Peso [kg]'",
",",
"'Personas en\\neste grupo'",
",",
"'Personas con\\nIMC mayor a 25'",
",",
"'Proporción [%]'",
"]",
"datos_tabla",
"=",
"list",
"(",
")",
"for",
"grupo",
",",
"_",
"in",
"peso_por_grupo",
".",
"items",
"(",
")",
":",
"datos_tabla",
".",
"append",
"(",
"[",
"grupo",
",",
"len",
"(",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'pgc'",
"]",
")",
",",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'imc>25'",
"]",
"[",
"0",
"]",
",",
"peso_por_grupo",
"[",
"grupo",
"]",
"[",
"'imc>25'",
"]",
"[",
"1",
"]",
"*",
"100",
"]",
")",
"printTable",
"(",
"encabezado",
",",
"datos_tabla",
")",
"# Gráficos",
"# Para crear dos gráficos superpuestos, en el primero se crea una",
"# plt.figure y en el segundo no, de forma tal que el segundo plt.plot se",
"# haga sobre la misma figura que el primero.",
"diagrama_puntos",
"(",
"peso_por_grupo",
"[",
"'< 70'",
"]",
"[",
"'var'",
"]",
",",
"peso_por_grupo",
"[",
"'< 70'",
"]",
"[",
"'pgc'",
"]",
",",
"nombre_leyenda",
"=",
"'Peso menor a 70 kg'",
",",
"crear_figure",
"=",
"True",
",",
")",
"diagrama_puntos",
"(",
"peso_por_grupo",
"[",
"'>= 70'",
"]",
"[",
"'var'",
"]",
",",
"peso_por_grupo",
"[",
"'>= 70'",
"]",
"[",
"'pgc'",
"]",
",",
"marker_color",
"=",
"'g'",
",",
"marker_style",
"=",
"'*'",
",",
"nombre_leyenda",
"=",
"'Peso mayor o igual a 70 kg'",
",",
"titulo_figura",
"=",
"'Diagramas de dispersión',",
"",
"titulo_ejes",
"=",
"[",
"columna",
"+",
"' [cm]'",
",",
"'PGC'",
"]",
",",
"mostrar_leyenda",
"=",
"True",
",",
"crear_figure",
"=",
"False",
")"
] | [
822,
0
] | [
926,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
gausiana_cv | (u) | return output | La funcion a integrar luego del cambio de variable u=1/y.
| La funcion a integrar luego del cambio de variable u=1/y.
| def gausiana_cv(u):
"""La funcion a integrar luego del cambio de variable u=1/y.
"""
output = np.exp(-1/(2 * u**2)) / u**2 / np.sqrt(2*np.pi)
return output | [
"def",
"gausiana_cv",
"(",
"u",
")",
":",
"output",
"=",
"np",
".",
"exp",
"(",
"-",
"1",
"/",
"(",
"2",
"*",
"u",
"**",
"2",
")",
")",
"/",
"u",
"**",
"2",
"/",
"np",
".",
"sqrt",
"(",
"2",
"*",
"np",
".",
"pi",
")",
"return",
"output"
] | [
32,
0
] | [
36,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_aritmetica2 | (t) | aritmetica : funciones_math_esenciales
| lista_funciones
| fun_binario_select
| fun_trigonometrica | aritmetica : funciones_math_esenciales
| lista_funciones
| fun_binario_select
| fun_trigonometrica | def p_aritmetica2(t) :
'''aritmetica : funciones_math_esenciales
| lista_funciones
| fun_binario_select
| fun_trigonometrica'''
id = inc()
t[0] = {'id': id}
dot.node(str(id), 'Funciones')
for element in t[1]:
dot.edge(str(id), str(element['id'])) | [
"def",
"p_aritmetica2",
"(",
"t",
")",
":",
"id",
"=",
"inc",
"(",
")",
"t",
"[",
"0",
"]",
"=",
"{",
"'id'",
":",
"id",
"}",
"dot",
".",
"node",
"(",
"str",
"(",
"id",
")",
",",
"'Funciones'",
")",
"for",
"element",
"in",
"t",
"[",
"1",
"]",
":",
"dot",
".",
"edge",
"(",
"str",
"(",
"id",
")",
",",
"str",
"(",
"element",
"[",
"'id'",
"]",
")",
")"
] | [
1916,
0
] | [
1926,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
texto_con_swag | (string) | return string.swapcase() | Invierte el texto recibido entre mayusculas/minusculas
>>> texto_con_swag("hEY YO hOMIE")
'Hey yo Homie'
| Invierte el texto recibido entre mayusculas/minusculas
>>> texto_con_swag("hEY YO hOMIE")
'Hey yo Homie'
| def texto_con_swag(string):
"""Invierte el texto recibido entre mayusculas/minusculas
>>> texto_con_swag("hEY YO hOMIE")
'Hey yo Homie'
"""
return string.swapcase() | [
"def",
"texto_con_swag",
"(",
"string",
")",
":",
"return",
"string",
".",
"swapcase",
"(",
")"
] | [
0,
0
] | [
5,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Matrix.col | (self, i) | return self[i] | Metodo para extraer una columna determinada de la matriz. | Metodo para extraer una columna determinada de la matriz. | def col(self, i):
""" Metodo para extraer una columna determinada de la matriz. """
return self[i] | [
"def",
"col",
"(",
"self",
",",
"i",
")",
":",
"return",
"self",
"[",
"i",
"]"
] | [
113,
4
] | [
115,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Audio.OnCancel | (self, evt) | Sirve para cancel y cerrar la opcion de text | Sirve para cancel y cerrar la opcion de text | def OnCancel(self, evt):
""" Sirve para cancel y cerrar la opcion de text """
self.parent.SetPanel(None) | [
"def",
"OnCancel",
"(",
"self",
",",
"evt",
")",
":",
"self",
".",
"parent",
".",
"SetPanel",
"(",
"None",
")"
] | [
132,
4
] | [
134,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
sort_por_rango | () | return sorted(champions_in_csv(), reverse=True, key=lambda x: int(x[35])) | Campeones con mas rango | Campeones con mas rango | def sort_por_rango():
"""Campeones con mas rango"""
return sorted(champions_in_csv(), reverse=True, key=lambda x: int(x[35])) | [
"def",
"sort_por_rango",
"(",
")",
":",
"return",
"sorted",
"(",
"champions_in_csv",
"(",
")",
",",
"reverse",
"=",
"True",
",",
"key",
"=",
"lambda",
"x",
":",
"int",
"(",
"x",
"[",
"35",
"]",
")",
")"
] | [
25,
0
] | [
27,
77
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
preprocessImage | (img) | return img_prep | Función para preprocesar una imagen pasada como parámetro
Args:
img: imagen a preprocesar
Returns:
imagen preprocesada
| Función para preprocesar una imagen pasada como parámetro
Args:
img: imagen a preprocesar
Returns:
imagen preprocesada
| def preprocessImage(img):
""" Función para preprocesar una imagen pasada como parámetro
Args:
img: imagen a preprocesar
Returns:
imagen preprocesada
"""
#Referencias:
#https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaf9bba239dfca11654cb7f50f889fc2ff
x,y,w,h = boundingBox(img) #Determinamos la caja englobante del caracter en la imagen
img_prep = img[y:y+h,x:x+w] #Nos quedamos con los píxeles englobados por la caja ('recortamos' la imagen)
img_prep = cv2.resize(img_prep,RESIZE_SHAPE,interpolation=cv2.INTER_LINEAR) #Reescalamos la imagen recortada, con interpolación bilineal
#Hacemos downsampling de la imagen, para reducir el número de píxeles
if DOWNSAMPLING:
img_prep = cv2.GaussianBlur(img_prep,ksize=(3,3),sigmaX=0.5) #Aplicamos un filtro gaussiano para prevenir el aliasing, con kernel
#de tamaño 3x3, y sigma=0.5
img_prep = img_prep[1:img_prep.shape[0]:2,1:img_prep.shape[1]:2] #Eliminamos las filas y columnas pares
img_prep = np.reshape(img_prep,img_prep.size) #Pasamos la imagen a forma de vector
return img_prep | [
"def",
"preprocessImage",
"(",
"img",
")",
":",
"#Referencias:",
"#https://docs.opencv.org/master/d4/d86/group__imgproc__filter.html#gaf9bba239dfca11654cb7f50f889fc2ff",
"x",
",",
"y",
",",
"w",
",",
"h",
"=",
"boundingBox",
"(",
"img",
")",
"#Determinamos la caja englobante del caracter en la imagen",
"img_prep",
"=",
"img",
"[",
"y",
":",
"y",
"+",
"h",
",",
"x",
":",
"x",
"+",
"w",
"]",
"#Nos quedamos con los píxeles englobados por la caja ('recortamos' la imagen)",
"img_prep",
"=",
"cv2",
".",
"resize",
"(",
"img_prep",
",",
"RESIZE_SHAPE",
",",
"interpolation",
"=",
"cv2",
".",
"INTER_LINEAR",
")",
"#Reescalamos la imagen recortada, con interpolación bilineal",
"#Hacemos downsampling de la imagen, para reducir el número de píxeles",
"if",
"DOWNSAMPLING",
":",
"img_prep",
"=",
"cv2",
".",
"GaussianBlur",
"(",
"img_prep",
",",
"ksize",
"=",
"(",
"3",
",",
"3",
")",
",",
"sigmaX",
"=",
"0.5",
")",
"#Aplicamos un filtro gaussiano para prevenir el aliasing, con kernel ",
"#de tamaño 3x3, y sigma=0.5",
"img_prep",
"=",
"img_prep",
"[",
"1",
":",
"img_prep",
".",
"shape",
"[",
"0",
"]",
":",
"2",
",",
"1",
":",
"img_prep",
".",
"shape",
"[",
"1",
"]",
":",
"2",
"]",
"#Eliminamos las filas y columnas pares",
"img_prep",
"=",
"np",
".",
"reshape",
"(",
"img_prep",
",",
"img_prep",
".",
"size",
")",
"#Pasamos la imagen a forma de vector",
"return",
"img_prep"
] | [
223,
0
] | [
243,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Director.get_food | (self) | return self._builder.food | Regresa todos los ingredientes que llevará el hotdog/hamburguesa | Regresa todos los ingredientes que llevará el hotdog/hamburguesa | def get_food(self):
"""Regresa todos los ingredientes que llevará el hotdog/hamburguesa"""
return self._builder.food | [
"def",
"get_food",
"(",
"self",
")",
":",
"return",
"self",
".",
"_builder",
".",
"food"
] | [
22,
4
] | [
24,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
_exec_drop | (host=None, user=None, passwd=None, db_name=None, queries=[]) | Función encargada de eliminar 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 eliminación a ejecutar
| Función encargada de eliminar las tablas en la base de datos. | def _exec_drop(host=None, user=None, passwd=None, db_name=None, queries=[]):
"""Función encargada de eliminar 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 eliminación a ejecutar
"""
db = psycopg2.connect(
host=host,
user=user,
password=passwd,
database=db_name
)
cursor = db.cursor()
for sql in queries:
try:
cursor.execute(sql)
except psycopg2.errors.ProgrammingError as e1:
print(str(e1))
pass
except Exception as e2:
print(str(e2))
pass
db.commit()
cursor.close()
db.close() | [
"def",
"_exec_drop",
"(",
"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",
"sql",
"in",
"queries",
":",
"try",
":",
"cursor",
".",
"execute",
"(",
"sql",
")",
"except",
"psycopg2",
".",
"errors",
".",
"ProgrammingError",
"as",
"e1",
":",
"print",
"(",
"str",
"(",
"e1",
")",
")",
"pass",
"except",
"Exception",
"as",
"e2",
":",
"print",
"(",
"str",
"(",
"e2",
")",
")",
"pass",
"db",
".",
"commit",
"(",
")",
"cursor",
".",
"close",
"(",
")",
"db",
".",
"close",
"(",
")"
] | [
104,
0
] | [
139,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
s3_token | (bot: DeltaBot, message: Message, replies: Replies) | Obtén un token temporal que sirve para autenticarse en el servidor de s3 con otras apps que lo soporten. | Obtén un token temporal que sirve para autenticarse en el servidor de s3 con otras apps que lo soporten. | def s3_token(bot: DeltaBot, message: Message, replies: Replies) -> None:
"""Obtén un token temporal que sirve para autenticarse en el servidor de s3 con otras apps que lo soporten."""
acc = db.get_account(message.get_sender_contact().addr)
if acc and acc["password"]:
def task():
replies = Replies(message, logger=bot.logger)
replies.add(ToDusClient().login(acc["phone"], acc["password"]))
replies.send_reply_messages()
Thread(target=task).start()
else:
replies.add(text="❌ No estás registrado", quote=message) | [
"def",
"s3_token",
"(",
"bot",
":",
"DeltaBot",
",",
"message",
":",
"Message",
",",
"replies",
":",
"Replies",
")",
"->",
"None",
":",
"acc",
"=",
"db",
".",
"get_account",
"(",
"message",
".",
"get_sender_contact",
"(",
")",
".",
"addr",
")",
"if",
"acc",
"and",
"acc",
"[",
"\"password\"",
"]",
":",
"def",
"task",
"(",
")",
":",
"replies",
"=",
"Replies",
"(",
"message",
",",
"logger",
"=",
"bot",
".",
"logger",
")",
"replies",
".",
"add",
"(",
"ToDusClient",
"(",
")",
".",
"login",
"(",
"acc",
"[",
"\"phone\"",
"]",
",",
"acc",
"[",
"\"password\"",
"]",
")",
")",
"replies",
".",
"send_reply_messages",
"(",
")",
"Thread",
"(",
"target",
"=",
"task",
")",
".",
"start",
"(",
")",
"else",
":",
"replies",
".",
"add",
"(",
"text",
"=",
"\"❌ No estás registrado\", q",
"u",
"te=me",
"s",
"sage)",
""
] | [
259,
0
] | [
271,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
crearArreglo | (fila, columnas) | return arreglo | Funcion que crea un arreglo | Funcion que crea un arreglo | def crearArreglo(fila, columnas):
"""Funcion que crea un arreglo"""
arreglo = []
for i in range(fila):
fila = []
for j in range(columnas):
fila.append(0)
arreglo.append(fila)
return arreglo | [
"def",
"crearArreglo",
"(",
"fila",
",",
"columnas",
")",
":",
"arreglo",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"fila",
")",
":",
"fila",
"=",
"[",
"]",
"for",
"j",
"in",
"range",
"(",
"columnas",
")",
":",
"fila",
".",
"append",
"(",
"0",
")",
"arreglo",
".",
"append",
"(",
"fila",
")",
"return",
"arreglo"
] | [
39,
0
] | [
48,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instruccionesPL_lista2 | (t) | instruccionesPL : instruccion | instruccionesPL : instruccion | def p_instruccionesPL_lista2(t):
'''instruccionesPL : instruccion'''
instru = grammer.nodoGramatical('instruccionesPL')
instru.agregarDetalle('::= instruccion')
listGrammer.insert(0,instru) | [
"def",
"p_instruccionesPL_lista2",
"(",
"t",
")",
":",
"instru",
"=",
"grammer",
".",
"nodoGramatical",
"(",
"'instruccionesPL'",
")",
"instru",
".",
"agregarDetalle",
"(",
"'::= instruccion'",
")",
"listGrammer",
".",
"insert",
"(",
"0",
",",
"instru",
")"
] | [
37,
0
] | [
41,
32
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
crear_usuario | () | Crear manualmente una cuenta de usuario. | Crear manualmente una cuenta de usuario. | def crear_usuario():
"""Crear manualmente una cuenta de usuario."""
form = LogonForm()
if form.validate_on_submit() or request.method == "POST":
usuario_ = Usuario(
usuario=form.usuario.data,
acceso=proteger_passwd(form.acceso.data),
nombre=form.nombre.data,
apellido=form.apellido.data,
correo_electronico=form.correo_electronico.data,
tipo="user",
activo=False,
)
try:
database.session.add(usuario_)
database.session.commit()
flash("Usuario creado exitosamente.")
return redirect(url_for("usuario", id_usuario=form.usuario.data))
except OperationalError:
flash("Error al crear la cuenta.")
return redirect("/new_user")
else:
return render_template(
"learning/nuevo_usuario.html",
form=form,
) | [
"def",
"crear_usuario",
"(",
")",
":",
"form",
"=",
"LogonForm",
"(",
")",
"if",
"form",
".",
"validate_on_submit",
"(",
")",
"or",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"usuario_",
"=",
"Usuario",
"(",
"usuario",
"=",
"form",
".",
"usuario",
".",
"data",
",",
"acceso",
"=",
"proteger_passwd",
"(",
"form",
".",
"acceso",
".",
"data",
")",
",",
"nombre",
"=",
"form",
".",
"nombre",
".",
"data",
",",
"apellido",
"=",
"form",
".",
"apellido",
".",
"data",
",",
"correo_electronico",
"=",
"form",
".",
"correo_electronico",
".",
"data",
",",
"tipo",
"=",
"\"user\"",
",",
"activo",
"=",
"False",
",",
")",
"try",
":",
"database",
".",
"session",
".",
"add",
"(",
"usuario_",
")",
"database",
".",
"session",
".",
"commit",
"(",
")",
"flash",
"(",
"\"Usuario creado exitosamente.\"",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"\"usuario\"",
",",
"id_usuario",
"=",
"form",
".",
"usuario",
".",
"data",
")",
")",
"except",
"OperationalError",
":",
"flash",
"(",
"\"Error al crear la cuenta.\"",
")",
"return",
"redirect",
"(",
"\"/new_user\"",
")",
"else",
":",
"return",
"render_template",
"(",
"\"learning/nuevo_usuario.html\"",
",",
"form",
"=",
"form",
",",
")"
] | [
606,
0
] | [
631,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ModelBase.get_company | (self) | return self.getattr(self.COMPANY_FIELD_NAME) | Obtiene la empresa a la que pertenece este objeto. | Obtiene la empresa a la que pertenece este objeto. | def get_company(self):
"""Obtiene la empresa a la que pertenece este objeto."""
return self.getattr(self.COMPANY_FIELD_NAME) | [
"def",
"get_company",
"(",
"self",
")",
":",
"return",
"self",
".",
"getattr",
"(",
"self",
".",
"COMPANY_FIELD_NAME",
")"
] | [
99,
4
] | [
101,
52
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_declaraciones_procedure | (t) | declaraciones_procedure : DECLARE instrucciones_asignacion | declaraciones_procedure : DECLARE instrucciones_asignacion | def p_declaraciones_procedure(t):
'''declaraciones_procedure : DECLARE instrucciones_asignacion'''
t[0] = Start("DECLARACIONES_PROCEDURE")
t[0].addChild(t[2]) | [
"def",
"p_declaraciones_procedure",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"DECLARACIONES_PROCEDURE\"",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"2",
"]",
")"
] | [
1795,
0
] | [
1798,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_deep_format | (objects_detected) | return deep_object_format, cls_conf, cls_ids | Función para transformar las detecciones al formato del DeepSort.
Parameters
----------
objects_detected: list
Objectos detectados en un frame
Returns
-------
bbox_xywh: np.array
Bboxes siendo xy el centro del recuadro y wh la anchura y altura del recuadro
cls_conf: np.array
Confianza de las detecciones de los objetos detectados
cls_ids: np.array
Identificadores de los objetos detectados
| Función para transformar las detecciones al formato del DeepSort. | def get_deep_format(objects_detected):
""" Función para transformar las detecciones al formato del DeepSort.
Parameters
----------
objects_detected: list
Objectos detectados en un frame
Returns
-------
bbox_xywh: np.array
Bboxes siendo xy el centro del recuadro y wh la anchura y altura del recuadro
cls_conf: np.array
Confianza de las detecciones de los objetos detectados
cls_ids: np.array
Identificadores de los objetos detectados
"""
if len(objects_detected) == 0:
deep_object_format, cls_conf, cls_ids = np.array([]), np.array([]), None
else:
deep_object_format = objects_detected[:, 0:4] # xyxy
deep_object_format[:, 2:] -= deep_object_format[:, 0:2] # blwh
deep_object_format[:, :2] += np.asarray(deep_object_format[:, 2:]/2, dtype=int) #xywh
deep_object_format[:, 2:] *= 1.1
cls_conf = objects_detected[:, 4]
cls_ids = objects_detected[:, 5]
return deep_object_format, cls_conf, cls_ids | [
"def",
"get_deep_format",
"(",
"objects_detected",
")",
":",
"if",
"len",
"(",
"objects_detected",
")",
"==",
"0",
":",
"deep_object_format",
",",
"cls_conf",
",",
"cls_ids",
"=",
"np",
".",
"array",
"(",
"[",
"]",
")",
",",
"np",
".",
"array",
"(",
"[",
"]",
")",
",",
"None",
"else",
":",
"deep_object_format",
"=",
"objects_detected",
"[",
":",
",",
"0",
":",
"4",
"]",
"# xyxy",
"deep_object_format",
"[",
":",
",",
"2",
":",
"]",
"-=",
"deep_object_format",
"[",
":",
",",
"0",
":",
"2",
"]",
"# blwh",
"deep_object_format",
"[",
":",
",",
":",
"2",
"]",
"+=",
"np",
".",
"asarray",
"(",
"deep_object_format",
"[",
":",
",",
"2",
":",
"]",
"/",
"2",
",",
"dtype",
"=",
"int",
")",
"#xywh",
"deep_object_format",
"[",
":",
",",
"2",
":",
"]",
"*=",
"1.1",
"cls_conf",
"=",
"objects_detected",
"[",
":",
",",
"4",
"]",
"cls_ids",
"=",
"objects_detected",
"[",
":",
",",
"5",
"]",
"return",
"deep_object_format",
",",
"cls_conf",
",",
"cls_ids"
] | [
25,
0
] | [
55,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ObraSocial.startdb | (cls) | inicializar la base de datos importando desde la libreria oss_ar
https://github.com/cluster311/obras-sociales-argentinas/ | inicializar la base de datos importando desde la libreria oss_ar
https://github.com/cluster311/obras-sociales-argentinas/ | def startdb(cls):
""" inicializar la base de datos importando desde la libreria oss_ar
https://github.com/cluster311/obras-sociales-argentinas/"""
osss = ObrasSocialesArgentinas()
for rnos, oss in osss.local_json_object.items():
print(oss)
if oss.get('nombre', None) is None:
continue
defaults = {
'nombre': oss['nombre'],
'siglas': oss['sigla'],
'provincia': oss['provincia'],
'localidad': oss['localidad'],
'domicilio': oss['domicilio'],
'cp': oss['cp'],
'web': oss['web'],
# telefonos y emails
}
o = ObraSocial.objects.get_or_create(
codigo=rnos,
defaults=defaults
) | [
"def",
"startdb",
"(",
"cls",
")",
":",
"osss",
"=",
"ObrasSocialesArgentinas",
"(",
")",
"for",
"rnos",
",",
"oss",
"in",
"osss",
".",
"local_json_object",
".",
"items",
"(",
")",
":",
"print",
"(",
"oss",
")",
"if",
"oss",
".",
"get",
"(",
"'nombre'",
",",
"None",
")",
"is",
"None",
":",
"continue",
"defaults",
"=",
"{",
"'nombre'",
":",
"oss",
"[",
"'nombre'",
"]",
",",
"'siglas'",
":",
"oss",
"[",
"'sigla'",
"]",
",",
"'provincia'",
":",
"oss",
"[",
"'provincia'",
"]",
",",
"'localidad'",
":",
"oss",
"[",
"'localidad'",
"]",
",",
"'domicilio'",
":",
"oss",
"[",
"'domicilio'",
"]",
",",
"'cp'",
":",
"oss",
"[",
"'cp'",
"]",
",",
"'web'",
":",
"oss",
"[",
"'web'",
"]",
",",
"# telefonos y emails",
"}",
"o",
"=",
"ObraSocial",
".",
"objects",
".",
"get_or_create",
"(",
"codigo",
"=",
"rnos",
",",
"defaults",
"=",
"defaults",
")"
] | [
25,
4
] | [
47,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_listaOpciones_una | (p) | listaOpciones : opCol | listaOpciones : opCol | def p_listaOpciones_una(p):
'listaOpciones : opCol' | [
"def",
"p_listaOpciones_una",
"(",
"p",
")",
":"
] | [
717,
0
] | [
718,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Areas.areaTriangulo | (base, altura) | return "el area del triangulo es: " +str((base*altura)/2) | Calcula el area de un triangulo utilizando los parametros base y altura | Calcula el area de un triangulo utilizando los parametros base y altura | def areaTriangulo(base, altura):
"""Calcula el area de un triangulo utilizando los parametros base y altura """
return "el area del triangulo es: " +str((base*altura)/2) | [
"def",
"areaTriangulo",
"(",
"base",
",",
"altura",
")",
":",
"return",
"\"el area del triangulo es: \"",
"+",
"str",
"(",
"(",
"base",
"*",
"altura",
")",
"/",
"2",
")"
] | [
16,
4
] | [
20,
65
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ObjPartirDoc.BuscarFinPag | (self, linea) | return haysalto, salida | Buscar el salto de pagina, si devuelve una lista >1 es que hubo salto(s) | Buscar el salto de pagina, si devuelve una lista >1 es que hubo salto(s) | def BuscarFinPag(self, linea):
'''Buscar el salto de pagina, si devuelve una lista >1 es que hubo salto(s) '''
salida=[]
if isinstance(linea,bytes):
linea=linea.decode("Latin-1")
haysalto=False
for salto in self.saltopag:
buscar=linea.find(salto)
print ("salto:",buscar, salto)
if buscar >-1:
while buscar >-1:
salida.append(linea[:buscar])
haysalto=True
if self.oviarsalto:
linea=linea[buscar+len(salto):]
else:
linea=linea[buscar:]
buscar=linea.find(salto)
return haysalto, salida | [
"def",
"BuscarFinPag",
"(",
"self",
",",
"linea",
")",
":",
"salida",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"linea",
",",
"bytes",
")",
":",
"linea",
"=",
"linea",
".",
"decode",
"(",
"\"Latin-1\"",
")",
"haysalto",
"=",
"False",
"for",
"salto",
"in",
"self",
".",
"saltopag",
":",
"buscar",
"=",
"linea",
".",
"find",
"(",
"salto",
")",
"print",
"(",
"\"salto:\"",
",",
"buscar",
",",
"salto",
")",
"if",
"buscar",
">",
"-",
"1",
":",
"while",
"buscar",
">",
"-",
"1",
":",
"salida",
".",
"append",
"(",
"linea",
"[",
":",
"buscar",
"]",
")",
"haysalto",
"=",
"True",
"if",
"self",
".",
"oviarsalto",
":",
"linea",
"=",
"linea",
"[",
"buscar",
"+",
"len",
"(",
"salto",
")",
":",
"]",
"else",
":",
"linea",
"=",
"linea",
"[",
"buscar",
":",
"]",
"buscar",
"=",
"linea",
".",
"find",
"(",
"salto",
")",
"return",
"haysalto",
",",
"salida"
] | [
66,
1
] | [
85,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TablaValores.SiguienteEt | (self) | return var | Retorna la siguiente equiqueta L# sin modificar el contador | Retorna la siguiente equiqueta L# sin modificar el contador | def SiguienteEt(self):
'''Retorna la siguiente equiqueta L# sin modificar el contador'''
num = self.et
var = 'L' + str(num)
return var | [
"def",
"SiguienteEt",
"(",
"self",
")",
":",
"num",
"=",
"self",
".",
"et",
"var",
"=",
"'L'",
"+",
"str",
"(",
"num",
")",
"return",
"var"
] | [
17,
4
] | [
21,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Tipo.tipoInt | (self) | devueleve el tipo indicado de tipo int | devueleve el tipo indicado de tipo int | def tipoInt(self):
'devueleve el tipo indicado de tipo int'
if self.valor<=32767 and self.valor>= -32768:
return 'smallint'
elif self.valor<=2147483647 and self.valor>= -2147483648:
return 'integer'
elif self.valor<=9223372036854775807 and self.valor>= -9223372036854775808:
return 'bigint' | [
"def",
"tipoInt",
"(",
"self",
")",
":",
"if",
"self",
".",
"valor",
"<=",
"32767",
"and",
"self",
".",
"valor",
">=",
"-",
"32768",
":",
"return",
"'smallint'",
"elif",
"self",
".",
"valor",
"<=",
"2147483647",
"and",
"self",
".",
"valor",
">=",
"-",
"2147483648",
":",
"return",
"'integer'",
"elif",
"self",
".",
"valor",
"<=",
"9223372036854775807",
"and",
"self",
".",
"valor",
">=",
"-",
"9223372036854775808",
":",
"return",
"'bigint'"
] | [
12,
4
] | [
19,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Relacional.__init__ | (self, exp1, exp2, operador) | Se usan los valores de las clases padres | Se usan los valores de las clases padres | def __init__(self, exp1, exp2, operador):
'Se usan los valores de las clases padres'
Binaria.__init__(self, exp1, exp2, operador) | [
"def",
"__init__",
"(",
"self",
",",
"exp1",
",",
"exp2",
",",
"operador",
")",
":",
"Binaria",
".",
"__init__",
"(",
"self",
",",
"exp1",
",",
"exp2",
",",
"operador",
")"
] | [
14,
4
] | [
16,
52
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
actualizar_usuarios | (username, values) | actualiza el usuario | actualiza el usuario | def actualizar_usuarios(username, values):
"""actualiza el usuario"""
datos = cargar_usuarios()
datos[username] = values
guardar_usuarios(datos) | [
"def",
"actualizar_usuarios",
"(",
"username",
",",
"values",
")",
":",
"datos",
"=",
"cargar_usuarios",
"(",
")",
"datos",
"[",
"username",
"]",
"=",
"values",
"guardar_usuarios",
"(",
"datos",
")"
] | [
27,
0
] | [
31,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
find_char | (m: List[List[Any]], char: str) | Busca la posición de un caracter en la matriz. | Busca la posición de un caracter en la matriz. | def find_char(m: List[List[Any]], char: str) -> None:
"""Busca la posición de un caracter en la matriz."""
t = ""
for row in range(len(m)):
for col in range(len(m[row])):
if m[row][col] == char:
t += f" ({row}, {col})"
print(f'Output:{t}') | [
"def",
"find_char",
"(",
"m",
":",
"List",
"[",
"List",
"[",
"Any",
"]",
"]",
",",
"char",
":",
"str",
")",
"->",
"None",
":",
"t",
"=",
"\"\"",
"for",
"row",
"in",
"range",
"(",
"len",
"(",
"m",
")",
")",
":",
"for",
"col",
"in",
"range",
"(",
"len",
"(",
"m",
"[",
"row",
"]",
")",
")",
":",
"if",
"m",
"[",
"row",
"]",
"[",
"col",
"]",
"==",
"char",
":",
"t",
"+=",
"f\" ({row}, {col})\"",
"print",
"(",
"f'Output:{t}'",
")"
] | [
73,
0
] | [
80,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_messages | (user) | return mensajes | Obtener todos los mensajes del usuario para la lista de novedades | Obtener todos los mensajes del usuario para la lista de novedades | def get_messages(user):
""" Obtener todos los mensajes del usuario para la lista de novedades """
if user.is_authenticated:
mensajes = MensajeDestinado.objects.filter(destinatario=user).exclude(estado=MensajeDestinado.DELETED)
else:
mensajes = []
return mensajes | [
"def",
"get_messages",
"(",
"user",
")",
":",
"if",
"user",
".",
"is_authenticated",
":",
"mensajes",
"=",
"MensajeDestinado",
".",
"objects",
".",
"filter",
"(",
"destinatario",
"=",
"user",
")",
".",
"exclude",
"(",
"estado",
"=",
"MensajeDestinado",
".",
"DELETED",
")",
"else",
":",
"mensajes",
"=",
"[",
"]",
"return",
"mensajes"
] | [
3,
0
] | [
9,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NDD | (x, y) | return NDD | Devuelve las diferencias divididas de Newton.
Args:
x : lista o array
Los valores de x
y : lista o array
Los valores de y
Returns:
NDD : array
Array con las diferencias divididas
| Devuelve las diferencias divididas de Newton. | def NDD(x, y):
"""Devuelve las diferencias divididas de Newton.
Args:
x : lista o array
Los valores de x
y : lista o array
Los valores de y
Returns:
NDD : array
Array con las diferencias divididas
"""
NDD = []
N = len(x)
M = np.zeros([N,N])
M[:,0] = y
for columna in range(1,N):
for fila in range(N-columna):
m = f"M[{fila}, {columna}]"
ll = [m, f"= (M[{fila+1},{columna-1}]", '-',
f"M[{fila}, {columna-1}])", '/',
f"(x[{fila+columna}] - x[{fila}])", '\n']
print(''.join(ll))
num = M[fila+1, columna-1] - M[fila, columna-1]
den = x[fila+columna] - x[fila]
M[fila,columna] = num/den
print('Matriz:')
print(M)
NDD = M[0,:]
return NDD | [
"def",
"NDD",
"(",
"x",
",",
"y",
")",
":",
"NDD",
"=",
"[",
"]",
"N",
"=",
"len",
"(",
"x",
")",
"M",
"=",
"np",
".",
"zeros",
"(",
"[",
"N",
",",
"N",
"]",
")",
"M",
"[",
":",
",",
"0",
"]",
"=",
"y",
"for",
"columna",
"in",
"range",
"(",
"1",
",",
"N",
")",
":",
"for",
"fila",
"in",
"range",
"(",
"N",
"-",
"columna",
")",
":",
"m",
"=",
"f\"M[{fila}, {columna}]\"",
"ll",
"=",
"[",
"m",
",",
"f\"= (M[{fila+1},{columna-1}]\"",
",",
"'-'",
",",
"f\"M[{fila}, {columna-1}])\"",
",",
"'/'",
",",
"f\"(x[{fila+columna}] - x[{fila}])\"",
",",
"'\\n'",
"]",
"print",
"(",
"''",
".",
"join",
"(",
"ll",
")",
")",
"num",
"=",
"M",
"[",
"fila",
"+",
"1",
",",
"columna",
"-",
"1",
"]",
"-",
"M",
"[",
"fila",
",",
"columna",
"-",
"1",
"]",
"den",
"=",
"x",
"[",
"fila",
"+",
"columna",
"]",
"-",
"x",
"[",
"fila",
"]",
"M",
"[",
"fila",
",",
"columna",
"]",
"=",
"num",
"/",
"den",
"print",
"(",
"'Matriz:'",
")",
"print",
"(",
"M",
")",
"NDD",
"=",
"M",
"[",
"0",
",",
":",
"]",
"return",
"NDD"
] | [
3,
0
] | [
37,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
valuecallable | (obj) | Intentará invocar el objeto --> obj() y retorna su valor. | Intentará invocar el objeto --> obj() y retorna su valor. | def valuecallable(obj):
"""Intentará invocar el objeto --> obj() y retorna su valor."""
try:
return obj()
except (TypeError):
return obj | [
"def",
"valuecallable",
"(",
"obj",
")",
":",
"try",
":",
"return",
"obj",
"(",
")",
"except",
"(",
"TypeError",
")",
":",
"return",
"obj"
] | [
24,
0
] | [
29,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_lista_condicion | (t) | condiciones : condiciones AND condicion
| condiciones OR condicion | condiciones : condiciones AND condicion
| condiciones OR condicion | def p_lista_condicion(t):
'''condiciones : condiciones AND condicion
| condiciones OR condicion'''
gramatica = '<condiciones> ::= <condiciones> \"'+ t[2]+'\" <condicion>'
t[0] = Nodo('OPLOG', t[2], [t[1], t[3]], t.lexer.lineno, 0, gramatica) | [
"def",
"p_lista_condicion",
"(",
"t",
")",
":",
"gramatica",
"=",
"'<condiciones> ::= <condiciones> \\\"'",
"+",
"t",
"[",
"2",
"]",
"+",
"'\\\" <condicion>'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'OPLOG'",
",",
"t",
"[",
"2",
"]",
",",
"[",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"3",
"]",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"gramatica",
")"
] | [
1114,
0
] | [
1118,
74
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ingresar_notas | (n: int = 10, min_: int = 0, max_: int = 10) | return notas | Solicita las notas de 'n' alumnos.
:param n: Cantidad de alumnos.
:param min_: Valor mínimo de la nota.
:param max_: Valor máximo de la nota.
:n type: int
:min_ type: int
:max_ type: int
:return: Lista con las notas de los alumnos.
:rtype: list
| Solicita las notas de 'n' alumnos. | def ingresar_notas(n: int = 10, min_: int = 0, max_: int = 10) -> List[int]:
"""Solicita las notas de 'n' alumnos.
:param n: Cantidad de alumnos.
:param min_: Valor mínimo de la nota.
:param max_: Valor máximo de la nota.
:n type: int
:min_ type: int
:max_ type: int
:return: Lista con las notas de los alumnos.
:rtype: list
"""
notas = []
i = 0
while i < n:
nota = input(f'[{i+1}] Ingrese la nota: ')
try:
nota = int(nota)
except ValueError:
print('La nota debe ser un número.')
continue
if min_ <= nota <= max_:
notas.append(nota)
i += 1
else:
print('Nota fuera de rango')
return notas | [
"def",
"ingresar_notas",
"(",
"n",
":",
"int",
"=",
"10",
",",
"min_",
":",
"int",
"=",
"0",
",",
"max_",
":",
"int",
"=",
"10",
")",
"->",
"List",
"[",
"int",
"]",
":",
"notas",
"=",
"[",
"]",
"i",
"=",
"0",
"while",
"i",
"<",
"n",
":",
"nota",
"=",
"input",
"(",
"f'[{i+1}] Ingrese la nota: '",
")",
"try",
":",
"nota",
"=",
"int",
"(",
"nota",
")",
"except",
"ValueError",
":",
"print",
"(",
"'La nota debe ser un número.')",
"",
"continue",
"if",
"min_",
"<=",
"nota",
"<=",
"max_",
":",
"notas",
".",
"append",
"(",
"nota",
")",
"i",
"+=",
"1",
"else",
":",
"print",
"(",
"'Nota fuera de rango'",
")",
"return",
"notas"
] | [
12,
0
] | [
38,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_propiedades2 | (t) | propiedades : not null propiedades | propiedades : not null propiedades | def p_propiedades2(t):
'''propiedades : not null 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_propiedades2",
"(",
"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"
] | [
286,
0
] | [
294,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ArregloDinamico.sumar_for | (arr: List[List[int]]) | return suma | Suma los elementos de un arreglo
:param arr: arreglo
:arr type: List[List[int]]
:return: suma de los elementos del arreglo
:rtype: int
| Suma los elementos de un arreglo | def sumar_for(arr: List[List[int]]) -> int:
"""Suma los elementos de un arreglo
:param arr: arreglo
:arr type: List[List[int]]
:return: suma de los elementos del arreglo
:rtype: int
"""
suma = 0
for i in range(len(arr)):
for j in range(len(arr[i])):
suma += arr[i][j]
return suma | [
"def",
"sumar_for",
"(",
"arr",
":",
"List",
"[",
"List",
"[",
"int",
"]",
"]",
")",
"->",
"int",
":",
"suma",
"=",
"0",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"arr",
")",
")",
":",
"for",
"j",
"in",
"range",
"(",
"len",
"(",
"arr",
"[",
"i",
"]",
")",
")",
":",
"suma",
"+=",
"arr",
"[",
"i",
"]",
"[",
"j",
"]",
"return",
"suma"
] | [
149,
4
] | [
161,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ArregloDinamico.__len__ | (self) | return self._n | Devuelve el tamaño del arreglo | Devuelve el tamaño del arreglo | def __len__(self) -> int:
"""Devuelve el tamaño del arreglo"""
return self._n | [
"def",
"__len__",
"(",
"self",
")",
"->",
"int",
":",
"return",
"self",
".",
"_n"
] | [
27,
4
] | [
29,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Matrix.QR | (self) | return Q, R | Metodo para calcular una descomposicion QR. | Metodo para calcular una descomposicion QR. | def QR(self):
""" Metodo para calcular una descomposicion QR. """
x = len(self)
Q = []
for i in xrange(x):
v = self.col(i)
if len(Q) == 0:
ein = Matrix([v]).unitary()[0]
Q.append(ein)
else:
u = Matrix([v])
for j in Q:
w = Matrix([j])
u -= u.v_proj(w)
ein = u.unitary()[0]
Q.append(ein)
Q = Matrix(Q)
R = (Q.t() * self)
return Q, R | [
"def",
"QR",
"(",
"self",
")",
":",
"x",
"=",
"len",
"(",
"self",
")",
"Q",
"=",
"[",
"]",
"for",
"i",
"in",
"xrange",
"(",
"x",
")",
":",
"v",
"=",
"self",
".",
"col",
"(",
"i",
")",
"if",
"len",
"(",
"Q",
")",
"==",
"0",
":",
"ein",
"=",
"Matrix",
"(",
"[",
"v",
"]",
")",
".",
"unitary",
"(",
")",
"[",
"0",
"]",
"Q",
".",
"append",
"(",
"ein",
")",
"else",
":",
"u",
"=",
"Matrix",
"(",
"[",
"v",
"]",
")",
"for",
"j",
"in",
"Q",
":",
"w",
"=",
"Matrix",
"(",
"[",
"j",
"]",
")",
"u",
"-=",
"u",
".",
"v_proj",
"(",
"w",
")",
"ein",
"=",
"u",
".",
"unitary",
"(",
")",
"[",
"0",
"]",
"Q",
".",
"append",
"(",
"ein",
")",
"Q",
"=",
"Matrix",
"(",
"Q",
")",
"R",
"=",
"(",
"Q",
".",
"t",
"(",
")",
"*",
"self",
")",
"return",
"Q",
",",
"R"
] | [
229,
4
] | [
247,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EAD.obtener_descompresor | (self, extension) | return '/bin/tar xvf {compressed} -C {outdir}' | Verifica la existencia de un compresor que pueda trabajar con el
tipo de archivo relacionado a la extensión y retorna la ruta del
ejecutable con los argumentos básicos necesarios para la descompresión
| Verifica la existencia de un compresor que pueda trabajar con el
tipo de archivo relacionado a la extensión y retorna la ruta del
ejecutable con los argumentos básicos necesarios para la descompresión
| def obtener_descompresor(self, extension):
"""Verifica la existencia de un compresor que pueda trabajar con el
tipo de archivo relacionado a la extensión y retorna la ruta del
ejecutable con los argumentos básicos necesarios para la descompresión
"""
return '/bin/tar xvf {compressed} -C {outdir}' | [
"def",
"obtener_descompresor",
"(",
"self",
",",
"extension",
")",
":",
"return",
"'/bin/tar xvf {compressed} -C {outdir}'"
] | [
23,
4
] | [
29,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_propiedades | (t) | propiedades : null propiedades | propiedades : null propiedades | def p_propiedades(t):
'propiedades : null propiedades'
node = grammer.nodoDireccion('propiedades')
node1 = grammer.nodoDireccion(t[1])
node.agregar(node1)
node.agregar(t[2])
t[0] = node | [
"def",
"p_propiedades",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'propiedades'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"2",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
278,
0
] | [
284,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TextEditor.set_memento | (self, memento) | Método que se encarga de deserializar el objeto, eliminamos su
contenido y actualizamos el contenido al estado anterior | Método que se encarga de deserializar el objeto, eliminamos su
contenido y actualizamos el contenido al estado anterior | def set_memento(self, memento):
"""Método que se encarga de deserializar el objeto, eliminamos su
contenido y actualizamos el contenido al estado anterior"""
previous_state = pickle.loads(memento)
vars(self).clear()
vars(self).update(previous_state) | [
"def",
"set_memento",
"(",
"self",
",",
"memento",
")",
":",
"previous_state",
"=",
"pickle",
".",
"loads",
"(",
"memento",
")",
"vars",
"(",
"self",
")",
".",
"clear",
"(",
")",
"vars",
"(",
"self",
")",
".",
"update",
"(",
"previous_state",
")"
] | [
22,
4
] | [
27,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_parametros_funciones | (t) | parametro : lista_funciones
| funciones_math_esenciales
| fun_binario_select
| date_functions
| state_subquery | parametro : lista_funciones
| funciones_math_esenciales
| fun_binario_select
| date_functions
| state_subquery | def p_parametros_funciones(t) :
'''parametro : lista_funciones
| funciones_math_esenciales
| fun_binario_select
| date_functions
| state_subquery'''
t[0] = t[1] | [
"def",
"p_parametros_funciones",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
421,
0
] | [
427,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funcion | (t) | funcion : funciones_select seguir_sobrenombre | funcion : funciones_select seguir_sobrenombre | def p_funcion(t):
'funcion : funciones_select seguir_sobrenombre'
reporte_bnf.append("<funcion> ::= <funciones_select> <seguir_sobrenombre>")
t[0] = Create_select_uno(OPCIONES_SELECT.FUNCIONES,None,t[1],t[2],None,None,None) | [
"def",
"p_funcion",
"(",
"t",
")",
":",
"reporte_bnf",
".",
"append",
"(",
"\"<funcion> ::= <funciones_select> <seguir_sobrenombre>\"",
")",
"t",
"[",
"0",
"]",
"=",
"Create_select_uno",
"(",
"OPCIONES_SELECT",
".",
"FUNCIONES",
",",
"None",
",",
"t",
"[",
"1",
"]",
",",
"t",
"[",
"2",
"]",
",",
"None",
",",
"None",
",",
"None",
")"
] | [
1833,
0
] | [
1836,
85
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
check_extra_fields | (fields, full=False) | return aditional_fields | Revisa si existen campos adicionales a los default
:param fields: Campos del usuario presentes en la cabecera del ``csv``
:type: list
:param full: Bandera opcional si se requieren los campos completos. Por
ejemplo cuando se sube un respaldo de la base de datos
:type: bool
:return: Los campos adicionales encontrados si existen
:rtype: set
| Revisa si existen campos adicionales a los default | def check_extra_fields(fields, full=False):
"""Revisa si existen campos adicionales a los default
:param fields: Campos del usuario presentes en la cabecera del ``csv``
:type: list
:param full: Bandera opcional si se requieren los campos completos. Por
ejemplo cuando se sube un respaldo de la base de datos
:type: bool
:return: Los campos adicionales encontrados si existen
:rtype: set
"""
# If user already create custom configurations
if os.path.isfile('user-elastic-config.json'):
with open('user-elastic-config.json') as json_file:
configs = json.loads(json_file.read())
# Using default configurations
else:
with open('elastic-config.json') as json_file:
configs = json.loads(json_file.read())
default_fields = configs['mappings']['properties'].keys()
if full:
# Remove additional fields
del default_fields['document_id']
del default_fields['document_name']
del default_fields['pdf_file']
# Aditional fields
if set(fields) - set(default_fields) != set():
aditional_fields = set(fields) - set(default_fields)
else:
aditional_fields = set()
return aditional_fields | [
"def",
"check_extra_fields",
"(",
"fields",
",",
"full",
"=",
"False",
")",
":",
"# If user already create custom configurations",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"'user-elastic-config.json'",
")",
":",
"with",
"open",
"(",
"'user-elastic-config.json'",
")",
"as",
"json_file",
":",
"configs",
"=",
"json",
".",
"loads",
"(",
"json_file",
".",
"read",
"(",
")",
")",
"# Using default configurations",
"else",
":",
"with",
"open",
"(",
"'elastic-config.json'",
")",
"as",
"json_file",
":",
"configs",
"=",
"json",
".",
"loads",
"(",
"json_file",
".",
"read",
"(",
")",
")",
"default_fields",
"=",
"configs",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
".",
"keys",
"(",
")",
"if",
"full",
":",
"# Remove additional fields",
"del",
"default_fields",
"[",
"'document_id'",
"]",
"del",
"default_fields",
"[",
"'document_name'",
"]",
"del",
"default_fields",
"[",
"'pdf_file'",
"]",
"# Aditional fields",
"if",
"set",
"(",
"fields",
")",
"-",
"set",
"(",
"default_fields",
")",
"!=",
"set",
"(",
")",
":",
"aditional_fields",
"=",
"set",
"(",
"fields",
")",
"-",
"set",
"(",
"default_fields",
")",
"else",
":",
"aditional_fields",
"=",
"set",
"(",
")",
"return",
"aditional_fields"
] | [
208,
0
] | [
238,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
solucion | (
a:int , d: int, n: int, t: Optional[int] = None
) | return a_n, s | Encuentra el n-ésimo termino y calcula suma de los 'n' terminos
de una progresión aritmética.
:param a: Primer termino de la progresión aritmética
:type a: int
:param diferencia: Diferencia constante de la progresión aritmética
:type diferencia: int
:param n: Número de terminos de la progresión aritmética
:type n: int
:param t: Último termino de la progresión aritmética
:type t: int, optional
:return: Tupla (n-ésimo termino, suma de la progresión)
:rtype: Tuple[int, float]
>>> solucion(1, 1, 100)
(100, 5050.0)
>>> solucion(9, 12, 20)
(237, 2460.0)
>>> solucion(1, 2, None, t=19)
(19, 100.0)
| Encuentra el n-ésimo termino y calcula suma de los 'n' terminos
de una progresión aritmética. | def solucion(
a:int , d: int, n: int, t: Optional[int] = None
) -> Tuple[int, float]:
"""Encuentra el n-ésimo termino y calcula suma de los 'n' terminos
de una progresión aritmética.
:param a: Primer termino de la progresión aritmética
:type a: int
:param diferencia: Diferencia constante de la progresión aritmética
:type diferencia: int
:param n: Número de terminos de la progresión aritmética
:type n: int
:param t: Último termino de la progresión aritmética
:type t: int, optional
:return: Tupla (n-ésimo termino, suma de la progresión)
:rtype: Tuple[int, float]
>>> solucion(1, 1, 100)
(100, 5050.0)
>>> solucion(9, 12, 20)
(237, 2460.0)
>>> solucion(1, 2, None, t=19)
(19, 100.0)
"""
if t and n is None:
a_n = t
n = (t - a + d) / d
s = ((a+a_n) * n) / 2
else:
a_n = a + (n-1) * d
s = (n/2) * (2*a + (n-1)*d)
return a_n, s | [
"def",
"solucion",
"(",
"a",
":",
"int",
",",
"d",
":",
"int",
",",
"n",
":",
"int",
",",
"t",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
")",
"->",
"Tuple",
"[",
"int",
",",
"float",
"]",
":",
"if",
"t",
"and",
"n",
"is",
"None",
":",
"a_n",
"=",
"t",
"n",
"=",
"(",
"t",
"-",
"a",
"+",
"d",
")",
"/",
"d",
"s",
"=",
"(",
"(",
"a",
"+",
"a_n",
")",
"*",
"n",
")",
"/",
"2",
"else",
":",
"a_n",
"=",
"a",
"+",
"(",
"n",
"-",
"1",
")",
"*",
"d",
"s",
"=",
"(",
"n",
"/",
"2",
")",
"*",
"(",
"2",
"*",
"a",
"+",
"(",
"n",
"-",
"1",
")",
"*",
"d",
")",
"return",
"a_n",
",",
"s"
] | [
6,
0
] | [
37,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_tiempo4 | (t) | tiempo : HOUR
| tiempo : HOUR
| def p_tiempo4(t):
''' tiempo : HOUR
''' | [
"def",
"p_tiempo4",
"(",
"t",
")",
":"
] | [
931,
0
] | [
933,
7
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
verifica_estudiante_asignado_a_curso | (id_curso: Union[None, str] = None) | Si el usuario no esta asignado como estudiante al curso devuelve None. | Si el usuario no esta asignado como estudiante al curso devuelve None. | def verifica_estudiante_asignado_a_curso(id_curso: Union[None, str] = None):
"""Si el usuario no esta asignado como estudiante al curso devuelve None."""
if current_user.is_authenticated:
return EstudianteCurso.query.filter(EstudianteCurso.usuario == current_user.usuario, EstudianteCurso.curso == id_curso)
else:
return False | [
"def",
"verifica_estudiante_asignado_a_curso",
"(",
"id_curso",
":",
"Union",
"[",
"None",
",",
"str",
"]",
"=",
"None",
")",
":",
"if",
"current_user",
".",
"is_authenticated",
":",
"return",
"EstudianteCurso",
".",
"query",
".",
"filter",
"(",
"EstudianteCurso",
".",
"usuario",
"==",
"current_user",
".",
"usuario",
",",
"EstudianteCurso",
".",
"curso",
"==",
"id_curso",
")",
"else",
":",
"return",
"False"
] | [
259,
0
] | [
264,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ComandoFiscalInterface.cancelAnyDocument | (self) | Cancela cualquier documento abierto, sea del tipo que sea.
No requiere que previamente se haya abierto el documento por este objeto.
Se usa para destrabar la impresora. | Cancela cualquier documento abierto, sea del tipo que sea.
No requiere que previamente se haya abierto el documento por este objeto.
Se usa para destrabar la impresora. | def cancelAnyDocument(self):
"""Cancela cualquier documento abierto, sea del tipo que sea.
No requiere que previamente se haya abierto el documento por este objeto.
Se usa para destrabar la impresora."""
raise NotImplementedError | [
"def",
"cancelAnyDocument",
"(",
"self",
")",
":",
"raise",
"NotImplementedError"
] | [
206,
4
] | [
210,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
error | (update, context) | Loggea los errores causados por el Updater. | Loggea los errores causados por el Updater. | def error(update, context):
"""Loggea los errores causados por el Updater."""
logger.warning('Update "%s" caused error "%s"', update, context.error) | [
"def",
"error",
"(",
"update",
",",
"context",
")",
":",
"logger",
".",
"warning",
"(",
"'Update \"%s\" caused error \"%s\"'",
",",
"update",
",",
"context",
".",
"error",
")"
] | [
106,
0
] | [
108,
74
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ProteinRecord.prot_to_dna | (self) | return t_seq | Convierte la secuencia de aminoacidos a DNA | Convierte la secuencia de aminoacidos a DNA | def prot_to_dna(self):
"""Convierte la secuencia de aminoacidos a DNA"""
# Obtener longitud de secuencia
seq_len = len(self.seq)
t_seq = ''
# Obtener del diccionario los codones correspondientes
for pos in range(0, seq_len):
t_seq += aa_cons_codon[self.seq[pos]]
return t_seq | [
"def",
"prot_to_dna",
"(",
"self",
")",
":",
"# Obtener longitud de secuencia",
"seq_len",
"=",
"len",
"(",
"self",
".",
"seq",
")",
"t_seq",
"=",
"''",
"# Obtener del diccionario los codones correspondientes",
"for",
"pos",
"in",
"range",
"(",
"0",
",",
"seq_len",
")",
":",
"t_seq",
"+=",
"aa_cons_codon",
"[",
"self",
".",
"seq",
"[",
"pos",
"]",
"]",
"return",
"t_seq"
] | [
64,
4
] | [
72,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Battery.__init__ | (self, battery_size=60) | Atributos de la bateria | Atributos de la bateria | def __init__(self, battery_size=60):
"""Atributos de la bateria"""
self.battery_size = battery_size | [
"def",
"__init__",
"(",
"self",
",",
"battery_size",
"=",
"60",
")",
":",
"self",
".",
"battery_size",
"=",
"battery_size"
] | [
41,
4
] | [
43,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
countMorphemes | (morphlist) | return counts | Cuenta el número de ocurrencias de cada label
:param morphlist: Lista de bio-labels
:return: Diccionario con las labesl como llave y el número de
ocurrencias como valor
| Cuenta el número de ocurrencias de cada label | def countMorphemes(morphlist):
""" Cuenta el número de ocurrencias de cada label
:param morphlist: Lista de bio-labels
:return: Diccionario con las labesl como llave y el número de
ocurrencias como valor
"""
counts = {}
for morpheme in morphlist:
label = morpheme[0][2:]
counts[label] = counts.get(label, 0) + 1
return counts | [
"def",
"countMorphemes",
"(",
"morphlist",
")",
":",
"counts",
"=",
"{",
"}",
"for",
"morpheme",
"in",
"morphlist",
":",
"label",
"=",
"morpheme",
"[",
"0",
"]",
"[",
"2",
":",
"]",
"counts",
"[",
"label",
"]",
"=",
"counts",
".",
"get",
"(",
"label",
",",
"0",
")",
"+",
"1",
"return",
"counts"
] | [
462,
0
] | [
473,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_valselect_7 | (t) | valselect : agregacion PARIZQ cualquieridentificador PARDER alias | valselect : agregacion PARIZQ cualquieridentificador PARDER alias | def p_valselect_7(t):
'valselect : agregacion PARIZQ cualquieridentificador PARDER alias'
t[0] = getValSelect(t, 'agregacion') | [
"def",
"p_valselect_7",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"getValSelect",
"(",
"t",
",",
"'agregacion'",
")"
] | [
828,
0
] | [
830,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_asignacion_2 | (t) | instrucciones_asignacion : declaracion_variable PUNTOYCOMA | instrucciones_asignacion : declaracion_variable PUNTOYCOMA | def p_instrucciones_asignacion_2(t):
'''instrucciones_asignacion : declaracion_variable PUNTOYCOMA'''
t[0] = Start("INSTRUCCIONES_ASIGNACION")
t[0].addChild(t[1]) | [
"def",
"p_instrucciones_asignacion_2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"INSTRUCCIONES_ASIGNACION\"",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"1",
"]",
")"
] | [
1602,
0
] | [
1605,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Annotation.parse_json | (data) | return Annotation(**data) | parsea el contenido json pasado a una instancia de Annotation Valida | parsea el contenido json pasado a una instancia de Annotation Valida | def parse_json(data) -> Annotation:
""" parsea el contenido json pasado a una instancia de Annotation Valida"""
return Annotation(**data) | [
"def",
"parse_json",
"(",
"data",
")",
"->",
"Annotation",
":",
"return",
"Annotation",
"(",
"*",
"*",
"data",
")"
] | [
48,
4
] | [
50,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Residential.name_json | (self) | Modifica el nombre de variable y añade .json-stat para exportar. | Modifica el nombre de variable y añade .json-stat para exportar. | def name_json(self):
"""Modifica el nombre de variable y añade .json-stat para exportar."""
lista = []
for val in self.var_list:
val1, val2 = val.split('|', 2)
val1 = val1.rpartition('_Cantabria')[0]
val1 = val1.casefold()
for regla in self.cfg.reglas:
val1 = val1.replace(regla, self.cfg.reglas[regla])
lista.append(val1)
for val in lista:
for regla in self.cfg.reglasEspecificas:
val = val.replace(regla, self.cfg.reglasEspecificas[regla])
self.json_vars.append(val) | [
"def",
"name_json",
"(",
"self",
")",
":",
"lista",
"=",
"[",
"]",
"for",
"val",
"in",
"self",
".",
"var_list",
":",
"val1",
",",
"val2",
"=",
"val",
".",
"split",
"(",
"'|'",
",",
"2",
")",
"val1",
"=",
"val1",
".",
"rpartition",
"(",
"'_Cantabria'",
")",
"[",
"0",
"]",
"val1",
"=",
"val1",
".",
"casefold",
"(",
")",
"for",
"regla",
"in",
"self",
".",
"cfg",
".",
"reglas",
":",
"val1",
"=",
"val1",
".",
"replace",
"(",
"regla",
",",
"self",
".",
"cfg",
".",
"reglas",
"[",
"regla",
"]",
")",
"lista",
".",
"append",
"(",
"val1",
")",
"for",
"val",
"in",
"lista",
":",
"for",
"regla",
"in",
"self",
".",
"cfg",
".",
"reglasEspecificas",
":",
"val",
"=",
"val",
".",
"replace",
"(",
"regla",
",",
"self",
".",
"cfg",
".",
"reglasEspecificas",
"[",
"regla",
"]",
")",
"self",
".",
"json_vars",
".",
"append",
"(",
"val",
")"
] | [
76,
4
] | [
93,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_funcion_abs_select | (t) | lista_funciones : ABS PARIZQ funcion_math_parametro PARDER | lista_funciones : ABS PARIZQ funcion_math_parametro PARDER | def p_instrucciones_funcion_abs_select(t) :
'lista_funciones : ABS PARIZQ funcion_math_parametro PARDER' | [
"def",
"p_instrucciones_funcion_abs_select",
"(",
"t",
")",
":"
] | [
882,
0
] | [
883,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones28 | (p) | funciones : TAN PABRE expresion PCIERRA | funciones : TAN PABRE expresion PCIERRA | def p_funciones28(p):
'funciones : TAN PABRE expresion PCIERRA' | [
"def",
"p_funciones28",
"(",
"p",
")",
":"
] | [
382,
0
] | [
383,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
csv_uploader | (csv_name, doc_name, pdf_file, doc_id="", extra_fields=False) | return total_lines | **Función encargada de cargar nuevas líneas al corpus**
Manipula los archivos mandados desde formulario y los carga al
corpus de Tsunkua por medio del API de elasticsearch. Se espera que
la primera columna del archivo csv sea el texto en español, la
segunda columna sea el texto en otomí y la tercera columna sea la
variante(s)
:param csv_name: Nombre del archivo csv con el texto alineado
:type: str
:param doc_name: Nombre del documento a cargar
:type: str
:param pdf_file: Nombre del archivo PDF del documento
:type: str
:return: Número de líneas cargadas al corpus
:rtype: int
| **Función encargada de cargar nuevas líneas al corpus** | def csv_uploader(csv_name, doc_name, pdf_file, doc_id="", extra_fields=False):
"""**Función encargada de cargar nuevas líneas al corpus**
Manipula los archivos mandados desde formulario y los carga al
corpus de Tsunkua por medio del API de elasticsearch. Se espera que
la primera columna del archivo csv sea el texto en español, la
segunda columna sea el texto en otomí y la tercera columna sea la
variante(s)
:param csv_name: Nombre del archivo csv con el texto alineado
:type: str
:param doc_name: Nombre del documento a cargar
:type: str
:param pdf_file: Nombre del archivo PDF del documento
:type: str
:return: Número de líneas cargadas al corpus
:rtype: int
"""
LOGGER.info(f"Subiendo nuevo CSV::{csv_name}")
# Subiendo al indice de Elasticsearch
LOGGER.info(f"Subiendo al indice de Elasticsearch::{settings.INDEX}")
with open(csv_name, 'r', encoding='utf-8') as f:
raw_csv = f.read()
total_lines = 0
# Si no existe el documento se crea un nuevo id
if not doc_id:
doc_id = str(uuid.uuid4()).replace('-', '')[:24]
rows = raw_csv.split('\n')
header = rows[0].lower().split(",")
# Quitando cabecera del csv
rows.pop(0)
if extra_fields:
# Toma en cuenta los campos del header del csv
fields = header
else:
# Agrega solo los campos existentes en el indice
fields = get_index_config()["mappings"]["properties"]
fields = set(header).intersection(set(fields))
for text in csv.reader(rows, delimiter=',', quotechar='"'):
if text:
if text[header.index("l1")] and text[header.index("l2")]:
document = {"pdf_file": pdf_file,
"document_id": doc_id,
"document_name": doc_name
}
for field in fields:
if field in ["document_name", "pdf_file", "document_id"]:
continue
else:
document[field] = text[header.index(field)]
LOGGER.debug(f"Subiendo linea #{total_lines}::{document}")
# TODO: Change to bulk
res = es.index(index=settings.INDEX, body=document)
total_lines += 1
LOGGER.info(f"Upload estatus #{total_lines}::{res['result']}")
else:
LOGGER.warning(f"Omitiendo la linea #{total_lines - 1} en blanco::{text}")
LOGGER.info(f"Lineas agregadas::{total_lines}")
LOGGER.debug(f"Eliminando csv temporal::{csv_name}")
os.remove(csv_name)
return total_lines | [
"def",
"csv_uploader",
"(",
"csv_name",
",",
"doc_name",
",",
"pdf_file",
",",
"doc_id",
"=",
"\"\"",
",",
"extra_fields",
"=",
"False",
")",
":",
"LOGGER",
".",
"info",
"(",
"f\"Subiendo nuevo CSV::{csv_name}\"",
")",
"# Subiendo al indice de Elasticsearch",
"LOGGER",
".",
"info",
"(",
"f\"Subiendo al indice de Elasticsearch::{settings.INDEX}\"",
")",
"with",
"open",
"(",
"csv_name",
",",
"'r'",
",",
"encoding",
"=",
"'utf-8'",
")",
"as",
"f",
":",
"raw_csv",
"=",
"f",
".",
"read",
"(",
")",
"total_lines",
"=",
"0",
"# Si no existe el documento se crea un nuevo id",
"if",
"not",
"doc_id",
":",
"doc_id",
"=",
"str",
"(",
"uuid",
".",
"uuid4",
"(",
")",
")",
".",
"replace",
"(",
"'-'",
",",
"''",
")",
"[",
":",
"24",
"]",
"rows",
"=",
"raw_csv",
".",
"split",
"(",
"'\\n'",
")",
"header",
"=",
"rows",
"[",
"0",
"]",
".",
"lower",
"(",
")",
".",
"split",
"(",
"\",\"",
")",
"# Quitando cabecera del csv",
"rows",
".",
"pop",
"(",
"0",
")",
"if",
"extra_fields",
":",
"# Toma en cuenta los campos del header del csv",
"fields",
"=",
"header",
"else",
":",
"# Agrega solo los campos existentes en el indice",
"fields",
"=",
"get_index_config",
"(",
")",
"[",
"\"mappings\"",
"]",
"[",
"\"properties\"",
"]",
"fields",
"=",
"set",
"(",
"header",
")",
".",
"intersection",
"(",
"set",
"(",
"fields",
")",
")",
"for",
"text",
"in",
"csv",
".",
"reader",
"(",
"rows",
",",
"delimiter",
"=",
"','",
",",
"quotechar",
"=",
"'\"'",
")",
":",
"if",
"text",
":",
"if",
"text",
"[",
"header",
".",
"index",
"(",
"\"l1\"",
")",
"]",
"and",
"text",
"[",
"header",
".",
"index",
"(",
"\"l2\"",
")",
"]",
":",
"document",
"=",
"{",
"\"pdf_file\"",
":",
"pdf_file",
",",
"\"document_id\"",
":",
"doc_id",
",",
"\"document_name\"",
":",
"doc_name",
"}",
"for",
"field",
"in",
"fields",
":",
"if",
"field",
"in",
"[",
"\"document_name\"",
",",
"\"pdf_file\"",
",",
"\"document_id\"",
"]",
":",
"continue",
"else",
":",
"document",
"[",
"field",
"]",
"=",
"text",
"[",
"header",
".",
"index",
"(",
"field",
")",
"]",
"LOGGER",
".",
"debug",
"(",
"f\"Subiendo linea #{total_lines}::{document}\"",
")",
"# TODO: Change to bulk",
"res",
"=",
"es",
".",
"index",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"document",
")",
"total_lines",
"+=",
"1",
"LOGGER",
".",
"info",
"(",
"f\"Upload estatus #{total_lines}::{res['result']}\"",
")",
"else",
":",
"LOGGER",
".",
"warning",
"(",
"f\"Omitiendo la linea #{total_lines - 1} en blanco::{text}\"",
")",
"LOGGER",
".",
"info",
"(",
"f\"Lineas agregadas::{total_lines}\"",
")",
"LOGGER",
".",
"debug",
"(",
"f\"Eliminando csv temporal::{csv_name}\"",
")",
"os",
".",
"remove",
"(",
"csv_name",
")",
"return",
"total_lines"
] | [
110,
0
] | [
171,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObjects.registered_tracked_objects | (self) | return registered_objects | Devuelve la lista de los objetos seguidos que están marcados como registrado.
Únicamente se devuelven los objetos cuyo estado esté marcado como registrado.
:return: lista de objetos seguidos que constan como registrados.
| Devuelve la lista de los objetos seguidos que están marcados como registrado. | def registered_tracked_objects(self) -> List[TrackedObject]:
"""Devuelve la lista de los objetos seguidos que están marcados como registrado.
Únicamente se devuelven los objetos cuyo estado esté marcado como registrado.
:return: lista de objetos seguidos que constan como registrados.
"""
registered_objects = []
for obj in self._tracked_objects:
if obj.status:
registered_objects.append(obj)
return registered_objects | [
"def",
"registered_tracked_objects",
"(",
"self",
")",
"->",
"List",
"[",
"TrackedObject",
"]",
":",
"registered_objects",
"=",
"[",
"]",
"for",
"obj",
"in",
"self",
".",
"_tracked_objects",
":",
"if",
"obj",
".",
"status",
":",
"registered_objects",
".",
"append",
"(",
"obj",
")",
"return",
"registered_objects"
] | [
294,
4
] | [
305,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BaseForm.get_form_kwargs | (self) | return kwargs | Incluimos la instancia 'company' a los argumentos del formulario. | Incluimos la instancia 'company' a los argumentos del formulario. | def get_form_kwargs(self):
"""Incluimos la instancia 'company' a los argumentos del formulario."""
kwargs = super().get_form_kwargs()
kwargs["company"] = self.get_company()
return kwargs | [
"def",
"get_form_kwargs",
"(",
"self",
")",
":",
"kwargs",
"=",
"super",
"(",
")",
".",
"get_form_kwargs",
"(",
")",
"kwargs",
"[",
"\"company\"",
"]",
"=",
"self",
".",
"get_company",
"(",
")",
"return",
"kwargs"
] | [
268,
4
] | [
272,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Molecule.get_center_atom | (self) | return distancias[0] | Metodo para calcular el atomo central de la molecula. | Metodo para calcular el atomo central de la molecula. | def get_center_atom(self):
""" Metodo para calcular el atomo central de la molecula. """
distancias = []
centro = self.get_center_of_mass()
for i in xrange(len(self.atoms)):
temp = self.atoms[i].coords - centro
distancias.append([i, self.atoms[i].element, temp.norm()])
distancias.sort(key=lambda s: s[2])
return distancias[0] | [
"def",
"get_center_atom",
"(",
"self",
")",
":",
"distancias",
"=",
"[",
"]",
"centro",
"=",
"self",
".",
"get_center_of_mass",
"(",
")",
"for",
"i",
"in",
"xrange",
"(",
"len",
"(",
"self",
".",
"atoms",
")",
")",
":",
"temp",
"=",
"self",
".",
"atoms",
"[",
"i",
"]",
".",
"coords",
"-",
"centro",
"distancias",
".",
"append",
"(",
"[",
"i",
",",
"self",
".",
"atoms",
"[",
"i",
"]",
".",
"element",
",",
"temp",
".",
"norm",
"(",
")",
"]",
")",
"distancias",
".",
"sort",
"(",
"key",
"=",
"lambda",
"s",
":",
"s",
"[",
"2",
"]",
")",
"return",
"distancias",
"[",
"0",
"]"
] | [
154,
4
] | [
162,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
languages | (request) | return {'L1': settings.L1, 'L2': settings.L2} | **Configura variables de entorno de las lenguas** | **Configura variables de entorno de las lenguas** | def languages(request):
"""**Configura variables de entorno de las lenguas**"""
return {'L1': settings.L1, 'L2': settings.L2} | [
"def",
"languages",
"(",
"request",
")",
":",
"return",
"{",
"'L1'",
":",
"settings",
".",
"L1",
",",
"'L2'",
":",
"settings",
".",
"L2",
"}"
] | [
15,
0
] | [
17,
49
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
introducir_numero | () | funcion que sirve para controlar que los datos que se introducen son correctos, es decir,
si se introduce un dato que no sea un número entero pide que se introduzca otra vez el dato | funcion que sirve para controlar que los datos que se introducen son correctos, es decir,
si se introduce un dato que no sea un número entero pide que se introduzca otra vez el dato | def introducir_numero():
"""funcion que sirve para controlar que los datos que se introducen son correctos, es decir,
si se introduce un dato que no sea un número entero pide que se introduzca otra vez el dato"""
while True:
try:
num = int(input ("Ingrese un número entero",))
return num
except:
print("\nEl dato introducido no es un número entero. Vuelva a intentarlo") | [
"def",
"introducir_numero",
"(",
")",
":",
"while",
"True",
":",
"try",
":",
"num",
"=",
"int",
"(",
"input",
"(",
"\"Ingrese un número entero\",",
")",
")",
"",
"return",
"num",
"except",
":",
"print",
"(",
"\"\\nEl dato introducido no es un número entero. Vuelva a intentarlo\")",
""
] | [
18,
0
] | [
28,
87
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
simpleColor | (r,g,b) | simpleColor obtiene el nombre del color mas general al cual se acerca su formato R G B | simpleColor obtiene el nombre del color mas general al cual se acerca su formato R G B | def simpleColor(r,g,b):
""" simpleColor obtiene el nombre del color mas general al cual se acerca su formato R G B """
r=int(r)
g=int(g)
b=int(b)
bg = ir = 0 # TODO: Fix these variables
try:
#ROJO --------------------------------------------------
if r > g and r > b:
rg = diff(r,g) #distancia rojo a verde
rb = diff(r,b) #distancia rojo a azul
if g < 65 and b < 65 and rg > 60: #azul y verde sin luz
return "ROJO"
gb=diff(g,b) #distancia de verde a azul
if rg < rb: # Verde mayor que Azul
if gb < rg: #Verde mas cerca de Azul
if gb >=30 and rg >= 80:
return "NARANJA"
elif gb<=20 and rg >= 80:
return "ROJO"
elif gb<=20 and b > 175:
return "CREMA"
else:
return "CHOCOLATE"
else: #Verde mas cerca de Rojo
if rg > 60:
return "NARANJA*"
elif r > 125:
return "AMARILLO"
else:
return "COCHOLATE"
elif rg > rb: #Azul mayor que verde
if bg < rb: #Verde mas cerca de Azul
if gb < 60:
if r >150:
return "ROJO 2"
else:
return "MARRON"
elif g > 125:
return "ROSADO"
else:
return "ROJO 3"
else: #Verde mas cerca de Rojo
if rb < 60:
if r > 160:
return "ROSADO*"
else:
return "ROJO"
else:
return "ROJO"
else: # g y b iguales
if rg > 20:
if r>=100 and b <60:
return "ROJO"
elif r >=100:
return "ROJO"
else:
return "MARRON"
else:
return "GRIS"
# VERDE ---------------------------------------------------
elif g > r and g > b:
gb = diff(g,b) #distancia verde a azul
gr = diff(g,r) #distancia verde a rojo
if r < 65 and b < 65 and gb > 60: #rojo y azul sin luz
return "VERDE"
rb=diff(r,b) #distancia de rojo a azul
if r > b: #ROJO > AZUL
if gr < gb: #Verde con Rojo
if rb>=150 and gr <=20:
return "AMARILLO"
else:
return "VERDE"
else: #...Verde
return "VERDE"
elif r < b: #AZUL > ROJO
if gb < gr: #Verde con Azul
if gb<=20:
return "TURQUESA"
else:
return "VERDE"
else: #...Verde
return "VERDE"
else: #r y b iguales
if gb > 10:
return "VERDE"
else:
return "GRIS"
#AZUL ------------------------------------------------------
elif b > r and b > g:
bg = diff(b,g) #distancia azul a verde
br = diff(b,r) #distancia azul a rojo
if r < 65 and g < 65 and bg > 60: #rojo y verde sin luz
return "AZUL"
rg=diff(r,g) #distancia de rojo a verde
if g < r: # ROJO > VERDE
if bg < rg: #Azul con Verde
if bg<=20:
return "TURQUESA"
else:
return "CELESTE"
else: #...Azul
if rg <= 20:
if r >= 150:
return "LILA"
else:
return "AZUL *************"
else:
return "AZUL"
elif g > r: # VERDE > ROJO
if br < rg: #Azul con rojo
if br <=20:
if r > 150 and g < 75:
return "ROSADO FIUSHA"
elif ir > 150:
return "LILA"
else:
return "MORADO"
else:
return "MORADO"
else: #...Azul
if rg <= 20:
if bg <=20:
return "GRIS"
else:
return "AZUL"
else: #r y g iguales
if bg > 20:
if r>=100 and b <60:
return "ROJO"
elif r >=100:
return "ROJO"
else:
return "MARRON"
else:
return "GRIS"
# IGUALES---------------------------------------
else:
return "GRIS"
except:
return "Not Color" | [
"def",
"simpleColor",
"(",
"r",
",",
"g",
",",
"b",
")",
":",
"r",
"=",
"int",
"(",
"r",
")",
"g",
"=",
"int",
"(",
"g",
")",
"b",
"=",
"int",
"(",
"b",
")",
"bg",
"=",
"ir",
"=",
"0",
"# TODO: Fix these variables",
"try",
":",
"#ROJO --------------------------------------------------",
"if",
"r",
">",
"g",
"and",
"r",
">",
"b",
":",
"rg",
"=",
"diff",
"(",
"r",
",",
"g",
")",
"#distancia rojo a verde",
"rb",
"=",
"diff",
"(",
"r",
",",
"b",
")",
"#distancia rojo a azul",
"if",
"g",
"<",
"65",
"and",
"b",
"<",
"65",
"and",
"rg",
">",
"60",
":",
"#azul y verde sin luz",
"return",
"\"ROJO\"",
"gb",
"=",
"diff",
"(",
"g",
",",
"b",
")",
"#distancia de verde a azul",
"if",
"rg",
"<",
"rb",
":",
"# Verde mayor que Azul",
"if",
"gb",
"<",
"rg",
":",
"#Verde mas cerca de Azul",
"if",
"gb",
">=",
"30",
"and",
"rg",
">=",
"80",
":",
"return",
"\"NARANJA\"",
"elif",
"gb",
"<=",
"20",
"and",
"rg",
">=",
"80",
":",
"return",
"\"ROJO\"",
"elif",
"gb",
"<=",
"20",
"and",
"b",
">",
"175",
":",
"return",
"\"CREMA\"",
"else",
":",
"return",
"\"CHOCOLATE\"",
"else",
":",
"#Verde mas cerca de Rojo",
"if",
"rg",
">",
"60",
":",
"return",
"\"NARANJA*\"",
"elif",
"r",
">",
"125",
":",
"return",
"\"AMARILLO\"",
"else",
":",
"return",
"\"COCHOLATE\"",
"elif",
"rg",
">",
"rb",
":",
"#Azul mayor que verde",
"if",
"bg",
"<",
"rb",
":",
"#Verde mas cerca de Azul",
"if",
"gb",
"<",
"60",
":",
"if",
"r",
">",
"150",
":",
"return",
"\"ROJO 2\"",
"else",
":",
"return",
"\"MARRON\"",
"elif",
"g",
">",
"125",
":",
"return",
"\"ROSADO\"",
"else",
":",
"return",
"\"ROJO 3\"",
"else",
":",
"#Verde mas cerca de Rojo",
"if",
"rb",
"<",
"60",
":",
"if",
"r",
">",
"160",
":",
"return",
"\"ROSADO*\"",
"else",
":",
"return",
"\"ROJO\"",
"else",
":",
"return",
"\"ROJO\"",
"else",
":",
"# g y b iguales",
"if",
"rg",
">",
"20",
":",
"if",
"r",
">=",
"100",
"and",
"b",
"<",
"60",
":",
"return",
"\"ROJO\"",
"elif",
"r",
">=",
"100",
":",
"return",
"\"ROJO\"",
"else",
":",
"return",
"\"MARRON\"",
"else",
":",
"return",
"\"GRIS\"",
"# VERDE ---------------------------------------------------",
"elif",
"g",
">",
"r",
"and",
"g",
">",
"b",
":",
"gb",
"=",
"diff",
"(",
"g",
",",
"b",
")",
"#distancia verde a azul",
"gr",
"=",
"diff",
"(",
"g",
",",
"r",
")",
"#distancia verde a rojo",
"if",
"r",
"<",
"65",
"and",
"b",
"<",
"65",
"and",
"gb",
">",
"60",
":",
"#rojo y azul sin luz",
"return",
"\"VERDE\"",
"rb",
"=",
"diff",
"(",
"r",
",",
"b",
")",
"#distancia de rojo a azul",
"if",
"r",
">",
"b",
":",
"#ROJO > AZUL",
"if",
"gr",
"<",
"gb",
":",
"#Verde con Rojo",
"if",
"rb",
">=",
"150",
"and",
"gr",
"<=",
"20",
":",
"return",
"\"AMARILLO\"",
"else",
":",
"return",
"\"VERDE\"",
"else",
":",
"#...Verde",
"return",
"\"VERDE\"",
"elif",
"r",
"<",
"b",
":",
"#AZUL > ROJO",
"if",
"gb",
"<",
"gr",
":",
"#Verde con Azul",
"if",
"gb",
"<=",
"20",
":",
"return",
"\"TURQUESA\"",
"else",
":",
"return",
"\"VERDE\"",
"else",
":",
"#...Verde",
"return",
"\"VERDE\"",
"else",
":",
"#r y b iguales",
"if",
"gb",
">",
"10",
":",
"return",
"\"VERDE\"",
"else",
":",
"return",
"\"GRIS\"",
"#AZUL ------------------------------------------------------",
"elif",
"b",
">",
"r",
"and",
"b",
">",
"g",
":",
"bg",
"=",
"diff",
"(",
"b",
",",
"g",
")",
"#distancia azul a verde",
"br",
"=",
"diff",
"(",
"b",
",",
"r",
")",
"#distancia azul a rojo",
"if",
"r",
"<",
"65",
"and",
"g",
"<",
"65",
"and",
"bg",
">",
"60",
":",
"#rojo y verde sin luz",
"return",
"\"AZUL\"",
"rg",
"=",
"diff",
"(",
"r",
",",
"g",
")",
"#distancia de rojo a verde",
"if",
"g",
"<",
"r",
":",
"# ROJO > VERDE",
"if",
"bg",
"<",
"rg",
":",
"#Azul con Verde",
"if",
"bg",
"<=",
"20",
":",
"return",
"\"TURQUESA\"",
"else",
":",
"return",
"\"CELESTE\"",
"else",
":",
"#...Azul",
"if",
"rg",
"<=",
"20",
":",
"if",
"r",
">=",
"150",
":",
"return",
"\"LILA\"",
"else",
":",
"return",
"\"AZUL *************\"",
"else",
":",
"return",
"\"AZUL\"",
"elif",
"g",
">",
"r",
":",
"# VERDE > ROJO",
"if",
"br",
"<",
"rg",
":",
"#Azul con rojo",
"if",
"br",
"<=",
"20",
":",
"if",
"r",
">",
"150",
"and",
"g",
"<",
"75",
":",
"return",
"\"ROSADO FIUSHA\"",
"elif",
"ir",
">",
"150",
":",
"return",
"\"LILA\"",
"else",
":",
"return",
"\"MORADO\"",
"else",
":",
"return",
"\"MORADO\"",
"else",
":",
"#...Azul",
"if",
"rg",
"<=",
"20",
":",
"if",
"bg",
"<=",
"20",
":",
"return",
"\"GRIS\"",
"else",
":",
"return",
"\"AZUL\"",
"else",
":",
"#r y g iguales",
"if",
"bg",
">",
"20",
":",
"if",
"r",
">=",
"100",
"and",
"b",
"<",
"60",
":",
"return",
"\"ROJO\"",
"elif",
"r",
">=",
"100",
":",
"return",
"\"ROJO\"",
"else",
":",
"return",
"\"MARRON\"",
"else",
":",
"return",
"\"GRIS\"",
"# IGUALES---------------------------------------",
"else",
":",
"return",
"\"GRIS\"",
"except",
":",
"return",
"\"Not Color\""
] | [
7,
0
] | [
173,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
export_data | (request) | return response | **Vista que exporta la base de datos completa del índice**
Vista llamada desde el botón de *exportar* en el administrador del corpus.
Se genera un respaldo de la base de datos en formato ``csv`` con el que se
puede restaurar en otro índice de Elasticsearch.
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
| **Vista que exporta la base de datos completa del índice** | def export_data(request):
"""**Vista que exporta la base de datos completa del índice**
Vista llamada desde el botón de *exportar* en el administrador del corpus.
Se genera un respaldo de la base de datos en formato ``csv`` con el que se
puede restaurar en otro índice de Elasticsearch.
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
"""
project_name = settings.NAME
# Setting file metadata
response = HttpResponse(content_type="text/csv")
date = datetime.datetime.now()
format_date = date.strftime("%d-%m-%Y")
response['Content-Disposition'] = f"attachment;filename={project_name}-bkp-{format_date}.csv"
writer = csv.writer(response)
mappings = es.indices.get_mapping(index=settings.INDEX)
csv_header = list(mappings[settings.INDEX]['mappings']['properties'].keys())
# Getting all data from index
query = '{"query": {"match_all": {}}}'
r = es.search(index=settings.INDEX, body=query, scroll="1m", size=1000)
data_response = r["hits"]
scroll_id = r["_scroll_id"]
total_rows = data_response["total"]["value"]
rows_count = len(data_response["hits"])
while rows_count != total_rows:
sub_response = es.scroll(scroll_id=scroll_id, scroll="1m")
data_response["hits"] += sub_response["hits"]["hits"]
rows_count += len(sub_response["hits"]["hits"])
scroll_id = sub_response["_scroll_id"]
writer.writerow(csv_header)
for hit in data_response["hits"]:
row = []
data = hit['_source']
fields = data.keys()
if "l1" not in fields or "l2" not in fields:
LOGGER.warning(f"Linea {hit['_id']} en blanco. Se omite")
continue
else:
# Filling list to sort csv row text later
row = ["" for _ in range(len(csv_header))]
for field in data:
# Sorting text on row by header position
header_position = csv_header.index(field)
row[header_position] = data[field]
writer.writerow(row)
return response | [
"def",
"export_data",
"(",
"request",
")",
":",
"project_name",
"=",
"settings",
".",
"NAME",
"# Setting file metadata",
"response",
"=",
"HttpResponse",
"(",
"content_type",
"=",
"\"text/csv\"",
")",
"date",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"format_date",
"=",
"date",
".",
"strftime",
"(",
"\"%d-%m-%Y\"",
")",
"response",
"[",
"'Content-Disposition'",
"]",
"=",
"f\"attachment;filename={project_name}-bkp-{format_date}.csv\"",
"writer",
"=",
"csv",
".",
"writer",
"(",
"response",
")",
"mappings",
"=",
"es",
".",
"indices",
".",
"get_mapping",
"(",
"index",
"=",
"settings",
".",
"INDEX",
")",
"csv_header",
"=",
"list",
"(",
"mappings",
"[",
"settings",
".",
"INDEX",
"]",
"[",
"'mappings'",
"]",
"[",
"'properties'",
"]",
".",
"keys",
"(",
")",
")",
"# Getting all data from index",
"query",
"=",
"'{\"query\": {\"match_all\": {}}}'",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"query",
",",
"scroll",
"=",
"\"1m\"",
",",
"size",
"=",
"1000",
")",
"data_response",
"=",
"r",
"[",
"\"hits\"",
"]",
"scroll_id",
"=",
"r",
"[",
"\"_scroll_id\"",
"]",
"total_rows",
"=",
"data_response",
"[",
"\"total\"",
"]",
"[",
"\"value\"",
"]",
"rows_count",
"=",
"len",
"(",
"data_response",
"[",
"\"hits\"",
"]",
")",
"while",
"rows_count",
"!=",
"total_rows",
":",
"sub_response",
"=",
"es",
".",
"scroll",
"(",
"scroll_id",
"=",
"scroll_id",
",",
"scroll",
"=",
"\"1m\"",
")",
"data_response",
"[",
"\"hits\"",
"]",
"+=",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
"rows_count",
"+=",
"len",
"(",
"sub_response",
"[",
"\"hits\"",
"]",
"[",
"\"hits\"",
"]",
")",
"scroll_id",
"=",
"sub_response",
"[",
"\"_scroll_id\"",
"]",
"writer",
".",
"writerow",
"(",
"csv_header",
")",
"for",
"hit",
"in",
"data_response",
"[",
"\"hits\"",
"]",
":",
"row",
"=",
"[",
"]",
"data",
"=",
"hit",
"[",
"'_source'",
"]",
"fields",
"=",
"data",
".",
"keys",
"(",
")",
"if",
"\"l1\"",
"not",
"in",
"fields",
"or",
"\"l2\"",
"not",
"in",
"fields",
":",
"LOGGER",
".",
"warning",
"(",
"f\"Linea {hit['_id']} en blanco. Se omite\"",
")",
"continue",
"else",
":",
"# Filling list to sort csv row text later",
"row",
"=",
"[",
"\"\"",
"for",
"_",
"in",
"range",
"(",
"len",
"(",
"csv_header",
")",
")",
"]",
"for",
"field",
"in",
"data",
":",
"# Sorting text on row by header position",
"header_position",
"=",
"csv_header",
".",
"index",
"(",
"field",
")",
"row",
"[",
"header_position",
"]",
"=",
"data",
"[",
"field",
"]",
"writer",
".",
"writerow",
"(",
"row",
")",
"return",
"response"
] | [
283,
0
] | [
331,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ApiRequest.setAuthVars | (self,endpoint,payload, headers) | establece las varaibles de seguridad necesarias para el request de autorizacion
Parameters
----------
endpoint : str
endponint para obtener el token de seguridad
payload : json
payload para obtener la seguridad: usuario y clave
headers : json
headers para obtener la seguridad
| establece las varaibles de seguridad necesarias para el request de autorizacion | def setAuthVars(self,endpoint,payload, headers):
""" establece las varaibles de seguridad necesarias para el request de autorizacion
Parameters
----------
endpoint : str
endponint para obtener el token de seguridad
payload : json
payload para obtener la seguridad: usuario y clave
headers : json
headers para obtener la seguridad
"""
self.secendpoint=endpoint
self.secpayload=payload
self.secheaders=headers | [
"def",
"setAuthVars",
"(",
"self",
",",
"endpoint",
",",
"payload",
",",
"headers",
")",
":",
"self",
".",
"secendpoint",
"=",
"endpoint",
"self",
".",
"secpayload",
"=",
"payload",
"self",
".",
"secheaders",
"=",
"headers"
] | [
125,
4
] | [
140,
31
] | 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.