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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
InstantaneousVelocity.calculate_velocities | (self, tracked_object: TrackedObject) | return v | Realiza el cálculo de las velocidades en cada instante que fue detectado el objeto.
La unidad de medida de las velocidades vendrá determinada por la introducida al instanciar
el modelo con el parámetro `units`.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
| Realiza el cálculo de las velocidades en cada instante que fue detectado el objeto. | def calculate_velocities(self, tracked_object: TrackedObject) -> List[FloatVector2D]:
"""Realiza el cálculo de las velocidades en cada instante que fue detectado el objeto.
La unidad de medida de las velocidades vendrá determinada por la introducida al instanciar
el modelo con el parámetro `units`.
:param tracked_object: seguimiento del objeto.
:return: lista de las velocidades en cada instante.
"""
# Desempaquetar información.
frames, detections = tracked_object.frames, tracked_object.detections
positions_pixels = [self.get_object_point(detection) for detection in detections]
# Convertir a las unidades deseadas.
positions = [self.convert_distance_vector_from_pixels(FloatVector2D(*p))
for p in positions_pixels]
instants = [self.convert_time_from_frames(t) for t in frames]
# Cálculo de las velocidades.
dx = np.diff(np.array(positions), axis=0)
dt = np.diff(np.array(instants))
v = [FloatVector2D(*dx[i] / dt[i]) for i in range(len(dx))]
# Puesto que las velocidades son vectores, y la imagen tiene el eje Y al revés, para
# estandarizarlo, cambiar el sentido del vector
v = v * np.array([1., -1.])
return v | [
"def",
"calculate_velocities",
"(",
"self",
",",
"tracked_object",
":",
"TrackedObject",
")",
"->",
"List",
"[",
"FloatVector2D",
"]",
":",
"# Desempaquetar información.",
"frames",
",",
"detections",
"=",
"tracked_object",
".",
"frames",
",",
"tracked_object",
".",
"detections",
"positions_pixels",
"=",
"[",
"self",
".",
"get_object_point",
"(",
"detection",
")",
"for",
"detection",
"in",
"detections",
"]",
"# Convertir a las unidades deseadas.",
"positions",
"=",
"[",
"self",
".",
"convert_distance_vector_from_pixels",
"(",
"FloatVector2D",
"(",
"*",
"p",
")",
")",
"for",
"p",
"in",
"positions_pixels",
"]",
"instants",
"=",
"[",
"self",
".",
"convert_time_from_frames",
"(",
"t",
")",
"for",
"t",
"in",
"frames",
"]",
"# Cálculo de las velocidades.",
"dx",
"=",
"np",
".",
"diff",
"(",
"np",
".",
"array",
"(",
"positions",
")",
",",
"axis",
"=",
"0",
")",
"dt",
"=",
"np",
".",
"diff",
"(",
"np",
".",
"array",
"(",
"instants",
")",
")",
"v",
"=",
"[",
"FloatVector2D",
"(",
"*",
"dx",
"[",
"i",
"]",
"/",
"dt",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"dx",
")",
")",
"]",
"# Puesto que las velocidades son vectores, y la imagen tiene el eje Y al revés, para",
"# estandarizarlo, cambiar el sentido del vector",
"v",
"=",
"v",
"*",
"np",
".",
"array",
"(",
"[",
"1.",
",",
"-",
"1.",
"]",
")",
"return",
"v"
] | [
14,
4
] | [
37,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackedObject.__getitem__ | (self, item: int) | return TrackedObjectDetection(id=self.id,
frame=self.frames[item],
object=self.detections[item]) | Devuelve el frame y la detección del objeto registrada.
:param item: posición del registro del objeto.
:return: tupla del frame y detección del objeto.
| Devuelve el frame y la detección del objeto registrada. | def __getitem__(self, item: int) -> TrackedObjectDetection:
"""Devuelve el frame y la detección del objeto registrada.
:param item: posición del registro del objeto.
:return: tupla del frame y detección del objeto.
"""
if item >= len(self):
raise IndexError(f'El índice {item} no está registrado para el objeto {self.id}')
return TrackedObjectDetection(id=self.id,
frame=self.frames[item],
object=self.detections[item]) | [
"def",
"__getitem__",
"(",
"self",
",",
"item",
":",
"int",
")",
"->",
"TrackedObjectDetection",
":",
"if",
"item",
">=",
"len",
"(",
"self",
")",
":",
"raise",
"IndexError",
"(",
"f'El índice {item} no está registrado para el objeto {self.id}')",
"",
"return",
"TrackedObjectDetection",
"(",
"id",
"=",
"self",
".",
"id",
",",
"frame",
"=",
"self",
".",
"frames",
"[",
"item",
"]",
",",
"object",
"=",
"self",
".",
"detections",
"[",
"item",
"]",
")"
] | [
38,
4
] | [
48,
67
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Sequence.length | (self) | return len(self.seq) | Obtiene la longitud de la secuencia | Obtiene la longitud de la secuencia | def length(self):
"""Obtiene la longitud de la secuencia"""
return len(self.seq) | [
"def",
"length",
"(",
"self",
")",
":",
"return",
"len",
"(",
"self",
".",
"seq",
")"
] | [
54,
4
] | [
56,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UnmaskingCurvePlotter.ylim | (self) | return self._ylim | Get y axis limits | Get y axis limits | def ylim(self):
"""Get y axis limits"""
return self._ylim | [
"def",
"ylim",
"(",
"self",
")",
":",
"return",
"self",
".",
"_ylim"
] | [
569,
4
] | [
571,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ArregloDinamico.pop | (self) | return r | Remueve el ultimo elemento del arreglo
:return: el ultimo elemento del arreglo
| Remueve el ultimo elemento del arreglo | def pop(self) -> py_object:
"""Remueve el ultimo elemento del arreglo
:return: el ultimo elemento del arreglo
"""
if self._n < 1:
return None
r = self._A[self._n - 1]
for i in range(self._n - 1):
self._A[i] = self._A[i + 1]
self._n -= 1
self._reducir()
return r | [
"def",
"pop",
"(",
"self",
")",
"->",
"py_object",
":",
"if",
"self",
".",
"_n",
"<",
"1",
":",
"return",
"None",
"r",
"=",
"self",
".",
"_A",
"[",
"self",
".",
"_n",
"-",
"1",
"]",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"_n",
"-",
"1",
")",
":",
"self",
".",
"_A",
"[",
"i",
"]",
"=",
"self",
".",
"_A",
"[",
"i",
"+",
"1",
"]",
"self",
".",
"_n",
"-=",
"1",
"self",
".",
"_reducir",
"(",
")",
"return",
"r"
] | [
113,
4
] | [
125,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
project_info | (request) | return {'PROJECT_NAME': settings.NAME, 'ORG_NAME': settings.ORG_NAME,
'COLABS': settings.COLABS, 'LINKS': settings.LINKS,
'META_DESC': settings.META_DESC, 'YEAR': current_year,
'BANNER': banner_path} | **Configura variables de entorno con información del proyecto**
La información que se establece es *nombre*, *nombre de la organización*,
*colaboradoras* y *redes sociales*. Las últimas dos son listas de python.
| **Configura variables de entorno con información del proyecto** | def project_info(request):
"""**Configura variables de entorno con información del proyecto**
La información que se establece es *nombre*, *nombre de la organización*,
*colaboradoras* y *redes sociales*. Las últimas dos son listas de python.
"""
current_year = date.today().year
banner_path = os.path.join(settings.STATICFILES_DIRS[0],
'user/img/banner.png')
if os.path.isfile(banner_path):
banner_path = 'user/img/banner.png'
else:
banner_path = 'img/banner.png'
return {'PROJECT_NAME': settings.NAME, 'ORG_NAME': settings.ORG_NAME,
'COLABS': settings.COLABS, 'LINKS': settings.LINKS,
'META_DESC': settings.META_DESC, 'YEAR': current_year,
'BANNER': banner_path} | [
"def",
"project_info",
"(",
"request",
")",
":",
"current_year",
"=",
"date",
".",
"today",
"(",
")",
".",
"year",
"banner_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"settings",
".",
"STATICFILES_DIRS",
"[",
"0",
"]",
",",
"'user/img/banner.png'",
")",
"if",
"os",
".",
"path",
".",
"isfile",
"(",
"banner_path",
")",
":",
"banner_path",
"=",
"'user/img/banner.png'",
"else",
":",
"banner_path",
"=",
"'img/banner.png'",
"return",
"{",
"'PROJECT_NAME'",
":",
"settings",
".",
"NAME",
",",
"'ORG_NAME'",
":",
"settings",
".",
"ORG_NAME",
",",
"'COLABS'",
":",
"settings",
".",
"COLABS",
",",
"'LINKS'",
":",
"settings",
".",
"LINKS",
",",
"'META_DESC'",
":",
"settings",
".",
"META_DESC",
",",
"'YEAR'",
":",
"current_year",
",",
"'BANNER'",
":",
"banner_path",
"}"
] | [
25,
0
] | [
41,
34
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
TrackingVideo.get_property | (self, property_: TrackingVideoProperty) | return self._properties.get(property_) | Devuelve el valor de una propiedad. Si no se encuentra, devuelve None.
:param property_: propiedad.
:return: valor de la propiedad o None si no existe.
| Devuelve el valor de una propiedad. Si no se encuentra, devuelve None. | def get_property(self, property_: TrackingVideoProperty) -> Any:
"""Devuelve el valor de una propiedad. Si no se encuentra, devuelve None.
:param property_: propiedad.
:return: valor de la propiedad o None si no existe.
"""
return self._properties.get(property_) | [
"def",
"get_property",
"(",
"self",
",",
"property_",
":",
"TrackingVideoProperty",
")",
"->",
"Any",
":",
"return",
"self",
".",
"_properties",
".",
"get",
"(",
"property_",
")"
] | [
342,
4
] | [
348,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AdministrativosTest.test_especialidades_permitidas_form_turno | (self) | Usuario `administrativo1` solamente puede agregar turnos de
Especialidades en Centros de Salud permitidos | Usuario `administrativo1` solamente puede agregar turnos de
Especialidades en Centros de Salud permitidos | def test_especialidades_permitidas_form_turno(self):
''' Usuario `administrativo1` solamente puede agregar turnos de
Especialidades en Centros de Salud permitidos '''
self.client.login(username=self.user_admin_1, password=self.user_admin_1)
# Instanciar el formulario de Turnos para nuestro usuario
form = TurnoForm(user=self.user_admin_1)
# Obtener la especialidad (Servicio de un centro de salud)
# permitida para este usuario
# El método get() devuelve un error si existe más de 1 objeto
servicio = form.fields['servicio'].queryset.get()
# El usuario administrativo1 solo puede agendar turnos
# de especialidades del CS 1 que es el que tiene asignado
self.assertEqual(servicio.centro.nombre, 'Centro de Salud 1')
self.assertEqual(servicio.especialidad.nombre, 'Especialidad 1') | [
"def",
"test_especialidades_permitidas_form_turno",
"(",
"self",
")",
":",
"self",
".",
"client",
".",
"login",
"(",
"username",
"=",
"self",
".",
"user_admin_1",
",",
"password",
"=",
"self",
".",
"user_admin_1",
")",
"# Instanciar el formulario de Turnos para nuestro usuario",
"form",
"=",
"TurnoForm",
"(",
"user",
"=",
"self",
".",
"user_admin_1",
")",
"# Obtener la especialidad (Servicio de un centro de salud) ",
"# permitida para este usuario",
"# El método get() devuelve un error si existe más de 1 objeto",
"servicio",
"=",
"form",
".",
"fields",
"[",
"'servicio'",
"]",
".",
"queryset",
".",
"get",
"(",
")",
"# El usuario administrativo1 solo puede agendar turnos",
"# de especialidades del CS 1 que es el que tiene asignado",
"self",
".",
"assertEqual",
"(",
"servicio",
".",
"centro",
".",
"nombre",
",",
"'Centro de Salud 1'",
")",
"self",
".",
"assertEqual",
"(",
"servicio",
".",
"especialidad",
".",
"nombre",
",",
"'Especialidad 1'",
")"
] | [
52,
4
] | [
70,
72
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackedObjects.tracked_objects | (self) | return self._tracked_objects | Devuelve la lista de objetos seguidos.
:return: lista de objetos seguidos.
| Devuelve la lista de objetos seguidos. | def tracked_objects(self) -> List[TrackedObject]:
"""Devuelve la lista de objetos seguidos.
:return: lista de objetos seguidos.
"""
return self._tracked_objects | [
"def",
"tracked_objects",
"(",
"self",
")",
"->",
"List",
"[",
"TrackedObject",
"]",
":",
"return",
"self",
".",
"_tracked_objects"
] | [
265,
4
] | [
270,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_window_range | (ts, label, file_pos) | return win_sta, win_end | Devuelve las ventanas donde empieza y termina el sismo | Devuelve las ventanas donde empieza y termina el sismo | def get_window_range(ts, label, file_pos):
"Devuelve las ventanas donde empieza y termina el sismo"
# Se calcula los segundos del archivo en que comienza y termina el sismo
sec_sta = label['tiempo_inicio'] - ts.dates[file_pos]
sec_end = label['tiempo_final'] - ts.dates[file_pos]
# En base a los segundos donde empieza y termina el sismo,
# se calcula la ventana inicial y final del sismo
win_sta = sec_sta // ts.step
win_end = sec_end // ts.step
return win_sta, win_end | [
"def",
"get_window_range",
"(",
"ts",
",",
"label",
",",
"file_pos",
")",
":",
"# Se calcula los segundos del archivo en que comienza y termina el sismo",
"sec_sta",
"=",
"label",
"[",
"'tiempo_inicio'",
"]",
"-",
"ts",
".",
"dates",
"[",
"file_pos",
"]",
"sec_end",
"=",
"label",
"[",
"'tiempo_final'",
"]",
"-",
"ts",
".",
"dates",
"[",
"file_pos",
"]",
"# En base a los segundos donde empieza y termina el sismo,",
"# se calcula la ventana inicial y final del sismo",
"win_sta",
"=",
"sec_sta",
"//",
"ts",
".",
"step",
"win_end",
"=",
"sec_end",
"//",
"ts",
".",
"step",
"return",
"win_sta",
",",
"win_end"
] | [
170,
0
] | [
182,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Loan.get_interest_payment | (self) | return int((self.balance_cop * self.interest) / 100) | Obtiene el pago del interes mensual del prestamo
| Obtiene el pago del interes mensual del prestamo
| def get_interest_payment(self):
"""Obtiene el pago del interes mensual del prestamo
"""
return int((self.balance_cop * self.interest) / 100) | [
"def",
"get_interest_payment",
"(",
"self",
")",
":",
"return",
"int",
"(",
"(",
"self",
".",
"balance_cop",
"*",
"self",
".",
"interest",
")",
"/",
"100",
")"
] | [
94,
4
] | [
97,
60
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
AccountMove._compute_invoice_taxes_by_group | (self) | return super(AccountMove, self - other_curr_ar_invoices).\
_compute_invoice_taxes_by_group() | Esto es para arreglar una especie de bug de odoo que al imprimir el
amount by group hace conversion confiando en la cotización existente a
ese momento pero esto puede NO ser real. Mandamos el inverso del
l10n_ar_currency_rate porque en este caso la conversión es al revez | Esto es para arreglar una especie de bug de odoo que al imprimir el
amount by group hace conversion confiando en la cotización existente a
ese momento pero esto puede NO ser real. Mandamos el inverso del
l10n_ar_currency_rate porque en este caso la conversión es al revez | def _compute_invoice_taxes_by_group(self):
""" Esto es para arreglar una especie de bug de odoo que al imprimir el
amount by group hace conversion confiando en la cotización existente a
ese momento pero esto puede NO ser real. Mandamos el inverso del
l10n_ar_currency_rate porque en este caso la conversión es al revez"""
other_curr_ar_invoices = self.filtered(
lambda x: x.is_invoice() and
x.company_id.country_id == self.env.ref('base.ar') and
x.currency_id != x.company_id.currency_id)
for rec in other_curr_ar_invoices:
rate = 1.0 / rec.l10n_ar_currency_rate if rec.\
l10n_ar_currency_rate else False
super(AccountMove, rec.with_context(force_rate=rate)).\
_compute_invoice_taxes_by_group()
return super(AccountMove, self - other_curr_ar_invoices).\
_compute_invoice_taxes_by_group() | [
"def",
"_compute_invoice_taxes_by_group",
"(",
"self",
")",
":",
"other_curr_ar_invoices",
"=",
"self",
".",
"filtered",
"(",
"lambda",
"x",
":",
"x",
".",
"is_invoice",
"(",
")",
"and",
"x",
".",
"company_id",
".",
"country_id",
"==",
"self",
".",
"env",
".",
"ref",
"(",
"'base.ar'",
")",
"and",
"x",
".",
"currency_id",
"!=",
"x",
".",
"company_id",
".",
"currency_id",
")",
"for",
"rec",
"in",
"other_curr_ar_invoices",
":",
"rate",
"=",
"1.0",
"/",
"rec",
".",
"l10n_ar_currency_rate",
"if",
"rec",
".",
"l10n_ar_currency_rate",
"else",
"False",
"super",
"(",
"AccountMove",
",",
"rec",
".",
"with_context",
"(",
"force_rate",
"=",
"rate",
")",
")",
".",
"_compute_invoice_taxes_by_group",
"(",
")",
"return",
"super",
"(",
"AccountMove",
",",
"self",
"-",
"other_curr_ar_invoices",
")",
".",
"_compute_invoice_taxes_by_group",
"(",
")"
] | [
187,
4
] | [
202,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BcraLiborScraperTestCase.test_get_last_business_day | (self) | probar que la fecha obtenida sea correcta | probar que la fecha obtenida sea correcta | def test_get_last_business_day(self):
"""probar que la fecha obtenida sea correcta"""
assert date(2019, 3, 15) == get_most_recent_previous_business_day(
date(2019, 3, 18)
)
assert date(2019, 3, 18) == get_most_recent_previous_business_day(
date(2019, 3, 19)
)
assert date(2019, 3, 22) == get_most_recent_previous_business_day(
date(2019, 3, 24)
) | [
"def",
"test_get_last_business_day",
"(",
"self",
")",
":",
"assert",
"date",
"(",
"2019",
",",
"3",
",",
"15",
")",
"==",
"get_most_recent_previous_business_day",
"(",
"date",
"(",
"2019",
",",
"3",
",",
"18",
")",
")",
"assert",
"date",
"(",
"2019",
",",
"3",
",",
"18",
")",
"==",
"get_most_recent_previous_business_day",
"(",
"date",
"(",
"2019",
",",
"3",
",",
"19",
")",
")",
"assert",
"date",
"(",
"2019",
",",
"3",
",",
"22",
")",
"==",
"get_most_recent_previous_business_day",
"(",
"date",
"(",
"2019",
",",
"3",
",",
"24",
")",
")"
] | [
23,
4
] | [
33,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
UserViewSet.resumen_partida | (self, request) | return Response(data, status=status.HTTP_200_OK) | Muestra una lista de los jugadores con los saldos finales de cada uno | Muestra una lista de los jugadores con los saldos finales de cada uno | def resumen_partida(self, request):
""" Muestra una lista de los jugadores con los saldos finales de cada uno"""
user = self.request.user
self.queryset = User.objects.all().filter(room=user.room).exclude(userType__name='Banquero').order_by('-amount')[1:4]
list_amounts = User.objects.all().filter(room=user.room).exclude(userType__name='Banquero').values_list('amount',flat=True).order_by('-amount')[1:4]
winner = User.objects.all().filter(room=user.room).exclude(userType__name='Banquero').order_by('-amount')[0]
serializer = UserSerializer(self.queryset, many=True)
data={
'winner' : {
'username': winner.username,
'amount': winner.amount,
'avatar': winner.avatar
},
'users':serializer.data,
'amounts':list_amounts,
'info': 'Partida finalizada.'
}
return Response(data, status=status.HTTP_200_OK) | [
"def",
"resumen_partida",
"(",
"self",
",",
"request",
")",
":",
"user",
"=",
"self",
".",
"request",
".",
"user",
"self",
".",
"queryset",
"=",
"User",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"room",
"=",
"user",
".",
"room",
")",
".",
"exclude",
"(",
"userType__name",
"=",
"'Banquero'",
")",
".",
"order_by",
"(",
"'-amount'",
")",
"[",
"1",
":",
"4",
"]",
"list_amounts",
"=",
"User",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"room",
"=",
"user",
".",
"room",
")",
".",
"exclude",
"(",
"userType__name",
"=",
"'Banquero'",
")",
".",
"values_list",
"(",
"'amount'",
",",
"flat",
"=",
"True",
")",
".",
"order_by",
"(",
"'-amount'",
")",
"[",
"1",
":",
"4",
"]",
"winner",
"=",
"User",
".",
"objects",
".",
"all",
"(",
")",
".",
"filter",
"(",
"room",
"=",
"user",
".",
"room",
")",
".",
"exclude",
"(",
"userType__name",
"=",
"'Banquero'",
")",
".",
"order_by",
"(",
"'-amount'",
")",
"[",
"0",
"]",
"serializer",
"=",
"UserSerializer",
"(",
"self",
".",
"queryset",
",",
"many",
"=",
"True",
")",
"data",
"=",
"{",
"'winner'",
":",
"{",
"'username'",
":",
"winner",
".",
"username",
",",
"'amount'",
":",
"winner",
".",
"amount",
",",
"'avatar'",
":",
"winner",
".",
"avatar",
"}",
",",
"'users'",
":",
"serializer",
".",
"data",
",",
"'amounts'",
":",
"list_amounts",
",",
"'info'",
":",
"'Partida finalizada.'",
"}",
"return",
"Response",
"(",
"data",
",",
"status",
"=",
"status",
".",
"HTTP_200_OK",
")"
] | [
133,
4
] | [
150,
56
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DNARecord.dna_to_prot | (self) | return t_seq | Convierte la secuencia de DNA a proteina. | Convierte la secuencia de DNA a proteina. | def dna_to_prot(self):
"""Convierte la secuencia de DNA a proteina."""
# Obtener longitud y crear secuencia transformada
seq_len = len(self.seq)
t_seq = ''
# Obtener los codones cada 3 caracteres
for pos in range(0, seq_len-2, 3):
# Obtener el codon del diccionario, y si no poner 'X'
if self.seq[pos:pos+3] in codon:
t_seq += codon[self.seq[pos:pos+3]]
else:
t_seq += 'X'
return t_seq | [
"def",
"dna_to_prot",
"(",
"self",
")",
":",
"# Obtener longitud y crear secuencia transformada",
"seq_len",
"=",
"len",
"(",
"self",
".",
"seq",
")",
"t_seq",
"=",
"''",
"# Obtener los codones cada 3 caracteres",
"for",
"pos",
"in",
"range",
"(",
"0",
",",
"seq_len",
"-",
"2",
",",
"3",
")",
":",
"# Obtener el codon del diccionario, y si no poner 'X'",
"if",
"self",
".",
"seq",
"[",
"pos",
":",
"pos",
"+",
"3",
"]",
"in",
"codon",
":",
"t_seq",
"+=",
"codon",
"[",
"self",
".",
"seq",
"[",
"pos",
":",
"pos",
"+",
"3",
"]",
"]",
"else",
":",
"t_seq",
"+=",
"'X'",
"return",
"t_seq"
] | [
85,
4
] | [
97,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
insert_superheores_by_default | () | Insertamos los personajes por defecto a la BBDD | Insertamos los personajes por defecto a la BBDD | def insert_superheores_by_default():
"""Insertamos los personajes por defecto a la BBDD"""
try:
db_comics.characters.drop()
db_comics.characters.insert_many(characters)
db_comics.movies.drop()
db_comics.movies.insert_many(movies)
return 'OK'
except:
raise | [
"def",
"insert_superheores_by_default",
"(",
")",
":",
"try",
":",
"db_comics",
".",
"characters",
".",
"drop",
"(",
")",
"db_comics",
".",
"characters",
".",
"insert_many",
"(",
"characters",
")",
"db_comics",
".",
"movies",
".",
"drop",
"(",
")",
"db_comics",
".",
"movies",
".",
"insert_many",
"(",
"movies",
")",
"return",
"'OK'",
"except",
":",
"raise"
] | [
12,
0
] | [
21,
13
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_funciones38 | (p) | funciones : CEIL PABRE expresion PCIERRA | funciones : CEIL PABRE expresion PCIERRA | def p_funciones38(p):
'funciones : CEIL PABRE expresion PCIERRA' | [
"def",
"p_funciones38",
"(",
"p",
")",
":"
] | [
412,
0
] | [
413,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
profile | (profiling_result_path) | return fn_decorator | Decorador de una función para que se corra haciendo profiling. | Decorador de una función para que se corra haciendo profiling. | def profile(profiling_result_path):
"""Decorador de una función para que se corra haciendo profiling."""
def fn_decorator(fn):
"""Decora una función con el análisis de profiling."""
@wraps(fn)
def fn_decorated(*args, **kwargs):
"""Crea la función decorada."""
graphviz = GraphvizOutput()
graphviz.output_file = profiling_result_path
with PyCallGraph(output=graphviz, config=None):
fn(*args, **kwargs)
return fn_decorated
return fn_decorator | [
"def",
"profile",
"(",
"profiling_result_path",
")",
":",
"def",
"fn_decorator",
"(",
"fn",
")",
":",
"\"\"\"Decora una función con el análisis de profiling.\"\"\"",
"@",
"wraps",
"(",
"fn",
")",
"def",
"fn_decorated",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"Crea la función decorada.\"\"\"",
"graphviz",
"=",
"GraphvizOutput",
"(",
")",
"graphviz",
".",
"output_file",
"=",
"profiling_result_path",
"with",
"PyCallGraph",
"(",
"output",
"=",
"graphviz",
",",
"config",
"=",
"None",
")",
":",
"fn",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"fn_decorated",
"return",
"fn_decorator"
] | [
39,
0
] | [
56,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Generador.compilarFuncionesNativas | (self, instruccion) | Aqui se genera el C3D de las funciones nativas | Aqui se genera el C3D de las funciones nativas | def compilarFuncionesNativas(self, instruccion):
'''Aqui se genera el C3D de las funciones nativas '''
#PRIMERO DETECTAR QUE TIPO DE FUNCION ES
if instruccion.tipo == TipoFunNativa.avg:
#Verificar que trae como parametro (valor, variable, expresion)
arregloDeValores =[]
for param in instruccion.parametros :
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
#agregamos el valor del retorno al arreglo de valores
arregloDeValores.append(retorno)
indice = 0;
for indice in len(arregloDeValores):
temporal=self.generarTemporal()
if indice+1 < len(arregloDeValores):
lineaSuma=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '+' + arregloDeValores[indice+1]
self.codigo3d.append(lineaSuma)
arregloDeValores[indice+1]=temporal
else:
lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)
self.codigo3d.append(lineaFinal)
ret = RetornoOp(temporal, None)
return ret
elif instruccion.tipo == TipoFunNativa.sum:
arregloDeValores =[]
for param in instruccion.parametros :
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
#agregamos el valor del retorno al arreglo de valores
arregloDeValores.append(retorno)
indice = 0;
for indice in len(arregloDeValores):
temporal=self.generarTemporal()
if indice+1 < len(arregloDeValores):
lineaSuma=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '+' + arregloDeValores[indice+1]
self.codigo3d.append(lineaSuma)
arregloDeValores[indice+1]=temporal
else:
#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)
#self.codigo3d.append(lineaFinal)
ret = RetornoOp(arregloDeValores[indice], None)
return ret
elif instruccion.tipo == TipoFunNativa.min:
arregloDeValores =[]
for param in instruccion.parametros :
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
#agregamos el valor del retorno al arreglo de valores
arregloDeValores.append(retorno)
indice = 0;
for indice in len(arregloDeValores):
#ciclo de comparaciones
#temporal=self.generarTemporal()
#def agregarIf(self, condicion, etiqueta):
etiquetaverdadero=self.generarEtiqueta()
if indice+1 < len(arregloDeValores):
self.agregarIf(arregloDeValores[indice] + '<' + arregloDeValores[indice+1], etiquetaverdadero)
etiquetafalso=self.generarEtiqueta()
#acciones de falso
#self.generarGoto(etiquetafalso)
self.agregarEtiqueta(etiquetaverdadero)
#acciones de verdadero
arregloDeValores[indice+1]=arregloDeValores[indice]
else:
#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)
#self.codigo3d.append(lineaFinal)
ret = RetornoOp(arregloDeValores[indice], None)
return ret
elif instruccion.tipo == TipoFunNativa.max:
arregloDeValores =[]
for param in instruccion.parametros :
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
#agregamos el valor del retorno al arreglo de valores
arregloDeValores.append(retorno)
indice = 0;
for indice in len(arregloDeValores):
#ciclo de comparaciones
#temporal=self.generarTemporal()
#def agregarIf(self, condicion, etiqueta):
etiquetaverdadero=self.generarEtiqueta()
if indice+1 < len(arregloDeValores):
self.agregarIf(arregloDeValores[indice] + '>' + arregloDeValores[indice+1], etiquetaverdadero)
etiquetafalso=self.generarEtiqueta()
#acciones de falso
#self.generarGoto(etiquetafalso)
self.agregarEtiqueta(etiquetaverdadero)
#acciones de verdadero
arregloDeValores[indice+1]=arregloDeValores[indice]
else:
#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)
#self.codigo3d.append(lineaFinal)
ret = RetornoOp(arregloDeValores[indice], None)
return ret
elif instruccion.tipo == TipoFunNativa.abs:
#FUNCION TIPO ABS
#Verificar que trae como parametro (valor, variable, expresion)
#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
#Linea del if
etiquetaverdadero=self.generarEtiqueta()
self.agregarIf(retorno.valor + '>' + str(0), etiquetaverdadero)
#self.codigo3d.append(inst)
lineaAbs=self.generarTab() + retorno.valor + '=' + retorno.valor + '*-1'
self.codigo3d.append(lineaAbs)
self.agregarEtiqueta(etiquetaverdadero)
ret = RetornoOp(retorno.valor, None)
return ret
#mandar a imprimir un if para validar si el valor del temporal que sale de operacion aritmetica es menor a 0
#si entra al if hacer la conversion, sino entra seguir con l
#elif isinstance(instruccion.parametros, Primitivo):
# retorno = self.compilarPrimitivo(instruccion.parametros)
# etiquetaverdadero=self.generarEtiqueta()
# self.agregarIf(retorno.valor + '>' + str(0), etiquetaverdadero)
# #AGREGAR UNA EXCEPCION PARA UN NUMERO NEGATIVO
# lineaAbs=retorno.valor + '=' + retorno.valor + '*-1'
# self.codigo3d.append(lineaAbs)
# self.agregarEtiqueta(etiquetaverdadero)
# ret = RetornoOp(retorno.valor, None)
# return ret
#elif isinstance(instruccion.parametros, FuncionNativa):
# retorno = self.compilarFuncionesNativas(instruccion.parametros)
# etiquetaverdadero = self.generarEtiqueta()
# self.agregarIf(retorno.valor + '>' + str(0), etiquetaverdadero)
# # AGREGAR UNA EXCEPCION PARA UN NUMERO NEGATIVO
# lineaAbs = self.generarTab() + retorno.valor + '=' + retorno.valor + '*-1'
# self.codigo3d.append(lineaAbs)
# self.agregarEtiqueta(etiquetaverdadero)
# ret = RetornoOp(retorno.valor, None)
# return ret
elif instruccion.tipo == TipoFunNativa.cbrt:
# Corresponde a función de CBRT
#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
lineaCubic = self.generarTab() + str(tag) + ' = ' + str(retorno.valor) + '** 1/3'
self.codigo3d.append(lineaCubic)
ret = RetornoOp(tag, None)
return ret
#elif isinstance(instruccion.parametros, Primitivo):
# retorno = self.compilarPrimitivo(instruccion.parametros)
# tag = self.generarTemporal()
# lineaCubic = self.generarTab() + str(tag) + ' = ' + str(retorno.valor) + '** 1/3'
# self.codigo3d.append(lineaCubic)
# ret = RetornoOp(tag, None)
# return ret
elif instruccion.tipo == TipoFunNativa.ceil:
# Corresponde a función de CEIL
#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'
self.codigo3d.append(lineaCeil)
ret = RetornoOp(tag, None)
return ret
#elif isinstance(instruccion.parametros, Primitivo):
# retorno = self.compilarPrimitivo(instruccion.parametros)
# tag = self.generarTemporal()
# lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'
# self.codigo3d.append(lineaCeil)
# ret = RetornoOp(tag, None)
# return ret
elif instruccion.tipo == TipoFunNativa.ceiling:
# Corresponde a función de CEILING
#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):
retorno = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'
self.codigo3d.append(lineaCeil)
ret = RetornoOp(tag, None)
return ret
#elif isinstance(instruccion.parametros, Primitivo):
# retorno = self.compilarPrimitivo(instruccion.parametros)
# tag = self.generarTemporal()
# lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'
# self.codigo3d.append(lineaCeil)
# ret = RetornoOp(tag, None)
# return ret
elif instruccion.tipo == TipoFunNativa.substring:
# Corresponde a función de SUBSTRING
pass
elif instruccion.tipo == TipoFunNativa.sin:
# Corresponde a función de SIN
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.sin(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.sinh:
# Corresponde a función de SINH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.sinh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.sind:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.sin(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.asin:
# Corresponde a función de ASIN
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.asin(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.asinh:
# Corresponde a función de ASINH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.asinh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.asind:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.asin(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.cos:
# Corresponde a función de COS
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.cos(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.cosh:
# Corresponde a función de COSH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.cosh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.cosd:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.cos(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.acos:
# Corresponde a función de ACOS
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.acos(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.acosh:
# Corresponde a función de ACOSH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.acosh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.acosd:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.acos(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.tan:
# Corresponde a función de TAN
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.tan(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.tanh:
# Corresponde a función de TANH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.tanh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.tand:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.tan(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.atan:
# Corresponde a función de ATAN
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.atan(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.atanh:
# Corresponde a función de ATANH
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.atanh(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.atan2:
# Corresponde a función de ATAN2
if instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.atan2(' + str(oper1.valor) + ', ' + str(oper2.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.atand:
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.atan(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.atan2d:
# Corresponde a función de ATAN2
if instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.atan2(' + str(oper1.valor) + ', ' + str(oper2.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = math.degrees(' + str(tag1) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.cot:
# Corresponde a función de COT
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.tan(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = 1 / ' + tag1
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.cotd:
# Corresponde a función de COTD
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag1 = self.generarTemporal()
linea = self.generarTab() + str(tag1) + ' = math.tan(' + str(oper.valor) + ')'
tag2 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag2) + ' = 1 / ' + tag1
tag3 = self.generarTemporal()
linea += '\n'
linea += self.generarTab() + str(tag3) + ' = math.degrees(' + str(tag2) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag2, None)
return ret
elif instruccion.tipo == TipoFunNativa.degree:
# Corresponde a función de DEGREES
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.degrees(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.factorial:
# Corresponde a función de FACTORIAL
oper = oper = self.compilarOperacionAritmetica(instruccion.parametros)
etiquetaSalida = self.generarEtiqueta()
etiquetaLoop = self.generarEtiqueta()
factorial = self.generarTemporal()
pivot = self.generarTemporal()
self.codigo3d.append(self.generarTab() + factorial + ' = ' + str(oper.valor))
self.codigo3d.append(self.generarTab() + pivot + ' = 1')
# IF de salida (if entrada < 0)
self.agregarIf(factorial + ' < 0' , etiquetaSalida)
# IF de salida (if entrada == 0)
self.agregarIf(factorial + ' == 0', etiquetaSalida)
# IF de salida (if entrada == 1)
self.agregarIf(factorial + ' == 1', etiquetaSalida)
self.generarGoto(etiquetaLoop)
self.agregarEtiqueta(etiquetaLoop)
etiquetaTrue = self.generarEtiqueta()
self.agregarIf(factorial + ' > 0', etiquetaTrue)
self.generarGoto(etiquetaSalida)
self.agregarEtiqueta(etiquetaTrue)
self.codigo3d.append(self.generarTab() + pivot + ' = ' + pivot + ' * ' + factorial)
self.codigo3d.append(self.generarTab() + factorial + ' = ' + factorial + ' - 1')
self.generarGoto(etiquetaLoop)
self.agregarEtiqueta(etiquetaSalida)
ret = RetornoOp(pivot, None)
return ret
elif instruccion.tipo == TipoFunNativa.div:
# Corresponde a función de DIV
if instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = ' + str(oper1.valor) + ' / ' + str(oper2.valor)
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.ln:
# Corresponde a función de LN
oper = self.compilarOperacionAritmetica(instruccion.parametros)
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.ln(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.log:
if instruccion.numparametros == 1:
oper = self.compilarOperacionAritmetica(instruccion.parametros[0])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.log(' + str(oper.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.log(' + str(oper1.valor) + ', ' + str(oper2.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.mod:
# Corresponde a función de MOD
if instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = ' + str(oper1.valor) + ' % ' + str(oper2.valor)
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret
elif instruccion.tipo == TipoFunNativa.pow:
# Corresponde a función de POW
if instruccion.numparametros == 2:
oper1 = self.compilarOperacionAritmetica(instruccion.parametros[0])
oper2 = self.compilarOperacionAritmetica(instruccion.parametros[1])
tag = self.generarTemporal()
linea = self.generarTab() + str(tag) + ' = math.pow(' + str(oper1.valor) + ', ' + str(oper2.valor) + ')'
self.codigo3d.append(linea)
ret = RetornoOp(tag, None)
return ret | [
"def",
"compilarFuncionesNativas",
"(",
"self",
",",
"instruccion",
")",
":",
"#PRIMERO DETECTAR QUE TIPO DE FUNCION ES ",
"if",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"avg",
":",
"#Verificar que trae como parametro (valor, variable, expresion)",
"arregloDeValores",
"=",
"[",
"]",
"for",
"param",
"in",
"instruccion",
".",
"parametros",
":",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"#agregamos el valor del retorno al arreglo de valores ",
"arregloDeValores",
".",
"append",
"(",
"retorno",
")",
"indice",
"=",
"0",
"for",
"indice",
"in",
"len",
"(",
"arregloDeValores",
")",
":",
"temporal",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"if",
"indice",
"+",
"1",
"<",
"len",
"(",
"arregloDeValores",
")",
":",
"lineaSuma",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"temporal",
"+",
"'='",
"+",
"arregloDeValores",
"[",
"indice",
"]",
"+",
"'+'",
"+",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaSuma",
")",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"=",
"temporal",
"else",
":",
"lineaFinal",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"temporal",
"+",
"'='",
"+",
"arregloDeValores",
"[",
"indice",
"]",
"+",
"'/'",
"+",
"len",
"(",
"arregloDeValores",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaFinal",
")",
"ret",
"=",
"RetornoOp",
"(",
"temporal",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"sum",
":",
"arregloDeValores",
"=",
"[",
"]",
"for",
"param",
"in",
"instruccion",
".",
"parametros",
":",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"#agregamos el valor del retorno al arreglo de valores ",
"arregloDeValores",
".",
"append",
"(",
"retorno",
")",
"indice",
"=",
"0",
"for",
"indice",
"in",
"len",
"(",
"arregloDeValores",
")",
":",
"temporal",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"if",
"indice",
"+",
"1",
"<",
"len",
"(",
"arregloDeValores",
")",
":",
"lineaSuma",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"temporal",
"+",
"'='",
"+",
"arregloDeValores",
"[",
"indice",
"]",
"+",
"'+'",
"+",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaSuma",
")",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"=",
"temporal",
"else",
":",
"#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)",
"#self.codigo3d.append(lineaFinal)",
"ret",
"=",
"RetornoOp",
"(",
"arregloDeValores",
"[",
"indice",
"]",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"min",
":",
"arregloDeValores",
"=",
"[",
"]",
"for",
"param",
"in",
"instruccion",
".",
"parametros",
":",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"#agregamos el valor del retorno al arreglo de valores ",
"arregloDeValores",
".",
"append",
"(",
"retorno",
")",
"indice",
"=",
"0",
"for",
"indice",
"in",
"len",
"(",
"arregloDeValores",
")",
":",
"#ciclo de comparaciones ",
"#temporal=self.generarTemporal()",
"#def agregarIf(self, condicion, etiqueta):",
"etiquetaverdadero",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"if",
"indice",
"+",
"1",
"<",
"len",
"(",
"arregloDeValores",
")",
":",
"self",
".",
"agregarIf",
"(",
"arregloDeValores",
"[",
"indice",
"]",
"+",
"'<'",
"+",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
",",
"etiquetaverdadero",
")",
"etiquetafalso",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"#acciones de falso",
"#self.generarGoto(etiquetafalso)",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaverdadero",
")",
"#acciones de verdadero",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"=",
"arregloDeValores",
"[",
"indice",
"]",
"else",
":",
"#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)",
"#self.codigo3d.append(lineaFinal)",
"ret",
"=",
"RetornoOp",
"(",
"arregloDeValores",
"[",
"indice",
"]",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"max",
":",
"arregloDeValores",
"=",
"[",
"]",
"for",
"param",
"in",
"instruccion",
".",
"parametros",
":",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"#agregamos el valor del retorno al arreglo de valores ",
"arregloDeValores",
".",
"append",
"(",
"retorno",
")",
"indice",
"=",
"0",
"for",
"indice",
"in",
"len",
"(",
"arregloDeValores",
")",
":",
"#ciclo de comparaciones ",
"#temporal=self.generarTemporal()",
"#def agregarIf(self, condicion, etiqueta):",
"etiquetaverdadero",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"if",
"indice",
"+",
"1",
"<",
"len",
"(",
"arregloDeValores",
")",
":",
"self",
".",
"agregarIf",
"(",
"arregloDeValores",
"[",
"indice",
"]",
"+",
"'>'",
"+",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
",",
"etiquetaverdadero",
")",
"etiquetafalso",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"#acciones de falso",
"#self.generarGoto(etiquetafalso)",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaverdadero",
")",
"#acciones de verdadero",
"arregloDeValores",
"[",
"indice",
"+",
"1",
"]",
"=",
"arregloDeValores",
"[",
"indice",
"]",
"else",
":",
"#lineaFinal=self.generarTab() + temporal + '=' + arregloDeValores[indice] + '/' + len(arregloDeValores)",
"#self.codigo3d.append(lineaFinal)",
"ret",
"=",
"RetornoOp",
"(",
"arregloDeValores",
"[",
"indice",
"]",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"abs",
":",
"#FUNCION TIPO ABS ",
"#Verificar que trae como parametro (valor, variable, expresion)",
"#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"#Linea del if ",
"etiquetaverdadero",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"self",
".",
"agregarIf",
"(",
"retorno",
".",
"valor",
"+",
"'>'",
"+",
"str",
"(",
"0",
")",
",",
"etiquetaverdadero",
")",
"#self.codigo3d.append(inst)",
"lineaAbs",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"retorno",
".",
"valor",
"+",
"'='",
"+",
"retorno",
".",
"valor",
"+",
"'*-1'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaAbs",
")",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaverdadero",
")",
"ret",
"=",
"RetornoOp",
"(",
"retorno",
".",
"valor",
",",
"None",
")",
"return",
"ret",
"#mandar a imprimir un if para validar si el valor del temporal que sale de operacion aritmetica es menor a 0",
"#si entra al if hacer la conversion, sino entra seguir con l",
"#elif isinstance(instruccion.parametros, Primitivo):",
"# retorno = self.compilarPrimitivo(instruccion.parametros)",
"# etiquetaverdadero=self.generarEtiqueta()",
"# self.agregarIf(retorno.valor + '>' + str(0), etiquetaverdadero)",
"# #AGREGAR UNA EXCEPCION PARA UN NUMERO NEGATIVO ",
"# lineaAbs=retorno.valor + '=' + retorno.valor + '*-1'",
"# self.codigo3d.append(lineaAbs)",
"# self.agregarEtiqueta(etiquetaverdadero)",
"# ret = RetornoOp(retorno.valor, None)",
"# return ret",
"#elif isinstance(instruccion.parametros, FuncionNativa):",
"# retorno = self.compilarFuncionesNativas(instruccion.parametros)",
"# etiquetaverdadero = self.generarEtiqueta()",
"# self.agregarIf(retorno.valor + '>' + str(0), etiquetaverdadero)",
"# # AGREGAR UNA EXCEPCION PARA UN NUMERO NEGATIVO",
"# lineaAbs = self.generarTab() + retorno.valor + '=' + retorno.valor + '*-1'",
"# self.codigo3d.append(lineaAbs)",
"# self.agregarEtiqueta(etiquetaverdadero)",
"# ret = RetornoOp(retorno.valor, None)",
"# return ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cbrt",
":",
"# Corresponde a función de CBRT",
"#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"lineaCubic",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = '",
"+",
"str",
"(",
"retorno",
".",
"valor",
")",
"+",
"'** 1/3'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaCubic",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"#elif isinstance(instruccion.parametros, Primitivo):",
"# retorno = self.compilarPrimitivo(instruccion.parametros)",
"# tag = self.generarTemporal()",
"# lineaCubic = self.generarTab() + str(tag) + ' = ' + str(retorno.valor) + '** 1/3'",
"# self.codigo3d.append(lineaCubic)",
"# ret = RetornoOp(tag, None)",
"# return ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"ceil",
":",
"# Corresponde a función de CEIL",
"#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"lineaCeil",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = round('",
"+",
"str",
"(",
"retorno",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaCeil",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"#elif isinstance(instruccion.parametros, Primitivo):",
"# retorno = self.compilarPrimitivo(instruccion.parametros)",
"# tag = self.generarTemporal()",
"# lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'",
"# self.codigo3d.append(lineaCeil)",
"# ret = RetornoOp(tag, None)",
"# return ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"ceiling",
":",
"# Corresponde a función de CEILING",
"#if isinstance(instruccion.parametros, Operaciones_Aritmeticas):",
"retorno",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"lineaCeil",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = round('",
"+",
"str",
"(",
"retorno",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"lineaCeil",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"#elif isinstance(instruccion.parametros, Primitivo):",
"# retorno = self.compilarPrimitivo(instruccion.parametros)",
"# tag = self.generarTemporal()",
"# lineaCeil = self.generarTab() + str(tag) + ' = round(' + str(retorno.valor) + ')'",
"# self.codigo3d.append(lineaCeil)",
"# ret = RetornoOp(tag, None)",
"# return ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"substring",
":",
"# Corresponde a función de SUBSTRING",
"pass",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"sin",
":",
"# Corresponde a función de SIN",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.sin('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"sinh",
":",
"# Corresponde a función de SINH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.sinh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"sind",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.sin('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"asin",
":",
"# Corresponde a función de ASIN",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.asin('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"asinh",
":",
"# Corresponde a función de ASINH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.asinh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"asind",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.asin('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cos",
":",
"# Corresponde a función de COS",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.cos('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cosh",
":",
"# Corresponde a función de COSH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.cosh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cosd",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.cos('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"acos",
":",
"# Corresponde a función de ACOS",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.acos('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"acosh",
":",
"# Corresponde a función de ACOSH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.acosh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"acosd",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.acos('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"tan",
":",
"# Corresponde a función de TAN",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.tan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"tanh",
":",
"# Corresponde a función de TANH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.tanh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"tand",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.tan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"atan",
":",
"# Corresponde a función de ATAN",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.atan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"atanh",
":",
"# Corresponde a función de ATANH",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.atanh('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"atan2",
":",
"# Corresponde a función de ATAN2",
"if",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.atan2('",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"', '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"atand",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.atan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"atan2d",
":",
"# Corresponde a función de ATAN2",
"if",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.atan2('",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"', '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag1",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cot",
":",
"# Corresponde a función de COT",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.tan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = 1 / '",
"+",
"tag1",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"cotd",
":",
"# Corresponde a función de COTD",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag1",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag1",
")",
"+",
"' = math.tan('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"tag2",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag2",
")",
"+",
"' = 1 / '",
"+",
"tag1",
"tag3",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"+=",
"'\\n'",
"linea",
"+=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag3",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"tag2",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag2",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"degree",
":",
"# Corresponde a función de DEGREES",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.degrees('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"factorial",
":",
"# Corresponde a función de FACTORIAL",
"oper",
"=",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"etiquetaSalida",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"etiquetaLoop",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"factorial",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"pivot",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"self",
".",
"generarTab",
"(",
")",
"+",
"factorial",
"+",
"' = '",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"self",
".",
"generarTab",
"(",
")",
"+",
"pivot",
"+",
"' = 1'",
")",
"# IF de salida (if entrada < 0)",
"self",
".",
"agregarIf",
"(",
"factorial",
"+",
"' < 0'",
",",
"etiquetaSalida",
")",
"# IF de salida (if entrada == 0)",
"self",
".",
"agregarIf",
"(",
"factorial",
"+",
"' == 0'",
",",
"etiquetaSalida",
")",
"# IF de salida (if entrada == 1)",
"self",
".",
"agregarIf",
"(",
"factorial",
"+",
"' == 1'",
",",
"etiquetaSalida",
")",
"self",
".",
"generarGoto",
"(",
"etiquetaLoop",
")",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaLoop",
")",
"etiquetaTrue",
"=",
"self",
".",
"generarEtiqueta",
"(",
")",
"self",
".",
"agregarIf",
"(",
"factorial",
"+",
"' > 0'",
",",
"etiquetaTrue",
")",
"self",
".",
"generarGoto",
"(",
"etiquetaSalida",
")",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaTrue",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"self",
".",
"generarTab",
"(",
")",
"+",
"pivot",
"+",
"' = '",
"+",
"pivot",
"+",
"' * '",
"+",
"factorial",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"self",
".",
"generarTab",
"(",
")",
"+",
"factorial",
"+",
"' = '",
"+",
"factorial",
"+",
"' - 1'",
")",
"self",
".",
"generarGoto",
"(",
"etiquetaLoop",
")",
"self",
".",
"agregarEtiqueta",
"(",
"etiquetaSalida",
")",
"ret",
"=",
"RetornoOp",
"(",
"pivot",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"div",
":",
"# Corresponde a función de DIV",
"if",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = '",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"' / '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"ln",
":",
"# Corresponde a función de LN",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.ln('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"log",
":",
"if",
"instruccion",
".",
"numparametros",
"==",
"1",
":",
"oper",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.log('",
"+",
"str",
"(",
"oper",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.log('",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"', '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"mod",
":",
"# Corresponde a función de MOD",
"if",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = '",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"' % '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret",
"elif",
"instruccion",
".",
"tipo",
"==",
"TipoFunNativa",
".",
"pow",
":",
"# Corresponde a función de POW",
"if",
"instruccion",
".",
"numparametros",
"==",
"2",
":",
"oper1",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"0",
"]",
")",
"oper2",
"=",
"self",
".",
"compilarOperacionAritmetica",
"(",
"instruccion",
".",
"parametros",
"[",
"1",
"]",
")",
"tag",
"=",
"self",
".",
"generarTemporal",
"(",
")",
"linea",
"=",
"self",
".",
"generarTab",
"(",
")",
"+",
"str",
"(",
"tag",
")",
"+",
"' = math.pow('",
"+",
"str",
"(",
"oper1",
".",
"valor",
")",
"+",
"', '",
"+",
"str",
"(",
"oper2",
".",
"valor",
")",
"+",
"')'",
"self",
".",
"codigo3d",
".",
"append",
"(",
"linea",
")",
"ret",
"=",
"RetornoOp",
"(",
"tag",
",",
"None",
")",
"return",
"ret"
] | [
535,
4
] | [
1009,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_StockMove._compute_custom_values | (self) | Calcula los campos añadidos al modelo cruzando información ya existente.
fab_product: product.product - Producto padre del cual proviene el ingrediente
std_quantity: float - Cantidad de productos a fabricar x cantidad en la lista de materiales
missing: float - Cantidad necesitada de producto - cantidad reservada
deviation: float - Cantidad en que difiere la cantidad digitada de la estándar en la receta
deviation_per: float - Razon de la diferencia entre las cantidades digitadas y estandar
real_cost: float - Valor total del producto x cantidad digitada
std_cost: float - Valor total del producto x cantidad estándar
| Calcula los campos añadidos al modelo cruzando información ya existente.
fab_product: product.product - Producto padre del cual proviene el ingrediente
std_quantity: float - Cantidad de productos a fabricar x cantidad en la lista de materiales
missing: float - Cantidad necesitada de producto - cantidad reservada
deviation: float - Cantidad en que difiere la cantidad digitada de la estándar en la receta
deviation_per: float - Razon de la diferencia entre las cantidades digitadas y estandar
real_cost: float - Valor total del producto x cantidad digitada
std_cost: float - Valor total del producto x cantidad estándar | def _compute_custom_values(self):
""" Calcula los campos añadidos al modelo cruzando información ya existente.
fab_product: product.product - Producto padre del cual proviene el ingrediente
std_quantity: float - Cantidad de productos a fabricar x cantidad en la lista de materiales
missing: float - Cantidad necesitada de producto - cantidad reservada
deviation: float - Cantidad en que difiere la cantidad digitada de la estándar en la receta
deviation_per: float - Razon de la diferencia entre las cantidades digitadas y estandar
real_cost: float - Valor total del producto x cantidad digitada
std_cost: float - Valor total del producto x cantidad estándar
"""
for record in self:
record.fab_product = record.bom_line_id.bom_id.product_id
record.std_quantity = record.raw_material_production_id.product_uom_qty * record.bom_line_id.product_qty
record.missing = record.product_uom_qty - record.reserved_availability
record.deviation = record.product_uom_qty - record.std_quantity
record.deviation_per = record.deviation / record.std_quantity if record.std_quantity > 0 else 1
record.real_cost = record.product_uom_qty * record.product_id.standard_price
record.std_cost = record.std_quantity * record.product_id.standard_price
record.real_cost_prom = record.product_uom_qty * record.cost_unit_lot_fab
record.std_cost_prom = record.std_quantity * record.cost_unit_lot_fab | [
"def",
"_compute_custom_values",
"(",
"self",
")",
":",
"for",
"record",
"in",
"self",
":",
"record",
".",
"fab_product",
"=",
"record",
".",
"bom_line_id",
".",
"bom_id",
".",
"product_id",
"record",
".",
"std_quantity",
"=",
"record",
".",
"raw_material_production_id",
".",
"product_uom_qty",
"*",
"record",
".",
"bom_line_id",
".",
"product_qty",
"record",
".",
"missing",
"=",
"record",
".",
"product_uom_qty",
"-",
"record",
".",
"reserved_availability",
"record",
".",
"deviation",
"=",
"record",
".",
"product_uom_qty",
"-",
"record",
".",
"std_quantity",
"record",
".",
"deviation_per",
"=",
"record",
".",
"deviation",
"/",
"record",
".",
"std_quantity",
"if",
"record",
".",
"std_quantity",
">",
"0",
"else",
"1",
"record",
".",
"real_cost",
"=",
"record",
".",
"product_uom_qty",
"*",
"record",
".",
"product_id",
".",
"standard_price",
"record",
".",
"std_cost",
"=",
"record",
".",
"std_quantity",
"*",
"record",
".",
"product_id",
".",
"standard_price",
"record",
".",
"real_cost_prom",
"=",
"record",
".",
"product_uom_qty",
"*",
"record",
".",
"cost_unit_lot_fab",
"record",
".",
"std_cost_prom",
"=",
"record",
".",
"std_quantity",
"*",
"record",
".",
"cost_unit_lot_fab"
] | [
53,
4
] | [
73,
81
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
PlacesExtractor._get_day_from_index | (self, idx) | return self._INDEX_TO_DAY.get(idx, "unknown") | Función auxiliar que permite obtener el nombre del día pasándole el índice que tienen google maps.
Arguments
---------
idx : int
índice del día
Returns
-------
str
devuelve el nombre del día por índice, en caso de no encontrarlo devuelve `unknown`
| Función auxiliar que permite obtener el nombre del día pasándole el índice que tienen google maps. | def _get_day_from_index(self, idx):
"""Función auxiliar que permite obtener el nombre del día pasándole el índice que tienen google maps.
Arguments
---------
idx : int
índice del día
Returns
-------
str
devuelve el nombre del día por índice, en caso de no encontrarlo devuelve `unknown`
"""
return self._INDEX_TO_DAY.get(idx, "unknown") | [
"def",
"_get_day_from_index",
"(",
"self",
",",
"idx",
")",
":",
"return",
"self",
".",
"_INDEX_TO_DAY",
".",
"get",
"(",
"idx",
",",
"\"unknown\"",
")"
] | [
253,
4
] | [
266,
53
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioAG.generar_n | (self, n) | Construye aleatoriamente una lista de estructuras de datos que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n estructuras de datos, cada una representando
una posible solución al problema modelado por el objeto de dominio.
| Construye aleatoriamente una lista de estructuras de datos que representa n
posibles soluciones al problema. | def generar_n(self, n):
"""Construye aleatoriamente una lista de estructuras de datos que representa n
posibles soluciones al problema.
Entradas:
n (int)
Número de soluciones aleatorias a generar.
Salidas:
(list) Lista que contiene n estructuras de datos, cada una representando
una posible solución al problema modelado por el objeto de dominio.
"""
pass | [
"def",
"generar_n",
"(",
"self",
",",
"n",
")",
":",
"pass"
] | [
23,
4
] | [
36,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ethno_btn_maker | (variante) | return variante + btn_info | **Crea botones ``html`` con información ethnologue**
Función encargada de construir los botones para la columna de
variantes que despliegan los modals con la información obtenida
de la plataforma ethnologue
:param variante: Variante de la lengua 2
:type: str
:return: Cadenas con los botones en ``html``
:rtype: str
| **Crea botones ``html`` con información ethnologue** | def ethno_btn_maker(variante):
"""**Crea botones ``html`` con información ethnologue**
Función encargada de construir los botones para la columna de
variantes que despliegan los modals con la información obtenida
de la plataforma ethnologue
:param variante: Variante de la lengua 2
:type: str
:return: Cadenas con los botones en ``html``
:rtype: str
"""
# TODO: Ver que hacer con el mapa
btn_map = '''
<button type="button" class="badge badge-pill badge-primary ethno-btn"
data-toggle="modal" data-target="#ethnologue-map"
title="Ver mapa de la variante (Ethnologue)">
<i class="fa fa-map"></i>
</button>
'''
iso = variante[variante.find('(')+1:variante.find(')')]
btn_info = f'''
<button type="button"
class="badge badge-pill badge-info ethno-btn"
data-toggle="modal" data-target="#ethnologue-table"
onClick="ethnologueData('{iso}')"
title="Ver información de la variante (Ethnologue)">
<i class="fa fa-info"></i>
</button>'''
return variante + btn_info | [
"def",
"ethno_btn_maker",
"(",
"variante",
")",
":",
"# TODO: Ver que hacer con el mapa",
"btn_map",
"=",
"'''\n <button type=\"button\" class=\"badge badge-pill badge-primary ethno-btn\"\n data-toggle=\"modal\" data-target=\"#ethnologue-map\"\n title=\"Ver mapa de la variante (Ethnologue)\">\n <i class=\"fa fa-map\"></i>\n </button>\n '''",
"iso",
"=",
"variante",
"[",
"variante",
".",
"find",
"(",
"'('",
")",
"+",
"1",
":",
"variante",
".",
"find",
"(",
"')'",
")",
"]",
"btn_info",
"=",
"f'''\n <button type=\"button\"\n class=\"badge badge-pill badge-info ethno-btn\"\n data-toggle=\"modal\" data-target=\"#ethnologue-table\"\n onClick=\"ethnologueData('{iso}')\"\n title=\"Ver información de la variante (Ethnologue)\">\n <i class=\"fa fa-info\"></i>\n </button>'''",
"return",
"variante",
"+",
"btn_info"
] | [
273,
0
] | [
302,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Simulador.calc_tiempo | (self) | return tiempo | Tiempo de vuelo en segundos, depende de
la velocidad (por defecto 295 m/s, es decir
la velocidad del sonido) y la distancia
entre el origen y destino.
| Tiempo de vuelo en segundos, depende de
la velocidad (por defecto 295 m/s, es decir
la velocidad del sonido) y la distancia
entre el origen y destino.
| def calc_tiempo(self):
"""Tiempo de vuelo en segundos, depende de
la velocidad (por defecto 295 m/s, es decir
la velocidad del sonido) y la distancia
entre el origen y destino.
"""
tiempo = self.calc_distancia() / self.velocidad
self.tiempo = tiempo
return tiempo | [
"def",
"calc_tiempo",
"(",
"self",
")",
":",
"tiempo",
"=",
"self",
".",
"calc_distancia",
"(",
")",
"/",
"self",
".",
"velocidad",
"self",
".",
"tiempo",
"=",
"tiempo",
"return",
"tiempo"
] | [
40,
4
] | [
48,
21
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Battery.describe_battery | (self) | Tamaño de la bateria | Tamaño de la bateria | def describe_battery(self):
"""Tamaño de la bateria"""
print("Este carro tiene una bateria de " + str(self.battery_size) + " kWh") | [
"def",
"describe_battery",
"(",
"self",
")",
":",
"print",
"(",
"\"Este carro tiene una bateria de \"",
"+",
"str",
"(",
"self",
".",
"battery_size",
")",
"+",
"\" kWh\"",
")"
] | [
45,
4
] | [
47,
83
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
NetworkCallback.id2network | (networkid: int, *, cursor) | return network | A partir del identificador, se obtiene la dirección de la red | A partir del identificador, se obtiene la dirección de la red | async def id2network(networkid: int, *, cursor) -> Tuple[str]:
"""A partir del identificador, se obtiene la dirección de la red"""
await cursor.execute(
"SELECT network FROM networks WHERE id_network = %s LIMIT 1",
(networkid,)
)
network = await cursor.fetchone()
return network | [
"async",
"def",
"id2network",
"(",
"networkid",
":",
"int",
",",
"*",
",",
"cursor",
")",
"->",
"Tuple",
"[",
"str",
"]",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT network FROM networks WHERE id_network = %s LIMIT 1\"",
",",
"(",
"networkid",
",",
")",
")",
"network",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"network"
] | [
528,
4
] | [
539,
22
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DominioTSP.fcosto | (self, sol) | return costo | Calcula el costo asociado con una solución dada.
Entradas:
sol (list)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
| Calcula el costo asociado con una solución dada. | def fcosto(self, sol):
"""Calcula el costo asociado con una solución dada.
Entradas:
sol (list)
Solución cuyo costo se debe calcular
Salidas:
(float) valor del costo asociado con la solución
"""
# Pendiente: implementar este método
# pass
#Posible implementacion, revisar luego
costo = 0
ciudad_actual = self.ciudades.index(self.posicion_ciudad_inicio)
#Se recorre la solucion
for i in sol:
sumar=self.costos[int(i)][int(ciudad_actual)]
costo=costo+float(sumar)
ciudad_actual = i
return costo | [
"def",
"fcosto",
"(",
"self",
",",
"sol",
")",
":",
"# Pendiente: implementar este método",
"# pass",
"#Posible implementacion, revisar luego",
"costo",
"=",
"0",
"ciudad_actual",
"=",
"self",
".",
"ciudades",
".",
"index",
"(",
"self",
".",
"posicion_ciudad_inicio",
")",
"#Se recorre la solucion",
"for",
"i",
"in",
"sol",
":",
"sumar",
"=",
"self",
".",
"costos",
"[",
"int",
"(",
"i",
")",
"]",
"[",
"int",
"(",
"ciudad_actual",
")",
"]",
"costo",
"=",
"costo",
"+",
"float",
"(",
"sumar",
")",
"ciudad_actual",
"=",
"i",
"return",
"costo"
] | [
133,
4
] | [
157,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Residential.transform_vars | (self) | Normaliza el excel de datos. | Normaliza el excel de datos. | def transform_vars(self):
"""Normaliza el excel de datos."""
self.var_list = []
variables = self.data.iloc[:, 15:]
var_labels = variables.keys()
loop_length = int(len(var_labels)/2)
for value in range(0, loop_length):
self.var_list.append(
var_labels[value] +
'|' +
var_labels[loop_length+value]
) | [
"def",
"transform_vars",
"(",
"self",
")",
":",
"self",
".",
"var_list",
"=",
"[",
"]",
"variables",
"=",
"self",
".",
"data",
".",
"iloc",
"[",
":",
",",
"15",
":",
"]",
"var_labels",
"=",
"variables",
".",
"keys",
"(",
")",
"loop_length",
"=",
"int",
"(",
"len",
"(",
"var_labels",
")",
"/",
"2",
")",
"for",
"value",
"in",
"range",
"(",
"0",
",",
"loop_length",
")",
":",
"self",
".",
"var_list",
".",
"append",
"(",
"var_labels",
"[",
"value",
"]",
"+",
"'|'",
"+",
"var_labels",
"[",
"loop_length",
"+",
"value",
"]",
")"
] | [
29,
4
] | [
44,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
getTareasById | (usuarioId) | return resultado | Funcion generica para el uso de busqueda de tareas por un id de usuario | Funcion generica para el uso de busqueda de tareas por un id de usuario | def getTareasById(usuarioId):
"""Funcion generica para el uso de busqueda de tareas por un id de usuario"""
tareas = TareaModel.query.filter_by(usuario=usuarioId).order_by(
TareaModel.tareaFecha.desc()).all()
resultado = []
for tarea in tareas:
resultado.append(tarea.json())
return resultado | [
"def",
"getTareasById",
"(",
"usuarioId",
")",
":",
"tareas",
"=",
"TareaModel",
".",
"query",
".",
"filter_by",
"(",
"usuario",
"=",
"usuarioId",
")",
".",
"order_by",
"(",
"TareaModel",
".",
"tareaFecha",
".",
"desc",
"(",
")",
")",
".",
"all",
"(",
")",
"resultado",
"=",
"[",
"]",
"for",
"tarea",
"in",
"tareas",
":",
"resultado",
".",
"append",
"(",
"tarea",
".",
"json",
"(",
")",
")",
"return",
"resultado"
] | [
39,
0
] | [
46,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Smartphone.carga | (self, enchufe) | Carga el smartphone con el voltaje de entrada proporcionado. | Carga el smartphone con el voltaje de entrada proporcionado. | def carga(self, enchufe):
"""Carga el smartphone con el voltaje de entrada proporcionado."""
self._carga(enchufe.voltaje_de_salida) | [
"def",
"carga",
"(",
"self",
",",
"enchufe",
")",
":",
"self",
".",
"_carga",
"(",
"enchufe",
".",
"voltaje_de_salida",
")"
] | [
6,
4
] | [
8,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TextRenderer.render | (self) | return self._text | Función que regresa el texto ingresado | Función que regresa el texto ingresado | def render(self):
"""Función que regresa el texto ingresado"""
return self._text | [
"def",
"render",
"(",
"self",
")",
":",
"return",
"self",
".",
"_text"
] | [
25,
4
] | [
27,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
ErrorHTML.__init__ | (self) | GENERAR HTML PARA LOS ERRORES LEXICOS, SINTACTICOS Y SEMANTICOS | GENERAR HTML PARA LOS ERRORES LEXICOS, SINTACTICOS Y SEMANTICOS | def __init__(self):
''' GENERAR HTML PARA LOS ERRORES LEXICOS, SINTACTICOS Y SEMANTICOS''' | [
"def",
"__init__",
"(",
"self",
")",
":"
] | [
10,
4
] | [
11,
78
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
RBF.rbf | (self, x, c, r) | return np.exp(-0.5 * distance/r**2 ) | Calcula el valor de la función de base radial
gaussiana en un punto x, con respecto al centroide
dado por c y con parámetro de escala r | Calcula el valor de la función de base radial
gaussiana en un punto x, con respecto al centroide
dado por c y con parámetro de escala r | def rbf(self, x, c, r):
""" Calcula el valor de la función de base radial
gaussiana en un punto x, con respecto al centroide
dado por c y con parámetro de escala r """
distance = np.linalg.norm(x-c, ord=2)
return np.exp(-0.5 * distance/r**2 ) | [
"def",
"rbf",
"(",
"self",
",",
"x",
",",
"c",
",",
"r",
")",
":",
"distance",
"=",
"np",
".",
"linalg",
".",
"norm",
"(",
"x",
"-",
"c",
",",
"ord",
"=",
"2",
")",
"return",
"np",
".",
"exp",
"(",
"-",
"0.5",
"*",
"distance",
"/",
"r",
"**",
"2",
")"
] | [
49,
4
] | [
55,
44
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlotGraphics.getYLabel | (self) | return self.yLabel | Get y axis label string | Get y axis label string | def getYLabel(self):
"""Get y axis label string"""
return self.yLabel | [
"def",
"getYLabel",
"(",
"self",
")",
":",
"return",
"self",
".",
"yLabel"
] | [
374,
4
] | [
376,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
BSimplex.set_mu | (self, simplex, j, l, value) | mu ha de ser una aplicacón que va de nCounters a nCounters | mu ha de ser una aplicacón que va de nCounters a nCounters | def set_mu(self, simplex, j, l, value):
'''mu ha de ser una aplicacón que va de nCounters a nCounters'''
self._mu[simplex,j,l]=value | [
"def",
"set_mu",
"(",
"self",
",",
"simplex",
",",
"j",
",",
"l",
",",
"value",
")",
":",
"self",
".",
"_mu",
"[",
"simplex",
",",
"j",
",",
"l",
"]",
"=",
"value"
] | [
249,
4
] | [
251,
35
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
replaceTupla | (tupla,i,val) | return tupla[:i] + (val,) + tupla[i+1:] | Cambia el valor i-esimo de una tupla por val | Cambia el valor i-esimo de una tupla por val | def replaceTupla(tupla,i,val):
"Cambia el valor i-esimo de una tupla por val"
return tupla[:i] + (val,) + tupla[i+1:] | [
"def",
"replaceTupla",
"(",
"tupla",
",",
"i",
",",
"val",
")",
":",
"return",
"tupla",
"[",
":",
"i",
"]",
"+",
"(",
"val",
",",
")",
"+",
"tupla",
"[",
"i",
"+",
"1",
":",
"]"
] | [
468,
0
] | [
470,
43
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
RatTube.confirmar_Descargar | (self) | Este método hace uso de la biblioteca pytube,de la clase Youtube y sus métodos.
Permite realizar la descarga del video, pideo una url y la ruta de guardado
por defecto se guarda en la carpeta donde esté el script | Este método hace uso de la biblioteca pytube,de la clase Youtube y sus métodos.
Permite realizar la descarga del video, pideo una url y la ruta de guardado
por defecto se guarda en la carpeta donde esté el script | def confirmar_Descargar(self):
url = input('\n\nIngresa la URL del video: ')
ruta = input('\nEn qué ruta de tu equipo guardarás el archivo\n(si no pones una ruta, se guardará en el directorio del script)? ')
yt = YouTube(url, on_progress_callback=self.progress_function)
print("\n", yt.title)
global video
video = yt.streams.first()
size1 = str(round(video.filesize / (1024 * 1024)))
print("\nTamaño del video: ", size1, " MB aprox.")
video.download(ruta)
tecla = input("\nPresione cualquier tecla para terminar")
time.sleep(3)
print("\n\nAdiós")
'''Este método hace uso de la biblioteca pytube,de la clase Youtube y sus métodos.
Permite realizar la descarga del video, pideo una url y la ruta de guardado
por defecto se guarda en la carpeta donde esté el script'''
| [
"def",
"confirmar_Descargar",
"(",
"self",
")",
":",
"url",
"=",
"input",
"(",
"'\\n\\nIngresa la URL del video: '",
")",
"ruta",
"=",
"input",
"(",
"'\\nEn qué ruta de tu equipo guardarás el archivo\\n(si no pones una ruta, se guardará en el directorio del script)? ')\r",
"",
"yt",
"=",
"YouTube",
"(",
"url",
",",
"on_progress_callback",
"=",
"self",
".",
"progress_function",
")",
"print",
"(",
"\"\\n\"",
",",
"yt",
".",
"title",
")",
"global",
"video",
"video",
"=",
"yt",
".",
"streams",
".",
"first",
"(",
")",
"size1",
"=",
"str",
"(",
"round",
"(",
"video",
".",
"filesize",
"/",
"(",
"1024",
"*",
"1024",
")",
")",
")",
"print",
"(",
"\"\\nTamaño del video: \",",
" ",
"ize1,",
" ",
" MB aprox.\")",
"\r",
"video",
".",
"download",
"(",
"ruta",
")",
"tecla",
"=",
"input",
"(",
"\"\\nPresione cualquier tecla para terminar\"",
")",
"time",
".",
"sleep",
"(",
"3",
")",
"print",
"(",
"\"\\n\\nAdiós\")",
"\r"
] | [
48,
1
] | [
68,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.fecha_completa | (self, field, time_format, keep_original=False,
inplace=False) | return parsed_series | Regla para fechas completas que están en un sólo campo.
Args:
field (str): Campo a limpiar.
time_format (str): Formato temporal del campo.
Returns:
pandas.Series: Serie de strings limpios
| Regla para fechas completas que están en un sólo campo. | def fecha_completa(self, field, time_format, keep_original=False,
inplace=False):
"""Regla para fechas completas que están en un sólo campo.
Args:
field (str): Campo a limpiar.
time_format (str): Formato temporal del campo.
Returns:
pandas.Series: Serie de strings limpios
"""
field = self._normalize_field(field)
series = self.df[field]
parsed_series = series.apply(self._parse_datetime,
args=(time_format,))
if inplace:
self._update_series(field=field, prefix="isodatetime",
keep_original=keep_original,
new_series=parsed_series)
return parsed_series | [
"def",
"fecha_completa",
"(",
"self",
",",
"field",
",",
"time_format",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"series",
"=",
"self",
".",
"df",
"[",
"field",
"]",
"parsed_series",
"=",
"series",
".",
"apply",
"(",
"self",
".",
"_parse_datetime",
",",
"args",
"=",
"(",
"time_format",
",",
")",
")",
"if",
"inplace",
":",
"self",
".",
"_update_series",
"(",
"field",
"=",
"field",
",",
"prefix",
"=",
"\"isodatetime\"",
",",
"keep_original",
"=",
"keep_original",
",",
"new_series",
"=",
"parsed_series",
")",
"return",
"parsed_series"
] | [
507,
4
] | [
527,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_mayores_registrantes | (limit=5, de_registrantes_etiquetados=False, etiqueta=None) | return regs[:limit] | registrantes con más dominios | registrantes con más dominios | def get_mayores_registrantes(limit=5, de_registrantes_etiquetados=False, etiqueta=None):
""" registrantes con más dominios """
regs = Registrante.objects.annotate(total_dominios=Count('dominios'))
if de_registrantes_etiquetados:
regs = regs.annotate(total_tags=Count('tags')).filter(total_tags__gt=0)
if etiqueta is not None:
regs = regs.filter(tags__tag=etiqueta)
regs = regs.order_by('-total_dominios')
return regs[:limit] | [
"def",
"get_mayores_registrantes",
"(",
"limit",
"=",
"5",
",",
"de_registrantes_etiquetados",
"=",
"False",
",",
"etiqueta",
"=",
"None",
")",
":",
"regs",
"=",
"Registrante",
".",
"objects",
".",
"annotate",
"(",
"total_dominios",
"=",
"Count",
"(",
"'dominios'",
")",
")",
"if",
"de_registrantes_etiquetados",
":",
"regs",
"=",
"regs",
".",
"annotate",
"(",
"total_tags",
"=",
"Count",
"(",
"'tags'",
")",
")",
".",
"filter",
"(",
"total_tags__gt",
"=",
"0",
")",
"if",
"etiqueta",
"is",
"not",
"None",
":",
"regs",
"=",
"regs",
".",
"filter",
"(",
"tags__tag",
"=",
"etiqueta",
")",
"regs",
"=",
"regs",
".",
"order_by",
"(",
"'-total_dominios'",
")",
"return",
"regs",
"[",
":",
"limit",
"]"
] | [
22,
0
] | [
33,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_PROPIETARIO_5 | (t) | PROPIETARIO : owner cadenaString | PROPIETARIO : owner cadenaString | def p_PROPIETARIO_5(t):
'''PROPIETARIO : owner cadenaString'''
t[0] = 'owner \"' + str(t[2]) + '\"'
listaBNF.append("PROPIETARIO ::= owner " + str(t[2])) | [
"def",
"p_PROPIETARIO_5",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"'owner \\\"'",
"+",
"str",
"(",
"t",
"[",
"2",
"]",
")",
"+",
"'\\\"'",
"listaBNF",
".",
"append",
"(",
"\"PROPIETARIO ::= owner \"",
"+",
"str",
"(",
"t",
"[",
"2",
"]",
")",
")"
] | [
1289,
0
] | [
1292,
57
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
strip | (cadena) | return "\n".join(linea.strip()
for linea in cadena.split("\n") if linea).strip() | Retorna una cadena sin espacios a los lados en cada línea. | Retorna una cadena sin espacios a los lados en cada línea. | def strip(cadena):
"""Retorna una cadena sin espacios a los lados en cada línea."""
return "\n".join(linea.strip()
for linea in cadena.split("\n") if linea).strip() | [
"def",
"strip",
"(",
"cadena",
")",
":",
"return",
"\"\\n\"",
".",
"join",
"(",
"linea",
".",
"strip",
"(",
")",
"for",
"linea",
"in",
"cadena",
".",
"split",
"(",
"\"\\n\"",
")",
"if",
"linea",
")",
".",
"strip",
"(",
")"
] | [
25,
0
] | [
28,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_expresionhaving | (t) | expresionhaving : cualquiercadena
| expresionaritmetica
| condicionhavingagregacion
| funcion_matematica_ws | expresionhaving : cualquiercadena
| expresionaritmetica
| condicionhavingagregacion
| funcion_matematica_ws | def p_expresionhaving(t):
'''expresionhaving : cualquiercadena
| expresionaritmetica
| condicionhavingagregacion
| funcion_matematica_ws'''
t[0] = t[1] | [
"def",
"p_expresionhaving",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
1039,
0
] | [
1044,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Compra.precio_total | (self) | return total | Retorna la suma de los precios totales de todos los detalles de la compra | Retorna la suma de los precios totales de todos los detalles de la compra | def precio_total(self):
"Retorna la suma de los precios totales de todos los detalles de la compra"
total = 0
total += sum(d.precio_total for d in self.detalleinsumo_set.all())
total += sum(d.precio_total for d in self.detalleproducto_set.all())
return total | [
"def",
"precio_total",
"(",
"self",
")",
":",
"total",
"=",
"0",
"total",
"+=",
"sum",
"(",
"d",
".",
"precio_total",
"for",
"d",
"in",
"self",
".",
"detalleinsumo_set",
".",
"all",
"(",
")",
")",
"total",
"+=",
"sum",
"(",
"d",
".",
"precio_total",
"for",
"d",
"in",
"self",
".",
"detalleproducto_set",
".",
"all",
"(",
")",
")",
"return",
"total"
] | [
23,
4
] | [
30,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
EAD.get_name_and_ext | (self, filename) | return (nombre_sin_extension, extension) | Separa el nombre y la extensión del archivo | Separa el nombre y la extensión del archivo | def get_name_and_ext(self, filename):
"""Separa el nombre y la extensión del archivo"""
extension = ''
for ext in self.extensiones:
if filename.endswith(ext):
extension = ext
break
if extension == '':
raise ExtensionError
ancho_extension = len(extension)
nombre_sin_extension = filename[:(ancho_extension+1)*-1]
return (nombre_sin_extension, extension) | [
"def",
"get_name_and_ext",
"(",
"self",
",",
"filename",
")",
":",
"extension",
"=",
"''",
"for",
"ext",
"in",
"self",
".",
"extensiones",
":",
"if",
"filename",
".",
"endswith",
"(",
"ext",
")",
":",
"extension",
"=",
"ext",
"break",
"if",
"extension",
"==",
"''",
":",
"raise",
"ExtensionError",
"ancho_extension",
"=",
"len",
"(",
"extension",
")",
"nombre_sin_extension",
"=",
"filename",
"[",
":",
"(",
"ancho_extension",
"+",
"1",
")",
"*",
"-",
"1",
"]",
"return",
"(",
"nombre_sin_extension",
",",
"extension",
")"
] | [
6,
4
] | [
21,
48
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
con_que_se_juega | () | Selector de horarios, se llama a los modulos respectivos de cada dataset | Selector de horarios, se llama a los modulos respectivos de cada dataset | def con_que_se_juega():
"""Selector de horarios, se llama a los modulos respectivos de cada dataset"""
if es_madrugada():
return sort_cars_by_rating()
if es_manana():
return countries_dataset(dia_de_juego)
if es_noche():
return lol_dataset(dia_de_juego) | [
"def",
"con_que_se_juega",
"(",
")",
":",
"if",
"es_madrugada",
"(",
")",
":",
"return",
"sort_cars_by_rating",
"(",
")",
"if",
"es_manana",
"(",
")",
":",
"return",
"countries_dataset",
"(",
"dia_de_juego",
")",
"if",
"es_noche",
"(",
")",
":",
"return",
"lol_dataset",
"(",
"dia_de_juego",
")"
] | [
23,
0
] | [
30,
40
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_Bom._calc_total | (self) | Calcula la multiplicacion de repeticiones y cantidad. | Calcula la multiplicacion de repeticiones y cantidad. | def _calc_total(self):
""" Calcula la multiplicacion de repeticiones y cantidad. """
for record in self:
record.total = record.repetitions * record.quantity | [
"def",
"_calc_total",
"(",
"self",
")",
":",
"for",
"record",
"in",
"self",
":",
"record",
".",
"total",
"=",
"record",
".",
"repetitions",
"*",
"record",
".",
"quantity"
] | [
53,
4
] | [
56,
63
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TrackingVideo.__getitem__ | (self, item: int) | return frame | Obtiene el frame item-ésimo con los dibujados aplicados.
Primeramente aplica las funciones y luego los dibujados internos.
:param item: índice del frame.
:return: frame con los dibujados aplicados.
| Obtiene el frame item-ésimo con los dibujados aplicados. | def __getitem__(self, item: int) -> Image:
"""Obtiene el frame item-ésimo con los dibujados aplicados.
Primeramente aplica las funciones y luego los dibujados internos.
:param item: índice del frame.
:return: frame con los dibujados aplicados.
"""
frame = self.input_sequence[item].copy()
# Aplicar funciones añadidas.
for function in self._functions:
frame = function(frame)
# Aplicar dibujados internos.
frame = self._apply_internal_drawings(item, frame)
return frame | [
"def",
"__getitem__",
"(",
"self",
",",
"item",
":",
"int",
")",
"->",
"Image",
":",
"frame",
"=",
"self",
".",
"input_sequence",
"[",
"item",
"]",
".",
"copy",
"(",
")",
"# Aplicar funciones añadidas.",
"for",
"function",
"in",
"self",
".",
"_functions",
":",
"frame",
"=",
"function",
"(",
"frame",
")",
"# Aplicar dibujados internos.",
"frame",
"=",
"self",
".",
"_apply_internal_drawings",
"(",
"item",
",",
"frame",
")",
"return",
"frame"
] | [
69,
4
] | [
83,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
UrlDbWriter.write | (self, element, is_update=False) | Escribe la información del código postal en la base de datos.
Arguments
---------
element : dict
diccionario con la información del código postal y la url de acceso búsqueda
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
Returns
-------
True
si se ha insertado correctamente en la base de datos.
False
si no se ha insertado.
| Escribe la información del código postal en la base de datos. | def write(self, element, is_update=False):
"""Escribe la información del código postal en la base de datos.
Arguments
---------
element : dict
diccionario con la información del código postal y la url de acceso búsqueda
is_update : bool
flag que determina si se está ejecutando un proceso de recovery
Returns
-------
True
si se ha insertado correctamente en la base de datos.
False
si no se ha insertado.
"""
cursor = self.db.cursor()
zip_code = element.get("zip_code")
gmaps_url = element.get("gmaps_url")
gmaps_coordinates = element.get("gmaps_coordinates")
country = element.get("country")
inserted = False
try:
values = (zip_code, gmaps_url, gmaps_coordinates, country)
cursor.execute(self._insert_zip_code_info, values)
self.db.commit()
inserted = True
except Exception as e:
self.db.rollback()
self.logger.error("error during writing data for postal code: -{zip_code}-".format(
zip_code=zip_code))
self.logger.error(str(e))
self.logger.error("wrong values:")
self.logger.error(element)
finally:
cursor.close()
return inserted | [
"def",
"write",
"(",
"self",
",",
"element",
",",
"is_update",
"=",
"False",
")",
":",
"cursor",
"=",
"self",
".",
"db",
".",
"cursor",
"(",
")",
"zip_code",
"=",
"element",
".",
"get",
"(",
"\"zip_code\"",
")",
"gmaps_url",
"=",
"element",
".",
"get",
"(",
"\"gmaps_url\"",
")",
"gmaps_coordinates",
"=",
"element",
".",
"get",
"(",
"\"gmaps_coordinates\"",
")",
"country",
"=",
"element",
".",
"get",
"(",
"\"country\"",
")",
"inserted",
"=",
"False",
"try",
":",
"values",
"=",
"(",
"zip_code",
",",
"gmaps_url",
",",
"gmaps_coordinates",
",",
"country",
")",
"cursor",
".",
"execute",
"(",
"self",
".",
"_insert_zip_code_info",
",",
"values",
")",
"self",
".",
"db",
".",
"commit",
"(",
")",
"inserted",
"=",
"True",
"except",
"Exception",
"as",
"e",
":",
"self",
".",
"db",
".",
"rollback",
"(",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"error during writing data for postal code: -{zip_code}-\"",
".",
"format",
"(",
"zip_code",
"=",
"zip_code",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"str",
"(",
"e",
")",
")",
"self",
".",
"logger",
".",
"error",
"(",
"\"wrong values:\"",
")",
"self",
".",
"logger",
".",
"error",
"(",
"element",
")",
"finally",
":",
"cursor",
".",
"close",
"(",
")",
"return",
"inserted"
] | [
120,
4
] | [
156,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Residential.listLabels | (self) | Divide la columna en category y label.
Si la suma de nulos es total - 1 es una category
Si no es una label y guarda ambas en una lista
separadas por el símbolo |.
| Divide la columna en category y label. | def listLabels(self):
"""Divide la columna en category y label.
Si la suma de nulos es total - 1 es una category
Si no es una label y guarda ambas en una lista
separadas por el símbolo |.
"""
self.categories = []
self.labels = []
val_cat = None
# Obtengo la cantidad de nulos por cada fila
dicNull = self.df.isnull().sum(axis=1).tolist()
# Cantidad de columnas del dataframe
df_length = len(self.df.columns) - 1
# Borra las primeras dos filas que son cabeceras
self.df = self.df.iloc[2:]
for row, col in self.df.iterrows():
if dicNull[row] == df_length:
self.categories.append(col[self.cfg.config_col_name])
val_cat = col[self.cfg.config_col_name]
else:
# Añadimos la category + la label juntas
# Ejemplo:
# Índice de Cobertura (nº de plazas/población>=65)*100.|Total
self.labels.append(val_cat+'|'+col[self.cfg.config_col_name]) | [
"def",
"listLabels",
"(",
"self",
")",
":",
"self",
".",
"categories",
"=",
"[",
"]",
"self",
".",
"labels",
"=",
"[",
"]",
"val_cat",
"=",
"None",
"# Obtengo la cantidad de nulos por cada fila",
"dicNull",
"=",
"self",
".",
"df",
".",
"isnull",
"(",
")",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
".",
"tolist",
"(",
")",
"# Cantidad de columnas del dataframe",
"df_length",
"=",
"len",
"(",
"self",
".",
"df",
".",
"columns",
")",
"-",
"1",
"# Borra las primeras dos filas que son cabeceras",
"self",
".",
"df",
"=",
"self",
".",
"df",
".",
"iloc",
"[",
"2",
":",
"]",
"for",
"row",
",",
"col",
"in",
"self",
".",
"df",
".",
"iterrows",
"(",
")",
":",
"if",
"dicNull",
"[",
"row",
"]",
"==",
"df_length",
":",
"self",
".",
"categories",
".",
"append",
"(",
"col",
"[",
"self",
".",
"cfg",
".",
"config_col_name",
"]",
")",
"val_cat",
"=",
"col",
"[",
"self",
".",
"cfg",
".",
"config_col_name",
"]",
"else",
":",
"# Añadimos la category + la label juntas",
"# Ejemplo:",
"# Índice de Cobertura (nº de plazas/población>=65)*100.|Total",
"self",
".",
"labels",
".",
"append",
"(",
"val_cat",
"+",
"'|'",
"+",
"col",
"[",
"self",
".",
"cfg",
".",
"config_col_name",
"]",
")"
] | [
46,
4
] | [
74,
77
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_op_aritmetica22 | (t) | operacion_aritmetica : funciones_extras | operacion_aritmetica : funciones_extras | def p_op_aritmetica22(t):
'operacion_aritmetica : funciones_extras'
node= grammer.nodoDireccion('operacion_aritmetica')
#node2= grammer.nodoDireccion(t[1])
node.agregar(t[1])
#node.agregar(t)
t[0]=node | [
"def",
"p_op_aritmetica22",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'operacion_aritmetica'",
")",
"#node2= grammer.nodoDireccion(t[1])",
"node",
".",
"agregar",
"(",
"t",
"[",
"1",
"]",
")",
"#node.agregar(t)",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1798,
0
] | [
1804,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Builder.create_new_hamburguer | (self) | Escogemos la clase Food | Escogemos la clase Food | def create_new_hamburguer(self):
"""Escogemos la clase Food"""
self.food = Food() | [
"def",
"create_new_hamburguer",
"(",
"self",
")",
":",
"self",
".",
"food",
"=",
"Food",
"(",
")"
] | [
31,
4
] | [
33,
26
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Factura.as_anexo2_json | (self) | return data, errores_generacion | recuperar los datos de esta factura en el formato que
la librería Anexo2 (en Pypi) requiere
Requisitos acá: https://github.com/cluster311/Anexo2
| recuperar los datos de esta factura en el formato que
la librería Anexo2 (en Pypi) requiere
Requisitos acá: https://github.com/cluster311/Anexo2
| def as_anexo2_json(self):
""" recuperar los datos de esta factura en el formato que
la librería Anexo2 (en Pypi) requiere
Requisitos acá: https://github.com/cluster311/Anexo2
"""
# Dict para almacenar errores de datos faltantes
errores_generacion = {}
try:
hospital = self.centro_de_salud.as_anexo2_json()
except AttributeError:
errores_generacion['hospital'] = "Debe asignar un centro de salud en la factura"
hospital = None
try:
beneficiario = self.paciente.as_anexo2_json()
except AttributeError:
errores_generacion['beneficiario'] = "Debe asignar un paciente en la factura"
beneficiario = None
try:
profesional = self.profesional.as_anexo2_json()
except AttributeError:
errores_generacion['profesional'] = "Debe asignar un profesional en la factura"
profesional = None
especialidad = str(self.especialidad) if self.especialidad else None
if especialidad is None:
errores_generacion['especialidad'] = "Debe asignar una especialidad en la factura"
try:
# TODO Verificar si el cod cie principal puede estar vacío
cie_principal = self.codigo_cie_principal.code
except AttributeError:
errores_generacion['cie_principal'] = "Debe asignar un código de CIE10 principal en la factura"
cie_principal = None
cie_secundarios = '' if self.codigos_cie_secundarios is None else [c10.code for c10 in self.codigos_cie_secundarios.all()]
try:
# Extraer códigos de las prestaciones copiadas de la consulta
cod_hpgd = [prestacion.tipo.codigo for prestacion in self.prestacionesFactura.all()]
# Obtener la lista de tipos de las prestaciones de la factura en minúscula
# > ['consulta', 'práctica', 'internación']
lista_tipos = [prestacion.tipo.get_tipo_display().casefold() for prestacion in self.prestacionesFactura.all()]
# Reemplazar valores Desconocido y Laboratorio
lista_tipos = [
t.replace('desconocido', 'consulta').replace('laboratorio', 'práctica')
for t in lista_tipos
]
# Al convertir a set se eliminan los valores duplicados
# Luego se convierte a lista porque es lo que espera el Anexo2
prestaciones = list(set(lista_tipos))
except AttributeError:
errores_generacion['códigos N HPGD'] = "Debe asignar al menos una prestación en la factura"
cod_hpgd = None
tipo = None
try:
fecha_atencion = {
'dia': self.fecha_atencion.day,
'mes': self.fecha_atencion.month,
'anio': self.fecha_atencion.year
}
except AttributeError:
errores_generacion['fecha_atencion'] = "Debe asignar una fecha correcta en la factura"
fecha_atencion = None
atencion = {'tipo': prestaciones,
'profesional': profesional,
'especialidad': especialidad,
'codigos_N_HPGD': cod_hpgd,
'fecha': fecha_atencion,
'diagnostico_ingreso_cie10': {
'principal': cie_principal,
'otros': cie_secundarios
}
}
# Obtener los datos de la Obra Social del Paciente
# a través de la relación M2M ObraSocial <=> Paciente
try:
os_paciente = self.obra_social.pacientes.get(paciente=self.paciente)
obra_social = os_paciente.as_anexo2_json()
except AttributeError:
errores_generacion['obra_social'] = "Debe asignar una obra social en la factura"
obra_social = None
try:
# TODO - Revisar como se obtienen los datos de la empresa actual del paciente
# Obtener la primera empresa del paciente
empresa_paciente = self.paciente.empresapaciente_set.first()
empresa = empresa_paciente.as_anexo2_json()
except AttributeError:
errores_generacion['empresa'] = "El paciente debe tener asignada al menos una empresa"
empresa = None
# Quitar los valores de obra_social y asignarlos a beneficiario
# para evitar errores de validación de Anexo2
beneficiario['tipo_beneficiario'] = obra_social.pop('tipo_beneficiario')
beneficiario['parentesco'] = obra_social.pop('parentesco')
fecha_actual = timezone.now().date()
data = {'dia': fecha_actual.day,
'mes': fecha_actual.month,
'anio': fecha_actual.year,
'hospital': hospital,
'beneficiario': beneficiario,
'atencion': atencion,
'obra_social': obra_social,
'empresa': empresa
}
return data, errores_generacion | [
"def",
"as_anexo2_json",
"(",
"self",
")",
":",
"# Dict para almacenar errores de datos faltantes",
"errores_generacion",
"=",
"{",
"}",
"try",
":",
"hospital",
"=",
"self",
".",
"centro_de_salud",
".",
"as_anexo2_json",
"(",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'hospital'",
"]",
"=",
"\"Debe asignar un centro de salud en la factura\"",
"hospital",
"=",
"None",
"try",
":",
"beneficiario",
"=",
"self",
".",
"paciente",
".",
"as_anexo2_json",
"(",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'beneficiario'",
"]",
"=",
"\"Debe asignar un paciente en la factura\"",
"beneficiario",
"=",
"None",
"try",
":",
"profesional",
"=",
"self",
".",
"profesional",
".",
"as_anexo2_json",
"(",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'profesional'",
"]",
"=",
"\"Debe asignar un profesional en la factura\"",
"profesional",
"=",
"None",
"especialidad",
"=",
"str",
"(",
"self",
".",
"especialidad",
")",
"if",
"self",
".",
"especialidad",
"else",
"None",
"if",
"especialidad",
"is",
"None",
":",
"errores_generacion",
"[",
"'especialidad'",
"]",
"=",
"\"Debe asignar una especialidad en la factura\"",
"try",
":",
"# TODO Verificar si el cod cie principal puede estar vacío",
"cie_principal",
"=",
"self",
".",
"codigo_cie_principal",
".",
"code",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'cie_principal'",
"]",
"=",
"\"Debe asignar un código de CIE10 principal en la factura\"",
"cie_principal",
"=",
"None",
"cie_secundarios",
"=",
"''",
"if",
"self",
".",
"codigos_cie_secundarios",
"is",
"None",
"else",
"[",
"c10",
".",
"code",
"for",
"c10",
"in",
"self",
".",
"codigos_cie_secundarios",
".",
"all",
"(",
")",
"]",
"try",
":",
"# Extraer códigos de las prestaciones copiadas de la consulta",
"cod_hpgd",
"=",
"[",
"prestacion",
".",
"tipo",
".",
"codigo",
"for",
"prestacion",
"in",
"self",
".",
"prestacionesFactura",
".",
"all",
"(",
")",
"]",
"# Obtener la lista de tipos de las prestaciones de la factura en minúscula",
"# > ['consulta', 'práctica', 'internación']",
"lista_tipos",
"=",
"[",
"prestacion",
".",
"tipo",
".",
"get_tipo_display",
"(",
")",
".",
"casefold",
"(",
")",
"for",
"prestacion",
"in",
"self",
".",
"prestacionesFactura",
".",
"all",
"(",
")",
"]",
"# Reemplazar valores Desconocido y Laboratorio",
"lista_tipos",
"=",
"[",
"t",
".",
"replace",
"(",
"'desconocido'",
",",
"'consulta'",
")",
".",
"replace",
"(",
"'laboratorio'",
",",
"'práctica')",
"",
"for",
"t",
"in",
"lista_tipos",
"]",
"# Al convertir a set se eliminan los valores duplicados",
"# Luego se convierte a lista porque es lo que espera el Anexo2",
"prestaciones",
"=",
"list",
"(",
"set",
"(",
"lista_tipos",
")",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'códigos N HPGD']",
" ",
" ",
"Debe asignar al menos una prestación en la factura\"",
"cod_hpgd",
"=",
"None",
"tipo",
"=",
"None",
"try",
":",
"fecha_atencion",
"=",
"{",
"'dia'",
":",
"self",
".",
"fecha_atencion",
".",
"day",
",",
"'mes'",
":",
"self",
".",
"fecha_atencion",
".",
"month",
",",
"'anio'",
":",
"self",
".",
"fecha_atencion",
".",
"year",
"}",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'fecha_atencion'",
"]",
"=",
"\"Debe asignar una fecha correcta en la factura\"",
"fecha_atencion",
"=",
"None",
"atencion",
"=",
"{",
"'tipo'",
":",
"prestaciones",
",",
"'profesional'",
":",
"profesional",
",",
"'especialidad'",
":",
"especialidad",
",",
"'codigos_N_HPGD'",
":",
"cod_hpgd",
",",
"'fecha'",
":",
"fecha_atencion",
",",
"'diagnostico_ingreso_cie10'",
":",
"{",
"'principal'",
":",
"cie_principal",
",",
"'otros'",
":",
"cie_secundarios",
"}",
"}",
"# Obtener los datos de la Obra Social del Paciente",
"# a través de la relación M2M ObraSocial <=> Paciente",
"try",
":",
"os_paciente",
"=",
"self",
".",
"obra_social",
".",
"pacientes",
".",
"get",
"(",
"paciente",
"=",
"self",
".",
"paciente",
")",
"obra_social",
"=",
"os_paciente",
".",
"as_anexo2_json",
"(",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'obra_social'",
"]",
"=",
"\"Debe asignar una obra social en la factura\"",
"obra_social",
"=",
"None",
"try",
":",
"# TODO - Revisar como se obtienen los datos de la empresa actual del paciente",
"# Obtener la primera empresa del paciente",
"empresa_paciente",
"=",
"self",
".",
"paciente",
".",
"empresapaciente_set",
".",
"first",
"(",
")",
"empresa",
"=",
"empresa_paciente",
".",
"as_anexo2_json",
"(",
")",
"except",
"AttributeError",
":",
"errores_generacion",
"[",
"'empresa'",
"]",
"=",
"\"El paciente debe tener asignada al menos una empresa\"",
"empresa",
"=",
"None",
"# Quitar los valores de obra_social y asignarlos a beneficiario",
"# para evitar errores de validación de Anexo2",
"beneficiario",
"[",
"'tipo_beneficiario'",
"]",
"=",
"obra_social",
".",
"pop",
"(",
"'tipo_beneficiario'",
")",
"beneficiario",
"[",
"'parentesco'",
"]",
"=",
"obra_social",
".",
"pop",
"(",
"'parentesco'",
")",
"fecha_actual",
"=",
"timezone",
".",
"now",
"(",
")",
".",
"date",
"(",
")",
"data",
"=",
"{",
"'dia'",
":",
"fecha_actual",
".",
"day",
",",
"'mes'",
":",
"fecha_actual",
".",
"month",
",",
"'anio'",
":",
"fecha_actual",
".",
"year",
",",
"'hospital'",
":",
"hospital",
",",
"'beneficiario'",
":",
"beneficiario",
",",
"'atencion'",
":",
"atencion",
",",
"'obra_social'",
":",
"obra_social",
",",
"'empresa'",
":",
"empresa",
"}",
"return",
"data",
",",
"errores_generacion"
] | [
228,
4
] | [
353,
39
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
download_to_file | (url, file_path, **kwargs) | Descarga un archivo a través del protocolo HTTP, en uno o más intentos,
y escribe el contenido descargado el el path especificado.
Args:
url (str): URL (schema HTTP) del archivo a descargar.
file_path (str): Path del archivo a escribir. Si un archivo ya existe
en el path especificado, se sobrescribirá con nuevos contenidos.
kwargs: Parámetros para download().
| Descarga un archivo a través del protocolo HTTP, en uno o más intentos,
y escribe el contenido descargado el el path especificado. | def download_to_file(url, file_path, **kwargs):
"""Descarga un archivo a través del protocolo HTTP, en uno o más intentos,
y escribe el contenido descargado el el path especificado.
Args:
url (str): URL (schema HTTP) del archivo a descargar.
file_path (str): Path del archivo a escribir. Si un archivo ya existe
en el path especificado, se sobrescribirá con nuevos contenidos.
kwargs: Parámetros para download().
"""
# print(url, file_path, kwargs)
content = download(url, **kwargs)
# crea todos los directorios necesarios
path = pathlib.Path(file_path)
path.parent.mkdir(parents=True, exist_ok=True)
with path.open("wb") as f:
try:
f.write(content)
except IOError as e:
# raise DownloadException() from e
raise e | [
"def",
"download_to_file",
"(",
"url",
",",
"file_path",
",",
"*",
"*",
"kwargs",
")",
":",
"# print(url, file_path, kwargs)",
"content",
"=",
"download",
"(",
"url",
",",
"*",
"*",
"kwargs",
")",
"# crea todos los directorios necesarios",
"path",
"=",
"pathlib",
".",
"Path",
"(",
"file_path",
")",
"path",
".",
"parent",
".",
"mkdir",
"(",
"parents",
"=",
"True",
",",
"exist_ok",
"=",
"True",
")",
"with",
"path",
".",
"open",
"(",
"\"wb\"",
")",
"as",
"f",
":",
"try",
":",
"f",
".",
"write",
"(",
"content",
")",
"except",
"IOError",
"as",
"e",
":",
"# raise DownloadException() from e",
"raise",
"e"
] | [
52,
0
] | [
75,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TraductoresHandler._restartService | (self) | Reinicializa el WS server tornado y levanta la configuracion nuevamente | Reinicializa el WS server tornado y levanta la configuracion nuevamente | def _restartService(self):
""" Reinicializa el WS server tornado y levanta la configuracion nuevamente """
self.fbApp.restart_service()
resdict = {
"action": "restartService",
"rta": "servidor reiniciado"
} | [
"def",
"_restartService",
"(",
"self",
")",
":",
"self",
".",
"fbApp",
".",
"restart_service",
"(",
")",
"resdict",
"=",
"{",
"\"action\"",
":",
"\"restartService\"",
",",
"\"rta\"",
":",
"\"servidor reiniciado\"",
"}"
] | [
258,
4
] | [
264,
9
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ExecutionDbReader.finish | (self) | Función encargada de cerrar la conexión a la base de datos. | Función encargada de cerrar la conexión a la base de datos. | def finish(self):
"""Función encargada de cerrar la conexión a la base de datos."""
self.db.close() | [
"def",
"finish",
"(",
"self",
")",
":",
"self",
".",
"db",
".",
"close",
"(",
")"
] | [
63,
4
] | [
65,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ColumnsDatabase.count | (self) | Método consultor que nos devuelve el número de columnas. Si el valor es 0 es que las listas son distintas | Método consultor que nos devuelve el número de columnas. Si el valor es 0 es que las listas son distintas | def count(self):
"""Método consultor que nos devuelve el número de columnas. Si el valor es 0 es que las listas son distintas"""
if len(self.name_column) == len(self.type_column):
return len(self.name_column)
else:
return 0 | [
"def",
"count",
"(",
"self",
")",
":",
"if",
"len",
"(",
"self",
".",
"name_column",
")",
"==",
"len",
"(",
"self",
".",
"type_column",
")",
":",
"return",
"len",
"(",
"self",
".",
"name_column",
")",
"else",
":",
"return",
"0"
] | [
78,
4
] | [
83,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Override_Bom_Production._get_moves_raw_values | (self) | return moves | @Overwrite: Obtiene los ingredietes de un producto una vez es selccionado.
En lugar de extraer los productos en la lista de materiales se dirige a sus listas hijas
'child_line_ids' para poblar la lista de productos
returns:
list<stock.move> -- Lista de productos asociados a la orden de producción
| @Overwrite: Obtiene los ingredietes de un producto una vez es selccionado.
En lugar de extraer los productos en la lista de materiales se dirige a sus listas hijas
'child_line_ids' para poblar la lista de productos | def _get_moves_raw_values(self):
""" @Overwrite: Obtiene los ingredietes de un producto una vez es selccionado.
En lugar de extraer los productos en la lista de materiales se dirige a sus listas hijas
'child_line_ids' para poblar la lista de productos
returns:
list<stock.move> -- Lista de productos asociados a la orden de producción
"""
moves = []
for production in self:
factor = production.product_uom_id._compute_quantity(production.product_qty, production.bom_id.product_uom_id) / production.bom_id.product_qty
boms, lines = production.bom_id.explode(production.product_id, factor, picking_type=production.bom_id.picking_type_id)
if production.add_bom_id:
for add_pro in production.add_bom_id:
factor2 = production.product_uom_id._compute_quantity(production.product_qty, add_pro.product_uom_id) / add_pro.product_qty
boms2, lines2 = add_pro.explode(production.product_id, factor2, picking_type=add_pro.picking_type_id)
boms += boms2
lines_aux2=[]
lines_aux3=[]
for i in range(len(lines2)):
lines_aux=[]
lines_aux.append(lines2[i][0]._origin)
lines_aux.append(lines2[i][1])
lines_aux2.append(lines_aux)
lines_aux3 = [tuple(e) for e in lines_aux2]
lines += lines_aux3
for bom_line, line_data in lines:
if bom_line.child_bom_id and bom_line.child_bom_id.type == 'phantom' or\
bom_line.product_id.type not in ['product', 'consu']:
continue
for p in bom_line.child_line_ids:
moves.append(production._get_move_raw_values(p, {'qty': p.product_qty * self.product_uom_qty, 'parent_line': ''}))
if len(bom_line.child_line_ids) == 0:
moves.append(production._get_move_raw_values(bom_line, line_data))
return moves | [
"def",
"_get_moves_raw_values",
"(",
"self",
")",
":",
"moves",
"=",
"[",
"]",
"for",
"production",
"in",
"self",
":",
"factor",
"=",
"production",
".",
"product_uom_id",
".",
"_compute_quantity",
"(",
"production",
".",
"product_qty",
",",
"production",
".",
"bom_id",
".",
"product_uom_id",
")",
"/",
"production",
".",
"bom_id",
".",
"product_qty",
"boms",
",",
"lines",
"=",
"production",
".",
"bom_id",
".",
"explode",
"(",
"production",
".",
"product_id",
",",
"factor",
",",
"picking_type",
"=",
"production",
".",
"bom_id",
".",
"picking_type_id",
")",
"if",
"production",
".",
"add_bom_id",
":",
"for",
"add_pro",
"in",
"production",
".",
"add_bom_id",
":",
"factor2",
"=",
"production",
".",
"product_uom_id",
".",
"_compute_quantity",
"(",
"production",
".",
"product_qty",
",",
"add_pro",
".",
"product_uom_id",
")",
"/",
"add_pro",
".",
"product_qty",
"boms2",
",",
"lines2",
"=",
"add_pro",
".",
"explode",
"(",
"production",
".",
"product_id",
",",
"factor2",
",",
"picking_type",
"=",
"add_pro",
".",
"picking_type_id",
")",
"boms",
"+=",
"boms2",
"lines_aux2",
"=",
"[",
"]",
"lines_aux3",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"lines2",
")",
")",
":",
"lines_aux",
"=",
"[",
"]",
"lines_aux",
".",
"append",
"(",
"lines2",
"[",
"i",
"]",
"[",
"0",
"]",
".",
"_origin",
")",
"lines_aux",
".",
"append",
"(",
"lines2",
"[",
"i",
"]",
"[",
"1",
"]",
")",
"lines_aux2",
".",
"append",
"(",
"lines_aux",
")",
"lines_aux3",
"=",
"[",
"tuple",
"(",
"e",
")",
"for",
"e",
"in",
"lines_aux2",
"]",
"lines",
"+=",
"lines_aux3",
"for",
"bom_line",
",",
"line_data",
"in",
"lines",
":",
"if",
"bom_line",
".",
"child_bom_id",
"and",
"bom_line",
".",
"child_bom_id",
".",
"type",
"==",
"'phantom'",
"or",
"bom_line",
".",
"product_id",
".",
"type",
"not",
"in",
"[",
"'product'",
",",
"'consu'",
"]",
":",
"continue",
"for",
"p",
"in",
"bom_line",
".",
"child_line_ids",
":",
"moves",
".",
"append",
"(",
"production",
".",
"_get_move_raw_values",
"(",
"p",
",",
"{",
"'qty'",
":",
"p",
".",
"product_qty",
"*",
"self",
".",
"product_uom_qty",
",",
"'parent_line'",
":",
"''",
"}",
")",
")",
"if",
"len",
"(",
"bom_line",
".",
"child_line_ids",
")",
"==",
"0",
":",
"moves",
".",
"append",
"(",
"production",
".",
"_get_move_raw_values",
"(",
"bom_line",
",",
"line_data",
")",
")",
"return",
"moves"
] | [
256,
4
] | [
296,
20
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
DataCleaner.normalizar_unidad_territorial | (self, field, entity_level, add_code=False,
add_centroid=False, add_parents=None,
filters=None, keep_original=False,
inplace=False) | Normaliza y enriquece una unidad territorial del DataFrame.
Args:
field (str): Nombre del campo a normalizar.
entity_level (str): Nivel de la unidad territorial.
add_code (bool): Específica si agrega código de la entidad.
add_centroid (bool): Específica si agrega centroide de la entidad.
add_parents (list): Lista de entidades padres a agregar.
filters (dict): Diccionario con entidades por las cuales filtrar.
keep_original (bool): Específica si conserva la columna original.
inplace (bool): Específica si la limpieza perdura en el objeto.
Returns:
pandas.Series: Serie de unidades territoriales normalizadas y
limpias.
| Normaliza y enriquece una unidad territorial del DataFrame. | def normalizar_unidad_territorial(self, field, entity_level, add_code=False,
add_centroid=False, add_parents=None,
filters=None, keep_original=False,
inplace=False):
"""Normaliza y enriquece una unidad territorial del DataFrame.
Args:
field (str): Nombre del campo a normalizar.
entity_level (str): Nivel de la unidad territorial.
add_code (bool): Específica si agrega código de la entidad.
add_centroid (bool): Específica si agrega centroide de la entidad.
add_parents (list): Lista de entidades padres a agregar.
filters (dict): Diccionario con entidades por las cuales filtrar.
keep_original (bool): Específica si conserva la columna original.
inplace (bool): Específica si la limpieza perdura en el objeto.
Returns:
pandas.Series: Serie de unidades territoriales normalizadas y
limpias.
"""
if len(self.df) > 100000:
print('El número máximo de unidades a normalizar es de 100000.')
return
if not self._validate_entity_level(entity_level):
print('"{}" no es un nivel de entidad válido.'.format(entity_level))
return
if filters:
if not self._validate_filters(entity_level, filters):
return self.df
data = self._build_data(field, entity_level, filters)
if data:
res = self._get_api_response(entity_level, data)
if 'error' in res:
print(res['error'])
if keep_original:
field_normalized = str(field + '_normalized')
self._update_column(field_normalized, NAME, entity_level, res)
else:
self._update_column(field, NAME, entity_level, res)
if add_code:
column_code = entity_level + '_' + ID
self._update_column(column_code, ID, entity_level, res)
if add_centroid:
column_lat = entity_level + '_' + LAT
column_lon = entity_level + '_' + LON
self._update_column(column_lat, LAT, entity_level, res)
self._update_column(column_lon, LON, entity_level, res)
if add_parents:
for parent in add_parents:
if entity_level not in PROV and parent in PROV:
self._update_column(
PROV_ID, PROV_ID, entity_level, res)
self._update_column(PROV_NAM, PROV_NAM, entity_level,
res)
if parent in DEPT and entity_level in [MUN, LOC]:
self._update_column(
DEPT_ID, DEPT_ID, entity_level, res)
self._update_column(DEPT_NAM, DEPT_NAM, entity_level,
res)
if parent in MUN and entity_level in LOC:
self._update_column(MUN_ID, MUN_ID, entity_level, res)
self._update_column(
MUN_NAM, MUN_NAM, entity_level, res)
return self.df
else:
return | [
"def",
"normalizar_unidad_territorial",
"(",
"self",
",",
"field",
",",
"entity_level",
",",
"add_code",
"=",
"False",
",",
"add_centroid",
"=",
"False",
",",
"add_parents",
"=",
"None",
",",
"filters",
"=",
"None",
",",
"keep_original",
"=",
"False",
",",
"inplace",
"=",
"False",
")",
":",
"if",
"len",
"(",
"self",
".",
"df",
")",
">",
"100000",
":",
"print",
"(",
"'El número máximo de unidades a normalizar es de 100000.')",
"",
"return",
"if",
"not",
"self",
".",
"_validate_entity_level",
"(",
"entity_level",
")",
":",
"print",
"(",
"'\"{}\" no es un nivel de entidad válido.'.",
"f",
"ormat(",
"e",
"ntity_level)",
")",
"",
"return",
"if",
"filters",
":",
"if",
"not",
"self",
".",
"_validate_filters",
"(",
"entity_level",
",",
"filters",
")",
":",
"return",
"self",
".",
"df",
"data",
"=",
"self",
".",
"_build_data",
"(",
"field",
",",
"entity_level",
",",
"filters",
")",
"if",
"data",
":",
"res",
"=",
"self",
".",
"_get_api_response",
"(",
"entity_level",
",",
"data",
")",
"if",
"'error'",
"in",
"res",
":",
"print",
"(",
"res",
"[",
"'error'",
"]",
")",
"if",
"keep_original",
":",
"field_normalized",
"=",
"str",
"(",
"field",
"+",
"'_normalized'",
")",
"self",
".",
"_update_column",
"(",
"field_normalized",
",",
"NAME",
",",
"entity_level",
",",
"res",
")",
"else",
":",
"self",
".",
"_update_column",
"(",
"field",
",",
"NAME",
",",
"entity_level",
",",
"res",
")",
"if",
"add_code",
":",
"column_code",
"=",
"entity_level",
"+",
"'_'",
"+",
"ID",
"self",
".",
"_update_column",
"(",
"column_code",
",",
"ID",
",",
"entity_level",
",",
"res",
")",
"if",
"add_centroid",
":",
"column_lat",
"=",
"entity_level",
"+",
"'_'",
"+",
"LAT",
"column_lon",
"=",
"entity_level",
"+",
"'_'",
"+",
"LON",
"self",
".",
"_update_column",
"(",
"column_lat",
",",
"LAT",
",",
"entity_level",
",",
"res",
")",
"self",
".",
"_update_column",
"(",
"column_lon",
",",
"LON",
",",
"entity_level",
",",
"res",
")",
"if",
"add_parents",
":",
"for",
"parent",
"in",
"add_parents",
":",
"if",
"entity_level",
"not",
"in",
"PROV",
"and",
"parent",
"in",
"PROV",
":",
"self",
".",
"_update_column",
"(",
"PROV_ID",
",",
"PROV_ID",
",",
"entity_level",
",",
"res",
")",
"self",
".",
"_update_column",
"(",
"PROV_NAM",
",",
"PROV_NAM",
",",
"entity_level",
",",
"res",
")",
"if",
"parent",
"in",
"DEPT",
"and",
"entity_level",
"in",
"[",
"MUN",
",",
"LOC",
"]",
":",
"self",
".",
"_update_column",
"(",
"DEPT_ID",
",",
"DEPT_ID",
",",
"entity_level",
",",
"res",
")",
"self",
".",
"_update_column",
"(",
"DEPT_NAM",
",",
"DEPT_NAM",
",",
"entity_level",
",",
"res",
")",
"if",
"parent",
"in",
"MUN",
"and",
"entity_level",
"in",
"LOC",
":",
"self",
".",
"_update_column",
"(",
"MUN_ID",
",",
"MUN_ID",
",",
"entity_level",
",",
"res",
")",
"self",
".",
"_update_column",
"(",
"MUN_NAM",
",",
"MUN_NAM",
",",
"entity_level",
",",
"res",
")",
"return",
"self",
".",
"df",
"else",
":",
"return"
] | [
764,
4
] | [
838,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ObjectCapsule.get_values | (self) | return {
e[0]: {"value": self._obj.getattr(e[0]),
"cssclass": self.get_list_display_cssclass().get(e[0], "")}
for e in self._view.get_list_display()} | Obtiene los valores de los campos declarados en list_display. | Obtiene los valores de los campos declarados en list_display. | def get_values(self):
"""Obtiene los valores de los campos declarados en list_display. """
return {
e[0]: {"value": self._obj.getattr(e[0]),
"cssclass": self.get_list_display_cssclass().get(e[0], "")}
for e in self._view.get_list_display()} | [
"def",
"get_values",
"(",
"self",
")",
":",
"return",
"{",
"e",
"[",
"0",
"]",
":",
"{",
"\"value\"",
":",
"self",
".",
"_obj",
".",
"getattr",
"(",
"e",
"[",
"0",
"]",
")",
",",
"\"cssclass\"",
":",
"self",
".",
"get_list_display_cssclass",
"(",
")",
".",
"get",
"(",
"e",
"[",
"0",
"]",
",",
"\"\"",
")",
"}",
"for",
"e",
"in",
"self",
".",
"_view",
".",
"get_list_display",
"(",
")",
"}"
] | [
67,
4
] | [
72,
51
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
FingerprintKeyerUnitTestCase.test_get_best_replacements | (self) | Testea la toma de los mejores strings de cada cluster. | Testea la toma de los mejores strings de cada cluster. | def test_get_best_replacements(self):
"""Testea la toma de los mejores strings de cada cluster."""
clusters = {'es juan per': ['Juan Per\tes'],
'juan peres': [' - juan peRes',
'Juan ; Per\xe9s',
'Juan -- Peres',
'ju\xe1n Peres',
'Juan Peres',
'Juan Peres',
' Juan\t \tPeres']}
counts = {' Juan\t \tPeres': 1,
' - juan peRes': 1,
'Juan -- Peres': 1,
'Juan ; Per\xe9s': 1,
'Juan Per\tes': 1,
'Juan Peres': 2,
'ju\xe1n Peres': 1}
exp_replacements = {'es juan per': 'Juan Per\tes',
'juan peres': 'Juan Peres'}
replacements = get_best_replacements(clusters, counts)
self.assertEqual(replacements, exp_replacements) | [
"def",
"test_get_best_replacements",
"(",
"self",
")",
":",
"clusters",
"=",
"{",
"'es juan per'",
":",
"[",
"'Juan Per\\tes'",
"]",
",",
"'juan peres'",
":",
"[",
"' - juan peRes'",
",",
"'Juan ; Per\\xe9s'",
",",
"'Juan -- Peres'",
",",
"'ju\\xe1n Peres'",
",",
"'Juan Peres'",
",",
"'Juan Peres'",
",",
"' Juan\\t \\tPeres'",
"]",
"}",
"counts",
"=",
"{",
"' Juan\\t \\tPeres'",
":",
"1",
",",
"' - juan peRes'",
":",
"1",
",",
"'Juan -- Peres'",
":",
"1",
",",
"'Juan ; Per\\xe9s'",
":",
"1",
",",
"'Juan Per\\tes'",
":",
"1",
",",
"'Juan Peres'",
":",
"2",
",",
"'ju\\xe1n Peres'",
":",
"1",
"}",
"exp_replacements",
"=",
"{",
"'es juan per'",
":",
"'Juan Per\\tes'",
",",
"'juan peres'",
":",
"'Juan Peres'",
"}",
"replacements",
"=",
"get_best_replacements",
"(",
"clusters",
",",
"counts",
")",
"self",
".",
"assertEqual",
"(",
"replacements",
",",
"exp_replacements",
")"
] | [
115,
4
] | [
136,
56
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ModelBase.get_fields_for_list | (cls, model=None, include_relations: bool = True,
fields: list = None, exclude: list = None) | return out | Obtiene un diccionario con información de los campos de este modelo
o el modelo indicado, ideal para mostrar en un listado.
Parameters:
- model (Model): opcional, si no se indica se usará la clase actual (cls).
- include_relations (bool): True por defecto. Si es True incluirá también
los campos de los modelos relacionados.
| Obtiene un diccionario con información de los campos de este modelo
o el modelo indicado, ideal para mostrar en un listado. | def get_fields_for_list(cls, model=None, include_relations: bool = True,
fields: list = None, exclude: list = None) -> dict:
"""Obtiene un diccionario con información de los campos de este modelo
o el modelo indicado, ideal para mostrar en un listado.
Parameters:
- model (Model): opcional, si no se indica se usará la clase actual (cls).
- include_relations (bool): True por defecto. Si es True incluirá también
los campos de los modelos relacionados.
"""
model = model or cls
out = {}
field_list = []
model_fields = model._meta.get_fields(include_parents=False, include_hidden=False)
fields = fields or getattr(model, "list_display_fields", None)
if fields != None:
field_list = [f for f in model_fields if f.name in fields]
else:
field_list = model_fields
if exclude != None:
field_list = [f for f in field_list if not f.name in exclude]
for field in field_list:
if isinstance(field, (models.ManyToOneRel, models.ManyToManyRel, models.ManyToManyField, models.AutoField, models.TextField)):
continue
if field.name in ("tags", "id"):
continue
verbose_name = getattr(field, "verbose_name", field.name.replace("_", " "))
related_model = getattr(field, "related_model", None)
if related_model:
if include_relations:
related_fields = cls.get_fields_for_list(
model=related_model,
include_relations=False,
fields=getattr(related_model, "list_display_fields", None))
for related_field in related_fields.values():
related_field["name"] = f"{field.name}__{related_field['name']}"
related_field["verbose_name"] = f"{verbose_name} {related_field['verbose_name']}"
out[f"{related_field['name']}"] = related_field
else:
out[field.name] = cls.get_field_info_dict(field)
return out | [
"def",
"get_fields_for_list",
"(",
"cls",
",",
"model",
"=",
"None",
",",
"include_relations",
":",
"bool",
"=",
"True",
",",
"fields",
":",
"list",
"=",
"None",
",",
"exclude",
":",
"list",
"=",
"None",
")",
"->",
"dict",
":",
"model",
"=",
"model",
"or",
"cls",
"out",
"=",
"{",
"}",
"field_list",
"=",
"[",
"]",
"model_fields",
"=",
"model",
".",
"_meta",
".",
"get_fields",
"(",
"include_parents",
"=",
"False",
",",
"include_hidden",
"=",
"False",
")",
"fields",
"=",
"fields",
"or",
"getattr",
"(",
"model",
",",
"\"list_display_fields\"",
",",
"None",
")",
"if",
"fields",
"!=",
"None",
":",
"field_list",
"=",
"[",
"f",
"for",
"f",
"in",
"model_fields",
"if",
"f",
".",
"name",
"in",
"fields",
"]",
"else",
":",
"field_list",
"=",
"model_fields",
"if",
"exclude",
"!=",
"None",
":",
"field_list",
"=",
"[",
"f",
"for",
"f",
"in",
"field_list",
"if",
"not",
"f",
".",
"name",
"in",
"exclude",
"]",
"for",
"field",
"in",
"field_list",
":",
"if",
"isinstance",
"(",
"field",
",",
"(",
"models",
".",
"ManyToOneRel",
",",
"models",
".",
"ManyToManyRel",
",",
"models",
".",
"ManyToManyField",
",",
"models",
".",
"AutoField",
",",
"models",
".",
"TextField",
")",
")",
":",
"continue",
"if",
"field",
".",
"name",
"in",
"(",
"\"tags\"",
",",
"\"id\"",
")",
":",
"continue",
"verbose_name",
"=",
"getattr",
"(",
"field",
",",
"\"verbose_name\"",
",",
"field",
".",
"name",
".",
"replace",
"(",
"\"_\"",
",",
"\" \"",
")",
")",
"related_model",
"=",
"getattr",
"(",
"field",
",",
"\"related_model\"",
",",
"None",
")",
"if",
"related_model",
":",
"if",
"include_relations",
":",
"related_fields",
"=",
"cls",
".",
"get_fields_for_list",
"(",
"model",
"=",
"related_model",
",",
"include_relations",
"=",
"False",
",",
"fields",
"=",
"getattr",
"(",
"related_model",
",",
"\"list_display_fields\"",
",",
"None",
")",
")",
"for",
"related_field",
"in",
"related_fields",
".",
"values",
"(",
")",
":",
"related_field",
"[",
"\"name\"",
"]",
"=",
"f\"{field.name}__{related_field['name']}\"",
"related_field",
"[",
"\"verbose_name\"",
"]",
"=",
"f\"{verbose_name} {related_field['verbose_name']}\"",
"out",
"[",
"f\"{related_field['name']}\"",
"]",
"=",
"related_field",
"else",
":",
"out",
"[",
"field",
".",
"name",
"]",
"=",
"cls",
".",
"get_field_info_dict",
"(",
"field",
")",
"return",
"out"
] | [
181,
4
] | [
225,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Ventana3.play | (self) | Si ban es True la música esta reproduciendoce y se quiere pausar | Si ban es True la música esta reproduciendoce y se quiere pausar | def play(self):
'''Si ban es True la música esta reproduciendoce y se quiere pausar'''
if(self.ban==True):
pygame.mixer.music.pause()
self.ban=False
else:
pygame.mixer.music.unpause()#Reanuda el audio
self.ban=True#Pone al atributo ban en True | [
"def",
"play",
"(",
"self",
")",
":",
"if",
"(",
"self",
".",
"ban",
"==",
"True",
")",
":",
"pygame",
".",
"mixer",
".",
"music",
".",
"pause",
"(",
")",
"self",
".",
"ban",
"=",
"False",
"else",
":",
"pygame",
".",
"mixer",
".",
"music",
".",
"unpause",
"(",
")",
"#Reanuda el audio",
"self",
".",
"ban",
"=",
"True",
"#Pone al atributo ban en True"
] | [
155,
4
] | [
162,
54
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
set_url | (protocol="http", ip="localhost", port="9200") | return url | Contruye una URL válida para el archivo de configuración
Dado el protocolo, la ip y el puerto contruye una URL válida para
el archivo de configuración. Si las variables no fueron dadas por
la usuaria utiliza la URL por defecto ``http://localhost:9200/``
:param protocol: Protocolo que debe ser ``HTTP`` o ``HTTPS``
:type: str
:param ip: Nombre o ip del server de Elasticsearch
:type: str
:param port: Puerto del server Elasticsearch
:type: str
:return: URL válida para el proyecto
:rtype: str
| Contruye una URL válida para el archivo de configuración | def set_url(protocol="http", ip="localhost", port="9200"):
""" Contruye una URL válida para el archivo de configuración
Dado el protocolo, la ip y el puerto contruye una URL válida para
el archivo de configuración. Si las variables no fueron dadas por
la usuaria utiliza la URL por defecto ``http://localhost:9200/``
:param protocol: Protocolo que debe ser ``HTTP`` o ``HTTPS``
:type: str
:param ip: Nombre o ip del server de Elasticsearch
:type: str
:param port: Puerto del server Elasticsearch
:type: str
:return: URL válida para el proyecto
:rtype: str
"""
if protocol:
url = f"{protocol}://"
else:
url = "http://"
if ip:
url += f"{ip}:"
else:
url += "localhost:"
if port:
url += f"{port}/"
else:
url += "9200/"
return url | [
"def",
"set_url",
"(",
"protocol",
"=",
"\"http\"",
",",
"ip",
"=",
"\"localhost\"",
",",
"port",
"=",
"\"9200\"",
")",
":",
"if",
"protocol",
":",
"url",
"=",
"f\"{protocol}://\"",
"else",
":",
"url",
"=",
"\"http://\"",
"if",
"ip",
":",
"url",
"+=",
"f\"{ip}:\"",
"else",
":",
"url",
"+=",
"\"localhost:\"",
"if",
"port",
":",
"url",
"+=",
"f\"{port}/\"",
"else",
":",
"url",
"+=",
"\"9200/\"",
"return",
"url"
] | [
38,
0
] | [
68,
14
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
limpiar_bordes | (imagen, lkernel) | return imagen - D_nueva | Esta función elimina los objetos que tocan el borde de una imagen,
utilizando reconstrucción por dilatación geodésica. | Esta función elimina los objetos que tocan el borde de una imagen,
utilizando reconstrucción por dilatación geodésica. | def limpiar_bordes(imagen, lkernel):
"""Esta función elimina los objetos que tocan el borde de una imagen,
utilizando reconstrucción por dilatación geodésica."""
ancho = imagen.shape[0]
largo = imagen.shape[1]
# Crear el marcador: imagen que es cero en todos lados salvo
# en los bordes, que coinciden con los de la imagen.
marcador = np.zeros((ancho, largo), dtype = "uint8")
marcador[0] = np.ones(largo, dtype = "uint8")
marcador[ancho - 1] = np.ones(largo, dtype = "uint8")
marcador[:, 0] = np.ones(ancho, dtype = "uint8").T
marcador[:, largo - 1] = np.ones(ancho, dtype = "uint8").T
marcador = marcador * imagen
marcador = np.uint8(marcador)
# Crear kernel para dilatación
kernel = np.ones((lkernel, lkernel), np.uint8)
D_vieja = marcador
D_nueva = np.bitwise_and(cv2.dilate(marcador, kernel, iterations = 1), imagen)
while np.array_equal(D_nueva, D_vieja) == False:
D_vieja = D_nueva
D_nueva = np.bitwise_and(cv2.dilate(D_nueva, kernel, iterations = 1), imagen)
return imagen - D_nueva | [
"def",
"limpiar_bordes",
"(",
"imagen",
",",
"lkernel",
")",
":",
"ancho",
"=",
"imagen",
".",
"shape",
"[",
"0",
"]",
"largo",
"=",
"imagen",
".",
"shape",
"[",
"1",
"]",
"# Crear el marcador: imagen que es cero en todos lados salvo",
"# en los bordes, que coinciden con los de la imagen.",
"marcador",
"=",
"np",
".",
"zeros",
"(",
"(",
"ancho",
",",
"largo",
")",
",",
"dtype",
"=",
"\"uint8\"",
")",
"marcador",
"[",
"0",
"]",
"=",
"np",
".",
"ones",
"(",
"largo",
",",
"dtype",
"=",
"\"uint8\"",
")",
"marcador",
"[",
"ancho",
"-",
"1",
"]",
"=",
"np",
".",
"ones",
"(",
"largo",
",",
"dtype",
"=",
"\"uint8\"",
")",
"marcador",
"[",
":",
",",
"0",
"]",
"=",
"np",
".",
"ones",
"(",
"ancho",
",",
"dtype",
"=",
"\"uint8\"",
")",
".",
"T",
"marcador",
"[",
":",
",",
"largo",
"-",
"1",
"]",
"=",
"np",
".",
"ones",
"(",
"ancho",
",",
"dtype",
"=",
"\"uint8\"",
")",
".",
"T",
"marcador",
"=",
"marcador",
"*",
"imagen",
"marcador",
"=",
"np",
".",
"uint8",
"(",
"marcador",
")",
"# Crear kernel para dilatación",
"kernel",
"=",
"np",
".",
"ones",
"(",
"(",
"lkernel",
",",
"lkernel",
")",
",",
"np",
".",
"uint8",
")",
"D_vieja",
"=",
"marcador",
"D_nueva",
"=",
"np",
".",
"bitwise_and",
"(",
"cv2",
".",
"dilate",
"(",
"marcador",
",",
"kernel",
",",
"iterations",
"=",
"1",
")",
",",
"imagen",
")",
"while",
"np",
".",
"array_equal",
"(",
"D_nueva",
",",
"D_vieja",
")",
"==",
"False",
":",
"D_vieja",
"=",
"D_nueva",
"D_nueva",
"=",
"np",
".",
"bitwise_and",
"(",
"cv2",
".",
"dilate",
"(",
"D_nueva",
",",
"kernel",
",",
"iterations",
"=",
"1",
")",
",",
"imagen",
")",
"return",
"imagen",
"-",
"D_nueva"
] | [
31,
0
] | [
57,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
tiempo_partida | () | return layout | Seccion tiempo de la partida | Seccion tiempo de la partida | def tiempo_partida():
""" Seccion tiempo de la partida"""
horas = [x for x in range(0, 100)]
min_seg = [x for x in range(0, 60)]
layout = [
sg.Text('Tiempo total de la partida:', background_color=theme.PRIMARY_COLOR_VARIANT, font=[theme.FONT, 12],
pad=(5, 6)),
sg.Spin(horas, initial_value=0, key='-HOURS-', font=[theme.FONT, 12], pad=(5, 6)),
sg.Text(':', background_color=theme.PRIMARY_COLOR_VARIANT, font=[theme.FONT, 12], pad=(5, 6)),
sg.Spin(min_seg, initial_value=10, key='-MINUTES-', font=[theme.FONT, 12], pad=(5, 6)),
sg.Text(':', background_color=theme.PRIMARY_COLOR_VARIANT, font=[theme.FONT, 12], pad=(5, 6)),
sg.Spin(min_seg, initial_value=0, key='-SECONDS-', font=[theme.FONT, 12], pad=(5, 6))
]
return layout | [
"def",
"tiempo_partida",
"(",
")",
":",
"horas",
"=",
"[",
"x",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"100",
")",
"]",
"min_seg",
"=",
"[",
"x",
"for",
"x",
"in",
"range",
"(",
"0",
",",
"60",
")",
"]",
"layout",
"=",
"[",
"sg",
".",
"Text",
"(",
"'Tiempo total de la partida:'",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Spin",
"(",
"horas",
",",
"initial_value",
"=",
"0",
",",
"key",
"=",
"'-HOURS-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Text",
"(",
"':'",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Spin",
"(",
"min_seg",
",",
"initial_value",
"=",
"10",
",",
"key",
"=",
"'-MINUTES-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Text",
"(",
"':'",
",",
"background_color",
"=",
"theme",
".",
"PRIMARY_COLOR_VARIANT",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
",",
"sg",
".",
"Spin",
"(",
"min_seg",
",",
"initial_value",
"=",
"0",
",",
"key",
"=",
"'-SECONDS-'",
",",
"font",
"=",
"[",
"theme",
".",
"FONT",
",",
"12",
"]",
",",
"pad",
"=",
"(",
"5",
",",
"6",
")",
")",
"]",
"return",
"layout"
] | [
73,
0
] | [
88,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
set_project_info | (config) | return config | Escribe información general del proyecto
Escribe en el diccionario de configuraciones el nombre de la
organización, nombre del proyecto la primera y segunda lengua
del corpus paralelo
:param config: Diccionario con la configuración
:type: dict
:return: Diccionario de configuraciones con información del
proyecto
:rtype: dict
| Escribe información general del proyecto | def set_project_info(config):
"""Escribe información general del proyecto
Escribe en el diccionario de configuraciones el nombre de la
organización, nombre del proyecto la primera y segunda lengua
del corpus paralelo
:param config: Diccionario con la configuración
:type: dict
:return: Diccionario de configuraciones con información del
proyecto
:rtype: dict
"""
# Redes por defecto
social = ["site", "blog", "email", "facebook", "twitter", "github"]
config['ORG_NAME'] = input("\t * Nombre de la organización>> ").upper()
config['NAME'] = input("\t * Nombre del proyecto>> ").upper()
config['L1'] = input("\t * Primera lengua del corpus (l1)>> ").title()
config['L2'] = input("\t * Segunda lengua del corpus (l2)>> ").title()
# Colaboradoras vacio por defecto
config['COLABS'] = []
config['LINKS'] = {'social': {k: "" for k in social}, 'corpora': dict()}
config['META_DESC'] = input("\t * Descripción (etiqueta meta html): ")
return config | [
"def",
"set_project_info",
"(",
"config",
")",
":",
"# Redes por defecto",
"social",
"=",
"[",
"\"site\"",
",",
"\"blog\"",
",",
"\"email\"",
",",
"\"facebook\"",
",",
"\"twitter\"",
",",
"\"github\"",
"]",
"config",
"[",
"'ORG_NAME'",
"]",
"=",
"input",
"(",
"\"\\t * Nombre de la organización>> \")",
".",
"u",
"pper(",
")",
"",
"config",
"[",
"'NAME'",
"]",
"=",
"input",
"(",
"\"\\t * Nombre del proyecto>> \"",
")",
".",
"upper",
"(",
")",
"config",
"[",
"'L1'",
"]",
"=",
"input",
"(",
"\"\\t * Primera lengua del corpus (l1)>> \"",
")",
".",
"title",
"(",
")",
"config",
"[",
"'L2'",
"]",
"=",
"input",
"(",
"\"\\t * Segunda lengua del corpus (l2)>> \"",
")",
".",
"title",
"(",
")",
"# Colaboradoras vacio por defecto",
"config",
"[",
"'COLABS'",
"]",
"=",
"[",
"]",
"config",
"[",
"'LINKS'",
"]",
"=",
"{",
"'social'",
":",
"{",
"k",
":",
"\"\"",
"for",
"k",
"in",
"social",
"}",
",",
"'corpora'",
":",
"dict",
"(",
")",
"}",
"config",
"[",
"'META_DESC'",
"]",
"=",
"input",
"(",
"\"\\t * Descripción (etiqueta meta html): \")",
"",
"return",
"config"
] | [
12,
0
] | [
35,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
PlacesExtractor._get_occupancy | (self, external_driver=None) | return occupancy_obj | Función que obtiene la ocupación por día.
Arguments
---------
external_driver : webdriver.Chrome
se le pasa por argumento el driver a usar para la extracción de la ocupación
Returns
-------
dict
se devuelve un diccionario con la ocupación por día, teniendo como clave el día
| Función que obtiene la ocupación por día. | def _get_occupancy(self, external_driver=None):
"""Función que obtiene la ocupación por día.
Arguments
---------
external_driver : webdriver.Chrome
se le pasa por argumento el driver a usar para la extracción de la ocupación
Returns
-------
dict
se devuelve un diccionario con la ocupación por día, teniendo como clave el día
"""
driver = external_driver if external_driver else self.get_driver()
occupancy = None
occupancy_obj = {}
try:
xpath_query = "//*[@id='pane']/div/div//div[@class='section-popular-times']/div[@class='section-popular-times-container']"
driver.wait.until(
ec.visibility_of_all_elements_located((By.XPATH, xpath_query)))
occupancy = driver.find_element_by_class_name('section-popular-times')
if occupancy:
days_occupancy_container = occupancy.find_elements_by_xpath(
self._occupancy_container_elements_xpath_query)
for d in days_occupancy_container:
day = self._get_day_from_index(d.get_attribute("jsinstance"))
occupancy_by_hour = d.find_elements_by_xpath(self._occupancy_by_hours_xpath)
occupancy_by_hour_values = [o.get_attribute("aria-label") for o in occupancy_by_hour]
occupancy_obj[day] = occupancy_by_hour_values
except NoSuchElementException:
self.logger.warning("-{place}-: there is no occupancy elements in: -{url}-".format(place=self._place_name,
url=self._url))
except TimeoutException:
self.logger.warning("-{place}-: there is no occupancy elements in: -{url}-".format(place=self._place_name,
url=self._url))
return occupancy_obj | [
"def",
"_get_occupancy",
"(",
"self",
",",
"external_driver",
"=",
"None",
")",
":",
"driver",
"=",
"external_driver",
"if",
"external_driver",
"else",
"self",
".",
"get_driver",
"(",
")",
"occupancy",
"=",
"None",
"occupancy_obj",
"=",
"{",
"}",
"try",
":",
"xpath_query",
"=",
"\"//*[@id='pane']/div/div//div[@class='section-popular-times']/div[@class='section-popular-times-container']\"",
"driver",
".",
"wait",
".",
"until",
"(",
"ec",
".",
"visibility_of_all_elements_located",
"(",
"(",
"By",
".",
"XPATH",
",",
"xpath_query",
")",
")",
")",
"occupancy",
"=",
"driver",
".",
"find_element_by_class_name",
"(",
"'section-popular-times'",
")",
"if",
"occupancy",
":",
"days_occupancy_container",
"=",
"occupancy",
".",
"find_elements_by_xpath",
"(",
"self",
".",
"_occupancy_container_elements_xpath_query",
")",
"for",
"d",
"in",
"days_occupancy_container",
":",
"day",
"=",
"self",
".",
"_get_day_from_index",
"(",
"d",
".",
"get_attribute",
"(",
"\"jsinstance\"",
")",
")",
"occupancy_by_hour",
"=",
"d",
".",
"find_elements_by_xpath",
"(",
"self",
".",
"_occupancy_by_hours_xpath",
")",
"occupancy_by_hour_values",
"=",
"[",
"o",
".",
"get_attribute",
"(",
"\"aria-label\"",
")",
"for",
"o",
"in",
"occupancy_by_hour",
"]",
"occupancy_obj",
"[",
"day",
"]",
"=",
"occupancy_by_hour_values",
"except",
"NoSuchElementException",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: there is no occupancy elements in: -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"except",
"TimeoutException",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"\"-{place}-: there is no occupancy elements in: -{url}-\"",
".",
"format",
"(",
"place",
"=",
"self",
".",
"_place_name",
",",
"url",
"=",
"self",
".",
"_url",
")",
")",
"return",
"occupancy_obj"
] | [
268,
4
] | [
303,
28
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_opciones_fecha6 | (t) | opciones_fecha : timestamp valor pyc | opciones_fecha : timestamp valor pyc | def p_opciones_fecha6(t):
'opciones_fecha : timestamp valor pyc'
node= grammer.nodoDireccion('opciones_fecha')
node1 = grammer.nodoDireccion(t[1])
node2 = grammer.nodoDireccion(t[3])
node.agregar(node1)
node.agregar(t[2])
node.agregar(node2)
t[0]=node | [
"def",
"p_opciones_fecha6",
"(",
"t",
")",
":",
"node",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"'opciones_fecha'",
")",
"node1",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"1",
"]",
")",
"node2",
"=",
"grammer",
".",
"nodoDireccion",
"(",
"t",
"[",
"3",
"]",
")",
"node",
".",
"agregar",
"(",
"node1",
")",
"node",
".",
"agregar",
"(",
"t",
"[",
"2",
"]",
")",
"node",
".",
"agregar",
"(",
"node2",
")",
"t",
"[",
"0",
"]",
"=",
"node"
] | [
1310,
0
] | [
1318,
17
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Matrix.submat | (self, i, j) | return new | Metodo para generar una submatriz (una menor) de la matriz original. | Metodo para generar una submatriz (una menor) de la matriz original. | def submat(self, i, j):
""" Metodo para generar una submatriz (una menor) de la matriz original. """
c = len(self)
r = len(self[0])
new = Matrix([[0] * (r - 1) for t in xrange(c - 1)])
for k in xrange(i):
for l in xrange(j):
new[k][l] = self[k][l]
for m in xrange(j + 1, r):
new[k][m - 1] = self[k][m]
for n in xrange(i + 1, c):
for l in xrange(j):
new[n - 1][l] = self[n][l]
for m in xrange(j + 1, r):
new[n - 1][m - 1] = self[n][m]
return new | [
"def",
"submat",
"(",
"self",
",",
"i",
",",
"j",
")",
":",
"c",
"=",
"len",
"(",
"self",
")",
"r",
"=",
"len",
"(",
"self",
"[",
"0",
"]",
")",
"new",
"=",
"Matrix",
"(",
"[",
"[",
"0",
"]",
"*",
"(",
"r",
"-",
"1",
")",
"for",
"t",
"in",
"xrange",
"(",
"c",
"-",
"1",
")",
"]",
")",
"for",
"k",
"in",
"xrange",
"(",
"i",
")",
":",
"for",
"l",
"in",
"xrange",
"(",
"j",
")",
":",
"new",
"[",
"k",
"]",
"[",
"l",
"]",
"=",
"self",
"[",
"k",
"]",
"[",
"l",
"]",
"for",
"m",
"in",
"xrange",
"(",
"j",
"+",
"1",
",",
"r",
")",
":",
"new",
"[",
"k",
"]",
"[",
"m",
"-",
"1",
"]",
"=",
"self",
"[",
"k",
"]",
"[",
"m",
"]",
"for",
"n",
"in",
"xrange",
"(",
"i",
"+",
"1",
",",
"c",
")",
":",
"for",
"l",
"in",
"xrange",
"(",
"j",
")",
":",
"new",
"[",
"n",
"-",
"1",
"]",
"[",
"l",
"]",
"=",
"self",
"[",
"n",
"]",
"[",
"l",
"]",
"for",
"m",
"in",
"xrange",
"(",
"j",
"+",
"1",
",",
"r",
")",
":",
"new",
"[",
"n",
"-",
"1",
"]",
"[",
"m",
"-",
"1",
"]",
"=",
"self",
"[",
"n",
"]",
"[",
"m",
"]",
"return",
"new"
] | [
135,
4
] | [
150,
18
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
delete_doc | (request) | **Vista encargada de eliminar documentos del corpus**
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
| **Vista encargada de eliminar documentos del corpus** | def delete_doc(request):
"""**Vista encargada de eliminar documentos del corpus**
* `:param request:` Objeto *HttpRequets* para pasar el estado de la app a
través del sistema
* `:type:` *HttpRequest*
"""
# TODO: Agregar excepcion cuando haya error de conexion
if request.method == "POST":
document_id = request.POST.get('doc_id')
query = {"query": {"term": {"document_id": document_id}}}
r = es.delete_by_query(index=settings.INDEX, body=query, refresh=True)
LOGGER.debug("# lineas borradas::{}".format(r['deleted']))
notification = f"{r['deleted']} líneas borradas de {document_id}"
messages.info(request, notification)
return HttpResponseRedirect("/corpus-admin/") | [
"def",
"delete_doc",
"(",
"request",
")",
":",
"# TODO: Agregar excepcion cuando haya error de conexion",
"if",
"request",
".",
"method",
"==",
"\"POST\"",
":",
"document_id",
"=",
"request",
".",
"POST",
".",
"get",
"(",
"'doc_id'",
")",
"query",
"=",
"{",
"\"query\"",
":",
"{",
"\"term\"",
":",
"{",
"\"document_id\"",
":",
"document_id",
"}",
"}",
"}",
"r",
"=",
"es",
".",
"delete_by_query",
"(",
"index",
"=",
"settings",
".",
"INDEX",
",",
"body",
"=",
"query",
",",
"refresh",
"=",
"True",
")",
"LOGGER",
".",
"debug",
"(",
"\"# lineas borradas::{}\"",
".",
"format",
"(",
"r",
"[",
"'deleted'",
"]",
")",
")",
"notification",
"=",
"f\"{r['deleted']} líneas borradas de {document_id}\"",
"messages",
".",
"info",
"(",
"request",
",",
"notification",
")",
"return",
"HttpResponseRedirect",
"(",
"\"/corpus-admin/\"",
")"
] | [
265,
0
] | [
280,
53
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Optimizador.Regla_8_9 | (self, asignacion) | (+)Regla 8 y (-)Regla 9 - Eliminacion de codigo | (+)Regla 8 y (-)Regla 9 - Eliminacion de codigo | def Regla_8_9(self, asignacion):
"(+)Regla 8 y (-)Regla 9 - Eliminacion de codigo"
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 (indice == op1 and op2 == '0' and signo == '+') or (indice == op2 and op1 == '0' and signo == '+'):
NuevoObjeto = obj.Optimizado("Regla 8", indice + " = " + op1 + " " + signo + " " + op2, "Se elimina la instruccion")
CodigoOptimizado.append(NuevoObjeto)
return True
elif indice == op1 and op2 == '0' and signo == '-':
NuevoObjeto = obj.Optimizado("Regla 9", indice + " = " + op1 + " " + signo + " " + op2, "Se elimina la instruccion")
CodigoOptimizado.append(NuevoObjeto)
return True
else:
return False | [
"def",
"Regla_8_9",
"(",
"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",
"(",
"indice",
"==",
"op1",
"and",
"op2",
"==",
"'0'",
"and",
"signo",
"==",
"'+'",
")",
"or",
"(",
"indice",
"==",
"op2",
"and",
"op1",
"==",
"'0'",
"and",
"signo",
"==",
"'+'",
")",
":",
"NuevoObjeto",
"=",
"obj",
".",
"Optimizado",
"(",
"\"Regla 8\"",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
"+",
"\" \"",
"+",
"signo",
"+",
"\" \"",
"+",
"op2",
",",
"\"Se elimina la instruccion\"",
")",
"CodigoOptimizado",
".",
"append",
"(",
"NuevoObjeto",
")",
"return",
"True",
"elif",
"indice",
"==",
"op1",
"and",
"op2",
"==",
"'0'",
"and",
"signo",
"==",
"'-'",
":",
"NuevoObjeto",
"=",
"obj",
".",
"Optimizado",
"(",
"\"Regla 9\"",
",",
"indice",
"+",
"\" = \"",
"+",
"op1",
"+",
"\" \"",
"+",
"signo",
"+",
"\" \"",
"+",
"op2",
",",
"\"Se elimina la instruccion\"",
")",
"CodigoOptimizado",
".",
"append",
"(",
"NuevoObjeto",
")",
"return",
"True",
"else",
":",
"return",
"False"
] | [
85,
4
] | [
105,
24
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_sentencia_crear_2 | (t) | sentencia_crear : CREATE sentencia_orreplace DATABASE sentencia_ifnotexists IDENTIFICADOR opcionales_crear_database | sentencia_crear : CREATE sentencia_orreplace DATABASE sentencia_ifnotexists IDENTIFICADOR opcionales_crear_database | def p_sentencia_crear_2(t):
'''sentencia_crear : CREATE sentencia_orreplace DATABASE sentencia_ifnotexists IDENTIFICADOR opcionales_crear_database'''
nuevo = Start("CREATE_DATABASE")
if t[2] != None: # sentencia orreplace
nuevo.addChild(t[2])
if t[4] != None: # sentencia ifnotexists
nuevo.addChild(t[4])
nuevo.createTerminal(t.slice[5])
if t[6] != None: # opcionales crear database
nuevo.addChild(t[6])
t[0] = nuevo | [
"def",
"p_sentencia_crear_2",
"(",
"t",
")",
":",
"nuevo",
"=",
"Start",
"(",
"\"CREATE_DATABASE\"",
")",
"if",
"t",
"[",
"2",
"]",
"!=",
"None",
":",
"# sentencia orreplace",
"nuevo",
".",
"addChild",
"(",
"t",
"[",
"2",
"]",
")",
"if",
"t",
"[",
"4",
"]",
"!=",
"None",
":",
"# sentencia ifnotexists",
"nuevo",
".",
"addChild",
"(",
"t",
"[",
"4",
"]",
")",
"nuevo",
".",
"createTerminal",
"(",
"t",
".",
"slice",
"[",
"5",
"]",
")",
"if",
"t",
"[",
"6",
"]",
"!=",
"None",
":",
"# opcionales crear database",
"nuevo",
".",
"addChild",
"(",
"t",
"[",
"6",
"]",
")",
"t",
"[",
"0",
"]",
"=",
"nuevo"
] | [
461,
0
] | [
471,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ColumnsDatabase.print_columns | (self) | Método que nos imprime las columnas introducidas | Método que nos imprime las columnas introducidas | def print_columns(self):
""""Método que nos imprime las columnas introducidas"""
print 'Name column: ', self.name_column, ' Type column: ', self.type_column | [
"def",
"print_columns",
"(",
"self",
")",
":",
"print",
"'Name column: '",
",",
"self",
".",
"name_column",
",",
"' Type column: '",
",",
"self",
".",
"type_column"
] | [
56,
4
] | [
58,
84
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
get_zip_codes_obj_config | (input_config=None, reader=None) | Función auxiliar para obtener los códigos postales dependiendo del input_config
Parameters
----------
input_config : dict
diccionario que contiene la configuración del soporte de entrada para la ejecución
reader : gmaps.commons.reader.reader.AbstractReader
referencia a un reader que realizará la lectura de los códigos postales para la ejecución
Returns
-------
dict
con la información (códigos postales) obtenidos del soporte de entrada configurado en input_config
None
en caso de que el `type` del soporte de entrada no esté soportado o en caso de que el soporte de entrada sea
`db` y no se haya pasado un `reader`
| Función auxiliar para obtener los códigos postales dependiendo del input_config | def get_zip_codes_obj_config(input_config=None, reader=None):
"""Función auxiliar para obtener los códigos postales dependiendo del input_config
Parameters
----------
input_config : dict
diccionario que contiene la configuración del soporte de entrada para la ejecución
reader : gmaps.commons.reader.reader.AbstractReader
referencia a un reader que realizará la lectura de los códigos postales para la ejecución
Returns
-------
dict
con la información (códigos postales) obtenidos del soporte de entrada configurado en input_config
None
en caso de que el `type` del soporte de entrada no esté soportado o en caso de que el soporte de entrada sea
`db` y no se haya pasado un `reader`
"""
if input_config.get("type") == "local":
return input_config.get("local")
elif input_config.get("type") == "file":
config = input_config.get("file")
config.update({"zip_codes": get_obj_from_file(config.get("file_path"))})
return config
elif input_config.get("type") == "db":
if reader:
return reader.read()
else:
return None
else:
return None | [
"def",
"get_zip_codes_obj_config",
"(",
"input_config",
"=",
"None",
",",
"reader",
"=",
"None",
")",
":",
"if",
"input_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"local\"",
":",
"return",
"input_config",
".",
"get",
"(",
"\"local\"",
")",
"elif",
"input_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"file\"",
":",
"config",
"=",
"input_config",
".",
"get",
"(",
"\"file\"",
")",
"config",
".",
"update",
"(",
"{",
"\"zip_codes\"",
":",
"get_obj_from_file",
"(",
"config",
".",
"get",
"(",
"\"file_path\"",
")",
")",
"}",
")",
"return",
"config",
"elif",
"input_config",
".",
"get",
"(",
"\"type\"",
")",
"==",
"\"db\"",
":",
"if",
"reader",
":",
"return",
"reader",
".",
"read",
"(",
")",
"else",
":",
"return",
"None",
"else",
":",
"return",
"None"
] | [
79,
0
] | [
109,
19
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
point_distance_to_line | (point: Point2D, line: Tuple[Point2D, Point2D]) | return np.abs(np.cross(p2-p1, p1-p3)) / np.linalg.norm(p2-p1) | Calcula la distancia entre un punto y una recta definida por sus extremos.
Extraído de:
https://stackoverflow.com/questions/39840030/distance-between-point-and-a-line-from-two-points
:param point: punto 2D (x, y).
:param line: recta definida por dos puntos [(x0, y0), (x1, y1)].
:return: mínima distancia entre el punto y la recta.
| Calcula la distancia entre un punto y una recta definida por sus extremos. | def point_distance_to_line(point: Point2D, line: Tuple[Point2D, Point2D]) -> float:
"""Calcula la distancia entre un punto y una recta definida por sus extremos.
Extraído de:
https://stackoverflow.com/questions/39840030/distance-between-point-and-a-line-from-two-points
:param point: punto 2D (x, y).
:param line: recta definida por dos puntos [(x0, y0), (x1, y1)].
:return: mínima distancia entre el punto y la recta.
"""
p1, p2 = np.array(line[0]), np.array(line[1])
p3 = np.array(point)
return np.abs(np.cross(p2-p1, p1-p3)) / np.linalg.norm(p2-p1) | [
"def",
"point_distance_to_line",
"(",
"point",
":",
"Point2D",
",",
"line",
":",
"Tuple",
"[",
"Point2D",
",",
"Point2D",
"]",
")",
"->",
"float",
":",
"p1",
",",
"p2",
"=",
"np",
".",
"array",
"(",
"line",
"[",
"0",
"]",
")",
",",
"np",
".",
"array",
"(",
"line",
"[",
"1",
"]",
")",
"p3",
"=",
"np",
".",
"array",
"(",
"point",
")",
"return",
"np",
".",
"abs",
"(",
"np",
".",
"cross",
"(",
"p2",
"-",
"p1",
",",
"p1",
"-",
"p3",
")",
")",
"/",
"np",
".",
"linalg",
".",
"norm",
"(",
"p2",
"-",
"p1",
")"
] | [
6,
0
] | [
18,
65
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_funciones25 | (p) | funciones : COTD PABRE expresion PCIERRA | funciones : COTD PABRE expresion PCIERRA | def p_funciones25(p):
'funciones : COTD PABRE expresion PCIERRA' | [
"def",
"p_funciones25",
"(",
"p",
")",
":"
] | [
373,
0
] | [
374,
46
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
BioPortalService.annotations | (self, ontologies: list, text: str) | return list(map(BioPortalService.annotation_parse, api_annotations)) | retorna las anotaciones relacionadas al termino buscado en la api de bioportal con el siguiente formato
de parseo determinado por ```BioPortalService.annotationParse```
| retorna las anotaciones relacionadas al termino buscado en la api de bioportal con el siguiente formato
de parseo determinado por ```BioPortalService.annotationParse```
| def annotations(self, ontologies: list, text: str):
"""retorna las anotaciones relacionadas al termino buscado en la api de bioportal con el siguiente formato
de parseo determinado por ```BioPortalService.annotationParse```
"""
api_annotations = self.bioportal_api.annotator(text, ontologies)
return list(map(BioPortalService.annotation_parse, api_annotations)) | [
"def",
"annotations",
"(",
"self",
",",
"ontologies",
":",
"list",
",",
"text",
":",
"str",
")",
":",
"api_annotations",
"=",
"self",
".",
"bioportal_api",
".",
"annotator",
"(",
"text",
",",
"ontologies",
")",
"return",
"list",
"(",
"map",
"(",
"BioPortalService",
".",
"annotation_parse",
",",
"api_annotations",
")",
")"
] | [
12,
4
] | [
17,
76
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
contar | () | Contar hasta cien | Contar hasta cien | def contar():
'''Contar hasta cien'''
contador = 0
while contador<100:
contador+=1
print('Hilo:',
threading.current_thread().getName(),
'con identificador:',
threading.current_thread().ident,
'Contador:', contador) | [
"def",
"contar",
"(",
")",
":",
"contador",
"=",
"0",
"while",
"contador",
"<",
"100",
":",
"contador",
"+=",
"1",
"print",
"(",
"'Hilo:'",
",",
"threading",
".",
"current_thread",
"(",
")",
".",
"getName",
"(",
")",
",",
"'con identificador:'",
",",
"threading",
".",
"current_thread",
"(",
")",
".",
"ident",
",",
"'Contador:'",
",",
"contador",
")"
] | [
2,
0
] | [
11,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
TokenCallback.renew_token | (self, token: str, token_len: int = 32, *, cursor) | return new_token.hex() | Renueva un token de acceso
En caso de que haya una filtración en la base de datos y se obtengan los
token's de acceso de las redes (la de los usuarios están protegidas por
SHA3_256) y/o se desee renovar (o sea cambiar el token de acceso mas no
cambiar la fecha de expiración).
Igualmente los token's expiran, aunque ésto lo decide un usuario.
Args:
token:
El token de acceso a renovar
token_len:
La longitud del nuevo token de acceso
Returns:
El nuevo token de acceso
| Renueva un token de acceso | async def renew_token(self, token: str, token_len: int = 32, *, cursor) -> str:
"""Renueva un token de acceso
En caso de que haya una filtración en la base de datos y se obtengan los
token's de acceso de las redes (la de los usuarios están protegidas por
SHA3_256) y/o se desee renovar (o sea cambiar el token de acceso mas no
cambiar la fecha de expiración).
Igualmente los token's expiran, aunque ésto lo decide un usuario.
Args:
token:
El token de acceso a renovar
token_len:
La longitud del nuevo token de acceso
Returns:
El nuevo token de acceso
"""
(new_token, hash_token) = self.__generate_token(token_len)
logging.debug(_("Renovando token de acceso..."))
await cursor.execute(
"UPDATE tokens SET token = %s WHERE token = %s",
(hash_token, token)
)
return new_token.hex() | [
"async",
"def",
"renew_token",
"(",
"self",
",",
"token",
":",
"str",
",",
"token_len",
":",
"int",
"=",
"32",
",",
"*",
",",
"cursor",
")",
"->",
"str",
":",
"(",
"new_token",
",",
"hash_token",
")",
"=",
"self",
".",
"__generate_token",
"(",
"token_len",
")",
"logging",
".",
"debug",
"(",
"_",
"(",
"\"Renovando token de acceso...\"",
")",
")",
"await",
"cursor",
".",
"execute",
"(",
"\"UPDATE tokens SET token = %s WHERE token = %s\"",
",",
"(",
"hash_token",
",",
"token",
")",
")",
"return",
"new_token",
".",
"hex",
"(",
")"
] | [
334,
4
] | [
365,
30
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_listaOpciones_List | (p) | listaOpciones : listaOpciones opCol | listaOpciones : listaOpciones opCol | def p_listaOpciones_List(p):
'listaOpciones : listaOpciones opCol' | [
"def",
"p_listaOpciones_List",
"(",
"p",
")",
":"
] | [
713,
0
] | [
714,
41
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ServiceCallback.extract_serviceid | (service_name: str, *, cursor) | return id_service | Extrae el identificador del servicio | Extrae el identificador del servicio | async def extract_serviceid(service_name: str, *, cursor) -> Tuple[int]:
"""Extrae el identificador del servicio"""
await cursor.execute(
"SELECT id_service FROM services WHERE service = %s LIMIT 1",
(service_name,)
)
id_service = await cursor.fetchone()
return id_service | [
"async",
"def",
"extract_serviceid",
"(",
"service_name",
":",
"str",
",",
"*",
",",
"cursor",
")",
"->",
"Tuple",
"[",
"int",
"]",
":",
"await",
"cursor",
".",
"execute",
"(",
"\"SELECT id_service FROM services WHERE service = %s LIMIT 1\"",
",",
"(",
"service_name",
",",
")",
")",
"id_service",
"=",
"await",
"cursor",
".",
"fetchone",
"(",
")",
"return",
"id_service"
] | [
818,
4
] | [
829,
25
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
get_image_path | (instancia, filename) | return path | Construye la ruta donde se van a guardar las imágenes de perfil | Construye la ruta donde se van a guardar las imágenes de perfil | def get_image_path(instancia, filename):
"""Construye la ruta donde se van a guardar las imágenes de perfil"""
user_id = instancia.user.id
# if user_id is None:
# user_id = User.objects.order_by("id").last().id + 1
path = os.path.join("img/users/", str(user_id), "profile", filename)
return path | [
"def",
"get_image_path",
"(",
"instancia",
",",
"filename",
")",
":",
"user_id",
"=",
"instancia",
".",
"user",
".",
"id",
"# if user_id is None:",
"# user_id = User.objects.order_by(\"id\").last().id + 1",
"path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"\"img/users/\"",
",",
"str",
"(",
"user_id",
")",
",",
"\"profile\"",
",",
"filename",
")",
"return",
"path"
] | [
17,
0
] | [
23,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
obtener_texto | (ruta: str) | Lee un archivo de texto y devuelve una lista de líneas
:param ruta: Ruta del archivo a leer
:ruta type: str
:return: Lista de líneas del archivo
:ruta type: List[str]
| Lee un archivo de texto y devuelve una lista de líneas | def obtener_texto(ruta: str) -> List[str]:
"""Lee un archivo de texto y devuelve una lista de líneas
:param ruta: Ruta del archivo a leer
:ruta type: str
:return: Lista de líneas del archivo
:ruta type: List[str]
"""
with open(ruta, encoding="utf-8") as f:
return f.read().splitlines() | [
"def",
"obtener_texto",
"(",
"ruta",
":",
"str",
")",
"->",
"List",
"[",
"str",
"]",
":",
"with",
"open",
"(",
"ruta",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"as",
"f",
":",
"return",
"f",
".",
"read",
"(",
")",
".",
"splitlines",
"(",
")"
] | [
16,
0
] | [
25,
36
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
round | (input, decimales) | return math.round(input,decimales) | Aproximación a n decimales
Redondear la entrada a cierta cantidad de decimales.
Args:
input(Number): valor real
Returns:
Number
| Aproximación a n decimales | def round(input, decimales):
"""Aproximación a n decimales
Redondear la entrada a cierta cantidad de decimales.
Args:
input(Number): valor real
Returns:
Number
"""
return math.round(input,decimales) | [
"def",
"round",
"(",
"input",
",",
"decimales",
")",
":",
"return",
"math",
".",
"round",
"(",
"input",
",",
"decimales",
")"
] | [
204,
0
] | [
215,
38
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_cuerpo_tipo_func | (t) | cuerpo_funcion : begin_op tipo_funcionalidad end_op | cuerpo_funcion : begin_op tipo_funcionalidad end_op | def p_cuerpo_tipo_func(t):
'''cuerpo_funcion : begin_op tipo_funcionalidad end_op'''
t[0] = t[2] | [
"def",
"p_cuerpo_tipo_func",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"2",
"]"
] | [
1449,
0
] | [
1451,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_culquiercadena | (t) | cualquiercadena : CADENASIMPLE
| CADENADOBLE | cualquiercadena : CADENASIMPLE
| CADENADOBLE | def p_culquiercadena (t):
'''cualquiercadena : CADENASIMPLE
| CADENADOBLE'''
gramatica = '<cualquiercadena> ::= \"'+str(t[1])+'\"'
t[0] = Nodo('CADENA', str(t[1]), [], t.lexer.lineno, 0, gramatica) | [
"def",
"p_culquiercadena",
"(",
"t",
")",
":",
"gramatica",
"=",
"'<cualquiercadena> ::= \\\"'",
"+",
"str",
"(",
"t",
"[",
"1",
"]",
")",
"+",
"'\\\"'",
"t",
"[",
"0",
"]",
"=",
"Nodo",
"(",
"'CADENA'",
",",
"str",
"(",
"t",
"[",
"1",
"]",
")",
",",
"[",
"]",
",",
"t",
".",
"lexer",
".",
"lineno",
",",
"0",
",",
"gramatica",
")"
] | [
1181,
0
] | [
1185,
70
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
quicksort | (v,izq,der) | Metodo de ordenamiento QuickSort | Metodo de ordenamiento QuickSort | def quicksort(v,izq,der):
"""Metodo de ordenamiento QuickSort"""
i=izq
j=der
x=v[(izq + der)/2]
while( i <= j ):
while v[i]<x and j<=der:
i=i+1
while x<v[j] and j>izq:
j=j-1
if i<=j:
aux = v[i]; v[i] = v[j]; v[j] = aux;
i=i+1; j=j-1;
if izq < j:
quicksort( v, izq, j );
if i < der:
quicksort( v, i, der ); | [
"def",
"quicksort",
"(",
"v",
",",
"izq",
",",
"der",
")",
":",
"i",
"=",
"izq",
"j",
"=",
"der",
"x",
"=",
"v",
"[",
"(",
"izq",
"+",
"der",
")",
"/",
"2",
"]",
"while",
"(",
"i",
"<=",
"j",
")",
":",
"while",
"v",
"[",
"i",
"]",
"<",
"x",
"and",
"j",
"<=",
"der",
":",
"i",
"=",
"i",
"+",
"1",
"while",
"x",
"<",
"v",
"[",
"j",
"]",
"and",
"j",
">",
"izq",
":",
"j",
"=",
"j",
"-",
"1",
"if",
"i",
"<=",
"j",
":",
"aux",
"=",
"v",
"[",
"i",
"]",
"v",
"[",
"i",
"]",
"=",
"v",
"[",
"j",
"]",
"v",
"[",
"j",
"]",
"=",
"aux",
"i",
"=",
"i",
"+",
"1",
"j",
"=",
"j",
"-",
"1",
"if",
"izq",
"<",
"j",
":",
"quicksort",
"(",
"v",
",",
"izq",
",",
"j",
")",
"if",
"i",
"<",
"der",
":",
"quicksort",
"(",
"v",
",",
"i",
",",
"der",
")"
] | [
59,
0
] | [
76,
31
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
DataCleaner.string_regex_split | (self, field, pattern, new_field_names,
keep_original=True, inplace=False) | Regla para separar un campo a partir de una expresión regular.
TODO!!! Falta implementar este método.
Args:
field (str): Campo a limpiar.
pattern (str): Expresión regular.
new_field_names (list): Sufijos de los nuevos campos para los
valores separados.
Returns:
pandas.Series: Serie de strings limpios
| Regla para separar un campo a partir de una expresión regular. | def string_regex_split(self, field, pattern, new_field_names,
keep_original=True, inplace=False):
"""Regla para separar un campo a partir de una expresión regular.
TODO!!! Falta implementar este método.
Args:
field (str): Campo a limpiar.
pattern (str): Expresión regular.
new_field_names (list): Sufijos de los nuevos campos para los
valores separados.
Returns:
pandas.Series: Serie de strings limpios
"""
field = self._normalize_field(field)
pass | [
"def",
"string_regex_split",
"(",
"self",
",",
"field",
",",
"pattern",
",",
"new_field_names",
",",
"keep_original",
"=",
"True",
",",
"inplace",
"=",
"False",
")",
":",
"field",
"=",
"self",
".",
"_normalize_field",
"(",
"field",
")",
"pass"
] | [
657,
4
] | [
673,
12
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
countries_in_csv | () | return datos | Trae los paises del archivo y los devuelve en formato de lista | Trae los paises del archivo y los devuelve en formato de lista | def countries_in_csv():
"""Trae los paises del archivo y los devuelve en formato de lista"""
datos = []
with open(countries_path()) as file_country:
countries = csv.reader(file_country, delimiter=',')
next(countries)
for elem in countries:
datos.append(elem)
return datos | [
"def",
"countries_in_csv",
"(",
")",
":",
"datos",
"=",
"[",
"]",
"with",
"open",
"(",
"countries_path",
"(",
")",
")",
"as",
"file_country",
":",
"countries",
"=",
"csv",
".",
"reader",
"(",
"file_country",
",",
"delimiter",
"=",
"','",
")",
"next",
"(",
"countries",
")",
"for",
"elem",
"in",
"countries",
":",
"datos",
".",
"append",
"(",
"elem",
")",
"return",
"datos"
] | [
9,
0
] | [
17,
16
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Simulador.tiempo_transcurrido | (self) | return tiempo_transcurrido.total_seconds() | Tiempo transcurrido del vuelo en segundos. | Tiempo transcurrido del vuelo en segundos. | def tiempo_transcurrido(self):
"""Tiempo transcurrido del vuelo en segundos."""
tiempo_actual = datetime.fromtimestamp(time.time())
tiempo_transcurrido = tiempo_actual - self.tiempo_inicio
return tiempo_transcurrido.total_seconds() | [
"def",
"tiempo_transcurrido",
"(",
"self",
")",
":",
"tiempo_actual",
"=",
"datetime",
".",
"fromtimestamp",
"(",
"time",
".",
"time",
"(",
")",
")",
"tiempo_transcurrido",
"=",
"tiempo_actual",
"-",
"self",
".",
"tiempo_inicio",
"return",
"tiempo_transcurrido",
".",
"total_seconds",
"(",
")"
] | [
70,
4
] | [
74,
50
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
cambio_a_futuro | (tc, tiL, tiE, n) | return round(tc * ((1 + tiL)/(1 + tiE))**(n/365), 4) | Estima el tipo de cambio a futuro
:param tc: Tipo de cambio actual
:param til: Tasa de interés local
:param tiE: Tasa de interés extranjero
:param n: Número días a futuro
| Estima el tipo de cambio a futuro | def cambio_a_futuro(tc, tiL, tiE, n):
"""Estima el tipo de cambio a futuro
:param tc: Tipo de cambio actual
:param til: Tasa de interés local
:param tiE: Tasa de interés extranjero
:param n: Número días a futuro
"""
tiL = tiL / 100
tiE = tiE / 100
return round(tc * ((1 + tiL)/(1 + tiE))**(n/365), 4) | [
"def",
"cambio_a_futuro",
"(",
"tc",
",",
"tiL",
",",
"tiE",
",",
"n",
")",
":",
"tiL",
"=",
"tiL",
"/",
"100",
"tiE",
"=",
"tiE",
"/",
"100",
"return",
"round",
"(",
"tc",
"*",
"(",
"(",
"1",
"+",
"tiL",
")",
"/",
"(",
"1",
"+",
"tiE",
")",
")",
"**",
"(",
"n",
"/",
"365",
")",
",",
"4",
")"
] | [
49,
0
] | [
59,
56
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
Expediente.propietarios_count | (self) | return self.expedientepersona_set.filter(propietario=True).count() | Devuelve la cantidad de personas que figuran como propietarias. | Devuelve la cantidad de personas que figuran como propietarias. | def propietarios_count(self):
"""Devuelve la cantidad de personas que figuran como propietarias."""
return self.expedientepersona_set.filter(propietario=True).count() | [
"def",
"propietarios_count",
"(",
"self",
")",
":",
"return",
"self",
".",
"expedientepersona_set",
".",
"filter",
"(",
"propietario",
"=",
"True",
")",
".",
"count",
"(",
")"
] | [
277,
4
] | [
279,
74
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
p_parametros_funciones2 | (t) | parametro : lista_funciones
| parametro : lista_funciones
| def p_parametros_funciones2(t) :
'''parametro : lista_funciones
'''
t[0] = t[1]
resultado = 0
'''if t[1]['funcion'] != 'MOD' and t[1]['funcion'] != 'POWER'and t[1]['funcion'] != 'WIDTH_BUCKET' and t[1]['funcion'] != 'DIV' and t[1]['funcion'] != 'GCD':
resultado = type_checker.Funciones_Matematicas_1( t[1]['funcion'], t[1]['valor'], line = t.lexer.lineno)
else:
resultado = type_checker.Funciones_Matematicas_2( t[1]['funcion'], t[1]['valor'], t[1]['valor2'], line = t.lexer.lineno)
'''
#print("=========>>>", resultado)
gramatica = " | <lista_funciones>"
no_terminal = ["<lista_funciones>"]
terminal = []
reg_gramatical = "\nparametro.syn = lista_funciones.syn"
gramatical.agregarGramatical(gramatica,reg_gramatical,terminal,no_terminal,"parametro") | [
"def",
"p_parametros_funciones2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]",
"resultado",
"=",
"0",
"'''if t[1]['funcion'] != 'MOD' and t[1]['funcion'] != 'POWER'and t[1]['funcion'] != 'WIDTH_BUCKET' and t[1]['funcion'] != 'DIV' and t[1]['funcion'] != 'GCD':\n resultado = type_checker.Funciones_Matematicas_1( t[1]['funcion'], t[1]['valor'], line = t.lexer.lineno)\n else:\n resultado = type_checker.Funciones_Matematicas_2( t[1]['funcion'], t[1]['valor'], t[1]['valor2'], line = t.lexer.lineno)\n '''",
"#print(\"=========>>>\", resultado)",
"gramatica",
"=",
"\"\t\t\t\t| <lista_funciones>\"",
"no_terminal",
"=",
"[",
"\"<lista_funciones>\"",
"]",
"terminal",
"=",
"[",
"]",
"reg_gramatical",
"=",
"\"\\nparametro.syn = lista_funciones.syn\"",
"gramatical",
".",
"agregarGramatical",
"(",
"gramatica",
",",
"reg_gramatical",
",",
"terminal",
",",
"no_terminal",
",",
"\"parametro\"",
")"
] | [
1780,
0
] | [
1796,
91
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_aritmetica2 | (t) | aritmetica : funciones_math_esenciales
| fun_binario_select
| aritmetica : funciones_math_esenciales
| fun_binario_select
| def p_aritmetica2(t) :
'''aritmetica : funciones_math_esenciales
| fun_binario_select
'''
t[0] = t[1] | [
"def",
"p_aritmetica2",
"(",
"t",
")",
":",
"t",
"[",
"0",
"]",
"=",
"t",
"[",
"1",
"]"
] | [
822,
0
] | [
826,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
Cubo.desplazamientoB | (self, fila) | Moveremos la cara del cubo 90º, generando un cubo nuevo tras la modificación | Moveremos la cara del cubo 90º, generando un cubo nuevo tras la modificación | def desplazamientoB(self, fila):
'''Moveremos la cara del cubo 90º, generando un cubo nuevo tras la modificación'''
arr1 = copy.copy(self.left[fila])
arr2 = copy.copy(self.down[fila])
arr3 = copy.copy(self.right[fila])
arr4 = copy.copy(self.up[fila])
self.left[fila] = arr4
self.down[fila] = arr1
self.right[fila] = arr2
self.up[fila] = arr3
# extremo izq
if fila == 0:
self.back = np.rot90(self.back, 3)
elif fila == len(self.back) - 1:
self.front = np.rot90(self.front, 3)
# centros
else:
pass
self.updateEstado() | [
"def",
"desplazamientoB",
"(",
"self",
",",
"fila",
")",
":",
"arr1",
"=",
"copy",
".",
"copy",
"(",
"self",
".",
"left",
"[",
"fila",
"]",
")",
"arr2",
"=",
"copy",
".",
"copy",
"(",
"self",
".",
"down",
"[",
"fila",
"]",
")",
"arr3",
"=",
"copy",
".",
"copy",
"(",
"self",
".",
"right",
"[",
"fila",
"]",
")",
"arr4",
"=",
"copy",
".",
"copy",
"(",
"self",
".",
"up",
"[",
"fila",
"]",
")",
"self",
".",
"left",
"[",
"fila",
"]",
"=",
"arr4",
"self",
".",
"down",
"[",
"fila",
"]",
"=",
"arr1",
"self",
".",
"right",
"[",
"fila",
"]",
"=",
"arr2",
"self",
".",
"up",
"[",
"fila",
"]",
"=",
"arr3",
"# extremo izq",
"if",
"fila",
"==",
"0",
":",
"self",
".",
"back",
"=",
"np",
".",
"rot90",
"(",
"self",
".",
"back",
",",
"3",
")",
"elif",
"fila",
"==",
"len",
"(",
"self",
".",
"back",
")",
"-",
"1",
":",
"self",
".",
"front",
"=",
"np",
".",
"rot90",
"(",
"self",
".",
"front",
",",
"3",
")",
"# centros",
"else",
":",
"pass",
"self",
".",
"updateEstado",
"(",
")"
] | [
32,
4
] | [
50,
27
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
ColumnsDatabase.delete_column | (self, name_column) | Método que permite eliminar la columna previamente introducida | Método que permite eliminar la columna previamente introducida | def delete_column(self, name_column):
"""Método que permite eliminar la columna previamente introducida"""
try:
index = self.name_column.index(name_column)
self.name_column.remove(name_column)
self.type_column.pop(self.index)
print "Delete column", name_column, "..."
except Exception as ex:
print "delete_column :->", type(ex), '-> ', ex | [
"def",
"delete_column",
"(",
"self",
",",
"name_column",
")",
":",
"try",
":",
"index",
"=",
"self",
".",
"name_column",
".",
"index",
"(",
"name_column",
")",
"self",
".",
"name_column",
".",
"remove",
"(",
"name_column",
")",
"self",
".",
"type_column",
".",
"pop",
"(",
"self",
".",
"index",
")",
"print",
"\"Delete column\"",
",",
"name_column",
",",
"\"...\"",
"except",
"Exception",
"as",
"ex",
":",
"print",
"\"delete_column :->\"",
",",
"type",
"(",
"ex",
")",
",",
"'-> '",
",",
"ex"
] | [
37,
4
] | [
45,
58
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
data_processor | (raw_data, idioma, query) | return data | **Procesa los datos crudo de la API de Elasticsearh para devolver
solo los resultados**
Función que recibe una lista con los datos que prove la API de
``elacticsearch``, procesa los datos para ignorar los metadatos del API
y retorna solo los resultados de búsqueda como una lista.
:param raw_data: Lista de resultados crudos del API de Elasticsearch
:type: list
:param idioma: ISO del idioma de búsqueda
:type: str
:param query: Cadena de búsqueda
:type: str
:return: Resultados de búsqueda
:rtype: list
| **Procesa los datos crudo de la API de Elasticsearh para devolver
solo los resultados** | def data_processor(raw_data, idioma, query):
"""**Procesa los datos crudo de la API de Elasticsearh para devolver
solo los resultados**
Función que recibe una lista con los datos que prove la API de
``elacticsearch``, procesa los datos para ignorar los metadatos del API
y retorna solo los resultados de búsqueda como una lista.
:param raw_data: Lista de resultados crudos del API de Elasticsearch
:type: list
:param idioma: ISO del idioma de búsqueda
:type: str
:param query: Cadena de búsqueda
:type: str
:return: Resultados de búsqueda
:rtype: list
"""
# TODO: Refactor
LOGGER.info("Procesando datos de Elasticsearch")
data = []
for hit in raw_data['hits']:
fields = hit["_source"].keys()
if "l1" not in fields and "l2" not in fields:
hit["_source"]["l1"] = ''
hit["_source"]["l2"] = ''
elif "l1" not in fields:
hit["_source"]["l1"] = ''
elif "l2" not in fields:
hit["_source"]["l2"] = ''
hit = highlighter(hit, idioma, query)
doc_name = hit['_source']['document_name']
doc_file = hit['_source']['pdf_file']
try:
variant = hit['_source']['variant']
except KeyError:
variant = ""
link = doc_file_to_link(doc_name, doc_file, settings.MEDIA_ROOT)
if idioma == "NONE":
# TODO: Este procesamiento es del preview del documento
edit_btn = """<a href="#" class="btn btn-outline-info btn-block btn-sm disabled">Editar <i class="fa fa-edit"></i></a>"""
delete_btn = """<a href="#" class="btn btn-outline-danger btn-block btn-sm disabled">Eliminar <i class="fa fa-close"></i></a>"""
hit['_source']['actions'] = edit_btn + delete_btn
hit['_source']['pdf_file'] = link
else:
hit['_source']['document_name'] = link
if variant:
hit['_source']['variant'] = ethno_btn_maker(variant)
data.append(hit['_source'])
return data | [
"def",
"data_processor",
"(",
"raw_data",
",",
"idioma",
",",
"query",
")",
":",
"# TODO: Refactor",
"LOGGER",
".",
"info",
"(",
"\"Procesando datos de Elasticsearch\"",
")",
"data",
"=",
"[",
"]",
"for",
"hit",
"in",
"raw_data",
"[",
"'hits'",
"]",
":",
"fields",
"=",
"hit",
"[",
"\"_source\"",
"]",
".",
"keys",
"(",
")",
"if",
"\"l1\"",
"not",
"in",
"fields",
"and",
"\"l2\"",
"not",
"in",
"fields",
":",
"hit",
"[",
"\"_source\"",
"]",
"[",
"\"l1\"",
"]",
"=",
"''",
"hit",
"[",
"\"_source\"",
"]",
"[",
"\"l2\"",
"]",
"=",
"''",
"elif",
"\"l1\"",
"not",
"in",
"fields",
":",
"hit",
"[",
"\"_source\"",
"]",
"[",
"\"l1\"",
"]",
"=",
"''",
"elif",
"\"l2\"",
"not",
"in",
"fields",
":",
"hit",
"[",
"\"_source\"",
"]",
"[",
"\"l2\"",
"]",
"=",
"''",
"hit",
"=",
"highlighter",
"(",
"hit",
",",
"idioma",
",",
"query",
")",
"doc_name",
"=",
"hit",
"[",
"'_source'",
"]",
"[",
"'document_name'",
"]",
"doc_file",
"=",
"hit",
"[",
"'_source'",
"]",
"[",
"'pdf_file'",
"]",
"try",
":",
"variant",
"=",
"hit",
"[",
"'_source'",
"]",
"[",
"'variant'",
"]",
"except",
"KeyError",
":",
"variant",
"=",
"\"\"",
"link",
"=",
"doc_file_to_link",
"(",
"doc_name",
",",
"doc_file",
",",
"settings",
".",
"MEDIA_ROOT",
")",
"if",
"idioma",
"==",
"\"NONE\"",
":",
"# TODO: Este procesamiento es del preview del documento",
"edit_btn",
"=",
"\"\"\"<a href=\"#\" class=\"btn btn-outline-info btn-block btn-sm disabled\">Editar <i class=\"fa fa-edit\"></i></a>\"\"\"",
"delete_btn",
"=",
"\"\"\"<a href=\"#\" class=\"btn btn-outline-danger btn-block btn-sm disabled\">Eliminar <i class=\"fa fa-close\"></i></a>\"\"\"",
"hit",
"[",
"'_source'",
"]",
"[",
"'actions'",
"]",
"=",
"edit_btn",
"+",
"delete_btn",
"hit",
"[",
"'_source'",
"]",
"[",
"'pdf_file'",
"]",
"=",
"link",
"else",
":",
"hit",
"[",
"'_source'",
"]",
"[",
"'document_name'",
"]",
"=",
"link",
"if",
"variant",
":",
"hit",
"[",
"'_source'",
"]",
"[",
"'variant'",
"]",
"=",
"ethno_btn_maker",
"(",
"variant",
")",
"data",
".",
"append",
"(",
"hit",
"[",
"'_source'",
"]",
")",
"return",
"data"
] | [
42,
0
] | [
90,
15
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
GraphNanopub.serialize | (self, _format) | realiza el proceso de serializacion de los datos de la nanopublicacion | realiza el proceso de serializacion de los datos de la nanopublicacion | def serialize(self, _format):
""" realiza el proceso de serializacion de los datos de la nanopublicacion"""
if _format == "json-html":
return self.__json_html()
else:
return self.nanopub.rdf.serialize(format=_format).decode("utf-8") | [
"def",
"serialize",
"(",
"self",
",",
"_format",
")",
":",
"if",
"_format",
"==",
"\"json-html\"",
":",
"return",
"self",
".",
"__json_html",
"(",
")",
"else",
":",
"return",
"self",
".",
"nanopub",
".",
"rdf",
".",
"serialize",
"(",
"format",
"=",
"_format",
")",
".",
"decode",
"(",
"\"utf-8\"",
")"
] | [
128,
4
] | [
133,
77
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
p_ASIGNACION3 | (t) | ASIGNACION : id igual METODOS
| ASIGNACION : id igual METODOS
| def p_ASIGNACION3(t):
'''ASIGNACION : id igual METODOS
'''
#t[0]=Asignacion(t[1],None,t[2],None,t.lexer.lineno).Optimizar()
print("ASIGNACION") | [
"def",
"p_ASIGNACION3",
"(",
"t",
")",
":",
"#t[0]=Asignacion(t[1],None,t[2],None,t.lexer.lineno).Optimizar()\r",
"print",
"(",
"\"ASIGNACION\"",
")"
] | [
278,
0
] | [
283,
23
] | null | python | es | ['es', 'es', 'es'] | True | true | null |
|
AviController.maybe_fix_bad_node_cluster | (self, new_node) | Scenarios:
- New node has different IP than old node
In this case, we can just update the cluster with new nodes IP
- New node has same IP as old node
This is bit tricky, as we need to remove node with same Ip and
create 1 node cluster.
Wait for all nodes to go in cluster_up_no_ha state
Configure 3 node cluster again
| Scenarios:
- New node has different IP than old node
In this case, we can just update the cluster with new nodes IP
- New node has same IP as old node
This is bit tricky, as we need to remove node with same Ip and
create 1 node cluster.
Wait for all nodes to go in cluster_up_no_ha state
Configure 3 node cluster again
| def maybe_fix_bad_node_cluster(self, new_node):
""" Scenarios:
- New node has different IP than old node
In this case, we can just update the cluster with new nodes IP
- New node has same IP as old node
This is bit tricky, as we need to remove node with same Ip and
create 1 node cluster.
Wait for all nodes to go in cluster_up_no_ha state
Configure 3 node cluster again
"""
def get_active_nodes(nodes):
return [node['name'] for node in nodes
if node['state'] != 'CLUSTER_INACTIVE']
def get_all_nodes(nodes):
return [node['name'] for node in nodes]
def get_cluster_leader(nodes):
for node in nodes:
if node['role'] == 'CLUSTER_LEADER':
return node['name']
resp = self.client.get('/api/cluster/runtime')
if resp.status_code / 100 != 2:
log.debug(
'Cluster Runtime status code: %s, content: %s' % (
resp.status_code, resp.content))
raise RuntimeError('Failed to get cluster node status')
response = json.loads(resp.content)
active_nodes = get_active_nodes(response['node_states'])
all_nodes = get_all_nodes(response['node_states'])
if get_cluster_leader(response['node_states']) not in self.__get_my_ip():
log.debug('Cluster leaader: %s, This node IP: %s' % (
get_cluster_leader(response['node_states']), self.__get_my_ip()))
raise RuntimeError(
'Please run this from cluster leader: %s' %
get_cluster_leader(response['node_states']))
if len(active_nodes) == 3:
log.debug('All cluster nodes are active. returning')
return
if new_node not in all_nodes:
# Different IP
resp = self.client.get('/api/cluster')
if resp.status_code / 100 != 2:
log.debug('%s, %s', resp.status_code, resp.content)
raise RuntimeError(
'Failed to get cluster config. Is controller running?')
cluster = json.loads(resp.content)
new_nodes = [node for node in cluster['nodes']
if node['name'] in active_nodes]
cluster['nodes'] = new_nodes
new_node_config = copy.deepcopy(cluster['nodes'][0])
new_node_config['ip']['addr'] = new_node
new_node_config['name'] = new_node
cluster['nodes'].append(new_node_config)
log.debug('%s' % str(cluster['nodes']))
response = self.client.put(
'/api/cluster', data=json.dumps(cluster))
if response.status_code / 100 != 2:
log.debug('%s, %s', response.status_code, response.content)
raise RuntimeError('Failed to remove node from cluster')
else:
self.fix_same_ip_node(
get_cluster_leader(response['node_states']),
active_nodes)
log.info('Cluster configuration successful!') | [
"def",
"maybe_fix_bad_node_cluster",
"(",
"self",
",",
"new_node",
")",
":",
"def",
"get_active_nodes",
"(",
"nodes",
")",
":",
"return",
"[",
"node",
"[",
"'name'",
"]",
"for",
"node",
"in",
"nodes",
"if",
"node",
"[",
"'state'",
"]",
"!=",
"'CLUSTER_INACTIVE'",
"]",
"def",
"get_all_nodes",
"(",
"nodes",
")",
":",
"return",
"[",
"node",
"[",
"'name'",
"]",
"for",
"node",
"in",
"nodes",
"]",
"def",
"get_cluster_leader",
"(",
"nodes",
")",
":",
"for",
"node",
"in",
"nodes",
":",
"if",
"node",
"[",
"'role'",
"]",
"==",
"'CLUSTER_LEADER'",
":",
"return",
"node",
"[",
"'name'",
"]",
"resp",
"=",
"self",
".",
"client",
".",
"get",
"(",
"'/api/cluster/runtime'",
")",
"if",
"resp",
".",
"status_code",
"/",
"100",
"!=",
"2",
":",
"log",
".",
"debug",
"(",
"'Cluster Runtime status code: %s, content: %s'",
"%",
"(",
"resp",
".",
"status_code",
",",
"resp",
".",
"content",
")",
")",
"raise",
"RuntimeError",
"(",
"'Failed to get cluster node status'",
")",
"response",
"=",
"json",
".",
"loads",
"(",
"resp",
".",
"content",
")",
"active_nodes",
"=",
"get_active_nodes",
"(",
"response",
"[",
"'node_states'",
"]",
")",
"all_nodes",
"=",
"get_all_nodes",
"(",
"response",
"[",
"'node_states'",
"]",
")",
"if",
"get_cluster_leader",
"(",
"response",
"[",
"'node_states'",
"]",
")",
"not",
"in",
"self",
".",
"__get_my_ip",
"(",
")",
":",
"log",
".",
"debug",
"(",
"'Cluster leaader: %s, This node IP: %s'",
"%",
"(",
"get_cluster_leader",
"(",
"response",
"[",
"'node_states'",
"]",
")",
",",
"self",
".",
"__get_my_ip",
"(",
")",
")",
")",
"raise",
"RuntimeError",
"(",
"'Please run this from cluster leader: %s'",
"%",
"get_cluster_leader",
"(",
"response",
"[",
"'node_states'",
"]",
")",
")",
"if",
"len",
"(",
"active_nodes",
")",
"==",
"3",
":",
"log",
".",
"debug",
"(",
"'All cluster nodes are active. returning'",
")",
"return",
"if",
"new_node",
"not",
"in",
"all_nodes",
":",
"# Different IP",
"resp",
"=",
"self",
".",
"client",
".",
"get",
"(",
"'/api/cluster'",
")",
"if",
"resp",
".",
"status_code",
"/",
"100",
"!=",
"2",
":",
"log",
".",
"debug",
"(",
"'%s, %s'",
",",
"resp",
".",
"status_code",
",",
"resp",
".",
"content",
")",
"raise",
"RuntimeError",
"(",
"'Failed to get cluster config. Is controller running?'",
")",
"cluster",
"=",
"json",
".",
"loads",
"(",
"resp",
".",
"content",
")",
"new_nodes",
"=",
"[",
"node",
"for",
"node",
"in",
"cluster",
"[",
"'nodes'",
"]",
"if",
"node",
"[",
"'name'",
"]",
"in",
"active_nodes",
"]",
"cluster",
"[",
"'nodes'",
"]",
"=",
"new_nodes",
"new_node_config",
"=",
"copy",
".",
"deepcopy",
"(",
"cluster",
"[",
"'nodes'",
"]",
"[",
"0",
"]",
")",
"new_node_config",
"[",
"'ip'",
"]",
"[",
"'addr'",
"]",
"=",
"new_node",
"new_node_config",
"[",
"'name'",
"]",
"=",
"new_node",
"cluster",
"[",
"'nodes'",
"]",
".",
"append",
"(",
"new_node_config",
")",
"log",
".",
"debug",
"(",
"'%s'",
"%",
"str",
"(",
"cluster",
"[",
"'nodes'",
"]",
")",
")",
"response",
"=",
"self",
".",
"client",
".",
"put",
"(",
"'/api/cluster'",
",",
"data",
"=",
"json",
".",
"dumps",
"(",
"cluster",
")",
")",
"if",
"response",
".",
"status_code",
"/",
"100",
"!=",
"2",
":",
"log",
".",
"debug",
"(",
"'%s, %s'",
",",
"response",
".",
"status_code",
",",
"response",
".",
"content",
")",
"raise",
"RuntimeError",
"(",
"'Failed to remove node from cluster'",
")",
"else",
":",
"self",
".",
"fix_same_ip_node",
"(",
"get_cluster_leader",
"(",
"response",
"[",
"'node_states'",
"]",
")",
",",
"active_nodes",
")",
"log",
".",
"info",
"(",
"'Cluster configuration successful!'",
")"
] | [
645,
4
] | [
717,
53
] | null | python | es | ['es', 'es', 'es'] | False | true | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.