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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Molecule.make_grid | (self, mesh=0.5, extent=4, charge=False, lims=False) | return grid | Funcion para construir una red de puntos sensibles al
campo electrico de la molecula. | Funcion para construir una red de puntos sensibles al
campo electrico de la molecula. | def make_grid(self, mesh=0.5, extent=4, charge=False, lims=False):
""" Funcion para construir una red de puntos sensibles al
campo electrico de la molecula. """
if not lims:
limits = self.get_limits()
for i in xrange(6):
if i % 2 == 0:
limits[i] -= extent
else:
limits[i] += extent
else:
limits = [l for l in lims]
if (type(mesh) == float) or (type(mesh) == int):
m = [mesh, mesh, mesh]
else:
m = mesh
d_x = int((limits[1] - limits[0]) / m[0])
d_y = int((limits[3] - limits[2]) / m[1])
d_z = int((limits[5] - limits[4]) / m[2])
grid = [0] * d_x * d_y * d_z
coords = self.get_coords()
for i in xrange(d_x):
for j in xrange(d_y):
for k in xrange(d_z):
x = limits[0] + i * m[0]
y = limits[2] + j * m[1]
z = limits[4] + k * m[2]
if charge:
c = feel_field(x, y, z, coords)
grid[i*d_y*d_z + j*d_z + k] = (x, y, z, c)
else:
grid[i*d_y*d_z + j*d_z + k] = (x, y, z)
return grid | [
"def",
"make_grid",
"(",
"self",
",",
"mesh",
"=",
"0.5",
",",
"extent",
"=",
"4",
",",
"charge",
"=",
"False",
",",
"lims",
"=",
"False",
")",
":",
"if",
"not",
"lims",
":",
"limits",
"=",
"self",
".",
"get_limits",
"(",
")",
"for",
"i",
"in",
"xrange",
"(",
"6",
")",
":",
"if",
"i",
"%",
"2",
"==",
"0",
":",
"limits",
"[",
"i",
"]",
"-=",
"extent",
"else",
":",
"limits",
"[",
"i",
"]",
"+=",
"extent",
"else",
":",
"limits",
"=",
"[",
"l",
"for",
"l",
"in",
"lims",
"]",
"if",
"(",
"type",
"(",
"mesh",
")",
"==",
"float",
")",
"or",
"(",
"type",
"(",
"mesh",
")",
"==",
"int",
")",
":",
"m",
"=",
"[",
"mesh",
",",
"mesh",
",",
"mesh",
"]",
"else",
":",
"m",
"=",
"mesh",
"d_x",
"=",
"int",
"(",
"(",
"limits",
"[",
"1",
"]",
"-",
"limits",
"[",
"0",
"]",
")",
"/",
"m",
"[",
"0",
"]",
")",
"d_y",
"=",
"int",
"(",
"(",
"limits",
"[",
"3",
"]",
"-",
"limits",
"[",
"2",
"]",
")",
"/",
"m",
"[",
"1",
"]",
")",
"d_z",
"=",
"int",
"(",
"(",
"limits",
"[",
"5",
"]",
"-",
"limits",
"[",
"4",
"]",
")",
"/",
"m",
"[",
"2",
"]",
")",
"grid",
"=",
"[",
"0",
"]",
"*",
"d_x",
"*",
"d_y",
"*",
"d_z",
"coords",
"=",
"self",
".",
"get_coords",
"(",
")",
"for",
"i",
"in",
"xrange",
"(",
"d_x",
")",
":",
"for",
"j",
"in",
"xrange",
"(",
"d_y",
")",
":",
"for",
"k",
"in",
"xrange",
"(",
"d_z",
")",
":",
"x",
"=",
"limits",
"[",
"0",
"]",
"+",
"i",
"*",
"m",
"[",
"0",
"]",
"y",
"=",
"limits",
"[",
"2",
"]",
"+",
"j",
"*",
"m",
"[",
"1",
"]",
"z",
"=",
"limits",
"[",
"4",
"]",
"+",
"k",
"*",
"m",
"[",
"2",
"]",
"if",
"charge",
":",
"c",
"=",
"feel_field",
"(",
"x",
",",
"y",
",",
"z",
",",
"coords",
")",
"grid",
"[",
"i",
"*",
"d_y",
"*",
"d_z",
"+",
"j",
"*",
"d_z",
"+",
"k",
"]",
"=",
"(",
"x",
",",
"y",
",",
"z",
",",
"c",
")",
"else",
":",
"grid",
"[",
"i",
"*",
"d_y",
"*",
"d_z",
"+",
"j",
"*",
"d_z",
"+",
"k",
"]",
"=",
"(",
"x",
",",
"y",
",",
"z",
")",
"return",
"grid"
] | [
236,
4
] | [
268,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Atajo.__init__ | (self, url, user, test='') | Exigimos la URL y el usuario, test es opcional,
_id es automático. | Exigimos la URL y el usuario, test es opcional,
_id es automático. | def __init__(self, url, user, test=''):
'''Exigimos la URL y el usuario, test es opcional,
_id es automático.'''
# Hace falta crear esto?
r = self.store.find(Atajo, user = user, url = url)
self.url = url
self.user = user
self.activo = True
# Test por default, verifica que la página exista.
self.test = u'code 200'
if r.count():
# FIXME: esto creo que es una race condition
# Existe la misma URL para el mismo usuario,
# reciclamos el id y el test, pero activa.
viejo = r.one()
Atajo.store.remove(viejo)
self.id = viejo.id
self.test = viejo.test
self.store.add(self)
# Autosave/flush/commit a la base de datos
self.save() | [
"def",
"__init__",
"(",
"self",
",",
"url",
",",
"user",
",",
"test",
"=",
"''",
")",
":",
"# Hace falta crear esto?",
"r",
"=",
"self",
".",
"store",
".",
"find",
"(",
"Atajo",
",",
"user",
"=",
"user",
",",
"url",
"=",
"url",
")",
"self",
".",
"url",
"=",
"url",
"self",
".",
"user",
"=",
"user",
"self",
".",
"activo",
"=",
"True",
"# Test por default, verifica que la página exista.",
"self",
".",
"test",
"=",
"u'code 200'",
"if",
"r",
".",
"count",
"(",
")",
":",
"# FIXME: esto creo que es una race condition",
"# Existe la misma URL para el mismo usuario,",
"# reciclamos el id y el test, pero activa.",
"viejo",
"=",
"r",
".",
"one",
"(",
")",
"Atajo",
".",
"store",
".",
"remove",
"(",
"viejo",
")",
"self",
".",
"id",
"=",
"viejo",
".",
"id",
"self",
".",
"test",
"=",
"viejo",
".",
"test",
"self",
".",
"store",
".",
"add",
"(",
"self",
")",
"# Autosave/flush/commit a la base de datos",
"self",
".",
"save",
"(",
")"
] | [
76,
4
] | [
97,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
perimetro | (n: int, l:float) | return n * l | Calcula el perimetro de un poligono regular.
:param n: Numero de lados del poligono.
:n type: int
:param l: Longitud de un lado.
:l type: float
:return: Perimetro del poligono.
| Calcula el perimetro de un poligono regular. | def perimetro(n: int, l:float) -> float:
"""Calcula el perimetro de un poligono regular.
:param n: Numero de lados del poligono.
:n type: int
:param l: Longitud de un lado.
:l type: float
:return: Perimetro del poligono.
"""
return n * l | [
"def",
"perimetro",
"(",
"n",
":",
"int",
",",
"l",
":",
"float",
")",
"->",
"float",
":",
"return",
"n",
"*",
"l"
] | [
12,
0
] | [
21,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BaseView.get_title | (self) | return str(self.title or self.get_object() or vnp) | Obtiene el valor del título que se mostrará en la página. | Obtiene el valor del título que se mostrará en la página. | def get_title(self):
"""Obtiene el valor del título que se mostrará en la página."""
try:
vnp = str(getattr(self.model._meta, "verbose_name_plural", "")).title()
except (AttributeError):
vnp = ""
return str(self.title or self.get_object() or vnp) | [
"def",
"get_title",
"(",
"self",
")",
":",
"try",
":",
"vnp",
"=",
"str",
"(",
"getattr",
"(",
"self",
".",
"model",
".",
"_meta",
",",
"\"verbose_name_plural\"",
",",
"\"\"",
")",
")",
".",
"title",
"(",
")",
"except",
"(",
"AttributeError",
")",
":",
"vnp",
"=",
"\"\"",
"return",
"str",
"(",
"self",
".",
"title",
"or",
"self",
".",
"get_object",
"(",
")",
"or",
"vnp",
")"
] | [
130,
4
] | [
136,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_source_ip | (request) | return ip | **Función encargada de obtener la IP del cliente**
Se obtiene la IP para poder verificar los límites para usuarios
anonimos que hagan consultas a la API
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: IP que hace la petición a la API
| **Función encargada de obtener la IP del cliente** | def get_source_ip(request):
"""**Función encargada de obtener la IP del cliente**
Se obtiene la IP para poder verificar los límites para usuarios
anonimos que hagan consultas a la API
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: IP que hace la petición a la API
"""
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip = x_forwarded_for.split(',')[0]
else:
ip = request.META.get('REMOTE_ADDR')
return ip | [
"def",
"get_source_ip",
"(",
"request",
")",
":",
"x_forwarded_for",
"=",
"request",
".",
"META",
".",
"get",
"(",
"'HTTP_X_FORWARDED_FOR'",
")",
"if",
"x_forwarded_for",
":",
"ip",
"=",
"x_forwarded_for",
".",
"split",
"(",
"','",
")",
"[",
"0",
"]",
"else",
":",
"ip",
"=",
"request",
".",
"META",
".",
"get",
"(",
"'REMOTE_ADDR'",
")",
"return",
"ip"
] | [
40,
0
] | [
56,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Optimizador.GenerarReporte | (self) | Generar el reporte en graphviz | Generar el reporte en graphviz | def GenerarReporte(self):
"Generar el reporte en graphviz" | [
"def",
"GenerarReporte",
"(",
"self",
")",
":"
] | [
190,
4
] | [
191,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Frases.fijar_pipes | (self) | Fija componentes adicionales del Pipeline de procesamiento. | Fija componentes adicionales del Pipeline de procesamiento. | def fijar_pipes(self):
"""Fija componentes adicionales del Pipeline de procesamiento."""
if not self.lang.has_pipe("cumplimiento"):
self.lang.add_pipe(self.cumplimiento, name="cumplimiento", last=True)
if self.grupos:
if not self.lang.has_pipe("presencia"):
self.lang.add_pipe(self.presencia, name="presencia", last=True)
if self.entes:
if not self.lang.has_pipe("entes"):
ruler = EntityRuler(self.lang, phrase_matcher_attr="LOWER")
ruler.add_patterns(self.crear_patrones())
self.lang.add_pipe(ruler, name="entes", before="ner") | [
"def",
"fijar_pipes",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"lang",
".",
"has_pipe",
"(",
"\"cumplimiento\"",
")",
":",
"self",
".",
"lang",
".",
"add_pipe",
"(",
"self",
".",
"cumplimiento",
",",
"name",
"=",
"\"cumplimiento\"",
",",
"last",
"=",
"True",
")",
"if",
"self",
".",
"grupos",
":",
"if",
"not",
"self",
".",
"lang",
".",
"has_pipe",
"(",
"\"presencia\"",
")",
":",
"self",
".",
"lang",
".",
"add_pipe",
"(",
"self",
".",
"presencia",
",",
"name",
"=",
"\"presencia\"",
",",
"last",
"=",
"True",
")",
"if",
"self",
".",
"entes",
":",
"if",
"not",
"self",
".",
"lang",
".",
"has_pipe",
"(",
"\"entes\"",
")",
":",
"ruler",
"=",
"EntityRuler",
"(",
"self",
".",
"lang",
",",
"phrase_matcher_attr",
"=",
"\"LOWER\"",
")",
"ruler",
".",
"add_patterns",
"(",
"self",
".",
"crear_patrones",
"(",
")",
")",
"self",
".",
"lang",
".",
"add_pipe",
"(",
"ruler",
",",
"name",
"=",
"\"entes\"",
",",
"before",
"=",
"\"ner\"",
")"
] | [
103,
4
] | [
117,
69
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
solucion_a | (imc: float) | Devuelve una categoría de acuerdo al imc
:param imc: Índice de masa corporal
:imc type: float
:return: Categoría
:rtype: str
| Devuelve una categoría de acuerdo al imc | def solucion_a(imc: float) -> str:
"""Devuelve una categoría de acuerdo al imc
:param imc: Índice de masa corporal
:imc type: float
:return: Categoría
:rtype: str
"""
if imc < 18.5:
return "Underweight"
elif 18.5 <= imc < 25:
return "Normal"
elif 25 <= imc < 30:
return "Overweight"
else:
return "Obesity" | [
"def",
"solucion_a",
"(",
"imc",
":",
"float",
")",
"->",
"str",
":",
"if",
"imc",
"<",
"18.5",
":",
"return",
"\"Underweight\"",
"elif",
"18.5",
"<=",
"imc",
"<",
"25",
":",
"return",
"\"Normal\"",
"elif",
"25",
"<=",
"imc",
"<",
"30",
":",
"return",
"\"Overweight\"",
"else",
":",
"return",
"\"Obesity\""
] | [
37,
0
] | [
52,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ModelBase.get_actions_links | (self, size: str="1rem", fill: str=None,
defaults: list=None) | return out | Obtiene un diccionarios con las acciones para el objeto. | Obtiene un diccionarios con las acciones para el objeto. | def get_actions_links(self, size: str="1rem", fill: str=None,
defaults: list=None) -> dict:
"""Obtiene un diccionarios con las acciones para el objeto."""
if not defaults:
defaults = ["detail", "update", "delete"]
out = {}
for action in defaults:
act = self.get_action(action, size=size, fill=fill)
if act:
out[action] = act
return out | [
"def",
"get_actions_links",
"(",
"self",
",",
"size",
":",
"str",
"=",
"\"1rem\"",
",",
"fill",
":",
"str",
"=",
"None",
",",
"defaults",
":",
"list",
"=",
"None",
")",
"->",
"dict",
":",
"if",
"not",
"defaults",
":",
"defaults",
"=",
"[",
"\"detail\"",
",",
"\"update\"",
",",
"\"delete\"",
"]",
"out",
"=",
"{",
"}",
"for",
"action",
"in",
"defaults",
":",
"act",
"=",
"self",
".",
"get_action",
"(",
"action",
",",
"size",
"=",
"size",
",",
"fill",
"=",
"fill",
")",
"if",
"act",
":",
"out",
"[",
"action",
"]",
"=",
"act",
"return",
"out"
] | [
294,
4
] | [
305,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UserCallback.is_guest_user | (userid: int, *, cursor) | return bool(guest_user) | Verifica si un usuario determinado es un usuario invitado | Verifica si un usuario determinado es un usuario invitado | async def is_guest_user(userid: int, *, cursor) -> bool:
"""Verifica si un usuario determinado es un usuario invitado"""
await cursor.execute("SELECT guest_user FROM users WHERE id = %s LIMIT 1", (userid,))
guest_user = await cursor.fetchone()
if (guest_user is None):
raise exceptions.UserNotFound(_("El usuario no existe"))
else:
(guest_user,) = guest_user
return bool(guest_user) | [
"async",
"def",
"is_guest_user",
"(",
"userid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"bool",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT guest_user FROM users WHERE id = %s LIMIT 1\"",
",",
"(",
"userid",
",",
")",
")",
"guest_user",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"if",
"(",
"guest_user",
"is",
"None",
")",
":",
"raise",
"exceptions",
".",
"UserNotFound",
"(",
"_",
"(",
"\"El usuario no existe\"",
")",
")",
"else",
":",
"(",
"guest_user",
",",
")",
"=",
"guest_user",
"return",
"bool",
"(",
"guest_user",
")"
] | [
52,
4
] | [
65,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
bolita | (replies) | Los resultados de la bolita (lotería de la Florida) | Los resultados de la bolita (lotería de la Florida) | def bolita(replies) -> None:
"""Los resultados de la bolita (lotería de la Florida)"""
import feedparser
with session.get("https://flalottery.com/video/en/theWinningNumber.xml") as resp:
resp.raise_for_status()
d = feedparser.parse(resp.text)
pick3, pick4 = "", ""
regex = re.compile(r"([\d-]+) for (\w+) ([\d/]+)")
for entry in d.entries:
title = entry.title.lower()
if title.startswith(("pick 3", "pick 4")):
text = ""
for result in regex.findall(entry.description):
text += f"{result[2]} {'☀️ Día' if result[1] == 'Midday' else '🌙 Noche'}: {result[0]}\n"
if title.startswith("pick 3"):
pick3 = text
else:
pick4 = text
assert pick3 and pick4
replies.add(text=f"**🎰 Resultados**\n\n**PICK 3**\n{pick3}\n**PICK 4**\n{pick4}") | [
"def",
"bolita",
"(",
"replies",
")",
"->",
"None",
":",
"import",
"feedparser",
"with",
"session",
".",
"get",
"(",
"\"https://flalottery.com/video/en/theWinningNumber.xml\"",
")",
"as",
"resp",
":",
"resp",
".",
"raise_for_status",
"(",
")",
"d",
"=",
"feedparser",
".",
"parse",
"(",
"resp",
".",
"text",
")",
"pick3",
",",
"pick4",
"=",
"\"\"",
",",
"\"\"",
"regex",
"=",
"re",
".",
"compile",
"(",
"r\"([\\d-]+) for (\\w+) ([\\d/]+)\"",
")",
"for",
"entry",
"in",
"d",
".",
"entries",
":",
"title",
"=",
"entry",
".",
"title",
".",
"lower",
"(",
")",
"if",
"title",
".",
"startswith",
"(",
"(",
"\"pick 3\"",
",",
"\"pick 4\"",
")",
")",
":",
"text",
"=",
"\"\"",
"for",
"result",
"in",
"regex",
".",
"findall",
"(",
"entry",
".",
"description",
")",
":",
"text",
"+=",
"f\"{result[2]} {'☀️ Día' if result[1] == 'Midday' else '🌙 Noche'}: {result[0]}\\n\"",
"if",
"title",
".",
"startswith",
"(",
"\"pick 3\"",
")",
":",
"pick3",
"=",
"text",
"else",
":",
"pick4",
"=",
"text",
"assert",
"pick3",
"and",
"pick4",
"replies",
".",
"add",
"(",
"text",
"=",
"f\"**🎰 Resultados**\\n\\n**PICK 3**\\n{pick3}\\n**PICK 4**\\n{pick4}\")",
""
] | [
44,
0
] | [
64,
88
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
about | (request) | return render(request, "about.html",
{"total": total, "docs": docs, "commit": last_commit}) | **Muestra la página acerca del corpus**
Vista encargada de mostrar la sección de acerca del corpus motivación del
corpus y descripción general de la comunidad Elotl. Además, muestra la
información actual del corpus como número de documentos, parrafos por
documentos y pdfs asociados.
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Vista de acerca del corpus
| **Muestra la página acerca del corpus** | def about(request):
"""**Muestra la página acerca del corpus**
Vista encargada de mostrar la sección de acerca del corpus motivación del
corpus y descripción general de la comunidad Elotl. Además, muestra la
información actual del corpus como número de documentos, parrafos por
documentos y pdfs asociados.
:param request: Objeto ``HttpRequets`` para pasar el estado de la app a
través del sistema
:type: ``HttpRequest``
:return: Vista de acerca del corpus
"""
LOGGER.info("Entrando a about")
total, docs = get_corpus_info(request)
try:
repo = Repo('.')
git = repo.git
branches = git.branch().split("\n")
current_branch = [branch for branch in branches if "*" in branch]
current_branch = current_branch[0].strip("*").strip(" ")
commits = list(repo.iter_commits(current_branch))
last_commit = commits[0].hexsha
except exc.InvalidGitRepositoryError:
LOGGER.error("No se encontró repositorio de git")
last_commit = ""
return render(request, "about.html",
{"total": total, "docs": docs, "commit": last_commit}) | [
"def",
"about",
"(",
"request",
")",
":",
"LOGGER",
".",
"info",
"(",
"\"Entrando a about\"",
")",
"total",
",",
"docs",
"=",
"get_corpus_info",
"(",
"request",
")",
"try",
":",
"repo",
"=",
"Repo",
"(",
"'.'",
")",
"git",
"=",
"repo",
".",
"git",
"branches",
"=",
"git",
".",
"branch",
"(",
")",
".",
"split",
"(",
"\"\\n\"",
")",
"current_branch",
"=",
"[",
"branch",
"for",
"branch",
"in",
"branches",
"if",
"\"*\"",
"in",
"branch",
"]",
"current_branch",
"=",
"current_branch",
"[",
"0",
"]",
".",
"strip",
"(",
"\"*\"",
")",
".",
"strip",
"(",
"\" \"",
")",
"commits",
"=",
"list",
"(",
"repo",
".",
"iter_commits",
"(",
"current_branch",
")",
")",
"last_commit",
"=",
"commits",
"[",
"0",
"]",
".",
"hexsha",
"except",
"exc",
".",
"InvalidGitRepositoryError",
":",
"LOGGER",
".",
"error",
"(",
"\"No se encontró repositorio de git\")",
"",
"last_commit",
"=",
"\"\"",
"return",
"render",
"(",
"request",
",",
"\"about.html\"",
",",
"{",
"\"total\"",
":",
"total",
",",
"\"docs\"",
":",
"docs",
",",
"\"commit\"",
":",
"last_commit",
"}",
")"
] | [
74,
0
] | [
101,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
RatTube.limpiar_Pantalla | (self) | Con este método comprobamos si la plataforma es NT (Windows) o si es Linux.
Según el retorno boleano que se obtenga del método, ejecuta la instrucción usada en dicha
plataforma para limpiar la consola | Con este método comprobamos si la plataforma es NT (Windows) o si es Linux.
Según el retorno boleano que se obtenga del método, ejecuta la instrucción usada en dicha
plataforma para limpiar la consola | def limpiar_Pantalla(self):
if name == "nt":
_ = system('cls')
else:
_ = system('clear')
''' Con este método comprobamos si la plataforma es NT (Windows) o si es Linux.
Según el retorno boleano que se obtenga del método, ejecuta la instrucción usada en dicha
plataforma para limpiar la consola''' | [
"def",
"limpiar_Pantalla",
"(",
"self",
")",
":",
"if",
"name",
"==",
"\"nt\"",
":",
"_",
"=",
"system",
"(",
"'cls'",
")",
"else",
":",
"_",
"=",
"system",
"(",
"'clear'",
")"
] | [
17,
1
] | [
26,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
anio_bisiesto | (x) | return (x % 4==0) and (x %100 != 0) and (x%400==0) | Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones:
- Si el año es divisible por 4 es bisiesto, a menos que:
- Si el año es divisible por 100 no es bisiesto a menos que:
- Si el año es divisible por 400 es bisiesto.
Retorna True o False
| Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones: | def anio_bisiesto(x):
'''Responder si el entero pasado como argumento es un año bisiesto
Para determinar si un año es bisiesto, se deben tener en cuenta las
siguientes condiciones:
- Si el año es divisible por 4 es bisiesto, a menos que:
- Si el año es divisible por 100 no es bisiesto a menos que:
- Si el año es divisible por 400 es bisiesto.
Retorna True o False
'''
# if (x % 4==0) and (x %100 != 0) and (x%400==0):
# return True
# else:
# return False
# pass
return (x % 4==0) and (x %100 != 0) and (x%400==0) | [
"def",
"anio_bisiesto",
"(",
"x",
")",
":",
"# if (x % 4==0) and (x %100 != 0) and (x%400==0):",
"# return True",
"# else:",
"# return False",
"# pass",
"return",
"(",
"x",
"%",
"4",
"==",
"0",
")",
"and",
"(",
"x",
"%",
"100",
"!=",
"0",
")",
"and",
"(",
"x",
"%",
"400",
"==",
"0",
")"
] | [
15,
0
] | [
32,
52
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo.add_function | (self, function: Callable[[Image], Image]) | Añade una función que recibe como argumento una imagen y devuelve una imagen.
Esto puede ser útil para aplicar funciones de homografía, por ejemplo.
:param function: función que recibe una imagen y devuelve una imagen.
:return: None.
| Añade una función que recibe como argumento una imagen y devuelve una imagen. | def add_function(self, function: Callable[[Image], Image]) -> None:
"""Añade una función que recibe como argumento una imagen y devuelve una imagen.
Esto puede ser útil para aplicar funciones de homografía, por ejemplo.
:param function: función que recibe una imagen y devuelve una imagen.
:return: None.
"""
self._functions.append(function) | [
"def",
"add_function",
"(",
"self",
",",
"function",
":",
"Callable",
"[",
"[",
"Image",
"]",
",",
"Image",
"]",
")",
"->",
"None",
":",
"self",
".",
"_functions",
".",
"append",
"(",
"function",
")"
] | [
332,
4
] | [
340,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
eliminar_repetidas | (cadena: str) | return " ".join([i for i in cadena.split() if cadena.count(i) <= 3]) | Elimina las palabras que se repiten más de tres veces.
:param cadena: cadena de caracteres.
:cadena type: str
:return: cadena sin las palabras repetidas más de tres veces.
:rtype: str
| Elimina las palabras que se repiten más de tres veces. | def eliminar_repetidas(cadena: str) -> str:
"""Elimina las palabras que se repiten más de tres veces.
:param cadena: cadena de caracteres.
:cadena type: str
:return: cadena sin las palabras repetidas más de tres veces.
:rtype: str
"""
return " ".join([i for i in cadena.split() if cadena.count(i) <= 3]) | [
"def",
"eliminar_repetidas",
"(",
"cadena",
":",
"str",
")",
"->",
"str",
":",
"return",
"\" \"",
".",
"join",
"(",
"[",
"i",
"for",
"i",
"in",
"cadena",
".",
"split",
"(",
")",
"if",
"cadena",
".",
"count",
"(",
"i",
")",
"<=",
"3",
"]",
")"
] | [
9,
0
] | [
17,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Molecule.make_bond_grid | (self, bond, angle_mesh=math.pi/6, mesh=0.5, charge=False) | Funcion para construir una red de puntos alrededor de un enlace,
sensibles al campo electrico de la molecula. | Funcion para construir una red de puntos alrededor de un enlace,
sensibles al campo electrico de la molecula. | def make_bond_grid(self, bond, angle_mesh=math.pi/6, mesh=0.5, charge=False):
""" Funcion para construir una red de puntos alrededor de un enlace,
sensibles al campo electrico de la molecula. """
pass | [
"def",
"make_bond_grid",
"(",
"self",
",",
"bond",
",",
"angle_mesh",
"=",
"math",
".",
"pi",
"/",
"6",
",",
"mesh",
"=",
"0.5",
",",
"charge",
"=",
"False",
")",
":",
"pass"
] | [
270,
4
] | [
273,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
capitalize | (string, sep=None, encoding="utf-8", lower_words=None) | return (sep if sep else " ").join(normalized_words) | Capitaliza una string que puede estar compuesta por varias palabras
Args:
string (str): Palabra
sep (str): Separador
Returns:
str: String normalizada
| Capitaliza una string que puede estar compuesta por varias palabras | def capitalize(string, sep=None, encoding="utf-8", lower_words=None):
"""Capitaliza una string que puede estar compuesta por varias palabras
Args:
string (str): Palabra
sep (str): Separador
Returns:
str: String normalizada
"""
if pd.isnull(string):
return pd.np.nan
if not isinstance(string, str):
string = str(string)
words = string.split(sep)
if len(words) == 0:
return ""
first_word = words[0].title()
partial_normalize_word = partial(normalize_word, lower_words=lower_words)
normalized_words = [first_word] + \
list(map(partial_normalize_word, words[1:]))
return (sep if sep else " ").join(normalized_words) | [
"def",
"capitalize",
"(",
"string",
",",
"sep",
"=",
"None",
",",
"encoding",
"=",
"\"utf-8\"",
",",
"lower_words",
"=",
"None",
")",
":",
"if",
"pd",
".",
"isnull",
"(",
"string",
")",
":",
"return",
"pd",
".",
"np",
".",
"nan",
"if",
"not",
"isinstance",
"(",
"string",
",",
"str",
")",
":",
"string",
"=",
"str",
"(",
"string",
")",
"words",
"=",
"string",
".",
"split",
"(",
"sep",
")",
"if",
"len",
"(",
"words",
")",
"==",
"0",
":",
"return",
"\"\"",
"first_word",
"=",
"words",
"[",
"0",
"]",
".",
"title",
"(",
")",
"partial_normalize_word",
"=",
"partial",
"(",
"normalize_word",
",",
"lower_words",
"=",
"lower_words",
")",
"normalized_words",
"=",
"[",
"first_word",
"]",
"+",
"list",
"(",
"map",
"(",
"partial_normalize_word",
",",
"words",
"[",
"1",
":",
"]",
")",
")",
"return",
"(",
"sep",
"if",
"sep",
"else",
"\" \"",
")",
".",
"join",
"(",
"normalized_words",
")"
] | [
43,
0
] | [
67,
55
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
solucion | (
a: Union[int, float],
b: Union[int, float],
c: Union[int, float]
) | return x1, x2 | Resuelve ecuaciones de 2do grado.
:param a: Coeficiente de la variable cuadrática
:type a: Union[int, float]
:param b: Coeficiente de la variable lineal
:type b: Union[int, float]
:param c: Término independiente
:type c: Union[int, float]
:return: Tupla de raices
:rtype: Tuple[float, float]
| Resuelve ecuaciones de 2do grado. | def solucion(
a: Union[int, float],
b: Union[int, float],
c: Union[int, float]
) -> Tuple[float, float]:
"""Resuelve ecuaciones de 2do grado.
:param a: Coeficiente de la variable cuadrática
:type a: Union[int, float]
:param b: Coeficiente de la variable lineal
:type b: Union[int, float]
:param c: Término independiente
:type c: Union[int, float]
:return: Tupla de raices
:rtype: Tuple[float, float]
"""
d = b*b - 4*a*c
if d < 0:
x1 = (-b + sqrt(d))/(2*a)
x2 = (-b - sqrt(d))/(2*a)
elif d == 0:
x1 = x2 = (-b/(2*a))
else:
x1 = (-b + d**0.5)/(2*a)
x2 = (-b - d**0.5)/(2*a)
return x1, x2 | [
"def",
"solucion",
"(",
"a",
":",
"Union",
"[",
"int",
",",
"float",
"]",
",",
"b",
":",
"Union",
"[",
"int",
",",
"float",
"]",
",",
"c",
":",
"Union",
"[",
"int",
",",
"float",
"]",
")",
"->",
"Tuple",
"[",
"float",
",",
"float",
"]",
":",
"d",
"=",
"b",
"*",
"b",
"-",
"4",
"*",
"a",
"*",
"c",
"if",
"d",
"<",
"0",
":",
"x1",
"=",
"(",
"-",
"b",
"+",
"sqrt",
"(",
"d",
")",
")",
"/",
"(",
"2",
"*",
"a",
")",
"x2",
"=",
"(",
"-",
"b",
"-",
"sqrt",
"(",
"d",
")",
")",
"/",
"(",
"2",
"*",
"a",
")",
"elif",
"d",
"==",
"0",
":",
"x1",
"=",
"x2",
"=",
"(",
"-",
"b",
"/",
"(",
"2",
"*",
"a",
")",
")",
"else",
":",
"x1",
"=",
"(",
"-",
"b",
"+",
"d",
"**",
"0.5",
")",
"/",
"(",
"2",
"*",
"a",
")",
"x2",
"=",
"(",
"-",
"b",
"-",
"d",
"**",
"0.5",
")",
"/",
"(",
"2",
"*",
"a",
")",
"return",
"x1",
",",
"x2"
] | [
7,
0
] | [
32,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Override_Bom._onchange_anything | (self) | Hace que cuando haya un cambio en cualquiera de los campos vuelva al estado borrador. | Hace que cuando haya un cambio en cualquiera de los campos vuelva al estado borrador. | def _onchange_anything(self):
""" Hace que cuando haya un cambio en cualquiera de los campos vuelva al estado borrador. """
self.state = 'Borrador'
self.approval_user = None
self.approval_date = None | [
"def",
"_onchange_anything",
"(",
"self",
")",
":",
"self",
".",
"state",
"=",
"'Borrador'",
"self",
".",
"approval_user",
"=",
"None",
"self",
".",
"approval_date",
"=",
"None"
] | [
73,
4
] | [
77,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Expediente.propietarios | (self) | return self.expedientepersona_set.filter(propietario=True) | Devuelve las personas que figuran como propietarias. | Devuelve las personas que figuran como propietarias. | def propietarios(self):
"""Devuelve las personas que figuran como propietarias."""
return self.expedientepersona_set.filter(propietario=True) | [
"def",
"propietarios",
"(",
"self",
")",
":",
"return",
"self",
".",
"expedientepersona_set",
".",
"filter",
"(",
"propietario",
"=",
"True",
")"
] | [
281,
4
] | [
283,
66
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Matrix.adj | (self) | return Matrix(self.cofactor_matrix().transpose()) | Metodo para calcular la adjunta de una matriz. | Metodo para calcular la adjunta de una matriz. | def adj(self):
""" Metodo para calcular la adjunta de una matriz. """
return Matrix(self.cofactor_matrix().transpose()) | [
"def",
"adj",
"(",
"self",
")",
":",
"return",
"Matrix",
"(",
"self",
".",
"cofactor_matrix",
"(",
")",
".",
"transpose",
"(",
")",
")"
] | [
183,
4
] | [
185,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EstimationModel.fit | (self, tracked_objects: TrackedObjects) | return estimation_results | Realizar la estimación del modelo.
:param tracked_objects: estructura con los seguimientos de los objetos.
:return: estimaciones calculadas.
| Realizar la estimación del modelo. | def fit(self, tracked_objects: TrackedObjects) -> EstimationResults:
"""Realizar la estimación del modelo.
:param tracked_objects: estructura con los seguimientos de los objetos.
:return: estimaciones calculadas.
"""
estimation_results = EstimationResults()
# Realizar la estimación de cada objeto seguido.
for tracked_object in tracked_objects:
# Comprobación previa. Para estimar una velocidad se necesitan al menos 2 observaciones.
if len(tracked_object) > 2:
estimated_velocities = self.calculate_velocities(tracked_object)
estimation = EstimationResult(estimated_velocities, tracked_object)
# Añadir a la lista de estimaciones.
estimation_results.add(estimation)
return estimation_results | [
"def",
"fit",
"(",
"self",
",",
"tracked_objects",
":",
"TrackedObjects",
")",
"->",
"EstimationResults",
":",
"estimation_results",
"=",
"EstimationResults",
"(",
")",
"# Realizar la estimación de cada objeto seguido.",
"for",
"tracked_object",
"in",
"tracked_objects",
":",
"# Comprobación previa. Para estimar una velocidad se necesitan al menos 2 observaciones.",
"if",
"len",
"(",
"tracked_object",
")",
">",
"2",
":",
"estimated_velocities",
"=",
"self",
".",
"calculate_velocities",
"(",
"tracked_object",
")",
"estimation",
"=",
"EstimationResult",
"(",
"estimated_velocities",
",",
"tracked_object",
")",
"# Añadir a la lista de estimaciones.",
"estimation_results",
".",
"add",
"(",
"estimation",
")",
"return",
"estimation_results"
] | [
270,
4
] | [
285,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AbstractGMapsExtractor.finish | (self) | finaliza el driver asociado a la instancia y cierra la conexión a la base de datos, si esta última existe. | finaliza el driver asociado a la instancia y cierra la conexión a la base de datos, si esta última existe. | def finish(self):
"""finaliza el driver asociado a la instancia y cierra la conexión a la base de datos, si esta última existe."""
if self._driver:
self._driver.quit()
else:
self.logger.warning("there is no any driver to shut down")
if self._writer:
self._writer.finish()
else:
self.logger.debug("there is no any writer to shut down") | [
"def",
"finish",
"(",
"self",
")",
":",
"if",
"self",
".",
"_driver",
":",
"self",
".",
"_driver",
".",
"quit",
"(",
")",
"else",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"there is no any driver to shut down\"",
")",
"if",
"self",
".",
"_writer",
":",
"self",
".",
"_writer",
".",
"finish",
"(",
")",
"else",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"there is no any writer to shut down\"",
")"
] | [
235,
4
] | [
244,
68
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Cursiva_Decorador.render | (self) | return "<i>" + self.textodecorado.render() + "</i>" | Decora el texto agregándole las etiquetas <i></i> | Decora el texto agregándole las etiquetas <i></i> | def render(self):
"""Decora el texto agregándole las etiquetas <i></i>"""
return "<i>" + self.textodecorado.render() + "</i>" | [
"def",
"render",
"(",
"self",
")",
":",
"return",
"\"<i>\"",
"+",
"self",
".",
"textodecorado",
".",
"render",
"(",
")",
"+",
"\"</i>\""
] | [
61,
4
] | [
63,
59
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Simulador.definir_coordenadas | (self, origen, destino) | Define las coordenadas de la simulación actual | Define las coordenadas de la simulación actual | def definir_coordenadas(self, origen, destino):
"""Define las coordenadas de la simulación actual"""
self.origen = origen
self.destino = destino | [
"def",
"definir_coordenadas",
"(",
"self",
",",
"origen",
",",
"destino",
")",
":",
"self",
".",
"origen",
"=",
"origen",
"self",
".",
"destino",
"=",
"destino"
] | [
16,
4
] | [
19,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
contar_valles | () | r'''Contar el número de valles
Esta función debe recibir como argumento una lista de -1's, 0's y 1's, y lo
que representan son las subidas y las bajadas en una ruta de caminata. -1
representa un paso hacia abajo, el 0 representa un paso hacia adelante y el
1 representa un paso hacia arriba, entonces por ejemplo, para la lista
[-1,1,0,1,1,-1,0,0,1,-1,1,1,-1,-1] representa la siguiente ruta:
/\
/\__/\/ \
_/
\/
El objetivo de esta función es devolver el número de valles que estén
representados en la lista, que para el ejemplo que se acaba de mostrar es
de 3 valles.
| r'''Contar el número de valles | def contar_valles():
r'''Contar el número de valles
Esta función debe recibir como argumento una lista de -1's, 0's y 1's, y lo
que representan son las subidas y las bajadas en una ruta de caminata. -1
representa un paso hacia abajo, el 0 representa un paso hacia adelante y el
1 representa un paso hacia arriba, entonces por ejemplo, para la lista
[-1,1,0,1,1,-1,0,0,1,-1,1,1,-1,-1] representa la siguiente ruta:
/\
/\__/\/ \
_/
\/
El objetivo de esta función es devolver el número de valles que estén
representados en la lista, que para el ejemplo que se acaba de mostrar es
de 3 valles.
'''
pass | [
"def",
"contar_valles",
"(",
")",
":",
"pass"
] | [
25,
0
] | [
43,
8
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Restaurant.describe_restaurant | (self) | mostrar un resumen del resultado. | mostrar un resumen del resultado. | def describe_restaurant(self):
"""mostrar un resumen del resultado."""
msg = self.name + " sirve maravilloso " + self.cuisine_type + "."
print("\n" + msg) | [
"def",
"describe_restaurant",
"(",
"self",
")",
":",
"msg",
"=",
"self",
".",
"name",
"+",
"\" sirve maravilloso \"",
"+",
"self",
".",
"cuisine_type",
"+",
"\".\"",
"print",
"(",
"\"\\n\"",
"+",
"msg",
")"
] | [
9,
4
] | [
12,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_instrucciones_lista_2 | (t) | instrucciones : instruccion PUNTOYCOMA | instrucciones : instruccion PUNTOYCOMA | def p_instrucciones_lista_2(t):
'instrucciones : instruccion PUNTOYCOMA '
t[0] = Start("S",-1,-1,None)
t[0].hijos.append(t[1]) | [
"def",
"p_instrucciones_lista_2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"S\"",
",",
"-",
"1",
",",
"-",
"1",
",",
"None",
")",
"t",
"[",
"0",
"]",
".",
"hijos",
".",
"append",
"(",
"t",
"[",
"1",
"]",
")"
] | [
340,
0
] | [
343,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Optimizador.Regla_14_15 | (self, asignacion) | (*)Regla 14 y (/)Regla 15 | (*)Regla 14 y (/)Regla 15 | def Regla_14_15(self, asignacion):
"(*)Regla 14 y (/)Regla 15"
global CodigoOptimizado
indice = asignacion.indice
op1 = asignacion.operador1
op2 = asignacion.operador2
signo = asignacion.signo
if self.BuscarTemporal(op1):
op1 = str(self.BuscarTemporal(op1).valor)
if self.BuscarTemporal(op2):
op2 = str(self.BuscarTemporal(op2).valor)
if op1 == '1' and op2 != '1' and signo == '*' and op2 != indice:
NuevoObjeto = obj.Optimizado("Regla 14", indice + " = " + op1 + " " + signo + " " + op2, indice + " = " + op2)
CodigoOptimizado.append(NuevoObjeto)
return True
elif op2 == '1' and op1 != '1' and signo == '*' and op1 != indice:
NuevoObjeto = obj.Optimizado("Regla 14", indice + " = " + op1 + " " + signo + " " + op2, indice + " = " + op1)
CodigoOptimizado.append(NuevoObjeto)
return True
elif op1 != '1' and op2 == '1' and signo == '/' and op1 != indice:
NuevoObjeto = obj.Optimizado("Regla 15", indice + " = " + op1 + " " + signo + " " + op2, indice + " = " + op1)
CodigoOptimizado.append(NuevoObjeto)
return True
else:
return False | [
"def",
"Regla_14_15",
"(",
"self",
",",
"asignacion",
")",
":",
"global",
"CodigoOptimizado",
"indice",
"=",
"asignacion",
".",
"indice",
"op1",
"=",
"asignacion",
".",
"operador1",
"op2",
"=",
"asignacion",
".",
"operador2",
"signo",
"=",
"asignacion",
".",
"signo",
"if",
"self",
".",
"BuscarTemporal",
"(",
"op1",
")",
":",
"op1",
"=",
"str",
"(",
"self",
".",
"BuscarTemporal",
"(",
"op1",
")",
".",
"valor",
")",
"if",
"self",
".",
"BuscarTemporal",
"(",
"op2",
")",
":",
"op2",
"=",
"str",
"(",
"self",
".",
"BuscarTemporal",
"(",
"op2",
")",
".",
"valor",
")",
"if",
"op1",
"==",
"'1'",
"and",
"op2",
"!=",
"'1'",
"and",
"signo",
"==",
"'*'",
"and",
"op2",
"!=",
"indice",
":",
"NuevoObjeto",
"=",
"obj",
".",
"Optimizado",
"(",
"\"Regla 14\"",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
"+",
"\" \"",
"+",
"signo",
"+",
"\" \"",
"+",
"op2",
",",
"indice",
"+",
"\" = \"",
"+",
"op2",
")",
"CodigoOptimizado",
".",
"append",
"(",
"NuevoObjeto",
")",
"return",
"True",
"elif",
"op2",
"==",
"'1'",
"and",
"op1",
"!=",
"'1'",
"and",
"signo",
"==",
"'*'",
"and",
"op1",
"!=",
"indice",
":",
"NuevoObjeto",
"=",
"obj",
".",
"Optimizado",
"(",
"\"Regla 14\"",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
"+",
"\" \"",
"+",
"signo",
"+",
"\" \"",
"+",
"op2",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
")",
"CodigoOptimizado",
".",
"append",
"(",
"NuevoObjeto",
")",
"return",
"True",
"elif",
"op1",
"!=",
"'1'",
"and",
"op2",
"==",
"'1'",
"and",
"signo",
"==",
"'/'",
"and",
"op1",
"!=",
"indice",
":",
"NuevoObjeto",
"=",
"obj",
".",
"Optimizado",
"(",
"\"Regla 15\"",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
"+",
"\" \"",
"+",
"signo",
"+",
"\" \"",
"+",
"op2",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
")",
"CodigoOptimizado",
".",
"append",
"(",
"NuevoObjeto",
")",
"return",
"True",
"else",
":",
"return",
"False"
] | [
155,
4
] | [
179,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_expresion_aritmetica_3 | (t) | expresionaritmetica : cualquiernumero
| cualquieridentificador
| cualquiercadena | expresionaritmetica : cualquiernumero
| cualquieridentificador
| cualquiercadena | def p_expresion_aritmetica_3(t):
'''expresionaritmetica : cualquiernumero
| cualquieridentificador
| cualquiercadena'''
t[1].gramatica = '<expresionaritmetica> ::= <cualquiernumero>\n' + t[1].gramatica
t[0] = t[1] | [
"def",
"p_expresion_aritmetica_3",
"(",
"t",
")",
":",
"t",
"[",
"1",
"]",
".",
"gramatica",
"=",
"'<expresionaritmetica> ::= <cualquiernumero>\\n'",
"+",
"t",
"[",
"1",
"]",
".",
"gramatica",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
368,
0
] | [
373,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_datos_usuario | (username) | return datos[username] | Retorna datos del usuario indicado por parámetro | Retorna datos del usuario indicado por parámetro | def get_datos_usuario(username):
"""Retorna datos del usuario indicado por parámetro"""
datos = cargar_usuarios()
return datos[username] | [
"def",
"get_datos_usuario",
"(",
"username",
")",
":",
"datos",
"=",
"cargar_usuarios",
"(",
")",
"return",
"datos",
"[",
"username",
"]"
] | [
33,
0
] | [
37,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_instrucciones_asignacion_1 | (t) | instrucciones_asignacion : instrucciones_asignacion declaracion_variable PUNTOYCOMA | instrucciones_asignacion : instrucciones_asignacion declaracion_variable PUNTOYCOMA | def p_instrucciones_asignacion_1(t):
'''instrucciones_asignacion : instrucciones_asignacion declaracion_variable PUNTOYCOMA'''
t[0] = Start("INSTRUCCIONES_ASIGNACION")
for hijo in t[1].hijos:
t[0].addChild(hijo)
t[0].addChild(t[2]) | [
"def",
"p_instrucciones_asignacion_1",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"Start",
"(",
"\"INSTRUCCIONES_ASIGNACION\"",
")",
"for",
"hijo",
"in",
"t",
"[",
"1",
"]",
".",
"hijos",
":",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"hijo",
")",
"t",
"[",
"0",
"]",
".",
"addChild",
"(",
"t",
"[",
"2",
"]",
")"
] | [
1595,
0
] | [
1600,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
extract | () | Función principal del programa y que lleva la lógica completa para la extracción de las urls por código postal
y por país. Los resultados los vuelca directamente en el soporte de salida que se haya establecido en el fichero de
configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del programa
`gmaps-url-scrapper`
| Función principal del programa y que lleva la lógica completa para la extracción de las urls por código postal
y por país. Los resultados los vuelca directamente en el soporte de salida que se haya establecido en el fichero de
configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del programa
`gmaps-url-scrapper`
| def extract():
"""Función principal del programa y que lleva la lógica completa para la extracción de las urls por código postal
y por país. Los resultados los vuelca directamente en el soporte de salida que se haya establecido en el fichero de
configuración que se le haya pasado por línea de comando la ejecución del script o la ejecución del programa
`gmaps-url-scrapper`
"""
parser = get_parser()
main_name = "gmaps_url_extractor"
args = parser.parse_args()
init_time = time.time()
required_keys = ["driver_path", "executors", "input_config", "output_config"]
execution_config = get_obj_from_file(args.config_file)
today_date = datetime.now()
init_default_handler(name=main_name, date=today_date, root_dir=execution_config.get("log_dir"),
level="INFO")
logger = logging.getLogger(main_name)
logger.info("configuration that will be used in the extraction is the following")
logger.info("{config}".format(config=execution_config))
# si el fichero de configuración que se ha pasado a la ejecución contiene las claves requeridas se procede a la
# ejecución
if validate_required_keys(keys=required_keys, obj=execution_config):
# se obtienen los códigos postales del soporte de entrada establecido en la configuración para los cuales se
# extraerán las urls de búsqueda.
input_config = execution_config.get("input_config")
output_config = execution_config.get("output_config")
zip_config = get_zip_codes_obj_config(input_config)
logger.info("zip codes to extract url: {zip_config}".format(zip_config=zip_config))
country = zip_config.get("country").capitalize()
zip_codes = zip_config.get("zip_codes", [])
# se construye la lista de objetos que serán los argumentos para la llamada a la función
# `scrape_postal_code_url` por cada uno de los procesos que formen el pool de procesos
results_args_list = [{"country": country,
"postal_code": zip_code,
"driver_location": execution_config.get("driver_path"),
"output_config": output_config} for zip_code in zip_codes]
with Pool(processes=execution_config.get("executors")) as pool:
pool.map(func=scrape_postal_code_url, iterable=iter(results_args_list))
else:
logger.error("there are error in configuration files. Some required configurations are not present")
logger.error("required keys: {keys}".format(keys=required_keys))
exit(-1)
end_time = time.time()
elapsed_time = int(end_time - init_time)
logger.info("elapsed time in this execution: {elapsed_time} seconds".format(elapsed_time=elapsed_time)) | [
"def",
"extract",
"(",
")",
":",
"parser",
"=",
"get_parser",
"(",
")",
"main_name",
"=",
"\"gmaps_url_extractor\"",
"args",
"=",
"parser",
".",
"parse_args",
"(",
")",
"init_time",
"=",
"time",
".",
"time",
"(",
")",
"required_keys",
"=",
"[",
"\"driver_path\"",
",",
"\"executors\"",
",",
"\"input_config\"",
",",
"\"output_config\"",
"]",
"execution_config",
"=",
"get_obj_from_file",
"(",
"args",
".",
"config_file",
")",
"today_date",
"=",
"datetime",
".",
"now",
"(",
")",
"init_default_handler",
"(",
"name",
"=",
"main_name",
",",
"date",
"=",
"today_date",
",",
"root_dir",
"=",
"execution_config",
".",
"get",
"(",
"\"log_dir\"",
")",
",",
"level",
"=",
"\"INFO\"",
")",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"main_name",
")",
"logger",
".",
"info",
"(",
"\"configuration that will be used in the extraction is the following\"",
")",
"logger",
".",
"info",
"(",
"\"{config}\"",
".",
"format",
"(",
"config",
"=",
"execution_config",
")",
")",
"# si el fichero de configuración que se ha pasado a la ejecución contiene las claves requeridas se procede a la",
"# ejecución",
"if",
"validate_required_keys",
"(",
"keys",
"=",
"required_keys",
",",
"obj",
"=",
"execution_config",
")",
":",
"# se obtienen los códigos postales del soporte de entrada establecido en la configuración para los cuales se",
"# extraerán las urls de búsqueda.",
"input_config",
"=",
"execution_config",
".",
"get",
"(",
"\"input_config\"",
")",
"output_config",
"=",
"execution_config",
".",
"get",
"(",
"\"output_config\"",
")",
"zip_config",
"=",
"get_zip_codes_obj_config",
"(",
"input_config",
")",
"logger",
".",
"info",
"(",
"\"zip codes to extract url: {zip_config}\"",
".",
"format",
"(",
"zip_config",
"=",
"zip_config",
")",
")",
"country",
"=",
"zip_config",
".",
"get",
"(",
"\"country\"",
")",
".",
"capitalize",
"(",
")",
"zip_codes",
"=",
"zip_config",
".",
"get",
"(",
"\"zip_codes\"",
",",
"[",
"]",
")",
"# se construye la lista de objetos que serán los argumentos para la llamada a la función",
"# `scrape_postal_code_url` por cada uno de los procesos que formen el pool de procesos",
"results_args_list",
"=",
"[",
"{",
"\"country\"",
":",
"country",
",",
"\"postal_code\"",
":",
"zip_code",
",",
"\"driver_location\"",
":",
"execution_config",
".",
"get",
"(",
"\"driver_path\"",
")",
",",
"\"output_config\"",
":",
"output_config",
"}",
"for",
"zip_code",
"in",
"zip_codes",
"]",
"with",
"Pool",
"(",
"processes",
"=",
"execution_config",
".",
"get",
"(",
"\"executors\"",
")",
")",
"as",
"pool",
":",
"pool",
".",
"map",
"(",
"func",
"=",
"scrape_postal_code_url",
",",
"iterable",
"=",
"iter",
"(",
"results_args_list",
")",
")",
"else",
":",
"logger",
".",
"error",
"(",
"\"there are error in configuration files. Some required configurations are not present\"",
")",
"logger",
".",
"error",
"(",
"\"required keys: {keys}\"",
".",
"format",
"(",
"keys",
"=",
"required_keys",
")",
")",
"exit",
"(",
"-",
"1",
")",
"end_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed_time",
"=",
"int",
"(",
"end_time",
"-",
"init_time",
")",
"logger",
".",
"info",
"(",
"\"elapsed time in this execution: {elapsed_time} seconds\"",
".",
"format",
"(",
"elapsed_time",
"=",
"elapsed_time",
")",
")"
] | [
83,
0
] | [
126,
107
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
resumen | (path,genes) | Creamos una estructura con dos for anidados que nos permitira recorrer el
archivo genbank en busca de las secuencias de los genes cuyos nombres
se encuentran en la lista para posteriormente imprimirlas | Creamos una estructura con dos for anidados que nos permitira recorrer el
archivo genbank en busca de las secuencias de los genes cuyos nombres
se encuentran en la lista para posteriormente imprimirlas | def resumen(path,genes):
#Damos lectura al archivo e imprimimos los datos que nos interesa conocer
for register in SeqIO.parse(path,"genbank"):
organismo = register.annotations["organism"]
version = register.annotations["sequence_version"]
source = register.features[0]
print(f"Organismo = {organismo}")
print(f"Version = {version}")
print("Fuente de aislamiento ",source.qualifiers["isolation_source"])
print("Pais",source.qualifiers["country"])
'''Creamos una estructura con dos for anidados que nos permitira recorrer el
archivo genbank en busca de las secuencias de los genes cuyos nombres
se encuentran en la lista para posteriormente imprimirlas'''
for j in range(0, len(genes)):
gen = "['"+genes[j]+"']"
for i in range(2, len(register.features) , 2):
if (str(gen) == str(register.features[i].qualifiers["gene"]) ):
start = register.features[i].location.nofuzzy_start
end = int(start) + 15
sec = register.seq[start:end]
print(f"Gene = {genes[j]}")
print(f"DNA = {sec}")
print(f"RNA = {sec.transcribe()}")
print(f"PROTEINA = {sec.translate()}")
gen = "" | [
"def",
"resumen",
"(",
"path",
",",
"genes",
")",
":",
"#Damos lectura al archivo e imprimimos los datos que nos interesa conocer",
"for",
"register",
"in",
"SeqIO",
".",
"parse",
"(",
"path",
",",
"\"genbank\"",
")",
":",
"organismo",
"=",
"register",
".",
"annotations",
"[",
"\"organism\"",
"]",
"version",
"=",
"register",
".",
"annotations",
"[",
"\"sequence_version\"",
"]",
"source",
"=",
"register",
".",
"features",
"[",
"0",
"]",
"print",
"(",
"f\"Organismo = {organismo}\"",
")",
"print",
"(",
"f\"Version = {version}\"",
")",
"print",
"(",
"\"Fuente de aislamiento \"",
",",
"source",
".",
"qualifiers",
"[",
"\"isolation_source\"",
"]",
")",
"print",
"(",
"\"Pais\"",
",",
"source",
".",
"qualifiers",
"[",
"\"country\"",
"]",
")",
"for",
"j",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"genes",
")",
")",
":",
"gen",
"=",
"\"['\"",
"+",
"genes",
"[",
"j",
"]",
"+",
"\"']\"",
"for",
"i",
"in",
"range",
"(",
"2",
",",
"len",
"(",
"register",
".",
"features",
")",
",",
"2",
")",
":",
"if",
"(",
"str",
"(",
"gen",
")",
"==",
"str",
"(",
"register",
".",
"features",
"[",
"i",
"]",
".",
"qualifiers",
"[",
"\"gene\"",
"]",
")",
")",
":",
"start",
"=",
"register",
".",
"features",
"[",
"i",
"]",
".",
"location",
".",
"nofuzzy_start",
"end",
"=",
"int",
"(",
"start",
")",
"+",
"15",
"sec",
"=",
"register",
".",
"seq",
"[",
"start",
":",
"end",
"]",
"print",
"(",
"f\"Gene = {genes[j]}\"",
")",
"print",
"(",
"f\"DNA = {sec}\"",
")",
"print",
"(",
"f\"RNA = {sec.transcribe()}\"",
")",
"print",
"(",
"f\"PROTEINA = {sec.translate()}\"",
")",
"gen",
"=",
"\"\""
] | [
60,
0
] | [
88,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_clean_data_csv | (csv_filename,cols="all") | return clean_data | Este método se encargará de recoger los datos de cualquier csv y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja | Este método se encargará de recoger los datos de cualquier csv y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja | def get_clean_data_csv(csv_filename,cols="all"):
''' Este método se encargará de recoger los datos de cualquier csv y limpiarlos bajo el mismo estandar:
quitar los elementos nulos, los strings en minuscula y sustituir los espacios por barra baja'''
if cols=="all":
raw_data=pd.read_csv(csv_filename,na_filter=True,keep_default_na=False)
else:
raw_data=pd.read_csv(csv_filename,usecols=cols,na_filter=True,keep_default_na=False)
col_names=raw_data.columns.values
clean_data=pd.DataFrame()
for cn in col_names:
aux_field=raw_data[cn]
try:
clean_data[cn]=[aux_row.lower().replace(" ","_") for aux_row in raw_data[cn]]
except Exception as e:
clean_data[cn]=raw_data[cn]
pass
return clean_data | [
"def",
"get_clean_data_csv",
"(",
"csv_filename",
",",
"cols",
"=",
"\"all\"",
")",
":",
"if",
"cols",
"==",
"\"all\"",
":",
"raw_data",
"=",
"pd",
".",
"read_csv",
"(",
"csv_filename",
",",
"na_filter",
"=",
"True",
",",
"keep_default_na",
"=",
"False",
")",
"else",
":",
"raw_data",
"=",
"pd",
".",
"read_csv",
"(",
"csv_filename",
",",
"usecols",
"=",
"cols",
",",
"na_filter",
"=",
"True",
",",
"keep_default_na",
"=",
"False",
")",
"col_names",
"=",
"raw_data",
".",
"columns",
".",
"values",
"clean_data",
"=",
"pd",
".",
"DataFrame",
"(",
")",
"for",
"cn",
"in",
"col_names",
":",
"aux_field",
"=",
"raw_data",
"[",
"cn",
"]",
"try",
":",
"clean_data",
"[",
"cn",
"]",
"=",
"[",
"aux_row",
".",
"lower",
"(",
")",
".",
"replace",
"(",
"\" \"",
",",
"\"_\"",
")",
"for",
"aux_row",
"in",
"raw_data",
"[",
"cn",
"]",
"]",
"except",
"Exception",
"as",
"e",
":",
"clean_data",
"[",
"cn",
"]",
"=",
"raw_data",
"[",
"cn",
"]",
"pass",
"return",
"clean_data"
] | [
25,
0
] | [
43,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_zip_execution_obj_config | (input_config) | return executions | Función encargada de obtener los códigos postales y tipos de locales para los cuales se va a ejecutar la
extracción de los locales.
Parameters
----------
input_config : dict
diccionario que contiene la configuración del soporte de entrada
Returns
-------
list
devuelve una lista de objetos de códigos postales para realizar la ejecución
| Función encargada de obtener los códigos postales y tipos de locales para los cuales se va a ejecutar la
extracción de los locales. | def get_zip_execution_obj_config(input_config):
"""Función encargada de obtener los códigos postales y tipos de locales para los cuales se va a ejecutar la
extracción de los locales.
Parameters
----------
input_config : dict
diccionario que contiene la configuración del soporte de entrada
Returns
-------
list
devuelve una lista de objetos de códigos postales para realizar la ejecución
"""
executions = []
if input_config.get("type") == "db":
config = input_config.get("db").get("config")
reader = ExecutionDbReader(config)
reader.auto_boot()
executions = get_zip_codes_obj_config(input_config, reader)
reader.finish()
else:
executions = get_zip_codes_obj_config(input_config)
return executions | [
"def",
"get_zip_execution_obj_config",
"(",
"input_config",
")",
":",
"executions",
"=",
"[",
"]",
"if",
"input_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"db\"",
":",
"config",
"=",
"input_config",
".",
"get",
"(",
"\"db\"",
")",
".",
"get",
"(",
"\"config\"",
")",
"reader",
"=",
"ExecutionDbReader",
"(",
"config",
")",
"reader",
".",
"auto_boot",
"(",
")",
"executions",
"=",
"get_zip_codes_obj_config",
"(",
"input_config",
",",
"reader",
")",
"reader",
".",
"finish",
"(",
")",
"else",
":",
"executions",
"=",
"get_zip_codes_obj_config",
"(",
"input_config",
")",
"return",
"executions"
] | [
81,
0
] | [
105,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlacesExtractor.scrap | (self, provided_driver=None) | return result_to_return | Función principal encargada de la extracción de la información, para ello primero checkea si el local que se
va a procesar ya está registrado en el soporte de salida para lo que usa la instancia de `writer`. De no estar
ya procesado se accede a la url del local comercial, en caso de que sea ambigua y Google Maps redireccione a un
listado de locales comerciales, se hace la llamada a la función _scrap. Una vez obtenida la información, se hace
la llamada a `writer.export_data(data)` que se encarga de persisitir los datos obtenidos en el soporte de salida
correspondiente que se haya configurado para la ejecución.
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para realizar la extracción, en caso de no estar definido, se usará el que se haya
definido para la instancia de la clase
Returns
-------
True
en caso de que se exporte correctamente los datos
False
en caso de que algo hubiera ocurrido durante la extracción o la exportación
dict
en caso de que no se haya writer definido
| Función principal encargada de la extracción de la información, para ello primero checkea si el local que se
va a procesar ya está registrado en el soporte de salida para lo que usa la instancia de `writer`. De no estar
ya procesado se accede a la url del local comercial, en caso de que sea ambigua y Google Maps redireccione a un
listado de locales comerciales, se hace la llamada a la función _scrap. Una vez obtenida la información, se hace
la llamada a `writer.export_data(data)` que se encarga de persisitir los datos obtenidos en el soporte de salida
correspondiente que se haya configurado para la ejecución. | def scrap(self, provided_driver=None):
"""Función principal encargada de la extracción de la información, para ello primero checkea si el local que se
va a procesar ya está registrado en el soporte de salida para lo que usa la instancia de `writer`. De no estar
ya procesado se accede a la url del local comercial, en caso de que sea ambigua y Google Maps redireccione a un
listado de locales comerciales, se hace la llamada a la función _scrap. Una vez obtenida la información, se hace
la llamada a `writer.export_data(data)` que se encarga de persisitir los datos obtenidos en el soporte de salida
correspondiente que se haya configurado para la ejecución.
Arguments
---------
provided_driver : webdriver.Chrome
driver que se usará para realizar la extracción, en caso de no estar definido, se usará el que se haya
definido para la instancia de la clase
Returns
-------
True
en caso de que se exporte correctamente los datos
False
en caso de que algo hubiera ocurrido durante la extracción o la exportación
dict
en caso de que no se haya writer definido
"""
logging.info("-{name}-: scrapping process for place with url -{url}- is starting".format(
name=self._place_name, url=self._url))
driver = provided_driver if provided_driver else self.get_driver()
init_time = time.time()
place_info = None
result_to_return = None
try:
# checkeo si ya existe registro para la fecha de extracción y el nombre del local para evitar volver a
# procesarlo
is_registered = self._writer.is_registered({"name": self._place_name, "date": self._extraction_date,
"address": self._place_address})
if is_registered:
self.logger.warning("-{name}-: place in {address} and for date: -{date}- is already processed".format(
name=self._place_name, date=self._extraction_date, address=self._place_address))
result_to_return = {"is_registered": True}
else:
place_info = self._scrap(driver)
result_to_return = self.export_data(place_info)
except Exception as e:
self.logger.error("-{name}-: error during reviews extraction: {error}".format(name=self._place_name,
error=str(e)))
finally:
self.finish()
end_time = time.time()
elapsed = int(end_time - init_time)
self.logger.info("-{name}-: scrapping process the url -{url}- has took: -{elapsed}- seconds".format(
name=self._place_name, elapsed=elapsed, url=self._url))
return result_to_return | [
"def",
"scrap",
"(",
"self",
",",
"provided_driver",
"=",
"None",
")",
":",
"logging",
".",
"info",
"(",
"\"-{name}-: scrapping process for place with url -{url}- is starting\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"driver",
"=",
"provided_driver",
"if",
"provided_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"init_time",
"=",
"time",
".",
"time",
"(",
")",
"place_info",
"=",
"None",
"result_to_return",
"=",
"None",
"try",
":",
"# checkeo si ya existe registro para la fecha de extracción y el nombre del local para evitar volver a",
"# procesarlo",
"is_registered",
"=",
"self",
".",
"_writer",
".",
"is_registered",
"(",
"{",
"\"name\"",
":",
"self",
".",
"_place_name",
",",
"\"date\"",
":",
"self",
".",
"_extraction_date",
",",
"\"address\"",
":",
"self",
".",
"_place_address",
"}",
")",
"if",
"is_registered",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{name}-: place in {address} and for date: -{date}- is already processed\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"date",
"=",
"self",
".",
"_extraction_date",
",",
"address",
"=",
"self",
".",
"_place_address",
")",
")",
"result_to_return",
"=",
"{",
"\"is_registered\"",
":",
"True",
"}",
"else",
":",
"place_info",
"=",
"self",
".",
"_scrap",
"(",
"driver",
")",
"result_to_return",
"=",
"self",
".",
"export_data",
"(",
"place_info",
")",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"logger",
".",
"error",
"(",
"\"-{name}-: error during reviews extraction: {error}\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"error",
"=",
"str",
"(",
"e",
")",
")",
")",
"finally",
":",
"self",
".",
"finish",
"(",
")",
"end_time",
"=",
"time",
".",
"time",
"(",
")",
"elapsed",
"=",
"int",
"(",
"end_time",
"-",
"init_time",
")",
"self",
".",
"logger",
".",
"info",
"(",
"\"-{name}-: scrapping process the url -{url}- has took: -{elapsed}- seconds\"",
".",
"format",
"(",
"name",
"=",
"self",
".",
"_place_name",
",",
"elapsed",
"=",
"elapsed",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"return",
"result_to_return"
] | [
584,
4
] | [
635,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
main | () | Defininmos los parametros y dimensiones de nuestras entradas | Defininmos los parametros y dimensiones de nuestras entradas | def main():
graficarFuncion()
"""Defininmos los parametros y dimensiones de nuestras entradas"""
NBITS = 10
NIPOP = 20
NPOP = int(random.randint(2, NIPOP))
NGOOD = int(random.randint(2, NPOP))
NBAD = NPOP - NGOOD
MODELO = np.array([0, 1, 1, 0, 1, 0, 0, 1, 0, 1]) # =-421
# Imprimimos el modelo
print("Modelo:")
print(MODELO)
print("\n")
# Generamos la poblacion inicial llamando a la funcion y guardando el valor de retorno en la
# variable "matrizIPOP"
matrizIPOP = generarPoblacionInicial(NBITS, NIPOP)
print("Matriz generada aleatoriamente")
print(matrizIPOP)
print("\n")
for i in range(0, 2):
"""Comienza mating pool"""
# Ordenamos los elementos de menor a mayor, imprime los valores iniciales desordenados,
# los valores ordenados de acuerdo al coste y devuelve una matriz con los valores NGOOD
matrizNGOOD = matingPool(matrizIPOP, NPOP, NGOOD)
"""Comienza Seleccion de pareja y Cruce"""
nuevaPoblacion = seleccionDeParejasYCruce(matrizNGOOD)
"""No se realiza mutacion"""
#mutacion()
"""Revisamos si se cumple la convergencia"""
if convergencia(nuevaPoblacion, MODELO):
print("convergencia alcanzada, mostrando minimo")
break
else:
print("Convergencia no alcanzada")
"""Reescribimos el valor de NIPOP, NPOP y NGOOD"""
NIPOP = len(nuevaPoblacion)
NPOP = int(random.randint(2, NIPOP))
NGOOD = int(random.randint(2, NPOP))
print("\n")
matrizIPOP = np.copy(nuevaPoblacion)
print("Minimo encontrado")
print(nuevaPoblacion[0])
print(convertirListaBinariaAEntero(nuevaPoblacion[0]))
print("Coste:", funcionCoste(convertirListaBinariaAEntero(nuevaPoblacion[0])))
graficarMinimo(convertirListaBinariaAEntero(nuevaPoblacion[0]), funcionCoste(convertirListaBinariaAEntero(nuevaPoblacion[0]))) | [
"def",
"main",
"(",
")",
":",
"graficarFuncion",
"(",
")",
"NBITS",
"=",
"10",
"NIPOP",
"=",
"20",
"NPOP",
"=",
"int",
"(",
"random",
".",
"randint",
"(",
"2",
",",
"NIPOP",
")",
")",
"NGOOD",
"=",
"int",
"(",
"random",
".",
"randint",
"(",
"2",
",",
"NPOP",
")",
")",
"NBAD",
"=",
"NPOP",
"-",
"NGOOD",
"MODELO",
"=",
"np",
".",
"array",
"(",
"[",
"0",
",",
"1",
",",
"1",
",",
"0",
",",
"1",
",",
"0",
",",
"0",
",",
"1",
",",
"0",
",",
"1",
"]",
")",
"# =-421",
"# Imprimimos el modelo",
"print",
"(",
"\"Modelo:\"",
")",
"print",
"(",
"MODELO",
")",
"print",
"(",
"\"\\n\"",
")",
"# Generamos la poblacion inicial llamando a la funcion y guardando el valor de retorno en la",
"# variable \"matrizIPOP\"",
"matrizIPOP",
"=",
"generarPoblacionInicial",
"(",
"NBITS",
",",
"NIPOP",
")",
"print",
"(",
"\"Matriz generada aleatoriamente\"",
")",
"print",
"(",
"matrizIPOP",
")",
"print",
"(",
"\"\\n\"",
")",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"2",
")",
":",
"\"\"\"Comienza mating pool\"\"\"",
"# Ordenamos los elementos de menor a mayor, imprime los valores iniciales desordenados,",
"# los valores ordenados de acuerdo al coste y devuelve una matriz con los valores NGOOD",
"matrizNGOOD",
"=",
"matingPool",
"(",
"matrizIPOP",
",",
"NPOP",
",",
"NGOOD",
")",
"\"\"\"Comienza Seleccion de pareja y Cruce\"\"\"",
"nuevaPoblacion",
"=",
"seleccionDeParejasYCruce",
"(",
"matrizNGOOD",
")",
"\"\"\"No se realiza mutacion\"\"\"",
"#mutacion()",
"\"\"\"Revisamos si se cumple la convergencia\"\"\"",
"if",
"convergencia",
"(",
"nuevaPoblacion",
",",
"MODELO",
")",
":",
"print",
"(",
"\"convergencia alcanzada, mostrando minimo\"",
")",
"break",
"else",
":",
"print",
"(",
"\"Convergencia no alcanzada\"",
")",
"\"\"\"Reescribimos el valor de NIPOP, NPOP y NGOOD\"\"\"",
"NIPOP",
"=",
"len",
"(",
"nuevaPoblacion",
")",
"NPOP",
"=",
"int",
"(",
"random",
".",
"randint",
"(",
"2",
",",
"NIPOP",
")",
")",
"NGOOD",
"=",
"int",
"(",
"random",
".",
"randint",
"(",
"2",
",",
"NPOP",
")",
")",
"print",
"(",
"\"\\n\"",
")",
"matrizIPOP",
"=",
"np",
".",
"copy",
"(",
"nuevaPoblacion",
")",
"print",
"(",
"\"Minimo encontrado\"",
")",
"print",
"(",
"nuevaPoblacion",
"[",
"0",
"]",
")",
"print",
"(",
"convertirListaBinariaAEntero",
"(",
"nuevaPoblacion",
"[",
"0",
"]",
")",
")",
"print",
"(",
"\"Coste:\"",
",",
"funcionCoste",
"(",
"convertirListaBinariaAEntero",
"(",
"nuevaPoblacion",
"[",
"0",
"]",
")",
")",
")",
"graficarMinimo",
"(",
"convertirListaBinariaAEntero",
"(",
"nuevaPoblacion",
"[",
"0",
"]",
")",
",",
"funcionCoste",
"(",
"convertirListaBinariaAEntero",
"(",
"nuevaPoblacion",
"[",
"0",
"]",
")",
")",
")"
] | [
180,
0
] | [
233,
130
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
b | (datos) | return min(datos, key=datos.get) | Devuelve el código de la sección con menos alumnos | Devuelve el código de la sección con menos alumnos | def b(datos):
"""Devuelve el código de la sección con menos alumnos"""
return min(datos, key=datos.get) | [
"def",
"b",
"(",
"datos",
")",
":",
"return",
"min",
"(",
"datos",
",",
"key",
"=",
"datos",
".",
"get",
")"
] | [
63,
0
] | [
65,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_valororderby | (t) | valororderby : cualquieridentificador ascdesc anular
| cualquiernumero ascdesc anular | valororderby : cualquieridentificador ascdesc anular
| cualquiernumero ascdesc anular | def p_valororderby(t):
'''valororderby : cualquieridentificador ascdesc anular
| cualquiernumero ascdesc anular'''
t[0] = getValOrder(t) | [
"def",
"p_valororderby",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"getValOrder",
"(",
"t",
")"
] | [
1077,
0
] | [
1080,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
fitness | (ind) | return res | 1º Ver si un profesor da más asignaturas al día de las permitidas. | 1º Ver si un profesor da más asignaturas al día de las permitidas. | def fitness(ind):
MAXIMUM_HOURS_BY_LAW = 4
# ###########--------- 1 --------------#############
"""1º Ver si un profesor da más asignaturas al día de las permitidas."""
init = 0
fin = 39 # 8 h. per day * 5 days
res = 999
for i in range(PROFESSOR_NUMBER):
init_day = 0
fin_day = 5
timetable = ind[init:fin]
for j in range(5): # 5 dias a la semana
t = timetable[init_day:fin_day]
count = 6 - t.count(0)
if count > MAXIMUM_HOURS_BY_LAW:
res += 999
break # muy ilegal
else:
res -= 66 # quita un maximo de 5*66 = 330
if res < 0:
res = 0
init_day += 6
fin_day += 6
init += 30
fin += 30
check = checkGroups(ind)
if check > 0:
res += 10 * check
else:
res -= 100
# clock = random.sample(0,PROFESSOR_NUMBER)
if res < 0:
res = 0
return res | [
"def",
"fitness",
"(",
"ind",
")",
":",
"MAXIMUM_HOURS_BY_LAW",
"=",
"4",
"# ###########--------- 1 --------------#############\r",
"init",
"=",
"0",
"fin",
"=",
"39",
"# 8 h. per day * 5 days\r",
"res",
"=",
"999",
"for",
"i",
"in",
"range",
"(",
"PROFESSOR_NUMBER",
")",
":",
"init_day",
"=",
"0",
"fin_day",
"=",
"5",
"timetable",
"=",
"ind",
"[",
"init",
":",
"fin",
"]",
"for",
"j",
"in",
"range",
"(",
"5",
")",
":",
"# 5 dias a la semana\r",
"t",
"=",
"timetable",
"[",
"init_day",
":",
"fin_day",
"]",
"count",
"=",
"6",
"-",
"t",
".",
"count",
"(",
"0",
")",
"if",
"count",
">",
"MAXIMUM_HOURS_BY_LAW",
":",
"res",
"+=",
"999",
"break",
"# muy ilegal\r",
"else",
":",
"res",
"-=",
"66",
"# quita un maximo de 5*66 = 330\r",
"if",
"res",
"<",
"0",
":",
"res",
"=",
"0",
"init_day",
"+=",
"6",
"fin_day",
"+=",
"6",
"init",
"+=",
"30",
"fin",
"+=",
"30",
"check",
"=",
"checkGroups",
"(",
"ind",
")",
"if",
"check",
">",
"0",
":",
"res",
"+=",
"10",
"*",
"check",
"else",
":",
"res",
"-=",
"100",
"# clock = random.sample(0,PROFESSOR_NUMBER)\r",
"if",
"res",
"<",
"0",
":",
"res",
"=",
"0",
"return",
"res"
] | [
532,
0
] | [
570,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo._get_object_estimated_speed | (self,
tracked_object: TrackedObject,
tracked_object_detection: TrackedObjectDetection) | return round(float(speed), 2) | Obtiene la velocidad estimada del vehículo en el instante actual.
El instante actual se obtiene a partir de la detección actual pasada por el parámetro+
``tracked_object_detection``.
:param tracked_object: seguimiento del objeto.
:param tracked_object_detection: detección del seguimiento del objeto del momento actual.
:return: velocidad del objeto estimada en este instante.
| Obtiene la velocidad estimada del vehículo en el instante actual. | def _get_object_estimated_speed(self,
tracked_object: TrackedObject,
tracked_object_detection: TrackedObjectDetection) -> float:
"""Obtiene la velocidad estimada del vehículo en el instante actual.
El instante actual se obtiene a partir de la detección actual pasada por el parámetro+
``tracked_object_detection``.
:param tracked_object: seguimiento del objeto.
:param tracked_object_detection: detección del seguimiento del objeto del momento actual.
:return: velocidad del objeto estimada en este instante.
"""
estimations: List[EstimationResult] = self.get_property(
TrackingVideoProperty.OBJECTS_ESTIMATIONS)
# Comprobar que se han establecido las estimaciones de los objetos.
if estimations is None:
raise Exception('Se deben introducir las estimaciones de los objetos.')
# Obtener la velocidad media en este instante y devolverla.
index = tracked_object.index_frame(tracked_object_detection.frame)
velocities = estimations[tracked_object.id].velocities
# Si no hay estimaciones, devolver 0.
if len(velocities) == 0:
return 0
# Obtener la velocidad de esta detección o la última registrada (estimada).
try:
velocity = velocities[index]
except IndexError:
velocity = velocities[-1]
speed = np.linalg.norm(np.array(velocity))
return round(float(speed), 2) | [
"def",
"_get_object_estimated_speed",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
",",
"tracked_object_detection",
":",
"TrackedObjectDetection",
")",
"->",
"float",
":",
"estimations",
":",
"List",
"[",
"EstimationResult",
"]",
"=",
"self",
".",
"get_property",
"(",
"TrackingVideoProperty",
".",
"OBJECTS_ESTIMATIONS",
")",
"# Comprobar que se han establecido las estimaciones de los objetos.",
"if",
"estimations",
"is",
"None",
":",
"raise",
"Exception",
"(",
"'Se deben introducir las estimaciones de los objetos.'",
")",
"# Obtener la velocidad media en este instante y devolverla.",
"index",
"=",
"tracked_object",
".",
"index_frame",
"(",
"tracked_object_detection",
".",
"frame",
")",
"velocities",
"=",
"estimations",
"[",
"tracked_object",
".",
"id",
"]",
".",
"velocities",
"# Si no hay estimaciones, devolver 0.",
"if",
"len",
"(",
"velocities",
")",
"==",
"0",
":",
"return",
"0",
"# Obtener la velocidad de esta detección o la última registrada (estimada).",
"try",
":",
"velocity",
"=",
"velocities",
"[",
"index",
"]",
"except",
"IndexError",
":",
"velocity",
"=",
"velocities",
"[",
"-",
"1",
"]",
"speed",
"=",
"np",
".",
"linalg",
".",
"norm",
"(",
"np",
".",
"array",
"(",
"velocity",
")",
")",
"return",
"round",
"(",
"float",
"(",
"speed",
")",
",",
"2",
")"
] | [
164,
4
] | [
193,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
centro_de_salud_habilitado_pk | (function) | return _inner | Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para las operaciones UPDATE, DELETE
| Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para las operaciones UPDATE, DELETE
| def centro_de_salud_habilitado_pk(function):
'''Decorador para asegurarse que un formulario X no pueda ejecutar su operación
si no tiene permiso el usuario Y, esta implementacion sirve mas para las operaciones UPDATE, DELETE
'''
def _inner(request, *args, **kwargs):
turno = Turno.objects.select_related('servicio').get(id=kwargs['pk'])
centro = turno.servicio.centro
if request.user.centros_de_salud_permitidos.filter(centro_de_salud=centro).exists():
return function(request, *args, **kwargs)
else:
raise PermissionDenied("No tiene permiso para actuar en este centro de salud")
return _inner | [
"def",
"centro_de_salud_habilitado_pk",
"(",
"function",
")",
":",
"def",
"_inner",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"turno",
"=",
"Turno",
".",
"objects",
".",
"select_related",
"(",
"'servicio'",
")",
".",
"get",
"(",
"id",
"=",
"kwargs",
"[",
"'pk'",
"]",
")",
"centro",
"=",
"turno",
".",
"servicio",
".",
"centro",
"if",
"request",
".",
"user",
".",
"centros_de_salud_permitidos",
".",
"filter",
"(",
"centro_de_salud",
"=",
"centro",
")",
".",
"exists",
"(",
")",
":",
"return",
"function",
"(",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"else",
":",
"raise",
"PermissionDenied",
"(",
"\"No tiene permiso para actuar en este centro de salud\"",
")",
"return",
"_inner"
] | [
20,
0
] | [
32,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
logprior | (param) | return d | Logaritmo natural de los prior para los parametros.
Todos corresponden a gaussianas con sigma=10.0.
| Logaritmo natural de los prior para los parametros.
Todos corresponden a gaussianas con sigma=10.0.
| def logprior(param):
"""Logaritmo natural de los prior para los parametros.
Todos corresponden a gaussianas con sigma=10.0.
"""
d = -0.5 * np.sum(param**2/(10.0)**2)
return d | [
"def",
"logprior",
"(",
"param",
")",
":",
"d",
"=",
"-",
"0.5",
"*",
"np",
".",
"sum",
"(",
"param",
"**",
"2",
"/",
"(",
"10.0",
")",
"**",
"2",
")",
"return",
"d"
] | [
22,
0
] | [
27,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TarjetaCreditoDepredadora.cargar | (self, precio: float) | return exito | Carga el precio dado en la tarjeta, asumiendo que hay
credito.
:param precio: precio a cargar
:return: True si se pudo cargar, False de lo contrario y cobra
$5 de impuesto si el cargo es denegado.
| Carga el precio dado en la tarjeta, asumiendo que hay
credito. | def cargar(self, precio: float) -> bool:
"""Carga el precio dado en la tarjeta, asumiendo que hay
credito.
:param precio: precio a cargar
:return: True si se pudo cargar, False de lo contrario y cobra
$5 de impuesto si el cargo es denegado.
"""
self.__i += 1
if self.__i >= 10:
self.__adicional = 1
exito = super().cargar(precio)
if not exito:
self._balance += self.__class__.__IMPUESTO + self.__adicional
return exito | [
"def",
"cargar",
"(",
"self",
",",
"precio",
":",
"float",
")",
"->",
"bool",
":",
"self",
".",
"__i",
"+=",
"1",
"if",
"self",
".",
"__i",
">=",
"10",
":",
"self",
".",
"__adicional",
"=",
"1",
"exito",
"=",
"super",
"(",
")",
".",
"cargar",
"(",
"precio",
")",
"if",
"not",
"exito",
":",
"self",
".",
"_balance",
"+=",
"self",
".",
"__class__",
".",
"__IMPUESTO",
"+",
"self",
".",
"__adicional",
"return",
"exito"
] | [
31,
4
] | [
45,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
_combinaciones | (arr: List[int], idx: int, n: int, r: int) | Funcion helper para hallar todas las combinaciones.
:param arr: Arreglo
:arr type: list
:param idx: Indice
:idx type: int
:param n: Número
:n type: int
:param r: Número reducido
:r type: int
| Funcion helper para hallar todas las combinaciones. | def _combinaciones(arr: List[int], idx: int, n: int, r: int) -> None:
"""Funcion helper para hallar todas las combinaciones.
:param arr: Arreglo
:arr type: list
:param idx: Indice
:idx type: int
:param n: Número
:n type: int
:param r: Número reducido
:r type: int
"""
if r < 0:
return
if r == 0:
t = f"{str(n)} = "
for i in range(idx):
t += f"{str(arr[i])} + "
print(t[:-2])
return
prev = 1 if (idx == 0) else arr[idx - 1]
for k in range(prev, n+1):
arr[idx] = k
_combinaciones(arr, idx+1, n, r-k) | [
"def",
"_combinaciones",
"(",
"arr",
":",
"List",
"[",
"int",
"]",
",",
"idx",
":",
"int",
",",
"n",
":",
"int",
",",
"r",
":",
"int",
")",
"->",
"None",
":",
"if",
"r",
"<",
"0",
":",
"return",
"if",
"r",
"==",
"0",
":",
"t",
"=",
"f\"{str(n)} = \"",
"for",
"i",
"in",
"range",
"(",
"idx",
")",
":",
"t",
"+=",
"f\"{str(arr[i])} + \"",
"print",
"(",
"t",
"[",
":",
"-",
"2",
"]",
")",
"return",
"prev",
"=",
"1",
"if",
"(",
"idx",
"==",
"0",
")",
"else",
"arr",
"[",
"idx",
"-",
"1",
"]",
"for",
"k",
"in",
"range",
"(",
"prev",
",",
"n",
"+",
"1",
")",
":",
"arr",
"[",
"idx",
"]",
"=",
"k",
"_combinaciones",
"(",
"arr",
",",
"idx",
"+",
"1",
",",
"n",
",",
"r",
"-",
"k",
")"
] | [
31,
0
] | [
54,
42
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
convertir | (hora: str) | return f"{hora_12}:{hora[3:]} {'AM' if hora_24 < 12 else 'PM'}" | Convierte una hora en notación de 24 horas a 12 horas.
:param hora: Hora a convertir
:hora type: str
:return: Hora en notación de 12 horas
:rtype: str
| Convierte una hora en notación de 24 horas a 12 horas. | def convertir(hora: str) -> str:
"""Convierte una hora en notación de 24 horas a 12 horas.
:param hora: Hora a convertir
:hora type: str
:return: Hora en notación de 12 horas
:rtype: str
"""
hora_24 = int(hora[:2])
hora_12 = 12 if hora_24 % 12 == 0 else hora_24 % 12
return f"{hora_12}:{hora[3:]} {'AM' if hora_24 < 12 else 'PM'}" | [
"def",
"convertir",
"(",
"hora",
":",
"str",
")",
"->",
"str",
":",
"hora_24",
"=",
"int",
"(",
"hora",
"[",
":",
"2",
"]",
")",
"hora_12",
"=",
"12",
"if",
"hora_24",
"%",
"12",
"==",
"0",
"else",
"hora_24",
"%",
"12",
"return",
"f\"{hora_12}:{hora[3:]} {'AM' if hora_24 < 12 else 'PM'}\""
] | [
11,
0
] | [
21,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ApiRequest.settokenname | (self,tparser,trequest) | Establece el nombre de lostoken para las request y para buscarlo cuando se recibe.
Parameters
----------
tparser : str
nombre del token devuelto al autorizarse
trequest : str
nombre del token al hacer las peticiones
| Establece el nombre de lostoken para las request y para buscarlo cuando se recibe. | def settokenname(self,tparser,trequest):
"""Establece el nombre de lostoken para las request y para buscarlo cuando se recibe.
Parameters
----------
tparser : str
nombre del token devuelto al autorizarse
trequest : str
nombre del token al hacer las peticiones
"""
self.tokenparser=tparser #token
self.tokenrequest=trequest | [
"def",
"settokenname",
"(",
"self",
",",
"tparser",
",",
"trequest",
")",
":",
"self",
".",
"tokenparser",
"=",
"tparser",
"#token ",
"self",
".",
"tokenrequest",
"=",
"trequest"
] | [
72,
4
] | [
84,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
CubeShell.do_ver_cubo | (self, arg) | Imprimir el objeto cubo actual por consola | Imprimir el objeto cubo actual por consola | def do_ver_cubo(self, arg):
'''Imprimir el objeto cubo actual por consola'''
print(str(cubo_actual)) | [
"def",
"do_ver_cubo",
"(",
"self",
",",
"arg",
")",
":",
"print",
"(",
"str",
"(",
"cubo_actual",
")",
")"
] | [
38,
4
] | [
40,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Operaciones.sumar | (self) | return self.op1 + self.op2 | Se realiza la operacion con los atributos de la clase | Se realiza la operacion con los atributos de la clase | def sumar(self):
"""Se realiza la operacion con los atributos de la clase"""
return self.op1 + self.op2 | [
"def",
"sumar",
"(",
"self",
")",
":",
"return",
"self",
".",
"op1",
"+",
"self",
".",
"op2"
] | [
6,
4
] | [
8,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
User.increment_login_attempts | (self) | Incrementando cuentas | Incrementando cuentas | def increment_login_attempts(self):
"""Incrementando cuentas"""
self.login_attempts += 1 | [
"def",
"increment_login_attempts",
"(",
"self",
")",
":",
"self",
".",
"login_attempts",
"+=",
"1"
] | [
28,
4
] | [
30,
32
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
|
BcraSmlScraperTestCase.test_sml_configuration_has_url | (self) | Validar la existencia de la clave url dentro de
la configuración de sml | Validar la existencia de la clave url dentro de
la configuración de sml | def test_sml_configuration_has_url(self):
"""Validar la existencia de la clave url dentro de
la configuración de sml"""
dict_config = {'sml': {'foo': 'bar'}}
with mock.patch(
'builtins.open',
return_value=io.StringIO(json.dumps(dict_config))
):
with self.assertRaises(InvalidConfigurationError):
config = read_config("config_general.json", "sml")
validate_url_config(config) | [
"def",
"test_sml_configuration_has_url",
"(",
"self",
")",
":",
"dict_config",
"=",
"{",
"'sml'",
":",
"{",
"'foo'",
":",
"'bar'",
"}",
"}",
"with",
"mock",
".",
"patch",
"(",
"'builtins.open'",
",",
"return_value",
"=",
"io",
".",
"StringIO",
"(",
"json",
".",
"dumps",
"(",
"dict_config",
")",
")",
")",
":",
"with",
"self",
".",
"assertRaises",
"(",
"InvalidConfigurationError",
")",
":",
"config",
"=",
"read_config",
"(",
"\"config_general.json\"",
",",
"\"sml\"",
")",
"validate_url_config",
"(",
"config",
")"
] | [
309,
4
] | [
321,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.SVD | (self) | return U, S, V | Metodo para hallar la descomposicion de valores singulares. | Metodo para hallar la descomposicion de valores singulares. | def SVD(self):
""" Metodo para hallar la descomposicion de valores singulares. """
ctc = self.transpose() * self
S, V = ctc.Eigen()
eigen_vals = S.diag()
x = len(S)
S *= 0
for s in xrange(x):
S[s][s] = eigen_vals[s] ** 0.5
U = self * V * S.inv()
return U, S, V | [
"def",
"SVD",
"(",
"self",
")",
":",
"ctc",
"=",
"self",
".",
"transpose",
"(",
")",
"*",
"self",
"S",
",",
"V",
"=",
"ctc",
".",
"Eigen",
"(",
")",
"eigen_vals",
"=",
"S",
".",
"diag",
"(",
")",
"x",
"=",
"len",
"(",
"S",
")",
"S",
"*=",
"0",
"for",
"s",
"in",
"xrange",
"(",
"x",
")",
":",
"S",
"[",
"s",
"]",
"[",
"s",
"]",
"=",
"eigen_vals",
"[",
"s",
"]",
"**",
"0.5",
"U",
"=",
"self",
"*",
"V",
"*",
"S",
".",
"inv",
"(",
")",
"return",
"U",
",",
"S",
",",
"V"
] | [
263,
4
] | [
273,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
minitwill | (url, script) | return True | Dada una URL y un script en una versión limitada
de twill, ejecuta ese script.
Apenas una línea falla, devuelve False.
Si todas tienen éxito, devuelve True.
Ejemplos:
>>> minitwill('http://google.com','code 200')
==> at http://www.google.com.ar/
True
>>> minitwill('http://google.com','title bing')
==> at http://www.google.com.ar/
title is 'Google'.
False
| Dada una URL y un script en una versión limitada
de twill, ejecuta ese script.
Apenas una línea falla, devuelve False. | def minitwill(url, script):
'''Dada una URL y un script en una versión limitada
de twill, ejecuta ese script.
Apenas una línea falla, devuelve False.
Si todas tienen éxito, devuelve True.
Ejemplos:
>>> minitwill('http://google.com','code 200')
==> at http://www.google.com.ar/
True
>>> minitwill('http://google.com','title bing')
==> at http://www.google.com.ar/
title is 'Google'.
False
'''
go (url)
for line in script.splitlines():
cmd,arg = line.split(' ',1)
try:
if cmd in ['code','find','notfind','title']:
r = globals()[cmd](arg)
except:
return False
return True | [
"def",
"minitwill",
"(",
"url",
",",
"script",
")",
":",
"go",
"(",
"url",
")",
"for",
"line",
"in",
"script",
".",
"splitlines",
"(",
")",
":",
"cmd",
",",
"arg",
"=",
"line",
".",
"split",
"(",
"' '",
",",
"1",
")",
"try",
":",
"if",
"cmd",
"in",
"[",
"'code'",
",",
"'find'",
",",
"'notfind'",
",",
"'title'",
"]",
":",
"r",
"=",
"globals",
"(",
")",
"[",
"cmd",
"]",
"(",
"arg",
")",
"except",
":",
"return",
"False",
"return",
"True"
] | [
14,
0
] | [
41,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
extraer_info | (archivo) | return content, metadata | Extrae contenido y metadata de archivo.
Parameters
----------
archivo : str | Path
Ruta del archivo del cual se quiere extraer texto y metadata.
Returns
-------
tuple (str, dict)
Content y Metadata.
| Extrae contenido y metadata de archivo. | def extraer_info(archivo):
"""Extrae contenido y metadata de archivo.
Parameters
----------
archivo : str | Path
Ruta del archivo del cual se quiere extraer texto y metadata.
Returns
-------
tuple (str, dict)
Content y Metadata.
"""
ruta = Path(archivo).resolve()
if ruta.is_file():
try:
info = parser.from_file(str(ruta), xmlContent=True)
except Exception:
print(f"No pudo extraerse información de {ruta.name}.")
info = dict()
else:
print(f"{ruta.name} no es un archivo.")
info = dict()
content = info.get("content")
metadata = info.get("metadata")
return content, metadata | [
"def",
"extraer_info",
"(",
"archivo",
")",
":",
"ruta",
"=",
"Path",
"(",
"archivo",
")",
".",
"resolve",
"(",
")",
"if",
"ruta",
".",
"is_file",
"(",
")",
":",
"try",
":",
"info",
"=",
"parser",
".",
"from_file",
"(",
"str",
"(",
"ruta",
")",
",",
"xmlContent",
"=",
"True",
")",
"except",
"Exception",
":",
"print",
"(",
"f\"No pudo extraerse información de {ruta.name}.\")",
"",
"info",
"=",
"dict",
"(",
")",
"else",
":",
"print",
"(",
"f\"{ruta.name} no es un archivo.\"",
")",
"info",
"=",
"dict",
"(",
")",
"content",
"=",
"info",
".",
"get",
"(",
"\"content\"",
")",
"metadata",
"=",
"info",
".",
"get",
"(",
"\"metadata\"",
")",
"return",
"content",
",",
"metadata"
] | [
12,
0
] | [
41,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
loadDataset | (directory_path, shuffle=True) | return imgs, labels | Función para cargar las imágenes en forma de arrays de numpy
Args:
directory_path: ruta donde se encuentran los datos
shuffle: booleano que determina si se baraja o no el conjunto de datos.
| Función para cargar las imágenes en forma de arrays de numpy | def loadDataset(directory_path, shuffle=True):
""" Función para cargar las imágenes en forma de arrays de numpy
Args:
directory_path: ruta donde se encuentran los datos
shuffle: booleano que determina si se baraja o no el conjunto de datos.
"""
import glob, os
current_dir = os.path.abspath(os.getcwd())
os.chdir(directory_path)
imgs, labels = [], []
for class_dir in os.listdir('./'):
print("Class:",class_dir)
class_name = class_dir
for i, file in enumerate(glob.glob("{}/*.png".format(class_dir))):
imgs.append(cv2.imread(file, 0))
labels.append(class_name)
imgs = np.asarray(imgs)
labels = np.asarray(labels)
if shuffle:
indices = np.random.permutation(len(imgs))
imgs = imgs[indices]
labels = labels[indices]
os.chdir(current_dir)
return imgs, labels | [
"def",
"loadDataset",
"(",
"directory_path",
",",
"shuffle",
"=",
"True",
")",
":",
"import",
"glob",
",",
"os",
"current_dir",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"getcwd",
"(",
")",
")",
"os",
".",
"chdir",
"(",
"directory_path",
")",
"imgs",
",",
"labels",
"=",
"[",
"]",
",",
"[",
"]",
"for",
"class_dir",
"in",
"os",
".",
"listdir",
"(",
"'./'",
")",
":",
"print",
"(",
"\"Class:\"",
",",
"class_dir",
")",
"class_name",
"=",
"class_dir",
"for",
"i",
",",
"file",
"in",
"enumerate",
"(",
"glob",
".",
"glob",
"(",
"\"{}/*.png\"",
".",
"format",
"(",
"class_dir",
")",
")",
")",
":",
"imgs",
".",
"append",
"(",
"cv2",
".",
"imread",
"(",
"file",
",",
"0",
")",
")",
"labels",
".",
"append",
"(",
"class_name",
")",
"imgs",
"=",
"np",
".",
"asarray",
"(",
"imgs",
")",
"labels",
"=",
"np",
".",
"asarray",
"(",
"labels",
")",
"if",
"shuffle",
":",
"indices",
"=",
"np",
".",
"random",
".",
"permutation",
"(",
"len",
"(",
"imgs",
")",
")",
"imgs",
"=",
"imgs",
"[",
"indices",
"]",
"labels",
"=",
"labels",
"[",
"indices",
"]",
"os",
".",
"chdir",
"(",
"current_dir",
")",
"return",
"imgs",
",",
"labels"
] | [
71,
0
] | [
102,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ProcControl.clear | (self, *args, **kwargs) | Los mismo que `AsyncClear()` pero sincrónico | Los mismo que `AsyncClear()` pero sincrónico | def clear(self, *args, **kwargs) -> None:
"""Los mismo que `AsyncClear()` pero sincrónico"""
asyncio.run(self.AsyncClear(*args, **kwargs)) | [
"def",
"clear",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"->",
"None",
":",
"asyncio",
".",
"run",
"(",
"self",
".",
"AsyncClear",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
")"
] | [
232,
4
] | [
235,
53
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
split_data | (data, window_size, step) | return np.array([
data[i * step: i * step + window_size]
for i in range((len(data) - window_size) // step + 1)
]) | Recibe un arreglo y lo divide en una matriz utilizando el tamaño de ventana y de paso definidos. | Recibe un arreglo y lo divide en una matriz utilizando el tamaño de ventana y de paso definidos. | def split_data(data, window_size, step):
"Recibe un arreglo y lo divide en una matriz utilizando el tamaño de ventana y de paso definidos."
assert window_size > 0, "El tamaño de paso debe ser mayor que 0."
assert step > 0, "El tamaño de paso debe ser mayor que 0."
return np.array([
data[i * step: i * step + window_size]
for i in range((len(data) - window_size) // step + 1)
]) | [
"def",
"split_data",
"(",
"data",
",",
"window_size",
",",
"step",
")",
":",
"assert",
"window_size",
">",
"0",
",",
"\"El tamaño de paso debe ser mayor que 0.\"",
"assert",
"step",
">",
"0",
",",
"\"El tamaño de paso debe ser mayor que 0.\"",
"return",
"np",
".",
"array",
"(",
"[",
"data",
"[",
"i",
"*",
"step",
":",
"i",
"*",
"step",
"+",
"window_size",
"]",
"for",
"i",
"in",
"range",
"(",
"(",
"len",
"(",
"data",
")",
"-",
"window_size",
")",
"//",
"step",
"+",
"1",
")",
"]",
")"
] | [
96,
0
] | [
103,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
run_test | (slug) | Corre el test correspondiente a un atajo | Corre el test correspondiente a un atajo | def run_test(slug):
"""Corre el test correspondiente a un atajo"""
if not 'REMOTE_USER' in bottle.request.environ:
bottle.abort(401, "Sorry, access denied.")
usuario = bottle.request.environ['REMOTE_USER'].decode('utf8')
# Solo el dueño de un atajo puede probarlo
a = Atajo.get(slug)
if a and a.user == usuario:
a.run_test()
# FIXME: pasar un mensaje en la sesión
bottle.redirect('/') | [
"def",
"run_test",
"(",
"slug",
")",
":",
"if",
"not",
"'REMOTE_USER'",
"in",
"bottle",
".",
"request",
".",
"environ",
":",
"bottle",
".",
"abort",
"(",
"401",
",",
"\"Sorry, access denied.\"",
")",
"usuario",
"=",
"bottle",
".",
"request",
".",
"environ",
"[",
"'REMOTE_USER'",
"]",
".",
"decode",
"(",
"'utf8'",
")",
"# Solo el dueño de un atajo puede probarlo",
"a",
"=",
"Atajo",
".",
"get",
"(",
"slug",
")",
"if",
"a",
"and",
"a",
".",
"user",
"==",
"usuario",
":",
"a",
".",
"run_test",
"(",
")",
"# FIXME: pasar un mensaje en la sesión",
"bottle",
".",
"redirect",
"(",
"'/'",
")"
] | [
295,
0
] | [
306,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
f | (s: str) | Calcula la operación matématica representada en una cadena
de texto
:param s: Representacion de la operación matématica
:s type: str
:return: Resultado de la operación
:rtype: float
| Calcula la operación matématica representada en una cadena
de texto | def f(s: str) -> float:
"""Calcula la operación matématica representada en una cadena
de texto
:param s: Representacion de la operación matématica
:s type: str
:return: Resultado de la operación
:rtype: float
"""
if s.isdigit():
return float(s)
if s.islower():
return "Error"
for c in op:
i, o, d = s.partition(c)
if o in op:
return op[o](f(i), f(d)) | [
"def",
"f",
"(",
"s",
":",
"str",
")",
"->",
"float",
":",
"if",
"s",
".",
"isdigit",
"(",
")",
":",
"return",
"float",
"(",
"s",
")",
"if",
"s",
".",
"islower",
"(",
")",
":",
"return",
"\"Error\"",
"for",
"c",
"in",
"op",
":",
"i",
",",
"o",
",",
"d",
"=",
"s",
".",
"partition",
"(",
"c",
")",
"if",
"o",
"in",
"op",
":",
"return",
"op",
"[",
"o",
"]",
"(",
"f",
"(",
"i",
")",
",",
"f",
"(",
"d",
")",
")"
] | [
22,
0
] | [
38,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
__lt__ | (self, otro_nodo) | Metodo _comparable_ de python para que el nodo arbol pueda
meterse sin problemas en la lista. | Metodo _comparable_ de python para que el nodo arbol pueda
meterse sin problemas en la lista. | def __lt__(self, otro_nodo):
'''Metodo _comparable_ de python para que el nodo arbol pueda
meterse sin problemas en la lista.'''
if not self.f == otro_nodo.f:
return self.f < otro_nodo.f
else:
return self.id < otro_nodo.id | [
"def",
"__lt__",
"(",
"self",
",",
"otro_nodo",
")",
":",
"if",
"not",
"self",
".",
"f",
"==",
"otro_nodo",
".",
"f",
":",
"return",
"self",
".",
"f",
"<",
"otro_nodo",
".",
"f",
"else",
":",
"return",
"self",
".",
"id",
"<",
"otro_nodo",
".",
"id"
] | [
20,
4
] | [
26,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
model_trainer | (train_data, hyper) | return train_time | Entrena un modelo y lo guarda en disco
Función encargada de entrenar un modelo con base en los hyperparametro y
lo guarda como un archivo utilizable por `pycrfsuite`
Parameters
----------
train_data : list
models_path : str
hyper : dict
verbose : bool
k : int
Returns
-------
train_time : float
Tiempo de entrenamiento
compositive_name : str
Nombre del modelo entrenado
| Entrena un modelo y lo guarda en disco | def model_trainer(train_data, hyper):
""" Entrena un modelo y lo guarda en disco
Función encargada de entrenar un modelo con base en los hyperparametro y
lo guarda como un archivo utilizable por `pycrfsuite`
Parameters
----------
train_data : list
models_path : str
hyper : dict
verbose : bool
k : int
Returns
-------
train_time : float
Tiempo de entrenamiento
compositive_name : str
Nombre del modelo entrenado
"""
X_train = sent2features(train_data)
y_train = sent2labels(train_data)
breakpoint()
# Train the model
trainer = pycrfsuite.Trainer(verbose=True)
for xseq, yseq in zip(X_train, y_train):
trainer.append(xseq, yseq)
# Set training parameters. L-BFGS is default. Using Elastic Net (L1 + L2)
trainer.set_params({
'c1': hyper['L1'], # coefficient for L1 penalty
'c2': hyper['L2'], # coefficient for L2 penalty
'max_iterations': hyper['max-iter'] # early stopping
})
# The program saves the trained model to a file:
start = time.time()
trainer.train(hyper['path'])
end = time.time()
train_time = end - start
return train_time | [
"def",
"model_trainer",
"(",
"train_data",
",",
"hyper",
")",
":",
"X_train",
"=",
"sent2features",
"(",
"train_data",
")",
"y_train",
"=",
"sent2labels",
"(",
"train_data",
")",
"breakpoint",
"(",
")",
"# Train the model",
"trainer",
"=",
"pycrfsuite",
".",
"Trainer",
"(",
"verbose",
"=",
"True",
")",
"for",
"xseq",
",",
"yseq",
"in",
"zip",
"(",
"X_train",
",",
"y_train",
")",
":",
"trainer",
".",
"append",
"(",
"xseq",
",",
"yseq",
")",
"# Set training parameters. L-BFGS is default. Using Elastic Net (L1 + L2)",
"trainer",
".",
"set_params",
"(",
"{",
"'c1'",
":",
"hyper",
"[",
"'L1'",
"]",
",",
"# coefficient for L1 penalty",
"'c2'",
":",
"hyper",
"[",
"'L2'",
"]",
",",
"# coefficient for L2 penalty",
"'max_iterations'",
":",
"hyper",
"[",
"'max-iter'",
"]",
"# early stopping",
"}",
")",
"# The program saves the trained model to a file:",
"start",
"=",
"time",
".",
"time",
"(",
")",
"trainer",
".",
"train",
"(",
"hyper",
"[",
"'path'",
"]",
")",
"end",
"=",
"time",
".",
"time",
"(",
")",
"train_time",
"=",
"end",
"-",
"start",
"return",
"train_time"
] | [
104,
0
] | [
146,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
CubeShell.do_resolver | (self, args) | Menu guiado donde se resolvera el cubo por medio de los metodos vistos en clase. | Menu guiado donde se resolvera el cubo por medio de los metodos vistos en clase. | def do_resolver(self, args):
'''Menu guiado donde se resolvera el cubo por medio de los metodos vistos en clase.'''
global cubo_actual
problema = Problema(cubo_actual)
# cubo_resuelto = utils.resolverCubo(problema)
# if cubo_resuelto is not None:
# cubo_actual = cubo_resuelto
utils.resolverCubo(problema) | [
"def",
"do_resolver",
"(",
"self",
",",
"args",
")",
":",
"global",
"cubo_actual",
"problema",
"=",
"Problema",
"(",
"cubo_actual",
")",
"# cubo_resuelto = utils.resolverCubo(problema)",
"# if cubo_resuelto is not None:",
"# cubo_actual = cubo_resuelto",
"utils",
".",
"resolverCubo",
"(",
"problema",
")"
] | [
23,
4
] | [
30,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
lol_dataset | (dia_de_juego) | Viene un dia para jugar por parametro y segun lo que surja se devuelve los datos sorteados de X forma | Viene un dia para jugar por parametro y segun lo que surja se devuelve los datos sorteados de X forma | def lol_dataset(dia_de_juego):
"""Viene un dia para jugar por parametro y segun lo que surja se devuelve los datos sorteados de X forma"""
if dia_de_juego == 0:
return sort_campeones_por_nombre()
if dia_de_juego == 1:
return sort_por_rango()
if dia_de_juego == 2:
return sort_por_precio_rp()
if dia_de_juego == 3:
return sort_por_clase()
if dia_de_juego == 4:
return sort_por_gamestyle()
if dia_de_juego == 5:
return sort_por_dano()
if dia_de_juego == 6:
return sort_por_mana() | [
"def",
"lol_dataset",
"(",
"dia_de_juego",
")",
":",
"if",
"dia_de_juego",
"==",
"0",
":",
"return",
"sort_campeones_por_nombre",
"(",
")",
"if",
"dia_de_juego",
"==",
"1",
":",
"return",
"sort_por_rango",
"(",
")",
"if",
"dia_de_juego",
"==",
"2",
":",
"return",
"sort_por_precio_rp",
"(",
")",
"if",
"dia_de_juego",
"==",
"3",
":",
"return",
"sort_por_clase",
"(",
")",
"if",
"dia_de_juego",
"==",
"4",
":",
"return",
"sort_por_gamestyle",
"(",
")",
"if",
"dia_de_juego",
"==",
"5",
":",
"return",
"sort_por_dano",
"(",
")",
"if",
"dia_de_juego",
"==",
"6",
":",
"return",
"sort_por_mana",
"(",
")"
] | [
55,
0
] | [
70,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
planilla.buscar_valor | (self,palabra_,index_) | return "no existe registro" | busca en el diccionario cualquier pablra dentro de value[index_], \
hay que indicarle el index_ \
donde index_=0 -> alias ; index_=1 -> Correo | busca en el diccionario cualquier pablra dentro de value[index_], \
hay que indicarle el index_ \
donde index_=0 -> alias ; index_=1 -> Correo | def buscar_valor(self,palabra_,index_):
"busca en el diccionario cualquier pablra dentro de value[index_], \
hay que indicarle el index_ \
donde index_=0 -> alias ; index_=1 -> Correo"
for key, value in self.Planilla_.items():
if palabra_ == value[index_]:
return key
return "no existe registro" | [
"def",
"buscar_valor",
"(",
"self",
",",
"palabra_",
",",
"index_",
")",
":",
"for",
"key",
",",
"value",
"in",
"self",
".",
"Planilla_",
".",
"items",
"(",
")",
":",
"if",
"palabra_",
"==",
"value",
"[",
"index_",
"]",
":",
"return",
"key",
"return",
"\"no existe registro\""
] | [
77,
4
] | [
84,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ColumnsDatabase.name_column_list | (self) | return self.name_column | Método consultor que nos devuelve la lista de nombres de columnas | Método consultor que nos devuelve la lista de nombres de columnas | def name_column_list(self):
"""Método consultor que nos devuelve la lista de nombres de columnas"""
return self.name_column | [
"def",
"name_column_list",
"(",
"self",
")",
":",
"return",
"self",
".",
"name_column"
] | [
48,
4
] | [
50,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Hasar2GenComandos.ImprimirAnticipoBonificacionEnvases | (self, description, amount, iva, negative=False) | return self.conector.sendCommand(jdata) | Agrega un descuento general a la Factura o Ticket.
@param description Descripción
@param amount Importe (sin iva en FC A, sino con IVA)
@param iva Porcentaje de Iva
@param negative Si negative = True, se añadira el monto como descuento, sino, sera un recargo
| Agrega un descuento general a la Factura o Ticket.
| def ImprimirAnticipoBonificacionEnvases(self, description, amount, iva, negative=False):
"""Agrega un descuento general a la Factura o Ticket.
@param description Descripción
@param amount Importe (sin iva en FC A, sino con IVA)
@param iva Porcentaje de Iva
@param negative Si negative = True, se añadira el monto como descuento, sino, sera un recargo
"""
tipo_operacion = "CobroAnticipo"
if negative:
tipo_operacion = "DescuentoAnticipo"
jdata = {
"ImprimirAnticipoBonificacionEnvases":
{
"Descripcion" : description,
"Monto" : amount,
"CondicionIVA" : "Gravado",
"AlicuotaIVA" : iva,
"TipoImpuestoInterno" : "IIVariableKIVA",
"MagnitudImpuestoInterno" : "0.00",
"ModoDisplay" : "DisplayNo",
"ModoBaseTotal" : "ModoPrecioTotal",
"CodigoProducto" : "",
"Operacion" : tipo_operacion
}
}
return self.conector.sendCommand(jdata) | [
"def",
"ImprimirAnticipoBonificacionEnvases",
"(",
"self",
",",
"description",
",",
"amount",
",",
"iva",
",",
"negative",
"=",
"False",
")",
":",
"tipo_operacion",
"=",
"\"CobroAnticipo\"",
"if",
"negative",
":",
"tipo_operacion",
"=",
"\"DescuentoAnticipo\"",
"jdata",
"=",
"{",
"\"ImprimirAnticipoBonificacionEnvases\"",
":",
"{",
"\"Descripcion\"",
":",
"description",
",",
"\"Monto\"",
":",
"amount",
",",
"\"CondicionIVA\"",
":",
"\"Gravado\"",
",",
"\"AlicuotaIVA\"",
":",
"iva",
",",
"\"TipoImpuestoInterno\"",
":",
"\"IIVariableKIVA\"",
",",
"\"MagnitudImpuestoInterno\"",
":",
"\"0.00\"",
",",
"\"ModoDisplay\"",
":",
"\"DisplayNo\"",
",",
"\"ModoBaseTotal\"",
":",
"\"ModoPrecioTotal\"",
",",
"\"CodigoProducto\"",
":",
"\"\"",
",",
"\"Operacion\"",
":",
"tipo_operacion",
"}",
"}",
"return",
"self",
".",
"conector",
".",
"sendCommand",
"(",
"jdata",
")"
] | [
330,
1
] | [
358,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
NetworkCallback.get_networks | (
limit: int = 0,
asc: bool = True,
use_options: bool = False,
*, cursor
) | Obtiene las direcciones de los nodos.
Args:
limit:
Límite del número de nodos a obtener
asc:
Si es **True** el resultado será ascendente, si no, descendente.
use_options:
Si es **True** se obtendrá el identificador del nodo, la dirección y
el token, si no, simplemente la dirección.
Returns:
Un iterador asincrónico con las redes obtenidas.
| Obtiene las direcciones de los nodos.
Args:
limit:
Límite del número de nodos a obtener | async def get_networks(
limit: int = 0,
asc: bool = True,
use_options: bool = False,
*, cursor
) -> AsyncIterator[Union[Tuple[int, str, str], Tuple[str]]]:
"""Obtiene las direcciones de los nodos.
Args:
limit:
Límite del número de nodos a obtener
asc:
Si es **True** el resultado será ascendente, si no, descendente.
use_options:
Si es **True** se obtendrá el identificador del nodo, la dirección y
el token, si no, simplemente la dirección.
Returns:
Un iterador asincrónico con las redes obtenidas.
"""
args = []
if (use_options):
sql = ["SELECT id_network, network, token FROM networks ORDER BY id_network"]
if (asc):
sql.append("ASC")
else:
sql.append("DESC")
if (limit > 0):
sql.append("LIMIT %s")
args.append(limit)
await cursor.execute(
" ".join(sql), args
)
else:
await cursor.execute(
"SELECT network FROM networks"
)
while (result := await cursor.fetchone()):
yield result | [
"async",
"def",
"get_networks",
"(",
"limit",
":",
"int",
"=",
"0",
",",
"asc",
":",
"bool",
"=",
"True",
",",
"use_options",
":",
"bool",
"=",
"False",
",",
"*",
",",
"cursor",
")",
"->",
"AsyncIterator",
"[",
"Union",
"[",
"Tuple",
"[",
"int",
",",
"str",
",",
"str",
"]",
",",
"Tuple",
"[",
"str",
"]",
"]",
"]",
":",
"args",
"=",
"[",
"]",
"if",
"(",
"use_options",
")",
":",
"sql",
"=",
"[",
"\"SELECT id_network, network, token FROM networks ORDER BY id_network\"",
"]",
"if",
"(",
"asc",
")",
":",
"sql",
".",
"append",
"(",
"\"ASC\"",
")",
"else",
":",
"sql",
".",
"append",
"(",
"\"DESC\"",
")",
"if",
"(",
"limit",
">",
"0",
")",
":",
"sql",
".",
"append",
"(",
"\"LIMIT %s\"",
")",
"args",
".",
"append",
"(",
"limit",
")",
"await",
"cursor",
".",
"execute",
"(",
"\" \"",
".",
"join",
"(",
"sql",
")",
",",
"args",
")",
"else",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT network FROM networks\"",
")",
"while",
"(",
"result",
":=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
")",
":",
"yield",
"result"
] | [
542,
4
] | [
593,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
HolaApiView.post | (self, request) | Crea un mensaje con el nombre que pasemos en el post | Crea un mensaje con el nombre que pasemos en el post | def post(self, request):
"""Crea un mensaje con el nombre que pasemos en el post"""
serializer = self.serializers_class(data=request.data)
if serializer.is_valid():
name = serializer.validated_data.get('name')
message = f'Hola {name}'
return Response({'message': message})
else:
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST) | [
"def",
"post",
"(",
"self",
",",
"request",
")",
":",
"serializer",
"=",
"self",
".",
"serializers_class",
"(",
"data",
"=",
"request",
".",
"data",
")",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"name",
"=",
"serializer",
".",
"validated_data",
".",
"get",
"(",
"'name'",
")",
"message",
"=",
"f'Hola {name}'",
"return",
"Response",
"(",
"{",
"'message'",
":",
"message",
"}",
")",
"else",
":",
"return",
"Response",
"(",
"serializer",
".",
"errors",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
30,
4
] | [
41,
51
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ApiRequest._ProcessResponse | (self,r) | Procesa la respuesta de un request
Parameters
----------
r : request
respuesta de la peticion request
Returns - Se debe validar con isinstance
----------
r : request
respuesta de la peticion request (si todo ha ido bien)
r : int
returncode de la peticion request (si ha habido problemas)
| Procesa la respuesta de un request | def _ProcessResponse(self,r):
"""Procesa la respuesta de un request
Parameters
----------
r : request
respuesta de la peticion request
Returns - Se debe validar con isinstance
----------
r : request
respuesta de la peticion request (si todo ha ido bien)
r : int
returncode de la peticion request (si ha habido problemas)
"""
if r.status_code == 200:
self._log ("_ProcessResponse: Ok",4)
return r
else:
self._log ("_ProcessResponse: Ha habido error en: " +r.url+ " con codigo: "+str(r.status_code) + " con Error: "+ r.text,1)
return r.status_code | [
"def",
"_ProcessResponse",
"(",
"self",
",",
"r",
")",
":",
"if",
"r",
".",
"status_code",
"==",
"200",
":",
"self",
".",
"_log",
"(",
"\"_ProcessResponse: Ok\"",
",",
"4",
")",
"return",
"r",
"else",
":",
"self",
".",
"_log",
"(",
"\"_ProcessResponse: Ha habido error en: \"",
"+",
"r",
".",
"url",
"+",
"\" con codigo: \"",
"+",
"str",
"(",
"r",
".",
"status_code",
")",
"+",
"\" con Error: \"",
"+",
"r",
".",
"text",
",",
"1",
")",
"return",
"r",
".",
"status_code"
] | [
102,
4
] | [
123,
32
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Restaurant.describe_restaurant | (self) | Descripción del restaurant | Descripción del restaurant | def describe_restaurant(self):
"""Descripción del restaurant"""
msg = self.name + " sirve un delicioso " + self.cuisine_type + "."
print("\n" + msg) | [
"def",
"describe_restaurant",
"(",
"self",
")",
":",
"msg",
"=",
"self",
".",
"name",
"+",
"\" sirve un delicioso \"",
"+",
"self",
".",
"cuisine_type",
"+",
"\".\"",
"print",
"(",
"\"\\n\"",
"+",
"msg",
")"
] | [
14,
4
] | [
17,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ArregloDinamico._redimensionar | (self, c: int) | Redimensiona el arreglo
:param c: nueva capacidad del arreglo
:c type: int
| Redimensiona el arreglo | def _redimensionar(self, c: int) -> None:
"""Redimensiona el arreglo
:param c: nueva capacidad del arreglo
:c type: int
"""
B = self._crear(c)
for k in range(self._n):
B[k] = self._A[k]
self._A = B
self._capacidad = c | [
"def",
"_redimensionar",
"(",
"self",
",",
"c",
":",
"int",
")",
"->",
"None",
":",
"B",
"=",
"self",
".",
"_crear",
"(",
"c",
")",
"for",
"k",
"in",
"range",
"(",
"self",
".",
"_n",
")",
":",
"B",
"[",
"k",
"]",
"=",
"self",
".",
"_A",
"[",
"k",
"]",
"self",
".",
"_A",
"=",
"B",
"self",
".",
"_capacidad",
"=",
"c"
] | [
136,
4
] | [
146,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
mensajes_a_mostrar | () | return layout | Seccion Mensajes de victoria/derrota/y el tiempo a poner | Seccion Mensajes de victoria/derrota/y el tiempo a poner | def mensajes_a_mostrar():
""" Seccion Mensajes de victoria/derrota/y el tiempo a poner"""
layout = [
sg.Text('Mensajes a mostrar:', font=[theme.FONT, 12], background_color=theme.PRIMARY_COLOR_VARIANT, pad=(5, 6)),
sg.Checkbox('Victoria', default=True, k='-WIN_MSG-', font=[theme.FONT, 12],
background_color=theme.PRIMARY_COLOR_VARIANT, pad=(5, 6)),
sg.Checkbox('Derrota', default=True, k='-LOSE_MSG-', font=[theme.FONT, 12],
background_color=theme.PRIMARY_COLOR_VARIANT, pad=(5, 6)),
sg.Checkbox('Tiempo restante', default=True, k='-TIME_MSG-', font=[theme.FONT, 12],
background_color=theme.PRIMARY_COLOR_VARIANT, pad=(5, 6))
]
return layout | [
"def",
"mensajes_a_mostrar",
"(",
")",
":",
"layout",
"=",
"[",
"sg",
".",
"Text",
"(",
"'Mensajes a mostrar:'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Checkbox",
"(",
"'Victoria'",
",",
"default",
"=",
"True",
",",
"k",
"=",
"'-WIN_MSG-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Checkbox",
"(",
"'Derrota'",
",",
"default",
"=",
"True",
",",
"k",
"=",
"'-LOSE_MSG-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Checkbox",
"(",
"'Tiempo restante'",
",",
"default",
"=",
"True",
",",
"k",
"=",
"'-TIME_MSG-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
"]",
"return",
"layout"
] | [
7,
0
] | [
18,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ModelBase.get_create_history | (self) | Obtiene el registro historico correspondiente a la creación. | Obtiene el registro historico correspondiente a la creación. | def get_create_history(self):
"""Obtiene el registro historico correspondiente a la creación."""
history_qs = self.get_history()
if history_qs != None:
return history_qs.filter(history_type="+").first()
# Si no existe un historial, se intentará retornar un diccionario con
# los valores de create_user y create_date si existen.
elif hasattr(self, "create_user"):
return {
"history_user": self.create_user,
"history_date": getattr(self, "create_date", "")
} | [
"def",
"get_create_history",
"(",
"self",
")",
":",
"history_qs",
"=",
"self",
".",
"get_history",
"(",
")",
"if",
"history_qs",
"!=",
"None",
":",
"return",
"history_qs",
".",
"filter",
"(",
"history_type",
"=",
"\"+\"",
")",
".",
"first",
"(",
")",
"# Si no existe un historial, se intentará retornar un diccionario con ",
"# los valores de create_user y create_date si existen.",
"elif",
"hasattr",
"(",
"self",
",",
"\"create_user\"",
")",
":",
"return",
"{",
"\"history_user\"",
":",
"self",
".",
"create_user",
",",
"\"history_date\"",
":",
"getattr",
"(",
"self",
",",
"\"create_date\"",
",",
"\"\"",
")",
"}"
] | [
423,
4
] | [
435,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
MyDataset.get_norm_values | (self) | return self.mean, self.std | Usado para traspasar los valores de normalización de train a val/test
| Usado para traspasar los valores de normalización de train a val/test
| def get_norm_values(self):
''' Usado para traspasar los valores de normalización de train a val/test
'''
return self.mean, self.std | [
"def",
"get_norm_values",
"(",
"self",
")",
":",
"return",
"self",
".",
"mean",
",",
"self",
".",
"std"
] | [
46,
1
] | [
49,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ModelBase.to_json | (self) | return self.to_dict(to_json=True) | Obtiene un objeto tipo Json con los datos de los campos. | Obtiene un objeto tipo Json con los datos de los campos. | def to_json(self):
"""Obtiene un objeto tipo Json con los datos de los campos."""
return self.to_dict(to_json=True) | [
"def",
"to_json",
"(",
"self",
")",
":",
"return",
"self",
".",
"to_dict",
"(",
"to_json",
"=",
"True",
")"
] | [
375,
4
] | [
377,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AccountStatementMoveImportWizard.onchange | (self, values, field_name, field_onchange) | return super().onchange(values, field_name, field_onchange) | Necesitamos hacer esto porque los onchange que agregan lineas,
cuando se va a guardar el registro, terminan creando registros.
| Necesitamos hacer esto porque los onchange que agregan lineas,
cuando se va a guardar el registro, terminan creando registros.
| def onchange(self, values, field_name, field_onchange):
"""Necesitamos hacer esto porque los onchange que agregan lineas,
cuando se va a guardar el registro, terminan creando registros.
"""
fields = []
for field in field_onchange.keys():
if field.startswith(('move_line_ids.')):
fields.append(field)
for field in fields:
del field_onchange[field]
return super().onchange(values, field_name, field_onchange) | [
"def",
"onchange",
"(",
"self",
",",
"values",
",",
"field_name",
",",
"field_onchange",
")",
":",
"fields",
"=",
"[",
"]",
"for",
"field",
"in",
"field_onchange",
".",
"keys",
"(",
")",
":",
"if",
"field",
".",
"startswith",
"(",
"(",
"'move_line_ids.'",
")",
")",
":",
"fields",
".",
"append",
"(",
"field",
")",
"for",
"field",
"in",
"fields",
":",
"del",
"field_onchange",
"[",
"field",
"]",
"return",
"super",
"(",
")",
".",
"onchange",
"(",
"values",
",",
"field_name",
",",
"field_onchange",
")"
] | [
48,
4
] | [
58,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EAD.ajustar_directorio_final | (
self, nombre_archivo, lista_archivos_descomprimidos) | return lista_archivos_descomprimidos[0] | Ajusta el directorio final, de modo que todo quede dentro de un
directorio.
| Ajusta el directorio final, de modo que todo quede dentro de un
directorio.
| def ajustar_directorio_final(
self, nombre_archivo, lista_archivos_descomprimidos):
"""Ajusta el directorio final, de modo que todo quede dentro de un
directorio.
"""
if len(lista_archivos_descomprimidos) > 1:
return nombre_archivo
return lista_archivos_descomprimidos[0] | [
"def",
"ajustar_directorio_final",
"(",
"self",
",",
"nombre_archivo",
",",
"lista_archivos_descomprimidos",
")",
":",
"if",
"len",
"(",
"lista_archivos_descomprimidos",
")",
">",
"1",
":",
"return",
"nombre_archivo",
"return",
"lista_archivos_descomprimidos",
"[",
"0",
"]"
] | [
31,
4
] | [
40,
47
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_value_funcion | (t) | value : funcionesLlamada | value : funcionesLlamada | def p_value_funcion(t):
'value : funcionesLlamada'
t[0] = {'text': t[1]['text'], 'c3d' : t[1]['c3d'], 'select':t[1]['c3d'] } | [
"def",
"p_value_funcion",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"{",
"'text'",
":",
"t",
"[",
"1",
"]",
"[",
"'text'",
"]",
",",
"'c3d'",
":",
"t",
"[",
"1",
"]",
"[",
"'c3d'",
"]",
",",
"'select'",
":",
"t",
"[",
"1",
"]",
"[",
"'c3d'",
"]",
"}"
] | [
2294,
0
] | [
2296,
78
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
estimarPGC | (h, a, n, sexo) | return est | Estimación del PGC utilizando la fórmula del item M.
Args:
h (float): Altura en centímetros
a (float): Circunferencia abdominal en centímetros
n (float): Circunferencia del cuello en centímetros
sexo (string): 'M': Masculino ; 'F': Femenino
Returns:
float: PGC estimado
| Estimación del PGC utilizando la fórmula del item M. | def estimarPGC(h, a, n, sexo):
"""Estimación del PGC utilizando la fórmula del item M.
Args:
h (float): Altura en centímetros
a (float): Circunferencia abdominal en centímetros
n (float): Circunferencia del cuello en centímetros
sexo (string): 'M': Masculino ; 'F': Femenino
Returns:
float: PGC estimado
"""
est = 0
if sexo == 'M':
est = 10.1 - 0.239 * h + 0.8 * a - 0.5 * n
elif sexo == 'F':
est = 19.2 - 0.239 * h + 0.8 * a - 0.5 * n
return est | [
"def",
"estimarPGC",
"(",
"h",
",",
"a",
",",
"n",
",",
"sexo",
")",
":",
"est",
"=",
"0",
"if",
"sexo",
"==",
"'M'",
":",
"est",
"=",
"10.1",
"-",
"0.239",
"*",
"h",
"+",
"0.8",
"*",
"a",
"-",
"0.5",
"*",
"n",
"elif",
"sexo",
"==",
"'F'",
":",
"est",
"=",
"19.2",
"-",
"0.239",
"*",
"h",
"+",
"0.8",
"*",
"a",
"-",
"0.5",
"*",
"n",
"return",
"est"
] | [
278,
0
] | [
297,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
jsonRead | (path) | Abre un archivo JSON y devuelve los datos del archivo.
Argumentos:
path (str): Ruta relativa hacia el archivo.
Returns:
data (Any): Datos contenidos en el JSON.
| Abre un archivo JSON y devuelve los datos del archivo. | def jsonRead(path):
"""Abre un archivo JSON y devuelve los datos del archivo.
Argumentos:
path (str): Ruta relativa hacia el archivo.
Returns:
data (Any): Datos contenidos en el JSON.
"""
with open(path) as json_file:
try:
data = json.load(json_file)
# pprint(data)
return data
except FileNotFoundError:
print('\nArchivo JSON no encontrado.') | [
"def",
"jsonRead",
"(",
"path",
")",
":",
"with",
"open",
"(",
"path",
")",
"as",
"json_file",
":",
"try",
":",
"data",
"=",
"json",
".",
"load",
"(",
"json_file",
")",
"# pprint(data)",
"return",
"data",
"except",
"FileNotFoundError",
":",
"print",
"(",
"'\\nArchivo JSON no encontrado.'",
")"
] | [
155,
0
] | [
169,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
mostrar | (texto: List[str]) | Muestra linea por linea el texto con un retardo de 1.5 segundos
:param texto: Lista de líneas del texto
:texto type: List[str]
| Muestra linea por linea el texto con un retardo de 1.5 segundos | def mostrar(texto: List[str]) -> None:
"""Muestra linea por linea el texto con un retardo de 1.5 segundos
:param texto: Lista de líneas del texto
:texto type: List[str]
"""
for linea in texto:
print(linea, end="\n", flush=True)
sleep(1.5) | [
"def",
"mostrar",
"(",
"texto",
":",
"List",
"[",
"str",
"]",
")",
"->",
"None",
":",
"for",
"linea",
"in",
"texto",
":",
"print",
"(",
"linea",
",",
"end",
"=",
"\"\\n\"",
",",
"flush",
"=",
"True",
")",
"sleep",
"(",
"1.5",
")"
] | [
28,
0
] | [
36,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Simulador.temperatura_exterior | (self) | return uniform(-54.15, -54.05) | Temperatura en el exterior del avión
en grados Celsius.
| Temperatura en el exterior del avión
en grados Celsius.
| def temperatura_exterior(self):
"""Temperatura en el exterior del avión
en grados Celsius.
"""
return uniform(-54.15, -54.05) | [
"def",
"temperatura_exterior",
"(",
"self",
")",
":",
"return",
"uniform",
"(",
"-",
"54.15",
",",
"-",
"54.05",
")"
] | [
105,
4
] | [
109,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
obtener_pais | (codigo: str) | Obtiene el nombre del país a partir del código.
:param codigo: Código del país.
:codigo type: str
:return: Nombre del país.
:rtype: str
| Obtiene el nombre del país a partir del código.
:param codigo: Código del país.
:codigo type: str
:return: Nombre del país.
:rtype: str
| def obtener_pais(codigo: str) -> str:
"""Obtiene el nombre del país a partir del código.
:param codigo: Código del país.
:codigo type: str
:return: Nombre del país.
:rtype: str
"""
url = f"https://restcountries.com/v3/alpha/{codigo}"
response = requests.get(url)
if response.status_code == 200:
data = response.json()
return data[0]["name"]["nativeName"]["spa"]["official"]
else:
return "No se encontró el país" | [
"def",
"obtener_pais",
"(",
"codigo",
":",
"str",
")",
"->",
"str",
":",
"url",
"=",
"f\"https://restcountries.com/v3/alpha/{codigo}\"",
"response",
"=",
"requests",
".",
"get",
"(",
"url",
")",
"if",
"response",
".",
"status_code",
"==",
"200",
":",
"data",
"=",
"response",
".",
"json",
"(",
")",
"return",
"data",
"[",
"0",
"]",
"[",
"\"name\"",
"]",
"[",
"\"nativeName\"",
"]",
"[",
"\"spa\"",
"]",
"[",
"\"official\"",
"]",
"else",
":",
"return",
"\"No se encontró el país\""
] | [
23,
0
] | [
37,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Estante.__setitem__ | (self, clave, valor) | Asigna un valor a una clave en el archivo shelve. | Asigna un valor a una clave en el archivo shelve. | def __setitem__(self, clave, valor):
"""Asigna un valor a una clave en el archivo shelve."""
self.dic[clave] = valor | [
"def",
"__setitem__",
"(",
"self",
",",
"clave",
",",
"valor",
")",
":",
"self",
".",
"dic",
"[",
"clave",
"]",
"=",
"valor"
] | [
33,
4
] | [
35,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
CajeroHandler.handle | (cantidad) | Manejar el evento | Manejar el evento | def handle(cantidad):
""" Manejar el evento """ | [
"def",
"handle",
"(",
"cantidad",
")",
":"
] | [
11,
4
] | [
12,
33
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
autenticador | (username, password) | return None | Funcion encargado en mi JWT de validar las credenciales si estas son ingresadas correctamente (si hacen match con algun usuario | Funcion encargado en mi JWT de validar las credenciales si estas son ingresadas correctamente (si hacen match con algun usuario | def autenticador(username, password):
"""Funcion encargado en mi JWT de validar las credenciales si estas son ingresadas correctamente (si hacen match con algun usuario"""
if username and password:
usuario = db.session.query(
UsuarioModel).filter_by(usuarioCorreo=username).first()
if usuario:
if checkpw(bytes(password, 'utf-8'), bytes(usuario.usuarioPassword, 'utf-8')):
return Usuario(usuario.usuarioId, usuario.usuarioCorreo)
return None | [
"def",
"autenticador",
"(",
"username",
",",
"password",
")",
":",
"if",
"username",
"and",
"password",
":",
"usuario",
"=",
"db",
".",
"session",
".",
"query",
"(",
"UsuarioModel",
")",
".",
"filter_by",
"(",
"usuarioCorreo",
"=",
"username",
")",
".",
"first",
"(",
")",
"if",
"usuario",
":",
"if",
"checkpw",
"(",
"bytes",
"(",
"password",
",",
"'utf-8'",
")",
",",
"bytes",
"(",
"usuario",
".",
"usuarioPassword",
",",
"'utf-8'",
")",
")",
":",
"return",
"Usuario",
"(",
"usuario",
".",
"usuarioId",
",",
"usuario",
".",
"usuarioCorreo",
")",
"return",
"None"
] | [
14,
0
] | [
22,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
test_listLabels | (setup) | Comprobar las columnas que sean category. | Comprobar las columnas que sean category. | def test_listLabels(setup):
"""Comprobar las columnas que sean category."""
with patch.object(Residential, "__init__", lambda x, y: None):
resi = Residential(None)
resi.cfg = setup
frame = extractor.xls(
dir_path=resi.cfg.path.input,
data_extension=resi.cfg.data_extension)
resi.df = frame[resi.cfg.excel_name][resi.cfg.df_name]
resi.listLabels()
assert len(resi.labels) == 30 | [
"def",
"test_listLabels",
"(",
"setup",
")",
":",
"with",
"patch",
".",
"object",
"(",
"Residential",
",",
"\"__init__\"",
",",
"lambda",
"x",
",",
"y",
":",
"None",
")",
":",
"resi",
"=",
"Residential",
"(",
"None",
")",
"resi",
".",
"cfg",
"=",
"setup",
"frame",
"=",
"extractor",
".",
"xls",
"(",
"dir_path",
"=",
"resi",
".",
"cfg",
".",
"path",
".",
"input",
",",
"data_extension",
"=",
"resi",
".",
"cfg",
".",
"data_extension",
")",
"resi",
".",
"df",
"=",
"frame",
"[",
"resi",
".",
"cfg",
".",
"excel_name",
"]",
"[",
"resi",
".",
"cfg",
".",
"df_name",
"]",
"resi",
".",
"listLabels",
"(",
")",
"assert",
"len",
"(",
"resi",
".",
"labels",
")",
"==",
"30"
] | [
121,
0
] | [
133,
37
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
EstimationResults.__len__ | (self) | return len(self._estimations_results) | Cantidad de estimaciones resultantes.
| Cantidad de estimaciones resultantes.
| def __len__(self) -> int:
"""Cantidad de estimaciones resultantes.
"""
return len(self._estimations_results) | [
"def",
"__len__",
"(",
"self",
")",
"->",
"int",
":",
"return",
"len",
"(",
"self",
".",
"_estimations_results",
")"
] | [
88,
4
] | [
91,
45
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
saltando_rocas | () | Mínimo número de saltos en las rocas
Esta función hace parte de un juego en el que el jugador debe cruzar un río
saltando de roca en roca hasta llegar al otro lado. Hay dos tipo de rocas,
secas y húmedas, y el jugador debe evitar saltar encima de las húmedas para
no resbalarse y caer. Además el jugador puede saltar 1 o 2 rocas, siempre y
cuando no caiga en una húmeda.
Esta función debe recibir como argumento una lista de ceros y unos. Los ceros
representan las rocas secas y los unos las húmedas.
El objetivo es devolver el número mínimo de saltos que debe realizar el
jugador para ganar la partida
| Mínimo número de saltos en las rocas | def saltando_rocas():
'''Mínimo número de saltos en las rocas
Esta función hace parte de un juego en el que el jugador debe cruzar un río
saltando de roca en roca hasta llegar al otro lado. Hay dos tipo de rocas,
secas y húmedas, y el jugador debe evitar saltar encima de las húmedas para
no resbalarse y caer. Además el jugador puede saltar 1 o 2 rocas, siempre y
cuando no caiga en una húmeda.
Esta función debe recibir como argumento una lista de ceros y unos. Los ceros
representan las rocas secas y los unos las húmedas.
El objetivo es devolver el número mínimo de saltos que debe realizar el
jugador para ganar la partida
'''
pass | [
"def",
"saltando_rocas",
"(",
")",
":",
"pass"
] | [
45,
0
] | [
59,
8
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_Bom_Production._compute_real_cost | (self) | Calcula el costo real a partir de los productos presentes en 'move_raw_ids' y las cantidades digitadas por el usuario. | Calcula el costo real a partir de los productos presentes en 'move_raw_ids' y las cantidades digitadas por el usuario. | def _compute_real_cost(self):
""" Calcula el costo real a partir de los productos presentes en 'move_raw_ids' y las cantidades digitadas por el usuario. """
for record in self:
real_cost = sum(product.product_uom_qty * product.product_id.standard_price for product in record.move_raw_ids)
record.total_real_cost = real_cost | [
"def",
"_compute_real_cost",
"(",
"self",
")",
":",
"for",
"record",
"in",
"self",
":",
"real_cost",
"=",
"sum",
"(",
"product",
".",
"product_uom_qty",
"*",
"product",
".",
"product_id",
".",
"standard_price",
"for",
"product",
"in",
"record",
".",
"move_raw_ids",
")",
"record",
".",
"total_real_cost",
"=",
"real_cost"
] | [
228,
4
] | [
232,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones4 | (t) | instruccion : CREATE FUNCTION IDENTIFICADOR PAR1 listid PAR2 RETURNS listid AS DOLLAR DOLLAR DECLARE declaraciones BEGIN contenidosbegin END PYC DOLLAR DOLLAR LANGUAGE IDENTIFICADOR PYC | instruccion : CREATE FUNCTION IDENTIFICADOR PAR1 listid PAR2 RETURNS listid AS DOLLAR DOLLAR DECLARE declaraciones BEGIN contenidosbegin END PYC DOLLAR DOLLAR LANGUAGE IDENTIFICADOR PYC | def p_funciones4(t):
'''instruccion : CREATE FUNCTION IDENTIFICADOR PAR1 listid PAR2 RETURNS listid AS DOLLAR DOLLAR DECLARE declaraciones BEGIN contenidosbegin END PYC DOLLAR DOLLAR LANGUAGE IDENTIFICADOR PYC'''
instru = grammer.nodoGramatical('instruccion')
instru.agregarDetalle('::= CREATE FUNCTION IDENTIFICADOR PAR1 listid PAR2 RETURNS listid AS DOLLAR DOLLAR DECLARE declaraciones BEGIN contenidosbegin END PYC DOLLAR DOLLAR LANGUAGE IDENTIFICADOR PYC')
listGrammer.insert(0,instru) | [
"def",
"p_funciones4",
"(",
"t",
")",
":",
"instru",
"=",
"grammer",
".",
"nodoGramatical",
"(",
"'instruccion'",
")",
"instru",
".",
"agregarDetalle",
"(",
"'::= CREATE FUNCTION IDENTIFICADOR PAR1 listid PAR2 RETURNS listid AS DOLLAR DOLLAR DECLARE declaraciones BEGIN contenidosbegin END PYC DOLLAR DOLLAR LANGUAGE IDENTIFICADOR PYC'",
")",
"listGrammer",
".",
"insert",
"(",
"0",
",",
"instru",
")"
] | [
80,
0
] | [
84,
32
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
printTable | (encabezado, datos) | Imprime una tabla utilizando tabulate, con dos decimales.
Args:
encabezado (list): Títulos para los encabezados
datos (list / dict): Contenido de la tabla
| Imprime una tabla utilizando tabulate, con dos decimales. | def printTable(encabezado, datos):
"""Imprime una tabla utilizando tabulate, con dos decimales.
Args:
encabezado (list): Títulos para los encabezados
datos (list / dict): Contenido de la tabla
"""
print(
tabulate(datos, # Datos para completar la tabla
headers=encabezado, # Encabezados de la tabla
tablefmt='presto', # Hacemos que se vea más bonita
floatfmt=".2f") # Redondeo a 2 decimales
) | [
"def",
"printTable",
"(",
"encabezado",
",",
"datos",
")",
":",
"print",
"(",
"tabulate",
"(",
"datos",
",",
"# Datos para completar la tabla",
"headers",
"=",
"encabezado",
",",
"# Encabezados de la tabla",
"tablefmt",
"=",
"'presto'",
",",
"# Hacemos que se vea más bonita",
"floatfmt",
"=",
"\".2f\"",
")",
"# Redondeo a 2 decimales",
")"
] | [
94,
0
] | [
106,
5
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
s3_login2 | (bot: DeltaBot, payload: str, message: Message, replies: Replies) | Iniciar sessión con tu número de teléfono y contraseña. Ejemplo: /s3_login2 5355555 ay21XjB8i7Uyz | Iniciar sessión con tu número de teléfono y contraseña. Ejemplo: /s3_login2 5355555 ay21XjB8i7Uyz | def s3_login2(bot: DeltaBot, payload: str, message: Message, replies: Replies) -> None:
"""Iniciar sessión con tu número de teléfono y contraseña. Ejemplo: /s3_login2 5355555 ay21XjB8i7Uyz"""
addr = message.get_sender_contact().addr
acc = db.get_account(addr)
if acc:
replies.add(
text="❌ Ya estás registrado, debes darte baja primero con /s3_logout"
)
return
def task():
replies = Replies(message, logger=bot.logger)
try:
phone, password = payload.rsplit(maxsplit=1)
phone = parse_phone(phone)
ToDusClient().login(phone, password)
db.add_account(addr, phone, password)
replies.add(
text=f"☑️ Tu cuenta ha sido verificada! ya puedes comenzar a pedir contenido.\n\nContraseña:\n{password}"
)
except Exception as ex:
bot.logger.exception(ex)
replies.add(
text=f"❌ Ocurrió un error, verifica que pusiste el número y contraseña correctamente. {ex}"
)
replies.send_reply_messages()
Thread(target=task).start() | [
"def",
"s3_login2",
"(",
"bot",
":",
"DeltaBot",
",",
"payload",
":",
"str",
",",
"message",
":",
"Message",
",",
"replies",
":",
"Replies",
")",
"->",
"None",
":",
"addr",
"=",
"message",
".",
"get_sender_contact",
"(",
")",
".",
"addr",
"acc",
"=",
"db",
".",
"get_account",
"(",
"addr",
")",
"if",
"acc",
":",
"replies",
".",
"add",
"(",
"text",
"=",
"\"❌ Ya estás registrado, debes darte baja primero con /s3_logout\"",
")",
"return",
"def",
"task",
"(",
")",
":",
"replies",
"=",
"Replies",
"(",
"message",
",",
"logger",
"=",
"bot",
".",
"logger",
")",
"try",
":",
"phone",
",",
"password",
"=",
"payload",
".",
"rsplit",
"(",
"maxsplit",
"=",
"1",
")",
"phone",
"=",
"parse_phone",
"(",
"phone",
")",
"ToDusClient",
"(",
")",
".",
"login",
"(",
"phone",
",",
"password",
")",
"db",
".",
"add_account",
"(",
"addr",
",",
"phone",
",",
"password",
")",
"replies",
".",
"add",
"(",
"text",
"=",
"f\"☑️ Tu cuenta ha sido verificada! ya puedes comenzar a pedir contenido.\\n\\nContraseña:\\n{password}\"",
")",
"except",
"Exception",
"as",
"ex",
":",
"bot",
".",
"logger",
".",
"exception",
"(",
"ex",
")",
"replies",
".",
"add",
"(",
"text",
"=",
"f\"❌ Ocurrió un error, verifica que pusiste el número y contraseña correctamente. {ex}\"",
")",
"replies",
".",
"send_reply_messages",
"(",
")",
"Thread",
"(",
"target",
"=",
"task",
")",
".",
"start",
"(",
")"
] | [
125,
0
] | [
152,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BCRALiborScraper.rates_config_validator | (self, parsed, rates) | Valida que parsed exista dentro de
los valores de rates en el archivo de
configuración
Parameters
----------
parsed : String
String con la clave correspondiente al plazo en días
rates : Dict
Diccionario que contiene los plazos en días de la tasa Libor
| Valida que parsed exista dentro de
los valores de rates en el archivo de
configuración | def rates_config_validator(self, parsed, rates):
"""Valida que parsed exista dentro de
los valores de rates en el archivo de
configuración
Parameters
----------
parsed : String
String con la clave correspondiente al plazo en días
rates : Dict
Diccionario que contiene los plazos en días de la tasa Libor
"""
if f'libor_{parsed}_dias' in rates.values():
return True
else:
raise InvalidConfigurationError(
f'La clave libor_{parsed}_dias ' +
'no se encuentra en el archivo de config'
) | [
"def",
"rates_config_validator",
"(",
"self",
",",
"parsed",
",",
"rates",
")",
":",
"if",
"f'libor_{parsed}_dias'",
"in",
"rates",
".",
"values",
"(",
")",
":",
"return",
"True",
"else",
":",
"raise",
"InvalidConfigurationError",
"(",
"f'La clave libor_{parsed}_dias '",
"+",
"'no se encuentra en el archivo de config'",
")"
] | [
233,
4
] | [
251,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TransactionViewSet.create | (self, request, *args, **kwargs) | Crea una transaccion donde un usuario envía dinero a otro usuario | Crea una transaccion donde un usuario envía dinero a otro usuario | def create(self, request, *args, **kwargs):
"""Crea una transaccion donde un usuario envía dinero a otro usuario"""
serializer = TransactionSerializer(data=request.data)
if serializer.is_valid():
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)
else:
return Response({"errors": (serializer.errors,)}, status=status.HTTP_400_BAD_REQUEST) | [
"def",
"create",
"(",
"self",
",",
"request",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"serializer",
"=",
"TransactionSerializer",
"(",
"data",
"=",
"request",
".",
"data",
")",
"if",
"serializer",
".",
"is_valid",
"(",
")",
":",
"self",
".",
"perform_create",
"(",
"serializer",
")",
"headers",
"=",
"self",
".",
"get_success_headers",
"(",
"serializer",
".",
"data",
")",
"return",
"Response",
"(",
"serializer",
".",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_201_CREATED",
",",
"headers",
"=",
"headers",
")",
"else",
":",
"return",
"Response",
"(",
"{",
"\"errors\"",
":",
"(",
"serializer",
".",
"errors",
",",
")",
"}",
",",
"status",
"=",
"status",
".",
"HTTP_400_BAD_REQUEST",
")"
] | [
32,
4
] | [
40,
97
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Hasar2GenComandos.openDrawer | (self) | return self.conector.sendCommand( jdata ) | Abrir cajón del dinero - No es mandatory implementarlo | Abrir cajón del dinero - No es mandatory implementarlo | def openDrawer(self):
"""Abrir cajón del dinero - No es mandatory implementarlo"""
jdata = {"AbrirCajonDinero" : {}}
return self.conector.sendCommand( jdata ) | [
"def",
"openDrawer",
"(",
"self",
")",
":",
"jdata",
"=",
"{",
"\"AbrirCajonDinero\"",
":",
"{",
"}",
"}",
"return",
"self",
".",
"conector",
".",
"sendCommand",
"(",
"jdata",
")"
] | [
509,
1
] | [
513,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_files_and_path | (path: str) | return leaked_files, cwd | Función para obtener la lista de los archivos en el directorio,
que le indiquen y filtrar por archivos XML.
Args:
path (str): Recibe la ruta absoluta del directorio en donde están,
los archivos.
Returns:
tuple: Retorna la lista con los archivos XML y la ruta completa en donde,
están los archivos.
| Función para obtener la lista de los archivos en el directorio,
que le indiquen y filtrar por archivos XML. | def get_files_and_path(path: str) -> tuple:
""" Función para obtener la lista de los archivos en el directorio,
que le indiquen y filtrar por archivos XML.
Args:
path (str): Recibe la ruta absoluta del directorio en donde están,
los archivos.
Returns:
tuple: Retorna la lista con los archivos XML y la ruta completa en donde,
están los archivos.
"""
os.chdir(path)
cwd: str = os.getcwd()
list_files: list = os.listdir(cwd)
leaked_files: list = [value for value in list_files if value.endswith(".xml")]
return leaked_files, cwd | [
"def",
"get_files_and_path",
"(",
"path",
":",
"str",
")",
"->",
"tuple",
":",
"os",
".",
"chdir",
"(",
"path",
")",
"cwd",
":",
"str",
"=",
"os",
".",
"getcwd",
"(",
")",
"list_files",
":",
"list",
"=",
"os",
".",
"listdir",
"(",
"cwd",
")",
"leaked_files",
":",
"list",
"=",
"[",
"value",
"for",
"value",
"in",
"list_files",
"if",
"value",
".",
"endswith",
"(",
"\".xml\"",
")",
"]",
"return",
"leaked_files",
",",
"cwd"
] | [
75,
0
] | [
91,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Override_Bom_Production._compute_std_cost | (self) | Calcula el costo estándar a partir de los productos presentes en 'move_raw_ids'. | Calcula el costo estándar a partir de los productos presentes en 'move_raw_ids'. | def _compute_std_cost(self):
""" Calcula el costo estándar a partir de los productos presentes en 'move_raw_ids'. """
for record in self:
std_cost = sum(product.std_quantity * product.product_id.standard_price for product in record.move_raw_ids)
record.total_std_cost = std_cost | [
"def",
"_compute_std_cost",
"(",
"self",
")",
":",
"for",
"record",
"in",
"self",
":",
"std_cost",
"=",
"sum",
"(",
"product",
".",
"std_quantity",
"*",
"product",
".",
"product_id",
".",
"standard_price",
"for",
"product",
"in",
"record",
".",
"move_raw_ids",
")",
"record",
".",
"total_std_cost",
"=",
"std_cost"
] | [
214,
4
] | [
218,
44
] | 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.