def __init__(símismo):
símismo.direc = pkg_resources.resource_filename('tinamit.Interfaz', 'Trads.json')
símismo.arch_config = pkg_resources.resource_filename('tinamit.Interfaz', 'Config.json')
símismo.estándar = 'Español'
símismo.config = None
símismo.dic = cargar_json(símismo.direc)
try:
símismo.config = cargar_json(símismo.arch_config)
except (FileNotFoundError, json.decoder.JSONDecodeError):
pass
símismo.lenguas = símismo.dic['Lenguas']
if símismo.config is None or \
'leng_act' not in símismo.config or símismo.config['leng_act'] not in símismo.lenguas:
config = {'leng_act': 'Kaqchikel'}
símismo.config = config
guardar_json(config, arch=símismo.arch_config)
símismo.verificar_estados()
leng_act = símismo.config['leng_act']
símismo.leng_act = símismo.lenguas[leng_act]
símismo.trads_act = símismo.leng_act['Trads']
símismo.izq_a_derech = símismo.leng_act['IzqaDerech']
def verificar_leer_egr(cls):
try:
arch_egr, arch_ref = cls.refs_prb_leer_egr()
except NotImplementedError:
return
egr = cls.leer_arch_resultados(arch_egr)
try:
ref = cargar_json(arch_ref)
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los archivos de egresos. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de egresos.').format(
arch_ref))
for var, val in egr.items():
if isinstance(val, np.ndarray):
egr[var] = val.tolist()
guardar_json(egr, arch=arch_ref)
ref = egr
for var in ref:
npt.assert_equal(ref[var], egr[var], err_msg=var)
def verificar_avanzar(cls, n_pasos=3):
try:
arch_ref = cls.refs_prb_avanzar()
arch_inic = cls.refs_prb_vals_inic()[0]
except NotImplementedError:
return
mod = cls(archivo=arch_inic)
res = mod.simular(t_final=n_pasos)
try:
ref = xr.Dataset.from_dict(cargar_json(arch_ref))
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté simulando correctamente. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de simulación de modelo.').format(
arch_ref))
guardar_json(res.to_dict(), arch=arch_ref)
ref = res
xr.testing.assert_equal(ref, res)
def verificar_inic_dic_vals(cls):
try:
arch_inic, arch_ref = cls.refs_prb_vals_inic()
except NotImplementedError:
return
mod = cls(arch_inic)
try:
ref = cargar_json(arch_ref)
except FileNotFoundError:
avisar(
_('\nNo encontramos diccionario con los valores corectos de referencia para comprobar que el'
'\nmodelo sí esté leyendo bien los datos iniciales. Lo generaremos con base en el los valores'
'\nactualmente leídos por el modelo. Asegúrate que los valores generados en'
'\n\t"{}"'
'\nestén correctos, y si no lo son, bórralo. En el futuro, se empleará este fuente para '
'\ncomprobar la función de lectura de datos iniciales.').
format(arch_ref))
d_vals = copiar_profundo(mod.variables)
for d_v in d_vals.values():
if isinstance(d_v['val'], np.ndarray):
d_v['val'] = d_v['val'].tolist()
guardar_json(d_vals, arch=arch_ref)
ref = d_vals
for var in mod.variables:
npt.assert_equal(ref[var]['val'],
mod.obt_val_actual_var(var),
err_msg=var)
def __init__(símismo, archivo, auto=None):
auto = auto or {}
símismo.archivo = archivo
símismo.val_auto = auto.copy()
try:
val_arch = cargar_json(archivo)
except (FileNotFoundError, json.decoder.JSONDecodeError,
PermissionError):
val_arch = {}
auto.update(val_arch)
super().__init__(pariente=None, valores=auto)
try:
símismo.guardar()
except OSError:
pass
def carg_simul_dt(arch_simular, num_samples, var_egr=None, dim=None, tipo_egr=None, método=None):
if arch_simular is None:
raise ValueError(_("la ruta de simulación es ninguna."))
simulation_data = {} # {625('0')× xarray} or {'0': ndarray}
if dim is None:
simulation_data.update(
{str(num_samples): Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{num_samples}')))[var_egr].values[2:, :]})
else:
for i in range(num_samples):
if tipo_egr == 'promedio':
# print(i, float(getsizeof(simulation_data)/(1024*1024)), 'MB')
if método == 'morris':
simulation_data.update(
{str(i): Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{i}')))
[var_egr].values[2:, :]})
elif método == 'fast':
print(f'Loading sample the-{i}th')
simulation_data.update(
{str(i): np.average(Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{i}')))
[var_egr].values[2:, dim])})
elif tipo_egr == 'paso_tiempo':
if método == 'morris':
simulation_data.update(
{str(i):Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{i}')))[var_egr].values})
elif método == 'fast':
print(f'Loading sample the-{i}th')
indices = [0, 4, 9, 14, 20]
simulation_data.update(
{str(i): np.take(
Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{i}')))[var_egr].values[:, dim],
indices)})
else:
simulation_data.update({str(i): Dataset.from_dict(cargar_json(os.path.join(arch_simular, f'{i}')))[var_egr].values[2:, :]})
if var_egr is None:
var_egr = [list(list(simulation_data.values())[0].data_vars.variables.mapping)[1]] # [0] - soil salinity, 1 wtd
return simulation_data, var_egr
def _obt_ref(arch, d_auto):
if not os.path.isfile(arch):
guardar_json(jsonificar(d_auto), arch)
return cargar_json(arch)
import tkinter as tk
import pkg_resources
from tinamit.cositas import cargar_json
from tinamit.Interfaz import Traducciones as Trad
# Una función para modificar los formatos según la dirección del texto de la lengua
direc = pkg_resources.resource_filename('tinamit.Interfaz', 'Trads.json')
arch_config = pkg_resources.resource_filename('tinamit.Interfaz', 'Config.json')
Trad.Diccionario()
dic = cargar_json(direc)
leng = cargar_json(arch_config)['leng_act']
IzqaDerech = dic['Lenguas'][leng]['IzqaDerech']
def gen_formato(formato):
if IzqaDerech:
return formato
else:
if isinstance(formato, str):
invers = [('e', 'w'), ('ne', 'nw'), ('se', 'sw'), ('right', 'left'), ('izquierda', 'derecha')]
for inver in invers:
if formato == inver[0]:
formato = inver[1]
break
elif formato == inver[1]:
formato = inver[0]
if isinstance(formato, dict):
formato = formato.copy()
from pkg_resources import resource_filename
from tinamit.cositas import cargar_json, guardar_json
# Código para manejar configuraciones de Tinamït
_dir_config = resource_filename('tinamit', 'config.json')
_config_base = {'leng': 'es', 'lengs_aux': [], 'envolturas': {}}
def _guardar_conf():
guardar_json(_configs, _dir_config)
try:
_configs = cargar_json(_dir_config)
for c, v_c in _config_base.items(): # pragma: sin cobertura
if c not in _configs:
_configs[c] = v_c
elif not isinstance(_configs[c], type(v_c)):
_configs[c] = v_c
_guardar_conf()
except (FileNotFoundError, json.decoder.JSONDecodeError):
_configs = _config_base.copy()
_guardar_conf()
def obt_val_config(llave, cond=None, mnsj_err=None, respaldo=None):
if not isinstance(respaldo, list):
respaldo = [respaldo]
from pint import UnitRegistry
from tinamit.config import _
from tinamit.cositas import guardar_json, cargar_json
regu = UnitRegistry()
C_ = regu.Quantity
_archivo_trads = pkg_resources.resource_filename('tinamit.unids', 'trads_unids.json')
_archivo_pluriales = pkg_resources.resource_filename('tinamit.unids', 'pluriales.json')
l_dic_trads = None
if l_dic_trads is None:
if os.path.isfile(_archivo_trads):
try:
l_dic_trads = cargar_json(_archivo_trads)
except json.JSONDecodeError: # pragma: sin cobertura
l_dic_trads = []
else:
l_dic_trads = []
if os.path.isfile(_archivo_pluriales):
_pluriales = cargar_json(_archivo_pluriales)
else: # pragma: sin cobertura
_pluriales = ['s', 'es', 'ें', 'கள்', 'க்கள்']
guardar_json(_pluriales, _archivo_pluriales)
def act_arch_trads(l_d_t):
"""
Actualiza el fuente de traducciones.
