def test_conversión_imposible(símismo):
"""
¡Comparemos bananas con naranjas!
"""
símismo.assertRaises(ValueError,
lambda: convertir('bananas', 'naranjas'))
# Y un error de dimensionalidad.
símismo.assertRaises(ValueError, lambda: convertir('m3', 'm2'))
def test_agregar_trad_sin_especificar_leng(símismo):
"""
Comprobar que podemos agregar traducciones de unidades sin especificar la lengua original de la unidad.
"""
trads.agregar_trad(unid='second',
trad='پل',
leng_trad='ur',
guardar=False)
símismo.assertEqual(convertir(de='second', a='پل'), 1)
def test_agregar_sinónimo_listas(símismo):
"""
Comprobar que podemos agregar sinónimos de unidades en formato de lista.
"""
trads.agregar_sinónimos(unid='meter',
sinónimos=['metre', 'm'],
leng='en',
guardar=False)
símismo.assertEqual(convertir(de='metre', a='m'), 1)
def test_agregar_sinónimo(símismo):
"""
Comprobar que podemos agregar sinónimos de unidades.
"""
trads.agregar_sinónimos(unid='foot',
sinónimos='feet',
leng='en',
guardar=True)
símismo.assertEqual(convertir(de='foot', a='feet'), 1)
def test_agregar_trad(símismo):
"""
Comprobar que podemos agregar traducciones de unidades.
"""
trads.agregar_trad(unid='second',
trad='پل',
leng_orig='en',
leng_trad='ur',
guardar=False)
símismo.assertEqual(convertir(de='second', a='پل'), 1)
def convertir_tiempo(de, a, q=1):
if de in sinónimos:
q *= sinónimos[de]['factor']
de = sinónimos[de]['ref']
if a in sinónimos:
q /= sinónimos[a]['factor']
a = sinónimos[a]['ref']
return convertir(de=de, a=a)
def test_convertir_con_traducción_necesaria(símismo):
# Registrar traducciones
trads.agregar_trad('pound', trad='paj', leng_trad='cak', guardar=False)
trads.agregar_trad('paj',
trad='libra',
leng_trad='es',
leng_orig='cak',
guardar=False)
de = 'paj'
a = 'libras'
# Deberían ser igual ahora.
símismo.assertEqual(convertir(de, a), 1)
def test_agregar_trad_por_sinónimo_pint(símismo):
"""
Comprobar que podemos agregar la traducción de una unidad según su sinónimo Pint.
"""
trads.agregar_trad(unid='l',
trad='litre',
leng_trad='fr',
guardar=False)
trads.agregar_trad(unid='l',
trad='litro',
leng_trad='es',
guardar=False)
símismo.assertEqual(convertir('litres', a='litros'), 1)
def test_convertir_plurial_erróneo(símismo):
"""
Intentemos convertir un nombre que parece ser forma plurial ("mes" podría reconocerse como el plurial
de "m"), pero no lo es.
"""
símismo.assertEqual(convertir('años', 'mes'), 12)
def test_convertir_con_valor(símismo):
# Comprobar conversión real.
símismo.assertEqual(convertir('km', 'm', val=2), 2000)
def test_convertir_con_traducción_desconocida(símismo):
# Aunque no sepa lo que es una "estación", el programa debería detectar que es lo mismo en ambos y solamente
# convertir los m3 a cm3.
símismo.assertAlmostEqual(convertir('m3/estación', 'cm3/estación'),
100**3)
def test_convertir_unids_iguales(símismo):
# Unidades idénticas deberían dar un factor de conversión de 1.
símismo.assertEqual(convertir('colibrís', 'colibrís'), 1)
def test_convertir_unids_equivalentes(símismo):
# Unidades equivalentes deberían dar un factor de conversión de 1.
símismo.assertEqual(convertir('m2/d', 'm3/d/m'), 1)
def conectar_vars(símismo, var_fuente, modelo_fuente, var_recip, modelo_recip, conv=None):
"""
Conecta variables entre los submodelos.
:param var_fuente: El variable fuente de la conexión.
:type var_fuente: str
:param modelo_fuente: El nombre del modelo fuente.
:type modelo_fuente: str
:param var_recip: El variable recipiente de la conexión.
:type var_recip: str
:param modelo_recip: El nombre del modelo recipiente.
:type modelo_recip: str
:param conv: La conversión entre las unidades de los modelos. En el caso ``None``, se intentará adivinar la
conversión con el módulo `~tinamit.Unidades`.
:type conv: float | int
"""
# Verificar que todos los modelos existan.
for m in [modelo_fuente, modelo_recip]:
if m not in símismo.modelos:
raise ValueError(_('El submodelo "{}" no existe en este modelo.').format(m))
# Verificar que todos los variables existan.
for v, m in [(var_fuente, modelo_fuente), (var_recip, modelo_recip)]:
mod = símismo.modelos[m]
if v not in mod.variables:
raise ValueError(_('El variable "{}" no existe en el modelo "{}".').format(v, m))
# Y también asegurarse de que el variable no haya sido conectado como variable recipiente ya.
if any(x['var_recip'] == var_recip and x['modelo_recip'] == modelo_recip for x in símismo.conexiones):
avisar(_('El variable "{}" del modelo "{}" ya está conectado como variable recipiente. '
'Borraremos la conexión anterior.').format(var_recip, modelo_recip))
# Identificar los nombres de los variables fuente y recipiente, tanto como sus unidades, dimensiones y límites.
unid_fuente = símismo.modelos[modelo_fuente].obt_unidades_var(var_fuente)
unid_recip = símismo.modelos[modelo_recip].obt_unidades_var(var_recip)
dims_fuente = símismo.modelos[modelo_fuente].obt_dims_var(var_fuente)
dims_recip = símismo.modelos[modelo_recip].obt_dims_var(var_recip)
líms_fuente = símismo.modelos[modelo_fuente].obt_lims_var(var_fuente)
líms_recip = símismo.modelos[modelo_recip].obt_lims_var(var_recip)
# Verificar que las dimensiones sean compatibles
if dims_fuente != dims_recip:
raise ValueError(_('Las dimensiones de los dos variables ({}: {}; {}: {}) no son compatibles.')
.format(var_fuente, dims_fuente, var_recip, dims_recip))
# Verificar que los límites sean compatibles
if (líms_recip[0] is not None) and (líms_fuente[0] is None or líms_recip[0] > líms_fuente[0]):
avisar(_('Pensamos bien avisarte que el límite inferior ({l_r}) del variable recipiente "{v_r}" '
'queda superior al límite inferior ({l_f}) del variable fuente "{v_f}" de la conexión.'
).format(v_r=var_recip, v_f=var_fuente, l_r=líms_recip[0], l_f=líms_fuente[0]))
if (líms_recip[1] is not None) and (líms_fuente[1] is None or líms_recip[1] < líms_fuente[1]):
avisar(_('Pensamos bien avisarte que el límite superior ({l_r}) del variable recipiente "{v_r}" '
'queda inferior al límite superior ({l_f}) del variable fuente "{v_f}" de la conexión.'
).format(v_r=var_recip, v_f=var_fuente, l_r=líms_recip[1], l_f=líms_fuente[1]))
if conv is None:
# Si no se especificó factor de conversión...
# Intentar hacer una conversión automática.
try:
conv = convertir(de=unid_fuente, a=unid_recip)
except ValueError:
# Si eso no funcionó, suponer una conversión de 1.
avisar(_('No se pudo identificar una conversión automática para las unidades de los variables'
'"{}" (unidades: {}) y "{}" (unidades: {}). Se está suponiendo un factor de conversión de 1.')
.format(var_fuente, unid_fuente, var_recip, unid_recip))
conv = 1
# Crear el diccionario de conexión.
dic_conex = {'modelo_fuente': modelo_fuente,
'modelo_recip': modelo_recip,
'var_fuente': var_fuente,
'var_recip': var_recip,
'conv': conv
}
# Agregar el diccionario de conexión a la lista de conexiones.
símismo.conexiones.append(dic_conex)
def unidad_tiempo(símismo):
"""
Esta función devolverá las unidades de tiempo del modelo conectado. Dependerá de los submodelos.
Si los dos submodelos tienen las mismas unidades, esta será la unidad del modelo conectado también.
Si los dos tienen unidades distintas, intentaremos encontrar la conversión entre los dos y después se
considerará como unidad de tiempo de base la más grande de los dos. Por ejemplo, si se conecta un modelo
con una unidad de tiempo de meses con un modelo de unidad de año, se aplicará una unidad de tiempo de سال
al modelo conectado.
Después se actualiza el variable símismo.conv_tiempo para guardar en memoria la conversión necesaria entre
los pasos de los dos submodelos.
Se emplea las clase `~tinamit.Unidades.Unidades` para convertir unidades.
:return: El tiempo de paso del modelo SuperConectado.
:rtype: str
"""
# Borrar información existente
símismo.conv_tiempo_dudoso = False
símismo.conv_tiempo.clear()
# Si se especificó modelo de base de tiempo, usar éste.
if símismo.mod_base_tiempo is not None:
return símismo.modelos[símismo.mod_base_tiempo].unidad_tiempo()
# Casos fáciles
if not len(símismo.modelos):
# Si todavía no se han conectado modelos, no hay nada que hacer.
return None
elif len(símismo.modelos) == 1:
# Si solamente se contectó un modelo, devolver la unidad de tiempo de éste.
m = list(símismo.modelos)[0]
símismo.conv_tiempo[m] = 1
return símismo.modelos[m].unidad_tiempo()
# Identificar las unidades de los submodelos.
l_mods = list(símismo.modelos) # Una lista ordenada de los nombres de los submodelos.
d_unids = {m: símismo.modelos[m].unidad_tiempo() for m in l_mods}
# Una función auxiliar aquí para verificar si los factores de conversión son números enteros o no.
def verificar_entero(factor, l_unids):
if not np.array_equal(factor.astype(int), factor):
# Si todos los factores no son números enteros, tendremos que aproximar.
avisar('Las unidades de tiempo de los dos modelos ({}) no tienen denominator común. '
'Se aproximará la conversión.'.format(', '.join(l_unids)))
np.round(factor, out=factor)
# Tomar cualquier unidad del diccionario como referencia de base
u_0 = d_unids[l_mods[0]]
# Si las unidades son idénticas, ya tenemos nuestra respuesta.
try:
if all(convertir(u, u_0) == 1 for u in d_unids.values()):
for m in l_mods:
símismo.conv_tiempo[m] = 1
return list(d_unids.values())[0]
except ValueError:
pass
# Sino, intentemos convertir automáticamente
factores_conv = np.empty(len(d_unids))
for i, m in enumerate(l_mods):
u = d_unids[m]
try:
# Intentar convertir la unidad del submodelo a la unidad de base
factores_conv[i] = convertir(de=u_0, a=u)
except ValueError:
# Si no lo logramos, hay un error, pero no querremos parar todo el programa por eso.
símismo.conv_tiempo_dudoso = True
factores_conv[i] = 1
# El factor más pequeño debe ser 1.
np.divide(factores_conv, factores_conv.min(), out=factores_conv)
# Verificar que no tengamos factores de conversión fraccionales.
verificar_entero(factores_conv, l_unids=list(d_unids))
# Aplicar los factores calculados.
for i, m in enumerate(l_mods):
símismo.conv_tiempo[m] = int(factores_conv[i])
# La unidad de base para el SuperConectado es la que tiene factor de conversión de 1.
unid_base = next(d_unids[m] for m, c in símismo.conv_tiempo.items() if c == 1)
# Devolver la unidad de base
return unid_base