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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
BinomialBandit.pull | (self) | return binomial(self.number, self.probability) | Realiza una tirada en el bandido
Retorna
-------
reward: float
Recompensa obtenida en la tirada
| Realiza una tirada en el bandido | def pull(self):
""" Realiza una tirada en el bandido
Retorna
-------
reward: float
Recompensa obtenida en la tirada
"""
return binomial(self.number, self.probability) | [
"def",
"pull",
"(",
"self",
")",
":",
"return",
"binomial",
"(",
"self",
".",
"number",
",",
"self",
".",
"probability",
")"
] | [
28,
4
] | [
36,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BotClient.is_DMChannel | (message: str) | return isinstance(message.channel, discord.channel.DMChannel) | Verifica si es un mensaje proveniente es de un canal privado | Verifica si es un mensaje proveniente es de un canal privado | def is_DMChannel(message: str) -> bool:
"""Verifica si es un mensaje proveniente es de un canal privado"""
return isinstance(message.channel, discord.channel.DMChannel) | [
"def",
"is_DMChannel",
"(",
"message",
":",
"str",
")",
"->",
"bool",
":",
"return",
"isinstance",
"(",
"message",
".",
"channel",
",",
"discord",
".",
"channel",
".",
"DMChannel",
")"
] | [
51,
4
] | [
53,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ordenSeleccion | (v) | Ordenamiento por seleccion | Ordenamiento por seleccion | def ordenSeleccion(v):
"""Ordenamiento por seleccion"""
for i in range(0,len(v)-1):
min=i
for j in range(i+1,len(v)):
if v[min] > v[j]:
min=j
aux=v[min]
v[min]=v[i]
v[i]=aux | [
"def",
"ordenSeleccion",
"(",
"v",
")",
":",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"v",
")",
"-",
"1",
")",
":",
"min",
"=",
"i",
"for",
"j",
"in",
"range",
"(",
"i",
"+",
"1",
",",
"len",
"(",
"v",
")",
")",
":",
"if",
"v",
"[",
"min",
"]",
">",
"v",
"[",
"j",
"]",
":",
"min",
"=",
"j",
"aux",
"=",
"v",
"[",
"min",
"]",
"v",
"[",
"min",
"]",
"=",
"v",
"[",
"i",
"]",
"v",
"[",
"i",
"]",
"=",
"aux"
] | [
47,
0
] | [
56,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
encrypt | (
signingKey: bytes,
publicKey: bytes,
secretKey: bytes,
data: bytes,
is_packed: bool = options.IS_PACKED
) | return ed25519.sign(signingKey, scheme.encrypt(
data if not (is_packed) else msgpack.dumps(data)
)) | Cifra y firma un mensaje
Args:
signingKey:
La clave para firmar
publicKey:
La clave pública del destinatario
secretKey:
La clave secreta
data:
Los datos a cifrar
is_packed:
Usar o no `msgpack`
Returns:
Los datos cifrados y firmados
| Cifra y firma un mensaje
Args:
signingKey:
La clave para firmar | def encrypt(
signingKey: bytes,
publicKey: bytes,
secretKey: bytes,
data: bytes,
is_packed: bool = options.IS_PACKED
) -> bytes:
"""Cifra y firma un mensaje
Args:
signingKey:
La clave para firmar
publicKey:
La clave pública del destinatario
secretKey:
La clave secreta
data:
Los datos a cifrar
is_packed:
Usar o no `msgpack`
Returns:
Los datos cifrados y firmados
"""
scheme = x25519_xsalsa20_poly1305MAC.InitSession(publicKey, secretKey)
return ed25519.sign(signingKey, scheme.encrypt(
data if not (is_packed) else msgpack.dumps(data)
)) | [
"def",
"encrypt",
"(",
"signingKey",
":",
"bytes",
",",
"publicKey",
":",
"bytes",
",",
"secretKey",
":",
"bytes",
",",
"data",
":",
"bytes",
",",
"is_packed",
":",
"bool",
"=",
"options",
".",
"IS_PACKED",
")",
"->",
"bytes",
":",
"scheme",
"=",
"x25519_xsalsa20_poly1305MAC",
".",
"InitSession",
"(",
"publicKey",
",",
"secretKey",
")",
"return",
"ed25519",
".",
"sign",
"(",
"signingKey",
",",
"scheme",
".",
"encrypt",
"(",
"data",
"if",
"not",
"(",
"is_packed",
")",
"else",
"msgpack",
".",
"dumps",
"(",
"data",
")",
")",
")"
] | [
6,
0
] | [
41,
6
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_declaracion_expr | (t) | declaracion : expresion | declaracion : expresion | def p_declaracion_expr(t):
'declaracion : expresion'
# print("Resultado: " + str(t[1]))
t[0] = t[1] | [
"def",
"p_declaracion_expr",
"(",
"t",
")",
":",
"# print(\"Resultado: \" + str(t[1]))",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
19,
0
] | [
22,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RatTube.mostrar_Banner | (self) | Imprime el banner que se muestra en pantalla.
el método cprint recibe parámetros texto,color del texto y fondo que tendrá el texto,
attrs hace referencia a la fuente que sería en negrita
el texto que recibe el método cprint es lo que se obtiene de
formatearlo con el método figlet_format que lo convierte en ascii art y nos permite
elegir fuentes que contiene la biblioteca pyfiglet | Imprime el banner que se muestra en pantalla.
el método cprint recibe parámetros texto,color del texto y fondo que tendrá el texto,
attrs hace referencia a la fuente que sería en negrita
el texto que recibe el método cprint es lo que se obtiene de
formatearlo con el método figlet_format que lo convierte en ascii art y nos permite
elegir fuentes que contiene la biblioteca pyfiglet | def mostrar_Banner(self):
cprint(figlet_format('RatTube', font='banner3'), 'yellow', 'on_blue', attrs=['bold'])
'''Imprime el banner que se muestra en pantalla.
el método cprint recibe parámetros texto,color del texto y fondo que tendrá el texto,
attrs hace referencia a la fuente que sería en negrita
el texto que recibe el método cprint es lo que se obtiene de
formatearlo con el método figlet_format que lo convierte en ascii art y nos permite
elegir fuentes que contiene la biblioteca pyfiglet''' | [
"def",
"mostrar_Banner",
"(",
"self",
")",
":",
"cprint",
"(",
"figlet_format",
"(",
"'RatTube'",
",",
"font",
"=",
"'banner3'",
")",
",",
"'yellow'",
",",
"'on_blue'",
",",
"attrs",
"=",
"[",
"'bold'",
"]",
")"
] | [
28,
1
] | [
37,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PlaceFileWriter.auto_boot | (self) | Función encargada de checkear que el directorio donde se alojarán los ficheros de resultados existe. | Función encargada de checkear que el directorio donde se alojarán los ficheros de resultados existe. | def auto_boot(self):
"""Función encargada de checkear que el directorio donde se alojarán los ficheros de resultados existe."""
# make sure root dir exists
if os.path.isdir(self._root_path):
self.logger.info("root path where results will be written exists")
else:
self.logger.error("root path where results will be written does not exist")
raise Exception("results directory does not exist") | [
"def",
"auto_boot",
"(",
"self",
")",
":",
"# make sure root dir exists",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"self",
".",
"_root_path",
")",
":",
"self",
".",
"logger",
".",
"info",
"(",
"\"root path where results will be written exists\"",
")",
"else",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"root path where results will be written does not exist\"",
")",
"raise",
"Exception",
"(",
"\"results directory does not exist\"",
")"
] | [
380,
4
] | [
387,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
limpiar | (texto: str) | return " ".join(texto.split()) | El texto que recibe se devuelve limpio, eliminando espacios dobles y los espacios que haya
tanto al principio como al final.
:param texto: Texto de entrada
:type texto: str
:return: Texto de entrada limpio (eliminando
:rtype: str
>>> limpiar("estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio ")
'estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio'
| El texto que recibe se devuelve limpio, eliminando espacios dobles y los espacios que haya
tanto al principio como al final.
:param texto: Texto de entrada
:type texto: str
:return: Texto de entrada limpio (eliminando
:rtype: str
>>> limpiar("estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio ")
'estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio'
| def limpiar(texto: str) -> str:
"""El texto que recibe se devuelve limpio, eliminando espacios dobles y los espacios que haya
tanto al principio como al final.
:param texto: Texto de entrada
:type texto: str
:return: Texto de entrada limpio (eliminando
:rtype: str
>>> limpiar("estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio ")
'estoy escribiendo desde móvil y meto un espacio al final y algunos por enmedio'
"""
texto = texto.strip()
return " ".join(texto.split()) | [
"def",
"limpiar",
"(",
"texto",
":",
"str",
")",
"->",
"str",
":",
"texto",
"=",
"texto",
".",
"strip",
"(",
")",
"return",
"\" \"",
".",
"join",
"(",
"texto",
".",
"split",
"(",
")",
")"
] | [
1,
0
] | [
12,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Url.only_domain | (self) | return (self.domain_port or '').split(':')[0] or None | Dominio sin el puerto
| Dominio sin el puerto
| def only_domain(self):
"""Dominio sin el puerto
"""
return (self.domain_port or '').split(':')[0] or None | [
"def",
"only_domain",
"(",
"self",
")",
":",
"return",
"(",
"self",
".",
"domain_port",
"or",
"''",
")",
".",
"split",
"(",
"':'",
")",
"[",
"0",
"]",
"or",
"None"
] | [
88,
4
] | [
91,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlaceFileWriter.write | (self, element, is_update=False) | Vuelca la información de `element` en un fichero generado dinámicamente.
Arguments
---------
element : dict
diccionario que se escribirá en un fichero creado dinámicamente. Como resultado habrá un fichero por local
comercial encontrado
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
| Vuelca la información de `element` en un fichero generado dinámicamente. | def write(self, element, is_update=False):
"""Vuelca la información de `element` en un fichero generado dinámicamente.
Arguments
---------
element : dict
diccionario que se escribirá en un fichero creado dinámicamente. Como resultado habrá un fichero por local
comercial encontrado
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
"""
if element.get("name"):
file_name = "{name}_{sufix}.{format}".format(
name="{postal_code}_{name}".format(postal_code=element.get("zip_code"),
name=element.get("name").replace(" ", "_")),
format=self._file_format,
sufix=self._sufix)
result_file_path = os.path.join(self._root_path, file_name)
with open(result_file_path, 'w') as f:
json.dump(element, f)
return True
else:
self.logger.error("there are errors trying to write the following element: ")
self.logger.error(element)
return False | [
"def",
"write",
"(",
"self",
",",
"element",
",",
"is_update",
"=",
"False",
")",
":",
"if",
"element",
".",
"get",
"(",
"\"name\"",
")",
":",
"file_name",
"=",
"\"{name}_{sufix}.{format}\"",
".",
"format",
"(",
"name",
"=",
"\"{postal_code}_{name}\"",
".",
"format",
"(",
"postal_code",
"=",
"element",
".",
"get",
"(",
"\"zip_code\"",
")",
",",
"name",
"=",
"element",
".",
"get",
"(",
"\"name\"",
")",
".",
"replace",
"(",
"\" \"",
",",
"\"_\"",
")",
")",
",",
"format",
"=",
"self",
".",
"_file_format",
",",
"sufix",
"=",
"self",
".",
"_sufix",
")",
"result_file_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"_root_path",
",",
"file_name",
")",
"with",
"open",
"(",
"result_file_path",
",",
"'w'",
")",
"as",
"f",
":",
"json",
".",
"dump",
"(",
"element",
",",
"f",
")",
"return",
"True",
"else",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"there are errors trying to write the following element: \"",
")",
"self",
".",
"logger",
".",
"error",
"(",
"element",
")",
"return",
"False"
] | [
393,
4
] | [
417,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cargar_usuarios | () | return dicc | Abre el json y lo trae en diccionario | Abre el json y lo trae en diccionario | def cargar_usuarios():
"""Abre el json y lo trae en diccionario"""
with open(PATH_FILE, 'r') as f:
dicc = json.load(f)
return dicc | [
"def",
"cargar_usuarios",
"(",
")",
":",
"with",
"open",
"(",
"PATH_FILE",
",",
"'r'",
")",
"as",
"f",
":",
"dicc",
"=",
"json",
".",
"load",
"(",
"f",
")",
"return",
"dicc"
] | [
14,
0
] | [
18,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ModelBase.get_object_detail | (self, exclude: list=[]) | return out | Obtiene un diccionario con informacion de los campos y sus valores. | Obtiene un diccionario con informacion de los campos y sus valores. | def get_object_detail(self, exclude: list=[]):
"""Obtiene un diccionario con informacion de los campos y sus valores."""
fields = self._meta.get_fields()
out = []
exclude = list(exclude) + ["id", "tags", "company_id"]
#raise TypeError("\n\n".join([str(field.__dict__) for field in fields]))
for field in fields:
try:
attname = field.attname
except (AttributeError):
continue
if attname in exclude:
continue
value = getattr(self, attname)
display = value
if getattr(field, "related_model", None):
value = field.related_model.objects.get(id=value)
try:
display = getattr(self, f"get_{attname}_display")()
except (AttributeError):
if isinstance(field, (models.DecimalField, models.IntegerField,
models.FloatField)):
display = f"{value:,}"
else:
display = str(value)
out.append({"field": field, "value": value, "display": display})
return out | [
"def",
"get_object_detail",
"(",
"self",
",",
"exclude",
":",
"list",
"=",
"[",
"]",
")",
":",
"fields",
"=",
"self",
".",
"_meta",
".",
"get_fields",
"(",
")",
"out",
"=",
"[",
"]",
"exclude",
"=",
"list",
"(",
"exclude",
")",
"+",
"[",
"\"id\"",
",",
"\"tags\"",
",",
"\"company_id\"",
"]",
"#raise TypeError(\"\\n\\n\".join([str(field.__dict__) for field in fields]))",
"for",
"field",
"in",
"fields",
":",
"try",
":",
"attname",
"=",
"field",
".",
"attname",
"except",
"(",
"AttributeError",
")",
":",
"continue",
"if",
"attname",
"in",
"exclude",
":",
"continue",
"value",
"=",
"getattr",
"(",
"self",
",",
"attname",
")",
"display",
"=",
"value",
"if",
"getattr",
"(",
"field",
",",
"\"related_model\"",
",",
"None",
")",
":",
"value",
"=",
"field",
".",
"related_model",
".",
"objects",
".",
"get",
"(",
"id",
"=",
"value",
")",
"try",
":",
"display",
"=",
"getattr",
"(",
"self",
",",
"f\"get_{attname}_display\"",
")",
"(",
")",
"except",
"(",
"AttributeError",
")",
":",
"if",
"isinstance",
"(",
"field",
",",
"(",
"models",
".",
"DecimalField",
",",
"models",
".",
"IntegerField",
",",
"models",
".",
"FloatField",
")",
")",
":",
"display",
"=",
"f\"{value:,}\"",
"else",
":",
"display",
"=",
"str",
"(",
"value",
")",
"out",
".",
"append",
"(",
"{",
"\"field\"",
":",
"field",
",",
"\"value\"",
":",
"value",
",",
"\"display\"",
":",
"display",
"}",
")",
"return",
"out"
] | [
103,
4
] | [
134,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
csv_dominios | (request) | return response | CSV con los dominios en la base | CSV con los dominios en la base | def csv_dominios(request):
""" CSV con los dominios en la base """
fields = ['id', 'nombre', 'zona__nombre', 'estado', 'registered', 'changed', 'expire']
override_fields = {
'zona__nombre': 'zona'
}
queryset = Dominio.objects.filter(estado=STATUS_NO_DISPONIBLE).values(*fields)
response = queryset_as_csv_view(
request=request,
filename='dominios.csv',
queryset=queryset,
fields=fields,
override_fields=override_fields)
return response | [
"def",
"csv_dominios",
"(",
"request",
")",
":",
"fields",
"=",
"[",
"'id'",
",",
"'nombre'",
",",
"'zona__nombre'",
",",
"'estado'",
",",
"'registered'",
",",
"'changed'",
",",
"'expire'",
"]",
"override_fields",
"=",
"{",
"'zona__nombre'",
":",
"'zona'",
"}",
"queryset",
"=",
"Dominio",
".",
"objects",
".",
"filter",
"(",
"estado",
"=",
"STATUS_NO_DISPONIBLE",
")",
".",
"values",
"(",
"*",
"fields",
")",
"response",
"=",
"queryset_as_csv_view",
"(",
"request",
"=",
"request",
",",
"filename",
"=",
"'dominios.csv'",
",",
"queryset",
"=",
"queryset",
",",
"fields",
"=",
"fields",
",",
"override_fields",
"=",
"override_fields",
")",
"return",
"response"
] | [
4,
0
] | [
18,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
lanzar | (n: int = 2) | return " ".join(caras[dado-1] for dado in dados), sum(dados) | Lanza 'n' dados al azar. Devuelve un tupla con la representación
de los dados lanzados y la suma de estos.
:param n: Número de dados a lanzar, por defecto 2
:type n: int
:returns: Tupla (representación, suma)
:rtype: Tuple(str, int)
| Lanza 'n' dados al azar. Devuelve un tupla con la representación
de los dados lanzados y la suma de estos. | def lanzar(n: int = 2) -> Tuple[str, int]:
"""Lanza 'n' dados al azar. Devuelve un tupla con la representación
de los dados lanzados y la suma de estos.
:param n: Número de dados a lanzar, por defecto 2
:type n: int
:returns: Tupla (representación, suma)
:rtype: Tuple(str, int)
"""
caras = ['\u2680', '\u2681', '\u2682', '\u2683', '\u2684', '\u2685']
dados = [randint(1, 6) for _ in range(n)]
return " ".join(caras[dado-1] for dado in dados), sum(dados) | [
"def",
"lanzar",
"(",
"n",
":",
"int",
"=",
"2",
")",
"->",
"Tuple",
"[",
"str",
",",
"int",
"]",
":",
"caras",
"=",
"[",
"'\\u2680'",
",",
"'\\u2681'",
",",
"'\\u2682'",
",",
"'\\u2683'",
",",
"'\\u2684'",
",",
"'\\u2685'",
"]",
"dados",
"=",
"[",
"randint",
"(",
"1",
",",
"6",
")",
"for",
"_",
"in",
"range",
"(",
"n",
")",
"]",
"return",
"\" \"",
".",
"join",
"(",
"caras",
"[",
"dado",
"-",
"1",
"]",
"for",
"dado",
"in",
"dados",
")",
",",
"sum",
"(",
"dados",
")"
] | [
14,
0
] | [
25,
64
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
MyDataset.set_norm_values | (self,
mean:torch.Tensor=None,
std:torch.Tensor=None,
) | Calcula la media y desviacion estandar en el dataset de ser necesario. No es calculada si estos valores se incluyen como argumentos.
Args:
mean (c): Media encontrada en el dataset completo de N samples por canal.
std (c): Desviación estandar encontrada en el dataset completo de N samples por canal.
| Calcula la media y desviacion estandar en el dataset de ser necesario. No es calculada si estos valores se incluyen como argumentos.
Args:
mean (c): Media encontrada en el dataset completo de N samples por canal.
std (c): Desviación estandar encontrada en el dataset completo de N samples por canal.
| def set_norm_values(self,
mean:torch.Tensor=None,
std:torch.Tensor=None,
):
''' Calcula la media y desviacion estandar en el dataset de ser necesario. No es calculada si estos valores se incluyen como argumentos.
Args:
mean (c): Media encontrada en el dataset completo de N samples por canal.
std (c): Desviación estandar encontrada en el dataset completo de N samples por canal.
'''
self.mean = torch.mean(self.x, dim=(0,2,3)) if mean is None else mean # (N,c,h,w) > (c)
self.std = torch.std(self.x, dim=(0,2,3)) if std is None else std | [
"def",
"set_norm_values",
"(",
"self",
",",
"mean",
":",
"torch",
".",
"Tensor",
"=",
"None",
",",
"std",
":",
"torch",
".",
"Tensor",
"=",
"None",
",",
")",
":",
"self",
".",
"mean",
"=",
"torch",
".",
"mean",
"(",
"self",
".",
"x",
",",
"dim",
"=",
"(",
"0",
",",
"2",
",",
"3",
")",
")",
"if",
"mean",
"is",
"None",
"else",
"mean",
"# (N,c,h,w) > (c)",
"self",
".",
"std",
"=",
"torch",
".",
"std",
"(",
"self",
".",
"x",
",",
"dim",
"=",
"(",
"0",
",",
"2",
",",
"3",
")",
")",
"if",
"std",
"is",
"None",
"else",
"std"
] | [
34,
1
] | [
44,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Restaurant.set_number_served | (self, number_served) | Permitir al usuario establecer la cantidad de clientes atendidos | Permitir al usuario establecer la cantidad de clientes atendidos | def set_number_served(self, number_served):
"""Permitir al usuario establecer la cantidad de clientes atendidos"""
self.number_served = number_served | [
"def",
"set_number_served",
"(",
"self",
",",
"number_served",
")",
":",
"self",
".",
"number_served",
"=",
"number_served"
] | [
19,
4
] | [
21,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TwoPositionsSpeedAverage.calculate_distance | (self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) | return self.convert_distance_vector_from_pixels(distance_pixels) | Calcular la distancia entre dos detecciones del objeto.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: distancia entre las dos posiciones del objeto.
| Calcular la distancia entre dos detecciones del objeto. | def calculate_distance(self,
tracked_object: TrackedObject,
index_initial: int = 0,
index_final: int = -1) -> FloatVector2D:
"""Calcular la distancia entre dos detecciones del objeto.
:param tracked_object: objeto seguido.
:param index_initial: índice inicial del historial del objeto.
:param index_final: índice final del historial del objeto.
:return: distancia entre las dos posiciones del objeto.
"""
initial_position = self.get_object_point(tracked_object[index_initial].object)
final_position = self.get_object_point(tracked_object[index_final].object)
distance_pixels = tuple(abs(np.array(initial_position) - np.array(final_position)))
distance_pixels = FloatVector2D(*distance_pixels)
return self.convert_distance_vector_from_pixels(distance_pixels) | [
"def",
"calculate_distance",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
",",
"index_initial",
":",
"int",
"=",
"0",
",",
"index_final",
":",
"int",
"=",
"-",
"1",
")",
"->",
"FloatVector2D",
":",
"initial_position",
"=",
"self",
".",
"get_object_point",
"(",
"tracked_object",
"[",
"index_initial",
"]",
".",
"object",
")",
"final_position",
"=",
"self",
".",
"get_object_point",
"(",
"tracked_object",
"[",
"index_final",
"]",
".",
"object",
")",
"distance_pixels",
"=",
"tuple",
"(",
"abs",
"(",
"np",
".",
"array",
"(",
"initial_position",
")",
"-",
"np",
".",
"array",
"(",
"final_position",
")",
")",
")",
"distance_pixels",
"=",
"FloatVector2D",
"(",
"*",
"distance_pixels",
")",
"return",
"self",
".",
"convert_distance_vector_from_pixels",
"(",
"distance_pixels",
")"
] | [
27,
4
] | [
42,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_combinaciones1_2 | (p) | combinaciones1 : ID combinaciones2 | combinaciones1 : ID combinaciones2 | def p_combinaciones1_2(p):
'combinaciones1 : ID combinaciones2' | [
"def",
"p_combinaciones1_2",
"(",
"p",
")",
":"
] | [
568,
0
] | [
569,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cambiar_curso_publico | () | return redirect(url_for("curso", course_code=request.args.get("curse"))) | Actualiza el estado publico de un curso. | Actualiza el estado publico de un curso. | def cambiar_curso_publico():
"""Actualiza el estado publico de un curso."""
cambia_curso_publico(
id_curso=request.args.get("curse"),
)
return redirect(url_for("curso", course_code=request.args.get("curse"))) | [
"def",
"cambiar_curso_publico",
"(",
")",
":",
"cambia_curso_publico",
"(",
"id_curso",
"=",
"request",
".",
"args",
".",
"get",
"(",
"\"curse\"",
")",
",",
")",
"return",
"redirect",
"(",
"url_for",
"(",
"\"curso\"",
",",
"course_code",
"=",
"request",
".",
"args",
".",
"get",
"(",
"\"curse\"",
")",
")",
")"
] | [
885,
0
] | [
890,
76
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ServiceCallback.service2id | (service_name: str, *, cursor) | Obtiene el identificador del nodo si tiene un servicio específico | Obtiene el identificador del nodo si tiene un servicio específico | async def service2id(service_name: str, *, cursor) -> AsyncIterator[int]:
"""Obtiene el identificador del nodo si tiene un servicio específico"""
await cursor.execute(
"SELECT id_network FROM services WHERE service = %s ORDER BY priority DESC",
(service_name,)
)
while (networkid := await cursor.fetchone()):
yield networkid | [
"async",
"def",
"service2id",
"(",
"service_name",
":",
"str",
",",
"*",
",",
"cursor",
")",
"->",
"AsyncIterator",
"[",
"int",
"]",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT id_network FROM services WHERE service = %s ORDER BY priority DESC\"",
",",
"(",
"service_name",
",",
")",
")",
"while",
"(",
"networkid",
":=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
")",
":",
"yield",
"networkid"
] | [
686,
4
] | [
696,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
show | (
service_file: str = "services/",
sub_service: bool = True,
autoreload: bool = False,
only_name: bool = False
) | Muestra la información extraida de cada
Args:
service_file:
La ubicación de la carpeta de los servicios
sub_service:
**True** para mostrar los sub-servicios; **False**
de lo contrario.
autoreload:
**True** para autorecargar el módulo al ser modificado.
Tiene que estar habilitado con `tornado.autoreload.start()`
only_name:
**True** para mostrar solo el nombre.
Esta opción no carga el archivo en memoria, simplemente busca
y parsea el nombre.
Returns:
Un iterador que contiene una con la información del
servicio actualmente analizado.
| Muestra la información extraida de cada | def show(
service_file: str = "services/",
sub_service: bool = True,
autoreload: bool = False,
only_name: bool = False
) -> Iterator[dict]:
"""Muestra la información extraida de cada
Args:
service_file:
La ubicación de la carpeta de los servicios
sub_service:
**True** para mostrar los sub-servicios; **False**
de lo contrario.
autoreload:
**True** para autorecargar el módulo al ser modificado.
Tiene que estar habilitado con `tornado.autoreload.start()`
only_name:
**True** para mostrar solo el nombre.
Esta opción no carga el archivo en memoria, simplemente busca
y parsea el nombre.
Returns:
Un iterador que contiene una con la información del
servicio actualmente analizado.
"""
service_file = remove_badchars.remove(service_file, "/")
for dir in pathlib.Path(service_file).iterdir():
if not (dir.is_dir()):
continue
index = "%s/%s.py" % (dir.as_posix(), dir.name)
if not (os.path.isfile(index)):
logging.warning(_("No existe '%s.py' en el servicio '%s'"), dir.name, dir.as_posix())
else:
yield get_service(index, autoreload, True, only_name)
if (sub_service):
for file in pathlib.Path(dir).rglob("*.py"):
if (file.as_posix() != index) and (file.is_file()):
yield get_service(file.as_posix(), autoreload, only_name=only_name) | [
"def",
"show",
"(",
"service_file",
":",
"str",
"=",
"\"services/\"",
",",
"sub_service",
":",
"bool",
"=",
"True",
",",
"autoreload",
":",
"bool",
"=",
"False",
",",
"only_name",
":",
"bool",
"=",
"False",
")",
"->",
"Iterator",
"[",
"dict",
"]",
":",
"service_file",
"=",
"remove_badchars",
".",
"remove",
"(",
"service_file",
",",
"\"/\"",
")",
"for",
"dir",
"in",
"pathlib",
".",
"Path",
"(",
"service_file",
")",
".",
"iterdir",
"(",
")",
":",
"if",
"not",
"(",
"dir",
".",
"is_dir",
"(",
")",
")",
":",
"continue",
"index",
"=",
"\"%s/%s.py\"",
"%",
"(",
"dir",
".",
"as_posix",
"(",
")",
",",
"dir",
".",
"name",
")",
"if",
"not",
"(",
"os",
".",
"path",
".",
"isfile",
"(",
"index",
")",
")",
":",
"logging",
".",
"warning",
"(",
"_",
"(",
"\"No existe '%s.py' en el servicio '%s'\"",
")",
",",
"dir",
".",
"name",
",",
"dir",
".",
"as_posix",
"(",
")",
")",
"else",
":",
"yield",
"get_service",
"(",
"index",
",",
"autoreload",
",",
"True",
",",
"only_name",
")",
"if",
"(",
"sub_service",
")",
":",
"for",
"file",
"in",
"pathlib",
".",
"Path",
"(",
"dir",
")",
".",
"rglob",
"(",
"\"*.py\"",
")",
":",
"if",
"(",
"file",
".",
"as_posix",
"(",
")",
"!=",
"index",
")",
"and",
"(",
"file",
".",
"is_file",
"(",
")",
")",
":",
"yield",
"get_service",
"(",
"file",
".",
"as_posix",
"(",
")",
",",
"autoreload",
",",
"only_name",
"=",
"only_name",
")"
] | [
186,
0
] | [
234,
87
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
planilla.crear_grupo | (self, cant_) | return self.Grupos_ | crear_grupo(cant_) crea una cant_ de grupos conformado aleatoriamente | crear_grupo(cant_) crea una cant_ de grupos conformado aleatoriamente | def crear_grupo(self, cant_):
"crear_grupo(cant_) crea una cant_ de grupos conformado aleatoriamente"
self.crear_lista() #Llama el metodo crear lista para tener la lista Participantes_ actualizada
listaC_ = list(ra.sample(self.Participantes_,len(self.Participantes_)))
#listaC_ es una lista como
self.Grupos_= {}
for i in range(cant_):
key = str("Grupo: "+str(i))
datos = [[],[]]
self.Grupos_[key] = datos #Resetea self.Grupos_
while listaC_ != []: #Mantiene este boclet hasta que listaC_ se quede sin elementos
for ikey, ivalue in self.Grupos_.items():
if listaC_ != []:
elegido_=listaC_.pop()
ivalue[0].append(elegido_)
ivalue[1].append(self.Planilla_[self.buscar_alia(elegido_)][1])
else:
break
return self.Grupos_ | [
"def",
"crear_grupo",
"(",
"self",
",",
"cant_",
")",
":",
"self",
".",
"crear_lista",
"(",
")",
"#Llama el metodo crear lista para tener la lista Participantes_ actualizada",
"listaC_",
"=",
"list",
"(",
"ra",
".",
"sample",
"(",
"self",
".",
"Participantes_",
",",
"len",
"(",
"self",
".",
"Participantes_",
")",
")",
")",
"#listaC_ es una lista como ",
"self",
".",
"Grupos_",
"=",
"{",
"}",
"for",
"i",
"in",
"range",
"(",
"cant_",
")",
":",
"key",
"=",
"str",
"(",
"\"Grupo: \"",
"+",
"str",
"(",
"i",
")",
")",
"datos",
"=",
"[",
"[",
"]",
",",
"[",
"]",
"]",
"self",
".",
"Grupos_",
"[",
"key",
"]",
"=",
"datos",
"#Resetea self.Grupos_",
"while",
"listaC_",
"!=",
"[",
"]",
":",
"#Mantiene este boclet hasta que listaC_ se quede sin elementos",
"for",
"ikey",
",",
"ivalue",
"in",
"self",
".",
"Grupos_",
".",
"items",
"(",
")",
":",
"if",
"listaC_",
"!=",
"[",
"]",
":",
"elegido_",
"=",
"listaC_",
".",
"pop",
"(",
")",
"ivalue",
"[",
"0",
"]",
".",
"append",
"(",
"elegido_",
")",
"ivalue",
"[",
"1",
"]",
".",
"append",
"(",
"self",
".",
"Planilla_",
"[",
"self",
".",
"buscar_alia",
"(",
"elegido_",
")",
"]",
"[",
"1",
"]",
")",
"else",
":",
"break",
"return",
"self",
".",
"Grupos_"
] | [
102,
4
] | [
122,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
contar | (frase: str) | return {
"vocales": vocales, "consonantes": consonantes,
"mayusculas": mayusculas, "minusculas": minusculas,
"digitos": digitos,
} | Cuenta vocales, consonantes, mayúsculas, minúsculas y digitos de
una frase.
:param frase: La frase a contar.
:frase type: str
:return: Un diccionario con las cantidades de vocales, consonantes
y digitos.
:rtype: Dict[str, int]
| Cuenta vocales, consonantes, mayúsculas, minúsculas y digitos de
una frase. | def contar(frase: str) -> Dict[str, int]:
"""Cuenta vocales, consonantes, mayúsculas, minúsculas y digitos de
una frase.
:param frase: La frase a contar.
:frase type: str
:return: Un diccionario con las cantidades de vocales, consonantes
y digitos.
:rtype: Dict[str, int]
"""
frase: str = frase
vocales: int = 0
consonantes: int = 0
mayusculas: int = 0
minusculas: int = 0
digitos: int = 0
for caracter in frase:
if caracter in "aeiouáéíóú" or caracter in "AEIOUÁÉÍÓÚ":
vocales += 1
if caracter in "bcdfghjklmnñpqrstvwxyzBCDFGHJKLMNÑPQRSTVWXYZ":
consonantes += 1
if caracter in "ABCDEFGHIJKLMNÑOPQRSTUVWXYZÁÉÍÓÚ":
mayusculas += 1
if caracter in "abcdefghijklmnñopqrstuvwxyzáéíóú":
minusculas += 1
if caracter in "0123456789":
digitos += 1
return {
"vocales": vocales, "consonantes": consonantes,
"mayusculas": mayusculas, "minusculas": minusculas,
"digitos": digitos,
} | [
"def",
"contar",
"(",
"frase",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"int",
"]",
":",
"frase",
":",
"str",
"=",
"frase",
"vocales",
":",
"int",
"=",
"0",
"consonantes",
":",
"int",
"=",
"0",
"mayusculas",
":",
"int",
"=",
"0",
"minusculas",
":",
"int",
"=",
"0",
"digitos",
":",
"int",
"=",
"0",
"for",
"caracter",
"in",
"frase",
":",
"if",
"caracter",
"in",
"\"aeiouáéíóú\" or c",
"ra",
"ter in \"",
"EI",
"UÁÉÍÓÚ\":",
"",
"vocales",
"+=",
"1",
"if",
"caracter",
"in",
"\"bcdfghjklmnñpqrstvwxyzBCDFGHJKLMNÑPQRSTVWXYZ\":",
"",
"consonantes",
"+=",
"1",
"if",
"caracter",
"in",
"\"ABCDEFGHIJKLMNÑOPQRSTUVWXYZÁÉÍÓÚ\":",
"",
"mayusculas",
"+=",
"1",
"if",
"caracter",
"in",
"\"abcdefghijklmnñopqrstuvwxyzáéíóú\":",
"",
"minusculas",
"+=",
"1",
"if",
"caracter",
"in",
"\"0123456789\"",
":",
"digitos",
"+=",
"1",
"return",
"{",
"\"vocales\"",
":",
"vocales",
",",
"\"consonantes\"",
":",
"consonantes",
",",
"\"mayusculas\"",
":",
"mayusculas",
",",
"\"minusculas\"",
":",
"minusculas",
",",
"\"digitos\"",
":",
"digitos",
",",
"}"
] | [
21,
0
] | [
52,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
create_database | (host=None, user=None, passwd=None, db_name=None) | Función encargada de crear la base de datos. Puede ser llamada en caso de recibir en la configuración:
`operation: init`
Parameters
----------
host: str
fqdn de la base de datos a la que se conectará el programa
user: str
usuario con el que el programa se conectará a la base de datos
passwd: str
contraseña con la que se el usuario se autenticará en la base de datos
db_name: str
nombre de la base de datos a la que conectarse
| Función encargada de crear la base de datos. Puede ser llamada en caso de recibir en la configuración:
`operation: init` | def create_database(host=None, user=None, passwd=None, db_name=None):
"""Función encargada de crear la base de datos. Puede ser llamada en caso de recibir en la configuración:
`operation: init`
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
"""
sql_create_database = "CREATE DATABASE {db_name} WITH ENCODING 'UTF8'"
db = psycopg2.connect(
host=host,
user=user,
password=passwd
)
db.autocommit = True
cursor = db.cursor()
cursor.execute(sql_create_database.format(db_name=db_name))
cursor.close()
db.close() | [
"def",
"create_database",
"(",
"host",
"=",
"None",
",",
"user",
"=",
"None",
",",
"passwd",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"sql_create_database",
"=",
"\"CREATE DATABASE {db_name} WITH ENCODING 'UTF8'\"",
"db",
"=",
"psycopg2",
".",
"connect",
"(",
"host",
"=",
"host",
",",
"user",
"=",
"user",
",",
"password",
"=",
"passwd",
")",
"db",
".",
"autocommit",
"=",
"True",
"cursor",
"=",
"db",
".",
"cursor",
"(",
")",
"cursor",
".",
"execute",
"(",
"sql_create_database",
".",
"format",
"(",
"db_name",
"=",
"db_name",
")",
")",
"cursor",
".",
"close",
"(",
")",
"db",
".",
"close",
"(",
")"
] | [
174,
0
] | [
200,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.simplificar_geometria | (self, tolerance=0.5,
keep_original=True, inplace=False) | Simplifica una geometría para que resulte
en un objeto de menor tamaño y complejidad,
que a la vez retenga sus características esenciales.
Args:
tolerance (float): Nivel de tolerancia en la transformación.
Returns:
pandas.Series: Serie de geometrías.
| Simplifica una geometría para que resulte
en un objeto de menor tamaño y complejidad,
que a la vez retenga sus características esenciales. | def simplificar_geometria(self, tolerance=0.5,
keep_original=True, inplace=False):
"""Simplifica una geometría para que resulte
en un objeto de menor tamaño y complejidad,
que a la vez retenga sus características esenciales.
Args:
tolerance (float): Nivel de tolerancia en la transformación.
Returns:
pandas.Series: Serie de geometrías.
"""
if isinstance(self.df, gpd.GeoDataFrame):
self.df.geometry = self.df.geometry.simplify(tolerance)
return self.df.geometry
else:
raise TypeError('El dataframe no es de tipo GeoDataFrame.') | [
"def",
"simplificar_geometria",
"(",
"self",
",",
"tolerance",
"=",
"0.5",
",",
"keep_original",
"=",
"True",
",",
"inplace",
"=",
"False",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"df",
",",
"gpd",
".",
"GeoDataFrame",
")",
":",
"self",
".",
"df",
".",
"geometry",
"=",
"self",
".",
"df",
".",
"geometry",
".",
"simplify",
"(",
"tolerance",
")",
"return",
"self",
".",
"df",
".",
"geometry",
"else",
":",
"raise",
"TypeError",
"(",
"'El dataframe no es de tipo GeoDataFrame.'",
")"
] | [
746,
4
] | [
762,
71
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
testStatus.test_http200 | (self) | Valida que exista respuesta en el http 200 | Valida que exista respuesta en el http 200 | def test_http200(self):
"""Valida que exista respuesta en el http 200"""
client = Client()
url = '/Devops'
data = {"message": "This is a test", "to": "Juan Perez", "from": "Rita Asturia", "timeToLifeSec": 45}
response = client.post(url, data, format='json',HTTP_X_PARSE_REST_API_KEY= API_KEY_SECRET)
self.assertEqual(response.status_code, status.HTTP_200_OK) | [
"def",
"test_http200",
"(",
"self",
")",
":",
"client",
"=",
"Client",
"(",
")",
"url",
"=",
"'/Devops'",
"data",
"=",
"{",
"\"message\"",
":",
"\"This is a test\"",
",",
"\"to\"",
":",
"\"Juan Perez\"",
",",
"\"from\"",
":",
"\"Rita Asturia\"",
",",
"\"timeToLifeSec\"",
":",
"45",
"}",
"response",
"=",
"client",
".",
"post",
"(",
"url",
",",
"data",
",",
"format",
"=",
"'json'",
",",
"HTTP_X_PARSE_REST_API_KEY",
"=",
"API_KEY_SECRET",
")",
"self",
".",
"assertEqual",
"(",
"response",
".",
"status_code",
",",
"status",
".",
"HTTP_200_OK",
")"
] | [
35,
4
] | [
43,
66
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
HolaViewSet.destroy | (self, request, pk=None) | return Response({'method': 'DELETE'}) | Maneja la eliminacion de un objeto por un ID | Maneja la eliminacion de un objeto por un ID | def destroy(self, request, pk=None):
"""Maneja la eliminacion de un objeto por un ID"""
return Response({'method': 'DELETE'}) | [
"def",
"destroy",
"(",
"self",
",",
"request",
",",
"pk",
"=",
"None",
")",
":",
"return",
"Response",
"(",
"{",
"'method'",
":",
"'DELETE'",
"}",
")"
] | [
94,
4
] | [
96,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ArregloDinamico.remove_all | (self, obj: py_object) | Remueve todas las ocurrencias de un elemento del arreglo
:param obj: elemento a remover
:obj type: py_object
| Remueve todas las ocurrencias de un elemento del arreglo | def remove_all(self, obj: py_object) -> None:
"""Remueve todas las ocurrencias de un elemento del arreglo
:param obj: elemento a remover
:obj type: py_object
"""
B = self._crear(self._n)
i = 0
for k in range(self._n):
if self._A[k] != obj:
B[i] = self._A[k]
i += 1
self._n = i
self._A = B | [
"def",
"remove_all",
"(",
"self",
",",
"obj",
":",
"py_object",
")",
"->",
"None",
":",
"B",
"=",
"self",
".",
"_crear",
"(",
"self",
".",
"_n",
")",
"i",
"=",
"0",
"for",
"k",
"in",
"range",
"(",
"self",
".",
"_n",
")",
":",
"if",
"self",
".",
"_A",
"[",
"k",
"]",
"!=",
"obj",
":",
"B",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"k",
"]",
"i",
"+=",
"1",
"self",
".",
"_n",
"=",
"i",
"self",
".",
"_A",
"=",
"B"
] | [
98,
4
] | [
111,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AbstractGMapsExtractor.get_driver | (self) | return self._driver | Devuelve la instancia del driver asociado a la instancia en el atributo: self._driver | Devuelve la instancia del driver asociado a la instancia en el atributo: self._driver | def get_driver(self):
"""Devuelve la instancia del driver asociado a la instancia en el atributo: self._driver"""
return self._driver | [
"def",
"get_driver",
"(",
"self",
")",
":",
"return",
"self",
".",
"_driver"
] | [
271,
4
] | [
273,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Parser.get_message | (
self,
data: bytes,
verify_key: bytes,
*args, **kwargs
) | return hibrid.decrypt(
verify_key,
self.session.destination,
self.session.source.private,
data,
*args, **kwargs
) | Descifra la respuesta del servidor.
Esta es la contraparte de `reply()`
Args:
data:
Los datos a descifrar
verify_key:
La clave de verificación
Returns:
Los datos descifrados y verificados
| Descifra la respuesta del servidor. | def get_message(
self,
data: bytes,
verify_key: bytes,
*args, **kwargs
) -> bytes:
"""Descifra la respuesta del servidor.
Esta es la contraparte de `reply()`
Args:
data:
Los datos a descifrar
verify_key:
La clave de verificación
Returns:
Los datos descifrados y verificados
"""
return hibrid.decrypt(
verify_key,
self.session.destination,
self.session.source.private,
data,
*args, **kwargs
) | [
"def",
"get_message",
"(",
"self",
",",
"data",
":",
"bytes",
",",
"verify_key",
":",
"bytes",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"bytes",
":",
"return",
"hibrid",
".",
"decrypt",
"(",
"verify_key",
",",
"self",
".",
"session",
".",
"destination",
",",
"self",
".",
"session",
".",
"source",
".",
"private",
",",
"data",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | [
214,
4
] | [
243,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_text | (archivo_scr, view=False) | return(output) | Funcion para reconocer texto en una imagen | Funcion para reconocer texto en una imagen | def get_text(archivo_scr, view=False):
""" Funcion para reconocer texto en una imagen """
# Cargamos la imagen
image = PIL.Image.open(archivo_scr).convert("RGB")
image = np.array(image)
#-----------------
# convert the warped image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.medianBlur(gray, 5)
# sharpen image
sharpen = cv2.GaussianBlur(gray, (7,7), 0)
#Get the best value for T with otsu thresholding
(T, threshInv) = cv2.threshold(sharpen, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
threshInv = cv2.erode(threshInv, None, iterations=2)
threshInv = cv2.dilate(threshInv, None, iterations=2)
# Detectamos los perfiles del documento segmentado
profile_h = threshInv.sum(0)
profile_v = threshInv.sum(1)
# Umbralizamos de acuerdo a la densidad de pixeles del documento
eje_x = np.where(profile_h > 200000)[0]
eje_y = np.where(profile_v > 200000)[0]
# Encontramos los vertices del documento
coor_x0 = eje_x[0]
coor_xf = eje_x[len(eje_x)-1]
coor_y0 = eje_y[0]
coor_yf = eje_y[len(eje_y)-1]
# Recortamos la imagen principal
image = image[coor_y0:coor_yf,coor_x0:coor_xf,:]
#-----------------
# Detectamos la orientacion con tesseract
if image.shape[1]<4000:
osd = pytesseract.image_to_osd(image)
angle = 360-int(re.search('(?<=Rotate: )\d+', osd).group(0))
else:
angle = 0
# Rotamos la imagen en caso de ser necesario
if angle!=0 and angle!=360:
rotated = ndimage.rotate(image, float(angle))
del image, osd, angle
image = rotated
#-----------------
## Iniciamos la limpieza de la imagen
# convert the warped image to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
# sharpen image
sharpen = cv2.GaussianBlur(gray, (0,0), 3)
sharpen = cv2.addWeighted(gray, 1.5, sharpen, -0.5, 0)
# apply adaptive threshold to get black and white effect
thresh = cv2.adaptiveThreshold(sharpen, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 71, 21)
thresh = cv2.medianBlur(thresh,3)
del sharpen, gray
## Analysis of connected components
# Etiquetamos cada region
label_im, nb_labels = ndimage.label(thresh)
# Calculamos el area de cada region
sizes = ndimage.sum(thresh, label_im, range(nb_labels + 1))
# Eliminamos las regiones con area menor al umbral (chicas)
mask_size = sizes < 2000
remove_pixel = mask_size[label_im]
remove_pixel.shape
label_im[remove_pixel] = 0
del remove_pixel, mask_size, sizes, nb_labels, thresh
# Usamos Tesseract para reconocer el texto
output = pytesseract.image_to_string(label_im>0, lang="eng")
if view:
# Visualizamos la segmentacion del texto
plt.figure(figsize=(15,10))
plt.imshow(label_im>0, cmap="gray")
plt.show()
print(output)
return(output) | [
"def",
"get_text",
"(",
"archivo_scr",
",",
"view",
"=",
"False",
")",
":",
"# Cargamos la imagen",
"image",
"=",
"PIL",
".",
"Image",
".",
"open",
"(",
"archivo_scr",
")",
".",
"convert",
"(",
"\"RGB\"",
")",
"image",
"=",
"np",
".",
"array",
"(",
"image",
")",
"#-----------------",
"# convert the warped image to grayscale",
"gray",
"=",
"cv2",
".",
"cvtColor",
"(",
"image",
",",
"cv2",
".",
"COLOR_BGR2GRAY",
")",
"blur",
"=",
"cv2",
".",
"medianBlur",
"(",
"gray",
",",
"5",
")",
"# sharpen image",
"sharpen",
"=",
"cv2",
".",
"GaussianBlur",
"(",
"gray",
",",
"(",
"7",
",",
"7",
")",
",",
"0",
")",
"#Get the best value for T with otsu thresholding",
"(",
"T",
",",
"threshInv",
")",
"=",
"cv2",
".",
"threshold",
"(",
"sharpen",
",",
"0",
",",
"255",
",",
"cv2",
".",
"THRESH_BINARY",
"|",
"cv2",
".",
"THRESH_OTSU",
")",
"threshInv",
"=",
"cv2",
".",
"erode",
"(",
"threshInv",
",",
"None",
",",
"iterations",
"=",
"2",
")",
"threshInv",
"=",
"cv2",
".",
"dilate",
"(",
"threshInv",
",",
"None",
",",
"iterations",
"=",
"2",
")",
"# Detectamos los perfiles del documento segmentado",
"profile_h",
"=",
"threshInv",
".",
"sum",
"(",
"0",
")",
"profile_v",
"=",
"threshInv",
".",
"sum",
"(",
"1",
")",
"# Umbralizamos de acuerdo a la densidad de pixeles del documento",
"eje_x",
"=",
"np",
".",
"where",
"(",
"profile_h",
">",
"200000",
")",
"[",
"0",
"]",
"eje_y",
"=",
"np",
".",
"where",
"(",
"profile_v",
">",
"200000",
")",
"[",
"0",
"]",
"# Encontramos los vertices del documento",
"coor_x0",
"=",
"eje_x",
"[",
"0",
"]",
"coor_xf",
"=",
"eje_x",
"[",
"len",
"(",
"eje_x",
")",
"-",
"1",
"]",
"coor_y0",
"=",
"eje_y",
"[",
"0",
"]",
"coor_yf",
"=",
"eje_y",
"[",
"len",
"(",
"eje_y",
")",
"-",
"1",
"]",
"# Recortamos la imagen principal",
"image",
"=",
"image",
"[",
"coor_y0",
":",
"coor_yf",
",",
"coor_x0",
":",
"coor_xf",
",",
":",
"]",
"#-----------------",
"# Detectamos la orientacion con tesseract",
"if",
"image",
".",
"shape",
"[",
"1",
"]",
"<",
"4000",
":",
"osd",
"=",
"pytesseract",
".",
"image_to_osd",
"(",
"image",
")",
"angle",
"=",
"360",
"-",
"int",
"(",
"re",
".",
"search",
"(",
"'(?<=Rotate: )\\d+'",
",",
"osd",
")",
".",
"group",
"(",
"0",
")",
")",
"else",
":",
"angle",
"=",
"0",
"# Rotamos la imagen en caso de ser necesario",
"if",
"angle",
"!=",
"0",
"and",
"angle",
"!=",
"360",
":",
"rotated",
"=",
"ndimage",
".",
"rotate",
"(",
"image",
",",
"float",
"(",
"angle",
")",
")",
"del",
"image",
",",
"osd",
",",
"angle",
"image",
"=",
"rotated",
"#-----------------",
"## Iniciamos la limpieza de la imagen",
"# convert the warped image to grayscale",
"gray",
"=",
"cv2",
".",
"cvtColor",
"(",
"image",
",",
"cv2",
".",
"COLOR_RGB2GRAY",
")",
"# sharpen image",
"sharpen",
"=",
"cv2",
".",
"GaussianBlur",
"(",
"gray",
",",
"(",
"0",
",",
"0",
")",
",",
"3",
")",
"sharpen",
"=",
"cv2",
".",
"addWeighted",
"(",
"gray",
",",
"1.5",
",",
"sharpen",
",",
"-",
"0.5",
",",
"0",
")",
"# apply adaptive threshold to get black and white effect",
"thresh",
"=",
"cv2",
".",
"adaptiveThreshold",
"(",
"sharpen",
",",
"255",
",",
"cv2",
".",
"ADAPTIVE_THRESH_GAUSSIAN_C",
",",
"cv2",
".",
"THRESH_BINARY_INV",
",",
"71",
",",
"21",
")",
"thresh",
"=",
"cv2",
".",
"medianBlur",
"(",
"thresh",
",",
"3",
")",
"del",
"sharpen",
",",
"gray",
"## Analysis of connected components",
"# Etiquetamos cada region",
"label_im",
",",
"nb_labels",
"=",
"ndimage",
".",
"label",
"(",
"thresh",
")",
"# Calculamos el area de cada region",
"sizes",
"=",
"ndimage",
".",
"sum",
"(",
"thresh",
",",
"label_im",
",",
"range",
"(",
"nb_labels",
"+",
"1",
")",
")",
"# Eliminamos las regiones con area menor al umbral (chicas)",
"mask_size",
"=",
"sizes",
"<",
"2000",
"remove_pixel",
"=",
"mask_size",
"[",
"label_im",
"]",
"remove_pixel",
".",
"shape",
"label_im",
"[",
"remove_pixel",
"]",
"=",
"0",
"del",
"remove_pixel",
",",
"mask_size",
",",
"sizes",
",",
"nb_labels",
",",
"thresh",
"# Usamos Tesseract para reconocer el texto",
"output",
"=",
"pytesseract",
".",
"image_to_string",
"(",
"label_im",
">",
"0",
",",
"lang",
"=",
"\"eng\"",
")",
"if",
"view",
":",
"# Visualizamos la segmentacion del texto",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"15",
",",
"10",
")",
")",
"plt",
".",
"imshow",
"(",
"label_im",
">",
"0",
",",
"cmap",
"=",
"\"gray\"",
")",
"plt",
".",
"show",
"(",
")",
"print",
"(",
"output",
")",
"return",
"(",
"output",
")"
] | [
48,
0
] | [
140,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Url.is_absolute | (self) | return bool(self.urlparsed.netloc) if self.urlparsed else False | Si es sólo un path o una dirección entera
| Si es sólo un path o una dirección entera
| def is_absolute(self):
"""Si es sólo un path o una dirección entera
"""
return bool(self.urlparsed.netloc) if self.urlparsed else False | [
"def",
"is_absolute",
"(",
"self",
")",
":",
"return",
"bool",
"(",
"self",
".",
"urlparsed",
".",
"netloc",
")",
"if",
"self",
".",
"urlparsed",
"else",
"False"
] | [
73,
4
] | [
76,
71
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Hasar2GenComandos.cancelDocument | (self) | return self.conector.sendCommand( jdata ) | Cancela el documento que esté abierto | Cancela el documento que esté abierto | def cancelDocument(self):
"""Cancela el documento que esté abierto"""
jdata = {"Cancelar" : {}}
return self.conector.sendCommand( jdata ) | [
"def",
"cancelDocument",
"(",
"self",
")",
":",
"jdata",
"=",
"{",
"\"Cancelar\"",
":",
"{",
"}",
"}",
"return",
"self",
".",
"conector",
".",
"sendCommand",
"(",
"jdata",
")"
] | [
143,
1
] | [
146,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
SchoolMember.funcion_de | (self) | return f"Funcion de {type(self).__name__}: \n" | Returnea la funcion del puesto | Returnea la funcion del puesto | def funcion_de(self):
""" Returnea la funcion del puesto"""
return f"Funcion de {type(self).__name__}: \n" | [
"def",
"funcion_de",
"(",
"self",
")",
":",
"return",
"f\"Funcion de {type(self).__name__}: \\n\""
] | [
12,
4
] | [
14,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
resultados | (arr: List[int]) | return {
k:v for k, v in zip(
llaves, (
len(arr),
len(list(filter(lambda x: x >= 11, arr))),
len(list(filter(lambda x: x < 11, arr))),
sum(arr) / len(arr)
)
)
} | Devuelve un diccionario con los resuldatos de la notas.
:param arr: Lista con las notas.
:arr type: List[int]
:return: Diccionario con los resultados.
:rtype: Dict[str, float]
| Devuelve un diccionario con los resuldatos de la notas. | def resultados(arr: List[int]) -> Dict[str, float]:
"""Devuelve un diccionario con los resuldatos de la notas.
:param arr: Lista con las notas.
:arr type: List[int]
:return: Diccionario con los resultados.
:rtype: Dict[str, float]
"""
llaves = ("cantidad", "mayores", "menores", "promedio")
return {
k:v for k, v in zip(
llaves, (
len(arr),
len(list(filter(lambda x: x >= 11, arr))),
len(list(filter(lambda x: x < 11, arr))),
sum(arr) / len(arr)
)
)
} | [
"def",
"resultados",
"(",
"arr",
":",
"List",
"[",
"int",
"]",
")",
"->",
"Dict",
"[",
"str",
",",
"float",
"]",
":",
"llaves",
"=",
"(",
"\"cantidad\"",
",",
"\"mayores\"",
",",
"\"menores\"",
",",
"\"promedio\"",
")",
"return",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"zip",
"(",
"llaves",
",",
"(",
"len",
"(",
"arr",
")",
",",
"len",
"(",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"x",
">=",
"11",
",",
"arr",
")",
")",
")",
",",
"len",
"(",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"x",
"<",
"11",
",",
"arr",
")",
")",
")",
",",
"sum",
"(",
"arr",
")",
"/",
"len",
"(",
"arr",
")",
")",
")",
"}"
] | [
64,
0
] | [
82,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
plotMatrix | (matrix, title, labels=False) | Función para visualizar una matriz como un mapa de calor
Args:
matrix: matriz a visualizar
title: título para el gráfico generado
labels: booleano que determina si se añaden etiquetas a los ejes
| Función para visualizar una matriz como un mapa de calor | def plotMatrix(matrix, title, labels=False):
""" Función para visualizar una matriz como un mapa de calor
Args:
matrix: matriz a visualizar
title: título para el gráfico generado
labels: booleano que determina si se añaden etiquetas a los ejes
"""
plt.figure(figsize=(8,8))
plt.matshow(matrix, cmap='viridis')
plt.colorbar()
plt.title(title,fontsize=15)
if labels:
plt.ylabel('Verdaderos')
plt.xlabel('Predicciones')
plt.show() | [
"def",
"plotMatrix",
"(",
"matrix",
",",
"title",
",",
"labels",
"=",
"False",
")",
":",
"plt",
".",
"figure",
"(",
"figsize",
"=",
"(",
"8",
",",
"8",
")",
")",
"plt",
".",
"matshow",
"(",
"matrix",
",",
"cmap",
"=",
"'viridis'",
")",
"plt",
".",
"colorbar",
"(",
")",
"plt",
".",
"title",
"(",
"title",
",",
"fontsize",
"=",
"15",
")",
"if",
"labels",
":",
"plt",
".",
"ylabel",
"(",
"'Verdaderos'",
")",
"plt",
".",
"xlabel",
"(",
"'Predicciones'",
")",
"plt",
".",
"show",
"(",
")"
] | [
265,
0
] | [
281,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
contar_palabra | (linea: str, palabra: str) | return linea.count(palabra) | Cuenta cuantas veces se repite una palabra en una cadena de
texto.
:param linea: Cadena de texto.
:linea type: str
:param palabra: Palabra a buscar.
:palabra type: str
:return: Cuantas veces se repite la palabra en la cadena.
:rtype: int
| Cuenta cuantas veces se repite una palabra en una cadena de
texto. | def contar_palabra(linea: str, palabra: str) -> int:
"""Cuenta cuantas veces se repite una palabra en una cadena de
texto.
:param linea: Cadena de texto.
:linea type: str
:param palabra: Palabra a buscar.
:palabra type: str
:return: Cuantas veces se repite la palabra en la cadena.
:rtype: int
"""
return linea.count(palabra) | [
"def",
"contar_palabra",
"(",
"linea",
":",
"str",
",",
"palabra",
":",
"str",
")",
"->",
"int",
":",
"return",
"linea",
".",
"count",
"(",
"palabra",
")"
] | [
9,
0
] | [
20,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BomRegister.get_all_products | (self) | return data | Extrae toda la información de los productos relacionados en un BomRegister.
La información aqui extraida está destinada a ser usada en el informe de Necesidad de compra
| Extrae toda la información de los productos relacionados en un BomRegister. | def get_all_products(self):
"""Extrae toda la información de los productos relacionados en un BomRegister.
La información aqui extraida está destinada a ser usada en el informe de Necesidad de compra
"""
boms = []
products = {}
for bom in self.boms_id:
boms.append(bom)
for child_bom in bom.bom_line_ids:
for inner_bom in child_bom.child_line_ids:
BomRegister.add_product(products, inner_bom, bom.total)
if len(child_bom.child_line_ids) == 0:
BomRegister.add_product(products, child_bom, bom.total)
data = {'material_lists': boms, 'products': products}
# print(data)
return data | [
"def",
"get_all_products",
"(",
"self",
")",
":",
"boms",
"=",
"[",
"]",
"products",
"=",
"{",
"}",
"for",
"bom",
"in",
"self",
".",
"boms_id",
":",
"boms",
".",
"append",
"(",
"bom",
")",
"for",
"child_bom",
"in",
"bom",
".",
"bom_line_ids",
":",
"for",
"inner_bom",
"in",
"child_bom",
".",
"child_line_ids",
":",
"BomRegister",
".",
"add_product",
"(",
"products",
",",
"inner_bom",
",",
"bom",
".",
"total",
")",
"if",
"len",
"(",
"child_bom",
".",
"child_line_ids",
")",
"==",
"0",
":",
"BomRegister",
".",
"add_product",
"(",
"products",
",",
"child_bom",
",",
"bom",
".",
"total",
")",
"data",
"=",
"{",
"'material_lists'",
":",
"boms",
",",
"'products'",
":",
"products",
"}",
"# print(data)",
"return",
"data"
] | [
66,
4
] | [
85,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sumatoria_primos | (a: int, b: int) | return sum(i for i in range(a, b + 1) if es_primo(i)) | Suma los primos entre a y b.
:param a: Limite inferior
:type a: int
:param b: Limite superior
:type b: int
:return: Suma de los primos entre a y b
:rtype: int
| Suma los primos entre a y b. | def sumatoria_primos(a: int, b: int) -> int:
"""Suma los primos entre a y b.
:param a: Limite inferior
:type a: int
:param b: Limite superior
:type b: int
:return: Suma de los primos entre a y b
:rtype: int
"""
return sum(i for i in range(a, b + 1) if es_primo(i)) | [
"def",
"sumatoria_primos",
"(",
"a",
":",
"int",
",",
"b",
":",
"int",
")",
"->",
"int",
":",
"return",
"sum",
"(",
"i",
"for",
"i",
"in",
"range",
"(",
"a",
",",
"b",
"+",
"1",
")",
"if",
"es_primo",
"(",
"i",
")",
")"
] | [
32,
0
] | [
42,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DataCleaner.string | (self, field, sufix=None, sort_tokens=False,
remove_duplicates=False, keep_original=False, inplace=False) | return parsed_series | Regla para todos los strings.
Aplica un algoritimo de clustering para normalizar strings que son
demasiado parecidos, sin pérdida de información.
Args:
field (str): Campo a limpiar.
Returns:
pandas.Series: Serie de strings limpios.
| Regla para todos los strings. | def string(self, field, sufix=None, sort_tokens=False,
remove_duplicates=False, keep_original=False, inplace=False):
"""Regla para todos los strings.
Aplica un algoritimo de clustering para normalizar strings que son
demasiado parecidos, sin pérdida de información.
Args:
field (str): Campo a limpiar.
Returns:
pandas.Series: Serie de strings limpios.
"""
sufix = sufix or self.DEFAULT_SUFIX
field = self._normalize_field(field)
series = self.df[field]
clusters, counts = group_fingerprint_strings(
series, sort_tokens=sort_tokens,
remove_duplicates=remove_duplicates)
replacements = get_best_replacements(clusters, counts)
parsed_series = pd.Series(replace_by_key(replacements, series))
parsed_series = parsed_series.str.strip()
if inplace:
self._update_series(field=field, sufix=sufix,
keep_original=keep_original,
new_series=parsed_series)
return parsed_series | [
"def",
"string",
"(",
"self",
",",
"field",
",",
"sufix",
"=",
"None",
",",
"sort_tokens",
"=",
"False",
",",
"remove_duplicates",
"=",
"False",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"sufix",
"=",
"sufix",
"or",
"self",
".",
"DEFAULT_SUFIX",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
"clusters",
",",
"counts",
"=",
"group_fingerprint_strings",
"(",
"series",
",",
"sort_tokens",
"=",
"sort_tokens",
",",
"remove_duplicates",
"=",
"remove_duplicates",
")",
"replacements",
"=",
"get_best_replacements",
"(",
"clusters",
",",
"counts",
")",
"parsed_series",
"=",
"pd",
".",
"Series",
"(",
"replace_by_key",
"(",
"replacements",
",",
"series",
")",
")",
"parsed_series",
"=",
"parsed_series",
".",
"str",
".",
"strip",
"(",
")",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"sufix",
"=",
"sufix",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"parsed_series",
")",
"return",
"parsed_series"
] | [
388,
4
] | [
417,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Molecule.get_center | (self) | return centro | Metodo para encontrar el centro geometrico de la molecula. | Metodo para encontrar el centro geometrico de la molecula. | def get_center(self):
""" Metodo para encontrar el centro geometrico de la molecula. """
atms = len(self.atoms)
centro = Matrix([[0,0,0]])
for i in xrange(atms):
centro = centro + self.atoms[i].coords
centro *= (1.0/atms)
return centro | [
"def",
"get_center",
"(",
"self",
")",
":",
"atms",
"=",
"len",
"(",
"self",
".",
"atoms",
")",
"centro",
"=",
"Matrix",
"(",
"[",
"[",
"0",
",",
"0",
",",
"0",
"]",
"]",
")",
"for",
"i",
"in",
"xrange",
"(",
"atms",
")",
":",
"centro",
"=",
"centro",
"+",
"self",
".",
"atoms",
"[",
"i",
"]",
".",
"coords",
"centro",
"*=",
"(",
"1.0",
"/",
"atms",
")",
"return",
"centro"
] | [
164,
4
] | [
171,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TablaValores.Et | (self) | return var | Retorna la nueva etiqueta L# y la incrementa | Retorna la nueva etiqueta L# y la incrementa | def Et(self):
'''Retorna la nueva etiqueta L# y la incrementa'''
var = 'L' + str(self.et)
self.et = self.et + 1
return var | [
"def",
"Et",
"(",
"self",
")",
":",
"var",
"=",
"'L'",
"+",
"str",
"(",
"self",
".",
"et",
")",
"self",
".",
"et",
"=",
"self",
".",
"et",
"+",
"1",
"return",
"var"
] | [
11,
4
] | [
15,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Estante.__contains__ | (self, clave) | Retorna True si existe una clave en el archivo shelve. | Retorna True si existe una clave en el archivo shelve. | def __contains__(self, clave):
"""Retorna True si existe una clave en el archivo shelve."""
try:
return clave in self.dic
except TypeError:
return False | [
"def",
"__contains__",
"(",
"self",
",",
"clave",
")",
":",
"try",
":",
"return",
"clave",
"in",
"self",
".",
"dic",
"except",
"TypeError",
":",
"return",
"False"
] | [
45,
4
] | [
50,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Counter.calc_days | (self) | return int(self.calc_seconds() // DAY) | Calcula los días transcurridos | Calcula los días transcurridos | def calc_days(self):
"""Calcula los días transcurridos"""
return int(self.calc_seconds() // DAY) | [
"def",
"calc_days",
"(",
"self",
")",
":",
"return",
"int",
"(",
"self",
".",
"calc_seconds",
"(",
")",
"//",
"DAY",
")"
] | [
39,
4
] | [
42,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UsuarioEnCentroDeSalud.save | (self, *args, **kwargs) | cuando un usuario es asignado a un
centro de salud es de hecho un
usuario administrativo | cuando un usuario es asignado a un
centro de salud es de hecho un
usuario administrativo | def save(self, *args, **kwargs):
""" cuando un usuario es asignado a un
centro de salud es de hecho un
usuario administrativo """
super().save(*args, **kwargs)
group, created = Group.objects.get_or_create(name=settings.GRUPO_ADMIN)
group.user_set.add(self.usuario) | [
"def",
"save",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"super",
"(",
")",
".",
"save",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"group",
",",
"created",
"=",
"Group",
".",
"objects",
".",
"get_or_create",
"(",
"name",
"=",
"settings",
".",
"GRUPO_ADMIN",
")",
"group",
".",
"user_set",
".",
"add",
"(",
"self",
".",
"usuario",
")"
] | [
43,
4
] | [
49,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
mezclarCuboTupla | (tupla, cubo) | Mezclar el cubo con movimientos definidos en un array de tuplas. | Mezclar el cubo con movimientos definidos en un array de tuplas. | def mezclarCuboTupla(tupla, cubo):
"""Mezclar el cubo con movimientos definidos en un array de tuplas."""
moverCubo(cubo, tupla[0], tupla[1])
print(str(tupla) + "\n" + str(cubo) + '\n') | [
"def",
"mezclarCuboTupla",
"(",
"tupla",
",",
"cubo",
")",
":",
"moverCubo",
"(",
"cubo",
",",
"tupla",
"[",
"0",
"]",
",",
"tupla",
"[",
"1",
"]",
")",
"print",
"(",
"str",
"(",
"tupla",
")",
"+",
"\"\\n\"",
"+",
"str",
"(",
"cubo",
")",
"+",
"'\\n'",
")"
] | [
39,
0
] | [
42,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
convert | (key: str, value: Any, type: Callable[..., Any]) | Trata de convertir un valor en otro tipo de datos | Trata de convertir un valor en otro tipo de datos | def convert(key: str, value: Any, type: Callable[..., Any]) -> Any:
"""Trata de convertir un valor en otro tipo de datos"""
if not (inspect.isclass(type)):
raise InvalidDataType(key, _("El tipo de dato no es válido para continuar con la operación"))
if (value is None) or \
(type is empty) or \
(isinstance(value, type)):
return value
try:
return type(value)
except Exception as err:
raise ConvertionException(key, err, _("Error en la conversión de tipos")) | [
"def",
"convert",
"(",
"key",
":",
"str",
",",
"value",
":",
"Any",
",",
"type",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
")",
"->",
"Any",
":",
"if",
"not",
"(",
"inspect",
".",
"isclass",
"(",
"type",
")",
")",
":",
"raise",
"InvalidDataType",
"(",
"key",
",",
"_",
"(",
"\"El tipo de dato no es válido para continuar con la operación\"))",
"",
"",
"if",
"(",
"value",
"is",
"None",
")",
"or",
"(",
"type",
"is",
"empty",
")",
"or",
"(",
"isinstance",
"(",
"value",
",",
"type",
")",
")",
":",
"return",
"value",
"try",
":",
"return",
"type",
"(",
"value",
")",
"except",
"Exception",
"as",
"err",
":",
"raise",
"ConvertionException",
"(",
"key",
",",
"err",
",",
"_",
"(",
"\"Error en la conversión de tipos\")",
")",
""
] | [
66,
0
] | [
81,
82
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
FingerprintKeyerIntegrationTestCase.test_fingerprint_methods_together | (self) | Testea todos los métodos de fingerprint juntos. | Testea todos los métodos de fingerprint juntos. | def test_fingerprint_methods_together(self):
"""Testea todos los métodos de fingerprint juntos."""
inp_strings = ["DIGCE - Esmeralda 1212 - Piso 6° Of. 604",
"DIGCE - Esmeralda 1212 - Piso 6° Of. 604",
"DIGCE - Esmeralda 1212 - Piso 6° Of. 604",
"DIGCE - Esmeralda 1212 Piso 6° Of. 604",
"DIGCE - Esmeralda 1212 Piso 6° Of. 604"]
clusters, counts = group_fingerprint_strings(inp_strings)
replacements = get_best_replacements(clusters, counts)
clean_strings = replace_by_key(replacements, inp_strings)
exp_strings = ["DIGCE - Esmeralda 1212 - Piso 6° Of. 604"] * 5
self.assertEqual(clean_strings, exp_strings) | [
"def",
"test_fingerprint_methods_together",
"(",
"self",
")",
":",
"inp_strings",
"=",
"[",
"\"DIGCE - Esmeralda 1212 - Piso 6° Of. 604\",",
"",
"\"DIGCE - Esmeralda 1212 - Piso 6° Of. 604\",",
"",
"\"DIGCE - Esmeralda 1212 - Piso 6° Of. 604\",",
"",
"\"DIGCE - Esmeralda 1212 Piso 6° Of. 604\",",
"",
"\"DIGCE - Esmeralda 1212 Piso 6° Of. 604\"]",
"",
"clusters",
",",
"counts",
"=",
"group_fingerprint_strings",
"(",
"inp_strings",
")",
"replacements",
"=",
"get_best_replacements",
"(",
"clusters",
",",
"counts",
")",
"clean_strings",
"=",
"replace_by_key",
"(",
"replacements",
",",
"inp_strings",
")",
"exp_strings",
"=",
"[",
"\"DIGCE - Esmeralda 1212 - Piso 6° Of. 604\"]",
" ",
" ",
"",
"self",
".",
"assertEqual",
"(",
"clean_strings",
",",
"exp_strings",
")"
] | [
23,
4
] | [
36,
52
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationModel.calculate_velocities | (self, tracked_object: TrackedObject) | Método que debe ser implementado.
Debe realizar el cálculo de las velocidades en cada instante que fue detectado el objeto.
La unidad de medida de las velocidades vendrá determinada por la introducida al instanciar
el modelo con el parámetro `units`.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
| Método que debe ser implementado. | def calculate_velocities(self, tracked_object: TrackedObject) -> List[FloatVector2D]:
"""Método que debe ser implementado.
Debe realizar el cálculo de las velocidades en cada instante que fue detectado el objeto.
La unidad de medida de las velocidades vendrá determinada por la introducida al instanciar
el modelo con el parámetro `units`.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
""" | [
"def",
"calculate_velocities",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
")",
"->",
"List",
"[",
"FloatVector2D",
"]",
":"
] | [
288,
4
] | [
298,
11
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones2 | (t) | instrucciones : instruccion | instrucciones : instruccion | def p_instrucciones2(t):
'instrucciones : instruccion'
t[0] = [t[1]] | [
"def",
"p_instrucciones2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]"
] | [
33,
0
] | [
35,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ApiRequest._log | (self,texto,level) | Escribe en el log
Parameters
----------
texto : str
Texto a escribir en el log
level : int
Nivel de severidad del log a escribir. Solo se escribe si esta variable supera al self.log valor
| Escribe en el log | def _log(self,texto,level):
"""Escribe en el log
Parameters
----------
texto : str
Texto a escribir en el log
level : int
Nivel de severidad del log a escribir. Solo se escribe si esta variable supera al self.log valor
"""
if self.logger:
self.logger.hazlog((str(type(self))+texto),level) | [
"def",
"_log",
"(",
"self",
",",
"texto",
",",
"level",
")",
":",
"if",
"self",
".",
"logger",
":",
"self",
".",
"logger",
".",
"hazlog",
"(",
"(",
"str",
"(",
"type",
"(",
"self",
")",
")",
"+",
"texto",
")",
",",
"level",
")"
] | [
87,
4
] | [
99,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
CubeShell.do_exit | (self, arg) | Método para salir del programa | Método para salir del programa | def do_exit(self, arg):
'''Método para salir del programa'''
print('El programa ha finalizado')
sys.exit(0) | [
"def",
"do_exit",
"(",
"self",
",",
"arg",
")",
":",
"print",
"(",
"'El programa ha finalizado'",
")",
"sys",
".",
"exit",
"(",
"0",
")"
] | [
81,
4
] | [
84,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.nombre_propio | (self, field, sufix=None, lower_words=None,
keep_original=False, inplace=False) | return capitalized | Regla para todos los nombres propios.
Capitaliza los nombres de países, ciudades, personas, instituciones y
similares.
Args:
field (str): Campo a limpiar
Returns:
pandas.Series: Serie de strings limpios
| Regla para todos los nombres propios. | def nombre_propio(self, field, sufix=None, lower_words=None,
keep_original=False, inplace=False):
"""Regla para todos los nombres propios.
Capitaliza los nombres de países, ciudades, personas, instituciones y
similares.
Args:
field (str): Campo a limpiar
Returns:
pandas.Series: Serie de strings limpios
"""
sufix = sufix or self.DEFAULT_SUFIX
field = self._normalize_field(field)
series = self.df[field]
capitalized = series.apply(capitalize, lower_words=lower_words)
if inplace:
self._update_series(field=field, sufix=sufix,
keep_original=keep_original,
new_series=capitalized)
return capitalized | [
"def",
"nombre_propio",
"(",
"self",
",",
"field",
",",
"sufix",
"=",
"None",
",",
"lower_words",
"=",
"None",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"sufix",
"=",
"sufix",
"or",
"self",
".",
"DEFAULT_SUFIX",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
"capitalized",
"=",
"series",
".",
"apply",
"(",
"capitalize",
",",
"lower_words",
"=",
"lower_words",
")",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"sufix",
"=",
"sufix",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"capitalized",
")",
"return",
"capitalized"
] | [
364,
4
] | [
386,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
RespuestaCorrecta | (x) | return x | Funcion para comprobar que la respuesta del usuario es SI o NO
Parametros:
-x= String
Return:
-Devuelve la respuesta SI o NO
| Funcion para comprobar que la respuesta del usuario es SI o NO
Parametros:
-x= String
Return:
-Devuelve la respuesta SI o NO
| def RespuestaCorrecta(x):
"""Funcion para comprobar que la respuesta del usuario es SI o NO
Parametros:
-x= String
Return:
-Devuelve la respuesta SI o NO
"""
while x.upper() != "NO" and x.upper() != "SI":
print("RESPUESTA INCORRECTA, RESPONDA CON UN SI O UN NO")
x = input("¿Desea CIFRAR-DESCIFRAR otro mensaje?")
return x | [
"def",
"RespuestaCorrecta",
"(",
"x",
")",
":",
"while",
"x",
".",
"upper",
"(",
")",
"!=",
"\"NO\"",
"and",
"x",
".",
"upper",
"(",
")",
"!=",
"\"SI\"",
":",
"print",
"(",
"\"RESPUESTA INCORRECTA, RESPONDA CON UN SI O UN NO\"",
")",
"x",
"=",
"input",
"(",
"\"¿Desea CIFRAR-DESCIFRAR otro mensaje?\")",
"",
"return",
"x"
] | [
237,
0
] | [
247,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
sin_salida_naive | (vuelos: Dict[str, Dict[str, Union[str, float]]]) | return aeropuertos | Retorna una lista de aeropuertos a los cuales hayan llegado vuelos
pero no hayan salido vuelos de este.
:param vuelos: Información de los vuelos.
:vuelos type: Dict[str, Dict[str, Union[str, float]]]
:return: Lista de aeropuertos
:rtype: List[str]
| Retorna una lista de aeropuertos a los cuales hayan llegado vuelos
pero no hayan salido vuelos de este. | def sin_salida_naive(vuelos: Dict[str, Dict[str, Union[str, float]]]) -> List[str]:
"""Retorna una lista de aeropuertos a los cuales hayan llegado vuelos
pero no hayan salido vuelos de este.
:param vuelos: Información de los vuelos.
:vuelos type: Dict[str, Dict[str, Union[str, float]]]
:return: Lista de aeropuertos
:rtype: List[str]
"""
salidas, llegadas, aeropuertos = [], [], []
for vuelo in vuelos.values():
salidas.append(vuelo['origen'])
llegadas.append(vuelo['destino'])
for aeropuerto in llegadas:
if aeropuerto not in salidas:
aeropuertos.append(aeropuerto)
return aeropuertos | [
"def",
"sin_salida_naive",
"(",
"vuelos",
":",
"Dict",
"[",
"str",
",",
"Dict",
"[",
"str",
",",
"Union",
"[",
"str",
",",
"float",
"]",
"]",
"]",
")",
"->",
"List",
"[",
"str",
"]",
":",
"salidas",
",",
"llegadas",
",",
"aeropuertos",
"=",
"[",
"]",
",",
"[",
"]",
",",
"[",
"]",
"for",
"vuelo",
"in",
"vuelos",
".",
"values",
"(",
")",
":",
"salidas",
".",
"append",
"(",
"vuelo",
"[",
"'origen'",
"]",
")",
"llegadas",
".",
"append",
"(",
"vuelo",
"[",
"'destino'",
"]",
")",
"for",
"aeropuerto",
"in",
"llegadas",
":",
"if",
"aeropuerto",
"not",
"in",
"salidas",
":",
"aeropuertos",
".",
"append",
"(",
"aeropuerto",
")",
"return",
"aeropuertos"
] | [
53,
0
] | [
69,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioAG.cruzar | (self, sol_a, sol_b) | Produce una nueva posible solución cruzando las dos soluciones dadas por parámetro.
Entradas:
sol_a (estructura de datos)
Estructura de datos que modela la solución antecesora A que será cruzada con la B
sol_b (estructura de datos)
Estructura de datos que modela la solución antecesora B que será cruzada con la A
Salidas:
(estructura de datos) Una nueva solución producto del cruzamiento entre las soluciones A y B
| Produce una nueva posible solución cruzando las dos soluciones dadas por parámetro. | def cruzar(self, sol_a, sol_b):
"""Produce una nueva posible solución cruzando las dos soluciones dadas por parámetro.
Entradas:
sol_a (estructura de datos)
Estructura de datos que modela la solución antecesora A que será cruzada con la B
sol_b (estructura de datos)
Estructura de datos que modela la solución antecesora B que será cruzada con la A
Salidas:
(estructura de datos) Una nueva solución producto del cruzamiento entre las soluciones A y B
"""
pass | [
"def",
"cruzar",
"(",
"self",
",",
"sol_a",
",",
"sol_b",
")",
":",
"pass"
] | [
39,
4
] | [
53,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Text.set_coin | (cls, numero, simbolo: str="$", ndec: int=2) | return f"{simbolo}{round(numero, 2):,}" | Convierte el número en una cadena de texto con formato moneda. | Convierte el número en una cadena de texto con formato moneda. | def set_coin(cls, numero, simbolo: str="$", ndec: int=2) -> str:
"""Convierte el número en una cadena de texto con formato moneda."""
return f"{simbolo}{round(numero, 2):,}" | [
"def",
"set_coin",
"(",
"cls",
",",
"numero",
",",
"simbolo",
":",
"str",
"=",
"\"$\"",
",",
"ndec",
":",
"int",
"=",
"2",
")",
"->",
"str",
":",
"return",
"f\"{simbolo}{round(numero, 2):,}\""
] | [
315,
4
] | [
317,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_corpus_info | (request) | return total, docs | **Función que obtiene la información general del corpus**
Está función utiliza el framework de ``Elasticsearch`` llamado
*aggregations* para obtener los ids del corpus. Con cada uno se
obtienen los nombres de documentos, nombres de archivos y total:>>.
:return: El total de documentos y una lista con información de los documentos
:rtype: int, list
| **Función que obtiene la información general del corpus** | def get_corpus_info(request):
"""**Función que obtiene la información general del corpus**
Está función utiliza el framework de ``Elasticsearch`` llamado
*aggregations* para obtener los ids del corpus. Con cada uno se
obtienen los nombres de documentos, nombres de archivos y total:>>.
:return: El total de documentos y una lista con información de los documentos
:rtype: int, list
"""
ids_filters = {
"size": 0, # No interesan resultados del corpus. Solo los documentos
"aggs": {
"ids": {
"terms": {
"field": "document_id",
"size": 1000 # TODO: Modificar la cantidad dinamicamente
}
}
}
}
docs = []
total = 0
LOGGER.info("Buscando documentos")
try:
r = es.search(index=settings.INDEX, body=ids_filters)
buckets = r['aggregations']['ids']['buckets']
LOGGER.info("Documentos actuales::" + str(len(buckets)))
for bucket in buckets:
total += int(bucket["doc_count"])
document = get_document_info(bucket['key'])
document['count'] = bucket['doc_count']
docs.append(document)
except es_exceptions.ConnectionError as e:
LOGGER.error("No hay conexión a Elasticsearch::{}".format(e.info))
LOGGER.error("No se pudo conectar al indice::" + settings.INDEX)
LOGGER.error("URL::" + settings.ELASTIC_URL)
total = 0
docs = []
except es_exceptions.NotFoundError as e:
LOGGER.error("No se encontró el indice::" + settings.INDEX)
LOGGER.error("URL::" + settings.ELASTIC_URL)
total = 0
docs = []
messages.warning(request, f"Parece que no existe el índice <b>{settings.INDEX}</b>")
return total, docs | [
"def",
"get_corpus_info",
"(",
"request",
")",
":",
"ids_filters",
"=",
"{",
"\"size\"",
":",
"0",
",",
"# No interesan resultados del corpus. Solo los documentos",
"\"aggs\"",
":",
"{",
"\"ids\"",
":",
"{",
"\"terms\"",
":",
"{",
"\"field\"",
":",
"\"document_id\"",
",",
"\"size\"",
":",
"1000",
"# TODO: Modificar la cantidad dinamicamente",
"}",
"}",
"}",
"}",
"docs",
"=",
"[",
"]",
"total",
"=",
"0",
"LOGGER",
".",
"info",
"(",
"\"Buscando documentos\"",
")",
"try",
":",
"r",
"=",
"es",
".",
"search",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"ids_filters",
")",
"buckets",
"=",
"r",
"[",
"'aggregations'",
"]",
"[",
"'ids'",
"]",
"[",
"'buckets'",
"]",
"LOGGER",
".",
"info",
"(",
"\"Documentos actuales::\"",
"+",
"str",
"(",
"len",
"(",
"buckets",
")",
")",
")",
"for",
"bucket",
"in",
"buckets",
":",
"total",
"+=",
"int",
"(",
"bucket",
"[",
"\"doc_count\"",
"]",
")",
"document",
"=",
"get_document_info",
"(",
"bucket",
"[",
"'key'",
"]",
")",
"document",
"[",
"'count'",
"]",
"=",
"bucket",
"[",
"'doc_count'",
"]",
"docs",
".",
"append",
"(",
"document",
")",
"except",
"es_exceptions",
".",
"ConnectionError",
"as",
"e",
":",
"LOGGER",
".",
"error",
"(",
"\"No hay conexión a Elasticsearch::{}\".",
"f",
"ormat(",
"e",
".",
"i",
"nfo)",
")",
"",
"LOGGER",
".",
"error",
"(",
"\"No se pudo conectar al indice::\"",
"+",
"settings",
".",
"INDEX",
")",
"LOGGER",
".",
"error",
"(",
"\"URL::\"",
"+",
"settings",
".",
"ELASTIC_URL",
")",
"total",
"=",
"0",
"docs",
"=",
"[",
"]",
"except",
"es_exceptions",
".",
"NotFoundError",
"as",
"e",
":",
"LOGGER",
".",
"error",
"(",
"\"No se encontró el indice::\" ",
" ",
"ettings.",
"I",
"NDEX)",
"",
"LOGGER",
".",
"error",
"(",
"\"URL::\"",
"+",
"settings",
".",
"ELASTIC_URL",
")",
"total",
"=",
"0",
"docs",
"=",
"[",
"]",
"messages",
".",
"warning",
"(",
"request",
",",
"f\"Parece que no existe el índice <b>{settings.INDEX}</b>\")",
"",
"return",
"total",
",",
"docs"
] | [
20,
0
] | [
65,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_lista_de_seleccionados_noterminal | (t) | listadeseleccionados : funcionesmatematicassimples
| funcionestrigonometricas
| funcionesmatematicas
| funcionesdefechas
| funcionesbinarias
| operadoresselect | listadeseleccionados : funcionesmatematicassimples
| funcionestrigonometricas
| funcionesmatematicas
| funcionesdefechas
| funcionesbinarias
| operadoresselect | def p_lista_de_seleccionados_noterminal(t):
'''listadeseleccionados : funcionesmatematicassimples
| funcionestrigonometricas
| funcionesmatematicas
| funcionesdefechas
| funcionesbinarias
| operadoresselect'''
grafo.newnode('L_SELECTS')
grafo.newchildrenF(grafo.index, t[1]['graph'])
reporte = '''<listadeseleccionados := <funcionesmatematicassimples>
|<funcionestrigonometricas>
|<funcionesmatematicas
|<funcionesdefechas>
|<funcionesbinarias>
|<operadoresselect>\n''' + t[1]['reporte'] #mm
t[0] = {'ast': t[1]['ast'],'graph' : grafo.index, 'reporte': reporte} | [
"def",
"p_lista_de_seleccionados_noterminal",
"(",
"t",
")",
":",
"grafo",
".",
"newnode",
"(",
"'L_SELECTS'",
")",
"grafo",
".",
"newchildrenF",
"(",
"grafo",
".",
"index",
",",
"t",
"[",
"1",
"]",
"[",
"'graph'",
"]",
")",
"reporte",
"=",
"'''<listadeseleccionados := <funcionesmatematicassimples>\n |<funcionestrigonometricas>\n |<funcionesmatematicas\n |<funcionesdefechas>\n |<funcionesbinarias>\n |<operadoresselect>\\n'''",
"+",
"t",
"[",
"1",
"]",
"[",
"'reporte'",
"]",
"#mm",
"t",
"[",
"0",
"]",
"=",
"{",
"'ast'",
":",
"t",
"[",
"1",
"]",
"[",
"'ast'",
"]",
",",
"'graph'",
":",
"grafo",
".",
"index",
",",
"'reporte'",
":",
"reporte",
"}"
] | [
668,
0
] | [
683,
73
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
mkdir_folder | (number: int) | Función para crear carpeta en el directorio.
Args:
number (int): Recibe el nombre de la carpeta a crear.
| Función para crear carpeta en el directorio. | def mkdir_folder(number: int) -> None:
""" Función para crear carpeta en el directorio.
Args:
number (int): Recibe el nombre de la carpeta a crear.
"""
os.mkdir(str(number)) | [
"def",
"mkdir_folder",
"(",
"number",
":",
"int",
")",
"->",
"None",
":",
"os",
".",
"mkdir",
"(",
"str",
"(",
"number",
")",
")"
] | [
116,
0
] | [
122,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
parse | (use_cache: bool = True) | return cache | Parsear la configuración
Args:
use_cache:
De forma global se almacena un diccionario que contiene toda la configuración,
si ``use_cache`` es **True** se retorna ese diccionario en vez de parsear el
archivo de configuración por cada invocación, lo cual mejoraría el rendimiento.
Returns:
Un diccionario con la configuración parseada.
| Parsear la configuración
Args:
use_cache:
De forma global se almacena un diccionario que contiene toda la configuración,
si ``use_cache`` es **True** se retorna ese diccionario en vez de parsear el
archivo de configuración por cada invocación, lo cual mejoraría el rendimiento. | def parse(use_cache: bool = True) -> dict:
"""Parsear la configuración
Args:
use_cache:
De forma global se almacena un diccionario que contiene toda la configuración,
si ``use_cache`` es **True** se retorna ese diccionario en vez de parsear el
archivo de configuración por cada invocación, lo cual mejoraría el rendimiento.
Returns:
Un diccionario con la configuración parseada.
"""
global cache
if (use_cache) and (cache):
return cache
config = configparser.ConfigParser(
defaults.defaults,
empty_lines_in_values = False,
interpolation = None
)
config.read(defaults.fileconfig)
for section, values in defaults.dictionary.items():
for (value, type) in values:
default = defaults.defaults[section][value]
env_default = os.getenv("UTESLA_{}_{}".format(section, value))
if (type == bool):
convert = config.getboolean
elif (type == int):
convert = config.getint
elif (type == float):
convert = config.getfloat
else:
convert = config.get
if not (section in cache):
cache[section] = {}
try:
aux = convert(
section, value, fallback=env_default or default
)
except Exception as err:
logging.exception(
"Exception captada al analizar la sección '%s' y el valor de clave '%s' %s",
section, value
)
aux = default
logging.warning(
"Usando el valor '%s' en la clave '%s' sobre la sección '%s'",
aux, value, section
)
finally:
cache[section][value] = aux
if (aux in defaults.default_dictionary):
cache[section][value] = defaults.default_dictionary[aux]
return cache | [
"def",
"parse",
"(",
"use_cache",
":",
"bool",
"=",
"True",
")",
"->",
"dict",
":",
"global",
"cache",
"if",
"(",
"use_cache",
")",
"and",
"(",
"cache",
")",
":",
"return",
"cache",
"config",
"=",
"configparser",
".",
"ConfigParser",
"(",
"defaults",
".",
"defaults",
",",
"empty_lines_in_values",
"=",
"False",
",",
"interpolation",
"=",
"None",
")",
"config",
".",
"read",
"(",
"defaults",
".",
"fileconfig",
")",
"for",
"section",
",",
"values",
"in",
"defaults",
".",
"dictionary",
".",
"items",
"(",
")",
":",
"for",
"(",
"value",
",",
"type",
")",
"in",
"values",
":",
"default",
"=",
"defaults",
".",
"defaults",
"[",
"section",
"]",
"[",
"value",
"]",
"env_default",
"=",
"os",
".",
"getenv",
"(",
"\"UTESLA_{}_{}\"",
".",
"format",
"(",
"section",
",",
"value",
")",
")",
"if",
"(",
"type",
"==",
"bool",
")",
":",
"convert",
"=",
"config",
".",
"getboolean",
"elif",
"(",
"type",
"==",
"int",
")",
":",
"convert",
"=",
"config",
".",
"getint",
"elif",
"(",
"type",
"==",
"float",
")",
":",
"convert",
"=",
"config",
".",
"getfloat",
"else",
":",
"convert",
"=",
"config",
".",
"get",
"if",
"not",
"(",
"section",
"in",
"cache",
")",
":",
"cache",
"[",
"section",
"]",
"=",
"{",
"}",
"try",
":",
"aux",
"=",
"convert",
"(",
"section",
",",
"value",
",",
"fallback",
"=",
"env_default",
"or",
"default",
")",
"except",
"Exception",
"as",
"err",
":",
"logging",
".",
"exception",
"(",
"\"Exception captada al analizar la sección '%s' y el valor de clave '%s' %s\",",
"",
"section",
",",
"value",
")",
"aux",
"=",
"default",
"logging",
".",
"warning",
"(",
"\"Usando el valor '%s' en la clave '%s' sobre la sección '%s'\",",
"",
"aux",
",",
"value",
",",
"section",
")",
"finally",
":",
"cache",
"[",
"section",
"]",
"[",
"value",
"]",
"=",
"aux",
"if",
"(",
"aux",
"in",
"defaults",
".",
"default_dictionary",
")",
":",
"cache",
"[",
"section",
"]",
"[",
"value",
"]",
"=",
"defaults",
".",
"default_dictionary",
"[",
"aux",
"]",
"return",
"cache"
] | [
11,
0
] | [
84,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones19 | (p) | funciones : ATAND PABRE expresion PCIERRA | funciones : ATAND PABRE expresion PCIERRA | def p_funciones19(p):
'funciones : ATAND PABRE expresion PCIERRA' | [
"def",
"p_funciones19",
"(",
"p",
")",
":"
] | [
355,
0
] | [
356,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
crear_cuenta | () | Crear cuenta de usuario. | Crear cuenta de usuario. | def crear_cuenta():
"""Crear 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("Cuenta creada exitosamente.")
return INICIO_SESION
except OperationalError:
flash("Error al crear la cuenta.")
return redirect("/logon")
else:
return render_template("auth/logon.html", form=form, titulo="Crear cuenta - NOW LMS") | [
"def",
"crear_cuenta",
"(",
")",
":",
"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",
"(",
"\"Cuenta creada exitosamente.\"",
")",
"return",
"INICIO_SESION",
"except",
"OperationalError",
":",
"flash",
"(",
"\"Error al crear la cuenta.\"",
")",
"return",
"redirect",
"(",
"\"/logon\"",
")",
"else",
":",
"return",
"render_template",
"(",
"\"auth/logon.html\"",
",",
"form",
"=",
"form",
",",
"titulo",
"=",
"\"Crear cuenta - NOW LMS\"",
")"
] | [
580,
0
] | [
602,
93
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResult.mean_speed | (self) | return np.linalg.norm(mean_velocity) | Calcula el módulo de la velocidad media.
:return: módulo de la velocidad media.
| Calcula el módulo de la velocidad media. | def mean_speed(self) -> float:
"""Calcula el módulo de la velocidad media.
:return: módulo de la velocidad media.
"""
if len(self.velocities) == 0:
return 0.
mean_velocity = np.array(self.velocities).mean(axis=0)
return np.linalg.norm(mean_velocity) | [
"def",
"mean_speed",
"(",
"self",
")",
"->",
"float",
":",
"if",
"len",
"(",
"self",
".",
"velocities",
")",
"==",
"0",
":",
"return",
"0.",
"mean_velocity",
"=",
"np",
".",
"array",
"(",
"self",
".",
"velocities",
")",
".",
"mean",
"(",
"axis",
"=",
"0",
")",
"return",
"np",
".",
"linalg",
".",
"norm",
"(",
"mean_velocity",
")"
] | [
40,
4
] | [
48,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
validate_required_keys | (keys=None, obj=None) | return all(all_present) | Función para validar que las claves necesarias, como mínimo, están incluidos en el objecto que se le pasa como
argumento.
Parameters
----------
keys : list
lista de claves que son requeridos
obj : dict
diccionario del cual que se validarán sus claves
Returns
-------
True
si todas las claves de `keys` están en `obj`
False
en caso de que alguna de las claves de `keys` no estén en `obj`
| Función para validar que las claves necesarias, como mínimo, están incluidos en el objecto que se le pasa como
argumento. | def validate_required_keys(keys=None, obj=None):
"""Función para validar que las claves necesarias, como mínimo, están incluidos en el objecto que se le pasa como
argumento.
Parameters
----------
keys : list
lista de claves que son requeridos
obj : dict
diccionario del cual que se validarán sus claves
Returns
-------
True
si todas las claves de `keys` están en `obj`
False
en caso de que alguna de las claves de `keys` no estén en `obj`
"""
all_present = [k in obj.keys() for k in keys]
return all(all_present) | [
"def",
"validate_required_keys",
"(",
"keys",
"=",
"None",
",",
"obj",
"=",
"None",
")",
":",
"all_present",
"=",
"[",
"k",
"in",
"obj",
".",
"keys",
"(",
")",
"for",
"k",
"in",
"keys",
"]",
"return",
"all",
"(",
"all_present",
")"
] | [
57,
0
] | [
76,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
home | () | return render_template("inicio/mooc.html", cursos=CURSOS) | Página principal de la aplicación. | Página principal de la aplicación. | def home():
"""Página principal de la aplicación."""
CURSOS = Curso.query.filter(Curso.publico == True, Curso.estado == "public").paginate( # noqa: E712
request.args.get("page", default=1, type=int), 6, False
)
return render_template("inicio/mooc.html", cursos=CURSOS) | [
"def",
"home",
"(",
")",
":",
"CURSOS",
"=",
"Curso",
".",
"query",
".",
"filter",
"(",
"Curso",
".",
"publico",
"==",
"True",
",",
"Curso",
".",
"estado",
"==",
"\"public\"",
")",
".",
"paginate",
"(",
"# noqa: E712",
"request",
".",
"args",
".",
"get",
"(",
"\"page\"",
",",
"default",
"=",
"1",
",",
"type",
"=",
"int",
")",
",",
"6",
",",
"False",
")",
"return",
"render_template",
"(",
"\"inicio/mooc.html\"",
",",
"cursos",
"=",
"CURSOS",
")"
] | [
647,
0
] | [
652,
61
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Proyectil.update | (self,x,y) | actualizar la posición del proyectil | actualizar la posición del proyectil | def update(self,x,y):
"actualizar la posición del proyectil"
self.velocx = self.veloc * math.cos(math.radians(self.angulo))
self.velocy = self.veloc * math.sin(math.radians(self.angulo))
if self.disparar is True:
# esta en movimiento, hay que actualizar la posición
self.xreal = (x + self.velocx * self.tiempo)
self.yreal = (y + self.velocy * self.tiempo +
(-9.8 * (self.tiempo ** 2)) / 2)
# Corregir la posición en el eje vertical
self.x = self.xreal
self.y = ancho - self.yreal
else:
# se mantiene sin disparar, por lo cual no se hace nada
pass | [
"def",
"update",
"(",
"self",
",",
"x",
",",
"y",
")",
":",
"self",
".",
"velocx",
"=",
"self",
".",
"veloc",
"*",
"math",
".",
"cos",
"(",
"math",
".",
"radians",
"(",
"self",
".",
"angulo",
")",
")",
"self",
".",
"velocy",
"=",
"self",
".",
"veloc",
"*",
"math",
".",
"sin",
"(",
"math",
".",
"radians",
"(",
"self",
".",
"angulo",
")",
")",
"if",
"self",
".",
"disparar",
"is",
"True",
":",
"# esta en movimiento, hay que actualizar la posición\r",
"self",
".",
"xreal",
"=",
"(",
"x",
"+",
"self",
".",
"velocx",
"*",
"self",
".",
"tiempo",
")",
"self",
".",
"yreal",
"=",
"(",
"y",
"+",
"self",
".",
"velocy",
"*",
"self",
".",
"tiempo",
"+",
"(",
"-",
"9.8",
"*",
"(",
"self",
".",
"tiempo",
"**",
"2",
")",
")",
"/",
"2",
")",
"# Corregir la posición en el eje vertical\r",
"self",
".",
"x",
"=",
"self",
".",
"xreal",
"self",
".",
"y",
"=",
"ancho",
"-",
"self",
".",
"yreal",
"else",
":",
"# se mantiene sin disparar, por lo cual no se hace nada\r",
"pass"
] | [
30,
4
] | [
45,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_lista_asignacion_salida | (t) | asignaciones : asignacion | asignaciones : asignacion | def p_lista_asignacion_salida(t) :
'asignaciones : asignacion' | [
"def",
"p_lista_asignacion_salida",
"(",
"t",
")",
":"
] | [
399,
0
] | [
400,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
generate | (
password: str,
time_cost: int,
memory_cost: int,
parallelism: int,
crypt_limits: Optional[dict] = None,
*args, **kwargs
) | return argon_func.hash(password) | Hash a `password` y retorna el hash codificado.
Args:
password:
La contraseña en texto plano
time_cost:
La cantidad de calculo utilizado
memory_cost:
Define el uso de memoria en KiB
parallelism:
Define el número de subprocesos paralelos
hash_len:
La longitud del hash
salt_len:
Longitud de la «salt» aleatoria que se generará para cada contraseña
crypt_limits:
La configuración para limitar el uso de parámetros excesivos
*args:
Argumentos variables para `argon2.PasswordHasher()`
**kwargs:
Argumentos claves variables para `argon2.PasswordHasher()`
Returns:
El hash de la contraseña
Raises:
exceptions.LimitsExceeded:
Cuando los límites pre-configurados no permiten
seguir con la operación.
| Hash a `password` y retorna el hash codificado.
Args:
password:
La contraseña en texto plano | def generate(
password: str,
time_cost: int,
memory_cost: int,
parallelism: int,
crypt_limits: Optional[dict] = None,
*args, **kwargs
) -> str:
"""Hash a `password` y retorna el hash codificado.
Args:
password:
La contraseña en texto plano
time_cost:
La cantidad de calculo utilizado
memory_cost:
Define el uso de memoria en KiB
parallelism:
Define el número de subprocesos paralelos
hash_len:
La longitud del hash
salt_len:
Longitud de la «salt» aleatoria que se generará para cada contraseña
crypt_limits:
La configuración para limitar el uso de parámetros excesivos
*args:
Argumentos variables para `argon2.PasswordHasher()`
**kwargs:
Argumentos claves variables para `argon2.PasswordHasher()`
Returns:
El hash de la contraseña
Raises:
exceptions.LimitsExceeded:
Cuando los límites pre-configurados no permiten
seguir con la operación.
"""
if (crypt_limits is not None):
options = (
(time_cost, crypt_limits["time_cost"]),
(memory_cost, crypt_limits["memory_cost"]),
(parallelism, crypt_limits["parallelism"])
)
for origin, limit in options:
if (origin > limit):
raise exceptions.LimitsExceeded(
_("Los límites pre-configurados no permiten seguir con la operación")
)
argon_func = argon2.PasswordHasher(
time_cost, memory_cost, parallelism,
32, *args, type=argon2.Type.ID, **kwargs
)
return argon_func.hash(password) | [
"def",
"generate",
"(",
"password",
":",
"str",
",",
"time_cost",
":",
"int",
",",
"memory_cost",
":",
"int",
",",
"parallelism",
":",
"int",
",",
"crypt_limits",
":",
"Optional",
"[",
"dict",
"]",
"=",
"None",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"str",
":",
"if",
"(",
"crypt_limits",
"is",
"not",
"None",
")",
":",
"options",
"=",
"(",
"(",
"time_cost",
",",
"crypt_limits",
"[",
"\"time_cost\"",
"]",
")",
",",
"(",
"memory_cost",
",",
"crypt_limits",
"[",
"\"memory_cost\"",
"]",
")",
",",
"(",
"parallelism",
",",
"crypt_limits",
"[",
"\"parallelism\"",
"]",
")",
")",
"for",
"origin",
",",
"limit",
"in",
"options",
":",
"if",
"(",
"origin",
">",
"limit",
")",
":",
"raise",
"exceptions",
".",
"LimitsExceeded",
"(",
"_",
"(",
"\"Los límites pre-configurados no permiten seguir con la operación\")",
"",
")",
"argon_func",
"=",
"argon2",
".",
"PasswordHasher",
"(",
"time_cost",
",",
"memory_cost",
",",
"parallelism",
",",
"32",
",",
"*",
"args",
",",
"type",
"=",
"argon2",
".",
"Type",
".",
"ID",
",",
"*",
"*",
"kwargs",
")",
"return",
"argon_func",
".",
"hash",
"(",
"password",
")"
] | [
9,
0
] | [
78,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_instruccion | (t) | instrucciones : | instrucciones : | def p_instrucciones_instruccion(t):
'instrucciones : '
t[0] = [] | [
"def",
"p_instrucciones_instruccion",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"]"
] | [
219,
0
] | [
221,
13
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
|
p_lista_condicion_salida1 | (t) | condiciones : NOT PARIZQ condiciones PARDER | condiciones : NOT PARIZQ condiciones PARDER | def p_lista_condicion_salida1(t):
'condiciones : NOT PARIZQ condiciones PARDER'
gramatica = '<condiciones> ::= NOT <condiciones>\n'
t[0] = Nodo('OPLOG', 'NOT', [t[3]], t.lexer.lineno, 0, gramatica) | [
"def",
"p_lista_condicion_salida1",
"(",
"t",
")",
":",
"gramatica",
"=",
"'<condiciones> ::= NOT <condiciones>\\n'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'OPLOG'",
",",
"'NOT'",
",",
"[",
"t",
"[",
"3",
"]",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"gramatica",
")"
] | [
311,
0
] | [
314,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AccountPaymentGroup._compute_matched_amount_untaxed | (self) | Lo separamos en otro metodo ya que es un poco mas costoso y no se
usa en conjunto con matched_amount
| Lo separamos en otro metodo ya que es un poco mas costoso y no se
usa en conjunto con matched_amount
| def _compute_matched_amount_untaxed(self):
""" Lo separamos en otro metodo ya que es un poco mas costoso y no se
usa en conjunto con matched_amount
"""
for rec in self:
rec.matched_amount_untaxed = 0.0
if rec.state != 'posted':
continue
matched_amount_untaxed = 0.0
sign = rec.partner_type == 'supplier' and -1.0 or 1.0
for line in rec.matched_move_line_ids.with_context(
payment_group_id=rec.id):
invoice = line.move_id
factor = invoice and invoice._get_tax_factor() or 1.0
matched_amount_untaxed += \
line.payment_group_matched_amount * factor
rec.matched_amount_untaxed = sign * matched_amount_untaxed | [
"def",
"_compute_matched_amount_untaxed",
"(",
"self",
")",
":",
"for",
"rec",
"in",
"self",
":",
"rec",
".",
"matched_amount_untaxed",
"=",
"0.0",
"if",
"rec",
".",
"state",
"!=",
"'posted'",
":",
"continue",
"matched_amount_untaxed",
"=",
"0.0",
"sign",
"=",
"rec",
".",
"partner_type",
"==",
"'supplier'",
"and",
"-",
"1.0",
"or",
"1.0",
"for",
"line",
"in",
"rec",
".",
"matched_move_line_ids",
".",
"with_context",
"(",
"payment_group_id",
"=",
"rec",
".",
"id",
")",
":",
"invoice",
"=",
"line",
".",
"move_id",
"factor",
"=",
"invoice",
"and",
"invoice",
".",
"_get_tax_factor",
"(",
")",
"or",
"1.0",
"matched_amount_untaxed",
"+=",
"line",
".",
"payment_group_matched_amount",
"*",
"factor",
"rec",
".",
"matched_amount_untaxed",
"=",
"sign",
"*",
"matched_amount_untaxed"
] | [
242,
4
] | [
258,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
cuad_pmedio | (x0, x1, f=None, y0=None, nargs_in=None) | return aprox | Implementación de la regla del punto medio
Parameters
----------
x0: float
Límite inferior del intervalo
x1: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y1: float
El valor de y en el punto medio.
Returns
-------
aprox: Aproximación de la integral por la regla del punto medio
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_trapecio(x0, x1, f=f)
cuad_trapecio(x0, x1, y0=f(x0), y1=f(x1))
| Implementación de la regla del punto medio
Parameters
----------
x0: float
Límite inferior del intervalo
x1: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y1: float
El valor de y en el punto medio. | def cuad_pmedio(x0, x1, f=None, y0=None, nargs_in=None):
"""Implementación de la regla del punto medio
Parameters
----------
x0: float
Límite inferior del intervalo
x1: float
Límite superior del intervalo
f: function (1 parameter)
La función a integrar
y0: float
El valor de y en el punto medio.
y1: float
El valor de y en el punto medio.
Returns
-------
aprox: Aproximación de la integral por la regla del punto medio
Notes
-----
Este código es parte del curso "Computación", Famaf
Uso:
cuad_trapecio(x0, x1, f=f)
cuad_trapecio(x0, x1, y0=f(x0), y1=f(x1))
"""
if nargs_in==4:
y1=y0
y0=f
f = None
elif nargs_in==3:
if type(f) is float:
raise ValueError("Verificar los argumentos")
else:
raise ValueError("Verificar el número de argumentos")
if x0 > x1:
raise ValueError("Oops! Debe ser a<b")
if (f is None) and (y0 is not None):
aprox = (x1-x0)*y0
elif (f is not None) and (y0 is None):
try:
y0 = f(x0)
except:
print(('Error: no fue posible calcular la función'
' Si desea ingresar un dato use y0='))
aprox = (x1-x0)*y0
else:
raise ValueError("Debe ingresar la función o los datos!")
return aprox | [
"def",
"cuad_pmedio",
"(",
"x0",
",",
"x1",
",",
"f",
"=",
"None",
",",
"y0",
"=",
"None",
",",
"nargs_in",
"=",
"None",
")",
":",
"if",
"nargs_in",
"==",
"4",
":",
"y1",
"=",
"y0",
"y0",
"=",
"f",
"f",
"=",
"None",
"elif",
"nargs_in",
"==",
"3",
":",
"if",
"type",
"(",
"f",
")",
"is",
"float",
":",
"raise",
"ValueError",
"(",
"\"Verificar los argumentos\"",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Verificar el número de argumentos\")",
"",
"if",
"x0",
">",
"x1",
":",
"raise",
"ValueError",
"(",
"\"Oops! Debe ser a<b\"",
")",
"if",
"(",
"f",
"is",
"None",
")",
"and",
"(",
"y0",
"is",
"not",
"None",
")",
":",
"aprox",
"=",
"(",
"x1",
"-",
"x0",
")",
"*",
"y0",
"elif",
"(",
"f",
"is",
"not",
"None",
")",
"and",
"(",
"y0",
"is",
"None",
")",
":",
"try",
":",
"y0",
"=",
"f",
"(",
"x0",
")",
"except",
":",
"print",
"(",
"(",
"'Error: no fue posible calcular la función'",
"' Si desea ingresar un dato use y0='",
")",
")",
"aprox",
"=",
"(",
"x1",
"-",
"x0",
")",
"*",
"y0",
"else",
":",
"raise",
"ValueError",
"(",
"\"Debe ingresar la función o los datos!\")",
" ",
"return",
"aprox"
] | [
211,
0
] | [
271,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_lista_expresiones_expresion | (t) | lista_expresiones : exp_operacion | lista_expresiones : exp_operacion | def p_lista_expresiones_expresion(t):
'lista_expresiones : exp_operacion'
nodoLista = crear_nodo_general("lista_expresiones","",str(t.lexer.lineno),columna)
nodoLista.hijos.append(t[1])
t[0] = nodoLista
GenerarRepGram.AgregarTexto("lista_expresiones ::= exp_operacion\n\n\
\t nodoLista = crear_nodo_general(\"lista_expresiones\","",str(t.lexer.lineno),columna)\n\
\t nodoLista.hijos.append(t[1])\n\
\t t[0] = t[1]\n\n") | [
"def",
"p_lista_expresiones_expresion",
"(",
"t",
")",
":",
"nodoLista",
"=",
"crear_nodo_general",
"(",
"\"lista_expresiones\"",
",",
"\"\"",
",",
"str",
"(",
"t",
".",
"lexer",
".",
"lineno",
")",
",",
"columna",
")",
"nodoLista",
".",
"hijos",
".",
"append",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"nodoLista",
"GenerarRepGram",
".",
"AgregarTexto",
"(",
"\"lista_expresiones ::= exp_operacion\\n\\n\\\n \\t nodoLista = crear_nodo_general(\\\"lista_expresiones\\\",\"",
"\",str(t.lexer.lineno),columna)\\n\\\n \\t nodoLista.hijos.append(t[1])\\n\\\n \\t t[0] = t[1]\\n\\n\"",
")"
] | [
775,
0
] | [
784,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResults.ignore_objects | (self, ids: List[int]) | Añade en objetos ignorados la lista de ids.
:param ids: ids de los objetos para ignorar.
:return: None.
| Añade en objetos ignorados la lista de ids. | def ignore_objects(self, ids: List[int]) -> None:
"""Añade en objetos ignorados la lista de ids.
:param ids: ids de los objetos para ignorar.
:return: None.
"""
for id_ in ids:
self.ignore_object(id_) | [
"def",
"ignore_objects",
"(",
"self",
",",
"ids",
":",
"List",
"[",
"int",
"]",
")",
"->",
"None",
":",
"for",
"id_",
"in",
"ids",
":",
"self",
".",
"ignore_object",
"(",
"id_",
")"
] | [
116,
4
] | [
123,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
FingerprintKeyerUnitTestCase.test_group_fingerprint_strings | (self) | Testea el agrupamiento de strings, por su fingerpint. | Testea el agrupamiento de strings, por su fingerpint. | def test_group_fingerprint_strings(self):
"""Testea el agrupamiento de strings, por su fingerpint."""
input_strings = [
" - juan peRes",
"Juan ; Perés",
"Juan -- Peres",
"Juan Per\tes",
"juán Peres",
"Juan Peres",
"Juan Peres",
" Juan\t \tPeres",
]
exp_clusters = {'es juan per': ['Juan Per\tes'],
'juan peres': [' - juan peRes',
'Juan ; Per\xe9s',
'Juan -- Peres',
'ju\xe1n Peres',
'Juan Peres',
'Juan Peres',
' Juan\t \tPeres']}
exp_counts = {' Juan\t \tPeres': 1,
' - juan peRes': 1,
'Juan -- Peres': 1,
'Juan ; Per\xe9s': 1,
'Juan Per\tes': 1,
'Juan Peres': 2,
'ju\xe1n Peres': 1}
clusters, counts = group_fingerprint_strings(input_strings, True,
True)
self.assertEqual(clusters, exp_clusters)
self.assertEqual(counts, exp_counts) | [
"def",
"test_group_fingerprint_strings",
"(",
"self",
")",
":",
"input_strings",
"=",
"[",
"\" - juan peRes\"",
",",
"\"Juan ; Perés\",",
"",
"\"Juan -- Peres\"",
",",
"\"Juan Per\\tes\"",
",",
"\"juán Peres\",",
"",
"\"Juan Peres\"",
",",
"\"Juan Peres\"",
",",
"\" Juan\\t \\tPeres\"",
",",
"]",
"exp_clusters",
"=",
"{",
"'es juan per'",
":",
"[",
"'Juan Per\\tes'",
"]",
",",
"'juan peres'",
":",
"[",
"' - juan peRes'",
",",
"'Juan ; Per\\xe9s'",
",",
"'Juan -- Peres'",
",",
"'ju\\xe1n Peres'",
",",
"'Juan Peres'",
",",
"'Juan Peres'",
",",
"' Juan\\t \\tPeres'",
"]",
"}",
"exp_counts",
"=",
"{",
"' Juan\\t \\tPeres'",
":",
"1",
",",
"' - juan peRes'",
":",
"1",
",",
"'Juan -- Peres'",
":",
"1",
",",
"'Juan ; Per\\xe9s'",
":",
"1",
",",
"'Juan Per\\tes'",
":",
"1",
",",
"'Juan Peres'",
":",
"2",
",",
"'ju\\xe1n Peres'",
":",
"1",
"}",
"clusters",
",",
"counts",
"=",
"group_fingerprint_strings",
"(",
"input_strings",
",",
"True",
",",
"True",
")",
"self",
".",
"assertEqual",
"(",
"clusters",
",",
"exp_clusters",
")",
"self",
".",
"assertEqual",
"(",
"counts",
",",
"exp_counts",
")"
] | [
82,
4
] | [
113,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
calculadora | () | Esta función pregunta al usuario 2 números a y b.
Realiza operaciones elementales con a y b | Esta función pregunta al usuario 2 números a y b.
Realiza operaciones elementales con a y b | def calculadora():
'''Esta función pregunta al usuario 2 números a y b.
Realiza operaciones elementales con a y b'''
a = input("Escribe un número:\n")#Con la función 'input()' se lee lo que escribe el usuario
b = input("Escribe un número:\n")
# La 'f' antes de las comillas permite leer la variable que se encuentra en llaves '{}'.
print(f'{a} + {b} = {float(a)+float(b)}')
print(f'{a} - {b} = {float(a)-float(b)}')
print(f'{a} * {b} = {float(a)*float(b)}')
print(f'{b} / {a} = {round(float(b)/float(a),2)}') | [
"def",
"calculadora",
"(",
")",
":",
"a",
"=",
"input",
"(",
"\"Escribe un número:\\n\")",
"#",
"Con la función 'input()' se lee lo que escribe el usuario",
"b",
"=",
"input",
"(",
"\"Escribe un número:\\n\")",
"",
"# La 'f' antes de las comillas permite leer la variable que se encuentra en llaves '{}'.",
"print",
"(",
"f'{a} + {b} = {float(a)+float(b)}'",
")",
"print",
"(",
"f'{a} - {b} = {float(a)-float(b)}'",
")",
"print",
"(",
"f'{a} * {b} = {float(a)*float(b)}'",
")",
"print",
"(",
"f'{b} / {a} = {round(float(b)/float(a),2)}'",
")"
] | [
1,
0
] | [
10,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
particion | (array, izquierda, derecha) | return i | i==> i se mueve hacia la derecha y comprueba si algún valor es MAYOR al pivote.
Cuando lo encuentra se detiene.
j<== j se mueve hacia la izquierda. y comprueba si algún valor es MENOR al pivote.
Cuando lo encuentra se detiene.
Pivote = Este tiene como función ser el comparador con los punteros i, j. Cuando no haya más cambios con este,
realizamos un swap entre el valor array[i] con el pivote. Ahora tendremos un nuevo pivote para comparar. | i==> i se mueve hacia la derecha y comprueba si algún valor es MAYOR al pivote.
Cuando lo encuentra se detiene.
j<== j se mueve hacia la izquierda. y comprueba si algún valor es MENOR al pivote.
Cuando lo encuentra se detiene.
Pivote = Este tiene como función ser el comparador con los punteros i, j. Cuando no haya más cambios con este,
realizamos un swap entre el valor array[i] con el pivote. Ahora tendremos un nuevo pivote para comparar. | def particion(array, izquierda, derecha):
i = izquierda # puntero izquierda
j = derecha - 1 # puntero derecha
# i se mueve a la derecha
#j se mueve a la izquierda
pivot = array[derecha] # pivote de la derecha. al principio es el ultimo elemento arr[-1]
""" i==> i se mueve hacia la derecha y comprueba si algún valor es MAYOR al pivote.
Cuando lo encuentra se detiene.
j<== j se mueve hacia la izquierda. y comprueba si algún valor es MENOR al pivote.
Cuando lo encuentra se detiene.
Pivote = Este tiene como función ser el comparador con los punteros i, j. Cuando no haya más cambios con este,
realizamos un swap entre el valor array[i] con el pivote. Ahora tendremos un nuevo pivote para comparar."""
while i<j: # Mientras el marcador de la izquierda (i) no supere al marcador de la derecha(j)
print(f'Array = {array}')
print()
while i< derecha and array[i]<pivot: # i es menor a la derecha y el elemento array de i es menor al pivot
i += 1 # muevo i a la derecha
"""
Mientras que el indice de i sea menor a la derecha(el último elemento del array), es decir,
no llegó hasta el final del array. Además el de array[i] debe ser menor al pivot.
Siempre y cuando se cumpla, i avanza hacia la derecha (i++).
ej
Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42 ==> El sentido de la vida,
el universo y todos lo demás
42 >15
42 > 23
42 < 95 ===> AQUí SE DETIENE i
"""
while j> izquierda and array[j]>= pivot: # j > izquierda y el elemento array[j] es mayor al pivote
j-=1 # muevo j a la izquierda
"""
Mientras que el indice de j sea mayor a la izquierda(el primer elemento del array), es decir,
no llegó hasta el principio del array. Además el de array[j] debe ser menor al pivot.
Siempre y cuando se cumpla, i avanza hacia la derecha.
Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42
42 > -523 ==> AQUí SE DETIENE j
"""
if i<j: # compruebo si i y j se cruzaron. Si no se cruzan:
"""
Si el índice de i es menor el de la izquierda. Se realiza el cambio
Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42
array[i] = 95. Este es MAYOR que el pivote 42.
array[j] = -523. Este es MENOR que el pivote 42.
Por ende, se intercambian array[i] <==> array[j]
Ahora nuestra array queda configurada así:
Array = [15, 23, -523, 8, 63, 321, 1786, 95, 42]
"""
print('*** i menor a j ***')
print()
print(f'Pivot: {pivot}')
print()
#print(f' Se intercambia array[{i}] = {array[i]}'\
# f' por array[{j}] = {array[j]} ')
print(f'array[{i}] = {array[i]} <==> array[{j}] = {array[j]} ')
print()
print('****************')
print()
array[i], array[j] = array[j], array[i] # intercambio los elementos i y j
print()
if array[i] > pivot: # Si se cruzan:
"""
Cuando j que viene por la derecha, sobrepasa a i(que es el que busca el mayor), quiere decir que no hay hay
un numero menor en ese rango, por ende array[i] debe ir al último, por que este es mayor que el pivote.
Intercambiamos array[i] por el pivote:
[15, 23, -523, 8, 63, 321, 1786, 95, 42]
42 > 15 42 < 95
42 > 23 42 < 1786
42 > -523 42 < 321
i se detiene 42 < 63 42 < 63
42 > 8 j se detiene.
En este caso j superó a i. Entonces, 42 ya no es el mayor valor, por lo que se intercambia el pivote con
array[i] (siempre y cuando sea mayor al pivote).
Como resultado, nuestra Array queda de la siguiente manera:
Array = [15, 23, -523, 8, 42, 321, 1786, 95, 63]
y volvemos a iterar nuevamente. Hasta que no haya un valor MAYOR al pivote.
"""
print('***Reemplazo de pivot****')
print()
print(f'Pivote: {pivot}')
print()
print(f'array[{i}] = {array[i]} <==> array[{derecha}](Pivote) = {pivot} ')
print()
print('****************')
array[i], array[derecha] = array[derecha], array[i] #intercambio i con el pivote
# Lo importante de esta función es que nos devuelve la posición de i. Es decir, desde donde debe empezar a
#realizar la búsqueda nuevamente. Tanto para la izquierda de i como la derecha de i
return i | [
"def",
"particion",
"(",
"array",
",",
"izquierda",
",",
"derecha",
")",
":",
"i",
"=",
"izquierda",
"# puntero izquierda\r",
"j",
"=",
"derecha",
"-",
"1",
"# puntero derecha\r",
"# i se mueve a la derecha\r",
"#j se mueve a la izquierda\r",
"pivot",
"=",
"array",
"[",
"derecha",
"]",
"# pivote de la derecha. al principio es el ultimo elemento arr[-1]\r",
"while",
"i",
"<",
"j",
":",
"# Mientras el marcador de la izquierda (i) no supere al marcador de la derecha(j)\r",
"print",
"(",
"f'Array = {array}'",
")",
"print",
"(",
")",
"while",
"i",
"<",
"derecha",
"and",
"array",
"[",
"i",
"]",
"<",
"pivot",
":",
"# i es menor a la derecha y el elemento array de i es menor al pivot\r",
"i",
"+=",
"1",
"# muevo i a la derecha\r",
"\"\"\" \r\n Mientras que el indice de i sea menor a la derecha(el último elemento del array), es decir,\r\n no llegó hasta el final del array. Además el de array[i] debe ser menor al pivot.\r\n Siempre y cuando se cumpla, i avanza hacia la derecha (i++).\r\n ej\r\n Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42 ==> El sentido de la vida,\r\n el universo y todos lo demás\r\n 42 >15\r\n 42 > 23\r\n 42 < 95 ===> AQUí SE DETIENE i\r\n \"\"\"",
"while",
"j",
">",
"izquierda",
"and",
"array",
"[",
"j",
"]",
">=",
"pivot",
":",
"# j > izquierda y el elemento array[j] es mayor al pivote \r",
"j",
"-=",
"1",
"# muevo j a la izquierda\r",
"\"\"\"\r\n Mientras que el indice de j sea mayor a la izquierda(el primer elemento del array), es decir,\r\n no llegó hasta el principio del array. Además el de array[j] debe ser menor al pivot.\r\n Siempre y cuando se cumpla, i avanza hacia la derecha.\r\n Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42\r\n 42 > -523 ==> AQUí SE DETIENE j\r\n \r\n \"\"\"",
"if",
"i",
"<",
"j",
":",
"# compruebo si i y j se cruzaron. Si no se cruzan:\r",
"\"\"\"\r\n Si el índice de i es menor el de la izquierda. Se realiza el cambio\r\n Array = [15, 23, 95, 8, 63, 321, 1786, -523, 42] | pivote = 42\r\n\r\n array[i] = 95. Este es MAYOR que el pivote 42.\r\n array[j] = -523. Este es MENOR que el pivote 42.\r\n\r\n Por ende, se intercambian array[i] <==> array[j]\r\n Ahora nuestra array queda configurada así:\r\n\r\n Array = [15, 23, -523, 8, 63, 321, 1786, 95, 42]\r\n \"\"\"",
"print",
"(",
"'*** i menor a j ***'",
")",
"print",
"(",
")",
"print",
"(",
"f'Pivot: {pivot}'",
")",
"print",
"(",
")",
"#print(f' Se intercambia array[{i}] = {array[i]}'\\\r",
"# f' por array[{j}] = {array[j]} ') \r",
"print",
"(",
"f'array[{i}] = {array[i]} <==> array[{j}] = {array[j]} '",
")",
"print",
"(",
")",
"print",
"(",
"'****************'",
")",
"print",
"(",
")",
"array",
"[",
"i",
"]",
",",
"array",
"[",
"j",
"]",
"=",
"array",
"[",
"j",
"]",
",",
"array",
"[",
"i",
"]",
"# intercambio los elementos i y j\r",
"print",
"(",
")",
"if",
"array",
"[",
"i",
"]",
">",
"pivot",
":",
"# Si se cruzan:\r",
"\"\"\"\r\n Cuando j que viene por la derecha, sobrepasa a i(que es el que busca el mayor), quiere decir que no hay hay\r\n un numero menor en ese rango, por ende array[i] debe ir al último, por que este es mayor que el pivote.\r\n Intercambiamos array[i] por el pivote:\r\n [15, 23, -523, 8, 63, 321, 1786, 95, 42]\r\n 42 > 15 42 < 95\r\n 42 > 23 42 < 1786\r\n 42 > -523 42 < 321\r\n i se detiene 42 < 63 42 < 63\r\n 42 > 8 j se detiene.\r\n\r\n En este caso j superó a i. Entonces, 42 ya no es el mayor valor, por lo que se intercambia el pivote con\r\n array[i] (siempre y cuando sea mayor al pivote).\r\n\r\n Como resultado, nuestra Array queda de la siguiente manera:\r\n Array = [15, 23, -523, 8, 42, 321, 1786, 95, 63]\r\n y volvemos a iterar nuevamente. Hasta que no haya un valor MAYOR al pivote.\r\n \"\"\"",
"print",
"(",
"'***Reemplazo de pivot****'",
")",
"print",
"(",
")",
"print",
"(",
"f'Pivote: {pivot}'",
")",
"print",
"(",
")",
"print",
"(",
"f'array[{i}] = {array[i]} <==> array[{derecha}](Pivote) = {pivot} '",
")",
"print",
"(",
")",
"print",
"(",
"'****************'",
")",
"array",
"[",
"i",
"]",
",",
"array",
"[",
"derecha",
"]",
"=",
"array",
"[",
"derecha",
"]",
",",
"array",
"[",
"i",
"]",
"#intercambio i con el pivote\r",
"# Lo importante de esta función es que nos devuelve la posición de i. Es decir, desde donde debe empezar a\r",
"#realizar la búsqueda nuevamente. Tanto para la izquierda de i como la derecha de i\r",
"return",
"i"
] | [
59,
0
] | [
159,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
solucion_a | (texto: str) | return resultado | Devuelve el texto ingresado sin mayúsculas.
:param texto: Texto
:type texto: str
:return: Texto ingresado sin mayúsculas
:rtype: str
| Devuelve el texto ingresado sin mayúsculas. | def solucion_a(texto: str) -> str:
"""Devuelve el texto ingresado sin mayúsculas.
:param texto: Texto
:type texto: str
:return: Texto ingresado sin mayúsculas
:rtype: str
"""
resultado = ""
for letra in texto:
if not letra.isupper():
resultado += letra
return resultado | [
"def",
"solucion_a",
"(",
"texto",
":",
"str",
")",
"->",
"str",
":",
"resultado",
"=",
"\"\"",
"for",
"letra",
"in",
"texto",
":",
"if",
"not",
"letra",
".",
"isupper",
"(",
")",
":",
"resultado",
"+=",
"letra",
"return",
"resultado"
] | [
13,
0
] | [
25,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Estante.__repr__ | (self) | return repr(self.dic) | Retorna la representación de la clase (archivo shelve). | Retorna la representación de la clase (archivo shelve). | def __repr__(self):
"""Retorna la representación de la clase (archivo shelve)."""
return repr(self.dic) | [
"def",
"__repr__",
"(",
"self",
")",
":",
"return",
"repr",
"(",
"self",
".",
"dic",
")"
] | [
25,
4
] | [
27,
29
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EAD.verificar_disponibilidad_directorio_tmp | (self, dirname) | return True | Verifica si el directorio temporal de destino está disponible
(no existe) | Verifica si el directorio temporal de destino está disponible
(no existe) | def verificar_disponibilidad_directorio_tmp(self, dirname):
"""Verifica si el directorio temporal de destino está disponible
(no existe)"""
return True | [
"def",
"verificar_disponibilidad_directorio_tmp",
"(",
"self",
",",
"dirname",
")",
":",
"return",
"True"
] | [
47,
4
] | [
51,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioTSP.vecino | (self, sol) | return temp | Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (list)
Solución a partir de la cual se originará una nueva solución vecina
Salidas:
(list) Solución vecina
| Calcula una solución vecina a partir de una solución dada. | def vecino(self, sol):
"""Calcula una solución vecina a partir de una solución dada.
Una solución vecina comparte la mayor parte de su estructura con
la solución que la origina, aunque no son exactamente iguales. El
método transforma aleatoriamente algún aspecto de la solución
original.
Entradas:
sol (list)
Solución a partir de la cual se originará una nueva solución vecina
Salidas:
(list) Solución vecina
"""
temp = sol.copy()
cambio_invalido = True
cambios = 3
while cambio_invalido or cambios == 0:
i,j = rd.randint(0,self.n_ciudades-2),rd.randint(0,self.n_ciudades-2)
temp[i],temp[j] = temp[j],temp[i]
cambio_invalido = True
if temp != sol:
cambio_invalido = False
cambios -=1
return temp | [
"def",
"vecino",
"(",
"self",
",",
"sol",
")",
":",
"temp",
"=",
"sol",
".",
"copy",
"(",
")",
"cambio_invalido",
"=",
"True",
"cambios",
"=",
"3",
"while",
"cambio_invalido",
"or",
"cambios",
"==",
"0",
":",
"i",
",",
"j",
"=",
"rd",
".",
"randint",
"(",
"0",
",",
"self",
".",
"n_ciudades",
"-",
"2",
")",
",",
"rd",
".",
"randint",
"(",
"0",
",",
"self",
".",
"n_ciudades",
"-",
"2",
")",
"temp",
"[",
"i",
"]",
",",
"temp",
"[",
"j",
"]",
"=",
"temp",
"[",
"j",
"]",
",",
"temp",
"[",
"i",
"]",
"cambio_invalido",
"=",
"True",
"if",
"temp",
"!=",
"sol",
":",
"cambio_invalido",
"=",
"False",
"cambios",
"-=",
"1",
"return",
"temp"
] | [
140,
4
] | [
166,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_Cuerpos_Cuerpo | (t) | CUERPOS : CUERPO | CUERPOS : CUERPO | def p_Cuerpos_Cuerpo(t):
'CUERPOS : CUERPO'
t[0] = [t[1]]
rep_gramatica('\n <TR><TD> CUERPOS → CUERPO </TD><TD> t[0] = [t[1]] </TD></TR>') | [
"def",
"p_Cuerpos_Cuerpo",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"[",
"t",
"[",
"1",
"]",
"]",
"rep_gramatica",
"(",
"'\\n <TR><TD> CUERPOS → CUERPO </TD><TD> t[0] = [t[1]] </TD></TR>')",
""
] | [
770,
0
] | [
773,
92
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solucion | (source: str, target: str, steps: int = 6, take: int = 2) | return "".join(
[target[pos*steps:pos*steps+steps] + source[pos*take:pos*take+take]
for pos in range(len(target)//steps)]
) | Toma una cantidad determinada de valores de una cadena fuente
y las inserta en un número determinado de posiciones de la cadena
destino.
:param source: Cadena de texto fuente de la cual tomar valores
:type source: str
:param target: Cadena de texto de destino a insertar valores
:type target: str
:param steps: Cantidad de pasos (posiciones)
:type target: int
:param take: Cantidad de valores a tomar
:type take: int
:return: Cadena destino con los valores de la fuente insertados
:rtype: str
:Example:
>>> resultado = solucion("E4F7", "FFD7FFA3EE5D")
>>> print(resultado)
FFD7FFE4A3EE5DF7
.. note:: Cambiar el nombre de la función a uno mas apropiado
| Toma una cantidad determinada de valores de una cadena fuente
y las inserta en un número determinado de posiciones de la cadena
destino. | def solucion(source: str, target: str, steps: int = 6, take: int = 2) -> str:
"""Toma una cantidad determinada de valores de una cadena fuente
y las inserta en un número determinado de posiciones de la cadena
destino.
:param source: Cadena de texto fuente de la cual tomar valores
:type source: str
:param target: Cadena de texto de destino a insertar valores
:type target: str
:param steps: Cantidad de pasos (posiciones)
:type target: int
:param take: Cantidad de valores a tomar
:type take: int
:return: Cadena destino con los valores de la fuente insertados
:rtype: str
:Example:
>>> resultado = solucion("E4F7", "FFD7FFA3EE5D")
>>> print(resultado)
FFD7FFE4A3EE5DF7
.. note:: Cambiar el nombre de la función a uno mas apropiado
"""
return "".join(
[target[pos*steps:pos*steps+steps] + source[pos*take:pos*take+take]
for pos in range(len(target)//steps)]
) | [
"def",
"solucion",
"(",
"source",
":",
"str",
",",
"target",
":",
"str",
",",
"steps",
":",
"int",
"=",
"6",
",",
"take",
":",
"int",
"=",
"2",
")",
"->",
"str",
":",
"return",
"\"\"",
".",
"join",
"(",
"[",
"target",
"[",
"pos",
"*",
"steps",
":",
"pos",
"*",
"steps",
"+",
"steps",
"]",
"+",
"source",
"[",
"pos",
"*",
"take",
":",
"pos",
"*",
"take",
"+",
"take",
"]",
"for",
"pos",
"in",
"range",
"(",
"len",
"(",
"target",
")",
"//",
"steps",
")",
"]",
")"
] | [
5,
0
] | [
32,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AbstractGMapsExtractor.force_sleep | (self, sleep_time=0) | Hace dormir el thread para dar tiempo a chrome a renderizar todos los elementos necesarios.
Parameters
----------
sleep_time : int
tiempo que se dormirá el thread donde corre esta isntancia. Representa segundos
| Hace dormir el thread para dar tiempo a chrome a renderizar todos los elementos necesarios. | def force_sleep(self, sleep_time=0):
"""Hace dormir el thread para dar tiempo a chrome a renderizar todos los elementos necesarios.
Parameters
----------
sleep_time : int
tiempo que se dormirá el thread donde corre esta isntancia. Representa segundos
"""
self.logger.debug(
"-{postal_code}- forcing to sleep for -{seconds}- seconds".format(postal_code=self._postal_code,
seconds=sleep_time))
time.sleep(sleep_time)
self.logger.debug("-{postal_code}- awaking... the process continues...".format(postal_code=self._postal_code)) | [
"def",
"force_sleep",
"(",
"self",
",",
"sleep_time",
"=",
"0",
")",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}- forcing to sleep for -{seconds}- seconds\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
",",
"seconds",
"=",
"sleep_time",
")",
")",
"time",
".",
"sleep",
"(",
"sleep_time",
")",
"self",
".",
"logger",
".",
"debug",
"(",
"\"-{postal_code}- awaking... the process continues...\"",
".",
"format",
"(",
"postal_code",
"=",
"self",
".",
"_postal_code",
")",
")"
] | [
221,
4
] | [
233,
118
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones_extras3 | (t) | funciones_extras : binary_string | funciones_extras : binary_string | def p_funciones_extras3(t):
'funciones_extras : binary_string'
node= grammer.nodoDireccion('funciones_extras')
node.agregar(t[1])
t[0]= node | [
"def",
"p_funciones_extras3",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'funciones_extras'",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"1",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1817,
0
] | [
1821,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
input_data | () | return data | Retorna una lista de números flotantes ingresados por el usuario
| Retorna una lista de números flotantes ingresados por el usuario
| def input_data() -> List[float]:
"""Retorna una lista de números flotantes ingresados por el usuario
"""
data = []
n = int(input("Cantidad: "))
for _ in range(n):
data.append(float(input("Dato: ")))
return data | [
"def",
"input_data",
"(",
")",
"->",
"List",
"[",
"float",
"]",
":",
"data",
"=",
"[",
"]",
"n",
"=",
"int",
"(",
"input",
"(",
"\"Cantidad: \"",
")",
")",
"for",
"_",
"in",
"range",
"(",
"n",
")",
":",
"data",
".",
"append",
"(",
"float",
"(",
"input",
"(",
"\"Dato: \"",
")",
")",
")",
"return",
"data"
] | [
35,
0
] | [
42,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_prima2 | (t) | instrucciones_prima2 : instruccion P_COMA instrucciones_prima2
| | instrucciones_prima2 : instruccion P_COMA instrucciones_prima2
| | def p_instrucciones_prima2(t):
'''instrucciones_prima2 : instruccion P_COMA instrucciones_prima2
| ''' | [
"def",
"p_instrucciones_prima2",
"(",
"t",
")",
":"
] | [
245,
0
] | [
247,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
collect | (
apiclient: ApiClient, collect_data: Dict[str, Any]
) | Este servicio envía un cobro a un cliente. Si el cliente tiene
registrada una tarjeta de crédito se le hace un cargo automático, si
no tiene registrada una tarjeta de credito se genera un cobro. Si se
envía el parámetro byEmail = 1, se genera un cobro por email.
| Este servicio envía un cobro a un cliente. Si el cliente tiene
registrada una tarjeta de crédito se le hace un cargo automático, si
no tiene registrada una tarjeta de credito se genera un cobro. Si se
envía el parámetro byEmail = 1, se genera un cobro por email.
| def collect(
apiclient: ApiClient, collect_data: Dict[str, Any]
) -> Union[CollectResponse, Error]:
"""Este servicio envía un cobro a un cliente. Si el cliente tiene
registrada una tarjeta de crédito se le hace un cargo automático, si
no tiene registrada una tarjeta de credito se genera un cobro. Si se
envía el parámetro byEmail = 1, se genera un cobro por email.
"""
url = f"{apiclient.api_url}/customer/collect"
collect = CollectRequest.from_dict(collect_data)
if collect.apiKey is None:
collect.apiKey = apiclient.api_key
collect.s = apiclient.make_signature(asdict(collect))
logging.debug("Before Request:" + str(collect))
response = apiclient.post(url, asdict(collect))
if response.status_code == 200:
return CollectResponse.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",
"collect",
"(",
"apiclient",
":",
"ApiClient",
",",
"collect_data",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"Union",
"[",
"CollectResponse",
",",
"Error",
"]",
":",
"url",
"=",
"f\"{apiclient.api_url}/customer/collect\"",
"collect",
"=",
"CollectRequest",
".",
"from_dict",
"(",
"collect_data",
")",
"if",
"collect",
".",
"apiKey",
"is",
"None",
":",
"collect",
".",
"apiKey",
"=",
"apiclient",
".",
"api_key",
"collect",
".",
"s",
"=",
"apiclient",
".",
"make_signature",
"(",
"asdict",
"(",
"collect",
")",
")",
"logging",
".",
"debug",
"(",
"\"Before Request:\"",
"+",
"str",
"(",
"collect",
")",
")",
"response",
"=",
"apiclient",
".",
"post",
"(",
"url",
",",
"asdict",
"(",
"collect",
")",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"return",
"CollectResponse",
".",
"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",
")"
] | [
278,
0
] | [
304,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
planilla.buscar_alia | (self,alias) | return "no existe registro" | busca en el diccionario el alias=value[0] donde [key:value] value=[value[0],...] | busca en el diccionario el alias=value[0] donde [key:value] value=[value[0],...] | def buscar_alia(self,alias):
"busca en el diccionario el alias=value[0] donde [key:value] value=[value[0],...]"
for key, value in self.Planilla_.items(): #bucle for donde i = [key, value] dentro de [k,v]=planilla_.items()
if (alias) == (value[0]):
return key
return "no existe registro" | [
"def",
"buscar_alia",
"(",
"self",
",",
"alias",
")",
":",
"for",
"key",
",",
"value",
"in",
"self",
".",
"Planilla_",
".",
"items",
"(",
")",
":",
"#bucle for donde i = [key, value] dentro de [k,v]=planilla_.items()",
"if",
"(",
"alias",
")",
"==",
"(",
"value",
"[",
"0",
"]",
")",
":",
"return",
"key",
"return",
"\"no existe registro\""
] | [
70,
4
] | [
75,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Areas.areaCuadrado | (lado) | return"el area del cuadrado es :" +str(lado*lado) | calculo el area de un cuadrado
elevando al cuadrado el lado pasado por parametro | calculo el area de un cuadrado
elevando al cuadrado el lado pasado por parametro | def areaCuadrado(lado):
"""calculo el area de un cuadrado
elevando al cuadrado el lado pasado por parametro"""
return"el area del cuadrado es :" +str(lado*lado) | [
"def",
"areaCuadrado",
"(",
"lado",
")",
":",
"return",
"\"el area del cuadrado es :\"",
"+",
"str",
"(",
"lado",
"*",
"lado",
")"
] | [
8,
4
] | [
13,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Main.__init__ | (self) | Incializamos nuestra app | Incializamos nuestra app | def __init__(self):
""" Incializamos nuestra app"""
QMainWindow.__init__(self)
# Instaciamos nuestra ventanas widget home
self.home = Ui_home()
self.home.setupUi(self)
# Eventos
self.home.bt_lexico.clicked.connect(self.ev_lexico)
self.home.bt_sintactico.clicked.connect(self.ev_sintactico)
self.home.bt_archivo.clicked.connect(self.ev_archivo)
self.home.bt_limpiar.clicked.connect(self.ev_limpiar)
#Desarrollandores
self.home.estado.showMessage("Desarrollado por Miguel Mazariegos y Ruth Carpio") | [
"def",
"__init__",
"(",
"self",
")",
":",
"QMainWindow",
".",
"__init__",
"(",
"self",
")",
"# Instaciamos nuestra ventanas widget home",
"self",
".",
"home",
"=",
"Ui_home",
"(",
")",
"self",
".",
"home",
".",
"setupUi",
"(",
"self",
")",
"# Eventos",
"self",
".",
"home",
".",
"bt_lexico",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ev_lexico",
")",
"self",
".",
"home",
".",
"bt_sintactico",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ev_sintactico",
")",
"self",
".",
"home",
".",
"bt_archivo",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ev_archivo",
")",
"self",
".",
"home",
".",
"bt_limpiar",
".",
"clicked",
".",
"connect",
"(",
"self",
".",
"ev_limpiar",
")",
"#Desarrollandores",
"self",
".",
"home",
".",
"estado",
".",
"showMessage",
"(",
"\"Desarrollado por Miguel Mazariegos y Ruth Carpio\"",
")"
] | [
12,
4
] | [
28,
88
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
encontrar | (entrada) | return arreglo | Se lista el directorio para saber si está conectado alguna USB, si la lista esta
vacía regresa una lista vacía | Se lista el directorio para saber si está conectado alguna USB, si la lista esta
vacía regresa una lista vacía | def encontrar(entrada):
contenido2=os.listdir('/media/pi/')#Se lista el contenido de la carpeta /media/pi
'''Se lista el directorio para saber si está conectado alguna USB, si la lista esta
vacía regresa una lista vacía'''
if len(contenido2)==0:#Si la lista contenido 2 esta vacía
return contenido2 #Regresa una lista vacía
'''Si está conectada una memoria la variable contenido tiene la lista de los
nombres de las carpetas de las USB. Se escoge la primera USB y
se concatena con /media/pi/ para obtener el contenido de la USB'''
contenido=os.listdir('/media/pi/'+contenido2[0])#Se obtiene el contenido de /media/pi+contenido2[0]
arreglo=[]#Arreglo sera una lista vacía
"""Revisa todos los archivos de la memoria y verifica si
es un archivo y si cumple con la extensión
que está determinada por la lista entrada"""
for fichero in contenido:# Se recorre la lista contenido
#con cada cadena fichero de la lista contenido
if os.path.isfile(os.path.join('/media/pi/'+contenido2[0],fichero))and buscar(entrada,fichero): #Si la ruta de /media/Pi+contenido2[0] es un archivo
#y el método buscar regresa un True
arreglo.append(fichero)#La lista arreglo agrega el valor de fichero
return arreglo | [
"def",
"encontrar",
"(",
"entrada",
")",
":",
"contenido2",
"=",
"os",
".",
"listdir",
"(",
"'/media/pi/'",
")",
"#Se lista el contenido de la carpeta /media/pi",
"if",
"len",
"(",
"contenido2",
")",
"==",
"0",
":",
"#Si la lista contenido 2 esta vacía",
"return",
"contenido2",
"#Regresa una lista vacía",
"'''Si está conectada una memoria la variable contenido tiene la lista de los\n nombres de las carpetas de las USB. Se escoge la primera USB y\n se concatena con /media/pi/ para obtener el contenido de la USB'''",
"contenido",
"=",
"os",
".",
"listdir",
"(",
"'/media/pi/'",
"+",
"contenido2",
"[",
"0",
"]",
")",
"#Se obtiene el contenido de /media/pi+contenido2[0]",
"arreglo",
"=",
"[",
"]",
"#Arreglo sera una lista vacía",
"\"\"\"Revisa todos los archivos de la memoria y verifica si\n es un archivo y si cumple con la extensión\n que está determinada por la lista entrada\"\"\"",
"for",
"fichero",
"in",
"contenido",
":",
"# Se recorre la lista contenido",
"#con cada cadena fichero de la lista contenido",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"os",
".",
"path",
".",
"join",
"(",
"'/media/pi/'",
"+",
"contenido2",
"[",
"0",
"]",
",",
"fichero",
")",
")",
"and",
"buscar",
"(",
"entrada",
",",
"fichero",
")",
":",
"#Si la ruta de /media/Pi+contenido2[0] es un archivo",
"#y el método buscar regresa un True",
"arreglo",
".",
"append",
"(",
"fichero",
")",
"#La lista arreglo agrega el valor de fichero",
"return",
"arreglo"
] | [
353,
0
] | [
372,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraSmlScraperTestCase.test_sml_coins_has_values | (self) | Validar la existencia de valores dentro de coins | Validar la existencia de valores dentro de coins | def test_sml_coins_has_values(self):
"""Validar la existencia de valores dentro de coins"""
dict_config = {'sml': {'coins': {}}}
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_coins_key_has_values(config) | [
"def",
"test_sml_coins_has_values",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'sml'",
":",
"{",
"'coins'",
":",
"{",
"}",
"}",
"}",
"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_coins_key_has_values",
"(",
"config",
")"
] | [
350,
4
] | [
361,
53
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ServiceCallback.network_in_service | (networkid: int, serviceid: int, *, cursor) | return bool(*exists) | Verifica si el servicio es parte de un nodo | Verifica si el servicio es parte de un nodo | async def network_in_service(networkid: int, serviceid: int, *, cursor) -> bool:
"""Verifica si el servicio es parte de un nodo"""
await cursor.execute(
"SELECT COUNT(id_network) FROM services WHERE id_service = %s AND id_network = %s LIMIT 1",
(serviceid, networkid)
)
exists = await cursor.fetchone()
return bool(*exists) | [
"async",
"def",
"network_in_service",
"(",
"networkid",
":",
"int",
",",
"serviceid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"bool",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT COUNT(id_network) FROM services WHERE id_service = %s AND id_network = %s LIMIT 1\"",
",",
"(",
"serviceid",
",",
"networkid",
")",
")",
"exists",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"bool",
"(",
"*",
"exists",
")"
] | [
734,
4
] | [
745,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_funcion_random | (t) | lista_funciones : RANDOM PARIZQ PARDER | lista_funciones : RANDOM PARIZQ PARDER | def p_instrucciones_funcion_random(t) :
'lista_funciones : RANDOM PARIZQ PARDER' | [
"def",
"p_instrucciones_funcion_random",
"(",
"t",
")",
":"
] | [
945,
0
] | [
946,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_declaraciones | (t) | declaraciones : DECLARE listadeclaraciones | declaraciones : DECLARE listadeclaraciones | def p_declaraciones(t):
'declaraciones : DECLARE listadeclaraciones'
g = '<declaraciones> : DECLARE <listadeclaraciones>'
t[0] = Nodo('DECLARE', '', t[2], t.lexer.lineno, 0, g) | [
"def",
"p_declaraciones",
"(",
"t",
")",
":",
"g",
"=",
"'<declaraciones> : DECLARE <listadeclaraciones>'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'DECLARE'",
",",
"''",
",",
"t",
"[",
"2",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"g",
")"
] | [
583,
0
] | [
586,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Epson2GenDriver.start | (self) | Inicia recurso de conexion con impresora | Inicia recurso de conexion con impresora | def start(self):
"""Inicia recurso de conexion con impresora"""
self.EpsonLibInterface.ConfigurarVelocidad( c_int(self.baudrate).value )
self.EpsonLibInterface.ConfigurarPuerto( self.port )
self.EpsonLibInterface.Conectar()
str_version_max_len = 500
str_version = create_string_buffer( b'\000' * str_version_max_len )
int_major = c_int()
int_minor = c_int()
error = self.EpsonLibInterface.ConsultarVersionEquipo( str_version, c_int(str_version_max_len).value, byref(int_major), byref(int_minor) )
print "Machinne Version : ",
print error
print "String Machinne Version : ",
print str_version.value
print "Major Machinne Version : ",
print int_major.value
print "Minor Machine Version : ",
print int_minor.value
# status
error = self.EpsonLibInterface.ConsultarEstadoDeConexion()
print "Conexion Status : ",
print error
error = self.EpsonLibInterface.ComenzarLog()
print "Log iniciado Status : ",
print error
logging.getLogger().info("Conectada la Epson 2Gen al puerto : %s" % (self.port) ) | [
"def",
"start",
"(",
"self",
")",
":",
"self",
".",
"EpsonLibInterface",
".",
"ConfigurarVelocidad",
"(",
"c_int",
"(",
"self",
".",
"baudrate",
")",
".",
"value",
")",
"self",
".",
"EpsonLibInterface",
".",
"ConfigurarPuerto",
"(",
"self",
".",
"port",
")",
"self",
".",
"EpsonLibInterface",
".",
"Conectar",
"(",
")",
"str_version_max_len",
"=",
"500",
"str_version",
"=",
"create_string_buffer",
"(",
"b'\\000'",
"*",
"str_version_max_len",
")",
"int_major",
"=",
"c_int",
"(",
")",
"int_minor",
"=",
"c_int",
"(",
")",
"error",
"=",
"self",
".",
"EpsonLibInterface",
".",
"ConsultarVersionEquipo",
"(",
"str_version",
",",
"c_int",
"(",
"str_version_max_len",
")",
".",
"value",
",",
"byref",
"(",
"int_major",
")",
",",
"byref",
"(",
"int_minor",
")",
")",
"print",
"\"Machinne Version : \"",
",",
"print",
"error",
"print",
"\"String Machinne Version : \"",
",",
"print",
"str_version",
".",
"value",
"print",
"\"Major Machinne Version : \"",
",",
"print",
"int_major",
".",
"value",
"print",
"\"Minor Machine Version : \"",
",",
"print",
"int_minor",
".",
"value",
"# status",
"error",
"=",
"self",
".",
"EpsonLibInterface",
".",
"ConsultarEstadoDeConexion",
"(",
")",
"print",
"\"Conexion Status : \"",
",",
"print",
"error",
"error",
"=",
"self",
".",
"EpsonLibInterface",
".",
"ComenzarLog",
"(",
")",
"print",
"\"Log iniciado Status : \"",
",",
"print",
"error",
"logging",
".",
"getLogger",
"(",
")",
".",
"info",
"(",
"\"Conectada la Epson 2Gen al puerto : %s\"",
"%",
"(",
"self",
".",
"port",
")",
")"
] | [
57,
1
] | [
89,
84
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObject.smooth_estimations | (self) | Suaviza las posiciones de las estimaciones (centro y bounding boxes).
TODO
:return:
| Suaviza las posiciones de las estimaciones (centro y bounding boxes). | def smooth_estimations(self):
"""Suaviza las posiciones de las estimaciones (centro y bounding boxes).
TODO
:return:
""" | [
"def",
"smooth_estimations",
"(",
"self",
")",
":"
] | [
138,
4
] | [
144,
11
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Restaurant.__init__ | (self, name, cuisine_type) | Inicializar el restaurante. | Inicializar el restaurante. | def __init__(self, name, cuisine_type):
"""Inicializar el restaurante."""
self.name = name.title()
self.cuisine_type = cuisine_type
self.number_served = 0 | [
"def",
"__init__",
"(",
"self",
",",
"name",
",",
"cuisine_type",
")",
":",
"self",
".",
"name",
"=",
"name",
".",
"title",
"(",
")",
"self",
".",
"cuisine_type",
"=",
"cuisine_type",
"self",
".",
"number_served",
"=",
"0"
] | [
3,
4
] | [
7,
30
] | 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.