def __init__(símismo, archivo, nombre=None, lugares=None, fechas=None, cód_vacío=None):
"""
Parameters
----------
archivo: str
El archivo con los datos.
nombre: str
El nombre de la fuente.
lugares: str or np.ndarray or list
Los lugares que corresponden a los datos. Puede se nombre de una columna en el csv, el nombre de un
lugar de cual vienen todos los datos, o una lista de los lugares.
fechas: str or np.ndarray or list or datetime.datetime
Las fechas de los datos.
cód_vacío:
Código para identificar variables que faltan. ``NA`` y ``NaN`` ya están reconocidos.
"""
nombre = nombre or os.path.splitext(os.path.split(archivo)[1])[0]
símismo.archivo = archivo
símismo.codif = detectar_codif(archivo, máx_líneas=1)
cód_vacío = cód_vacío or ['na', 'NA', 'NaN', 'nan', 'NAN', '']
símismo.cód_vacío = [cód_vacío] if isinstance(cód_vacío, (int, float, str)) else cód_vacío
super().__init__(nombre, variables=símismo.obt_vars(), lugares=lugares, fechas=fechas)
def _efec_calib(símismo, líms_paráms, método, n_iter, obs):
temp = tempfile.NamedTemporaryFile('w',
encoding='UTF-8',
prefix='CalibTinamït_')
mod_spotpy = _ModSpotPy(mod=símismo.mod,
líms_paráms=líms_paráms,
obs=obs)
alg = algs_spotpy[método.lower()] if isinstance(método,
str) else método
muestreador = alg(mod_spotpy, dbname=temp.name, dbformat='csv')
if método is sp.algorithms.dream:
muestreador.sample(repetitions=n_iter, runs_after_convergence=200)
else:
muestreador.sample(n_iter)
codif = detectar_codif(
temp.name +
'.csv', máx_líneas=1) if platform.system() == 'Windows' else 'utf8'
egr_spotpy = pd.read_csv(temp.name + '.csv', encoding=codif)
cols_prm = [c for c in egr_spotpy.columns if c.startswith('par')]
probs = egr_spotpy['like1']
if método in (sp.algorithms.dream, sp.algorithms.mcmc):
trzs = {p: egr_spotpy[p][-200:] for p in cols_prm}
else:
buenas = (probs >= 0.80)
trzs = {p: egr_spotpy[p][buenas] for p in cols_prm}
res = {}
for p in líms_paráms:
col_p = ('par' + p).replace(' ', '_')
res[p] = {
'dist': trzs[col_p],
'cumbre': calc_máx_trz(trzs[col_p]),
'mejor': egr_spotpy[col_p][np.argmax(probs.values)]
}
return res
def gen_lugares(archivo, nivel_base, nombre=None, col_cód='Código'):
"""
Genera un lugar con todos los niveles y sublugares asociados desde un archivo ``.csv``.
Cada columna en el ``.csv`` debe empezar con el nombre de un nivel, con la excepción de la columna ``col_cód``,
la cual tendrá el código identificador único de cada lugar.
Cada fila representa un lugar, con su **nombre** en la columna correspondiendo al nivel de este lugar y
el **código** del lugar pariente en las otras columnas. Si un nivel no se aplica a un lugar (por ejemplo,
un departamento no tendrá municipio pariente), se deja vacía la célula.
Parameters
----------
archivo: str
El archivo ``.csv``.
nivel_base: str
El el nivel más alto. Por ejemplo, si tu csv entero representa un país, sería ``país``.
nombre: str
El nombre del lugar correspondiendo al nivel más alto. Por ejemplo, "Guatemala".
col_cód: str
El nombre de la columna con los códigos de cada sublugar.
Returns
-------
Lugar
"""
codif_csv = detectar_codif(archivo)
nombre = nombre or os.path.splitext(os.path.split(nombre)[1])[0]
with open(archivo, newline='', encoding=codif_csv) as d:
lc = csv.DictReader(d) # El lector de csv
# Guardar la primera fila como nombres de columnas
cols = [x.strip() for x in lc.fieldnames]
if col_cód not in cols:
raise ValueError(_(
'La columna de código de región especificada ("{c}") no concuerda con los nombres de '
'columnas del csv ({n}).'
).format(c=col_cód, n=', '.join(cols)))
doc = [OrderedDict((ll.strip(), v.strip()) for ll, v in f.items()) for f in lc]
# Inferir el orden de la jerarquía
órden = []
escalas = [x for x in cols if x != col_cód]
coescalas = []
for f in doc:
coescalas_f = {ll for ll, v in f.items() if len(v) and ll in escalas}
if not any(x == coescalas_f for x in coescalas):
coescalas.append(coescalas_f)
coescalas.sort(key=lambda x: len(x))
while len(coescalas):
siguientes = {x.pop() for x in coescalas if len(x) == 1}
if not len(siguientes):
raise ValueError(_('Parece que hay un error con el fuente de información regional.'))
órden.append(sorted(list(siguientes)) if len(siguientes) > 1 else siguientes.pop())
for cn in coescalas.copy():
cn.difference_update(siguientes)
if not len(cn):
coescalas.remove(cn)
órden.insert(0, nivel_base)
niveles = {}
anterior = None
for nvls in órden[::-1]:
if isinstance(nvls, str):
niveles[nvls] = Nivel(nombre=nvls, subniveles=anterior)
anterior = niveles[nvls]
else:
for nvl in nvls:
niveles[nvl] = Nivel(nombre=nvl, subniveles=anterior)
anterior = [niveles[nv] for nv in nvls]
dic_doc = {f[col_cód]: f for f in doc}
quedan = list(dic_doc)
lugares = {}
for nvl, obj_nvl in niveles.items():
for cód in list(quedan):
lg = dic_doc[cód]
if lg[nvl]:
nmb = lg[nvl]
subs = {s for c, s in lugares.items() if dic_doc[c][nvl] == cód}
lugares[cód] = Lugar(nmb, nivel=obj_nvl, cód=cód, sub_lugares=subs)
quedan.remove(cód)
return Lugar(nombre=nombre, nivel=niveles[nivel_base], sub_lugares=lugares.values())
def espec_estruct_geog(símismo, archivo, col_cód='Código'):
símismo.cód_a_lugar.clear()
símismo.info_geog.clear()
símismo.orden_jerárquico.clear()
símismo.escalas.clear()
col_cód = col_cód.lower()
codif_csv = detectar_codif(archivo)
with open(archivo, newline='', encoding=codif_csv) as d:
l = csv.DictReader(d) # El lector de csv
# Guardar la primera fila como nombres de columnas
cols = [x.lower().strip() for x in l.fieldnames]
if col_cód not in cols:
raise ValueError(
_('La columna de código de región especificada ({}) no concuerda con los nombres de '
'columnas del fuente ({}).').format(
col_cód, ', '.join(cols)))
doc = [
OrderedDict((ll.lower().strip(), v.strip())
for ll, v in f.items()) for f in l
]
# Inferir el orden de la jerarquía
órden = []
escalas = [x for x in cols if x != col_cód]
símismo.escalas.extend(escalas)
símismo.info_geog.update({esc: [] for esc in escalas})
coescalas = []
for f in doc:
coescalas_f = {
ll
for ll, v in f.items() if len(v) and ll in escalas
}
if not any(x == coescalas_f for x in coescalas):
coescalas.append(coescalas_f)
coescalas.sort(key=lambda x: len(x))
while len(coescalas):
siguientes = {x.pop() for x in coescalas if len(x) == 1}
if not len(siguientes):
raise ValueError(
_('Parece que hay un error con el fuente de información regional.'
))
órden.append(
sorted(list(siguientes)
) if len(siguientes) > 1 else siguientes.pop())
for cn in coescalas.copy():
cn.difference_update(siguientes)
if not len(cn):
coescalas.remove(cn)
símismo.orden_jerárquico.extend(órden)
for f in doc:
cód = f[col_cód]
escala = None
for esc in órden[::-1]:
if isinstance(esc, str):
if len(f[esc]):
escala = esc
else:
for nv_ig in esc:
if len(f[nv_ig]):
escala = nv_ig
if escala is not None:
break
nombre = f[escala]
símismo.cód_a_lugar[cód] = {
'escala': escala,
'nombre': nombre,
'en': {
ll: v
for ll, v in f.items()
if ll in escalas and len(v) and ll != escala
}
}
símismo.info_geog[escala].append(cód)
for cód, dic in símismo.cód_a_lugar.items():
for esc, lg_en in dic['en'].items():
if lg_en not in símismo.cód_a_lugar:
dic['en'][esc] = símismo.nombre_a_cód(nombre=lg_en,
escala=esc)
def __init__(símismo, archivo, llenar, alpha):
codif = detectar_codif(os.path.splitext(archivo)[0] + '.dbf')
símismo.forma = sf.Reader(archivo, encoding=codif)
símismo.llenar = llenar
símismo.alpha = alpha
