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.