def _extend(self, parent):
if isinstance(parent, basestring):
parent = self.loader.import_(parent)
p_inst = parent(self._context)
p_globals = p_inst.__globals__
# Find overrides
for k, v in iteritems(self.__globals__):
if k == '__main__':
continue
if not isinstance(v, TplFunc):
continue
p_globals[k] = v
# Find inherited funcs
for k, v in iteritems(p_inst.__globals__):
if k == '__main__':
continue
if not isinstance(v, TplFunc):
continue
if k not in self.__globals__:
self.__globals__[k] = v
if not hasattr(self, k):
def _(k=k):
'''Capture the 'k' variable in a closure'''
def trampoline(*a, **kw):
global parent
return getattr(parent, k)(*a, **kw)
return trampoline
setattr(self, k, TplFunc(_()).bind_instance(self))
p_globals['child'] = self
p_globals['local'] = p_inst
p_globals['self'] = self.__globals__['self']
self.__globals__['parent'] = p_inst
self.__globals__['local'] = self
return p_inst
def __init__(self, settings_file):
dom = xml.dom.minidom.parse(settings_file)
self.settings_path = os.path.normpath(
os.path.dirname((os.path.abspath(settings_file))))
user_settings, bindings = self._bindings(dom)
self.timestep_init = None if not bindings.get(
'timestepInit') else bindings['timestepInit']
self.output_dir = self._out_dirs(user_settings)
self.ncores = self._ncores(user_settings)
self.binding = bindings
self.options = self._options(dom)
self.flags = self._flags()
self.model_steps = self._model_steps()
self.report_steps = self._report_steps(user_settings, bindings)
self.filter_steps = self._filter_steps(user_settings)
self.ens_members = self._ens_members(user_settings)
self.report_timeseries = self._report_tss()
self.report_maps_steps, self.report_maps_all, self.report_maps_end = self._reported_maps(
)
self.report_timeseries = {
k: v
for k, v in iteritems(self.report_timeseries) if v
}
self.report_maps_steps = {
k: v
for k, v in iteritems(self.report_maps_steps) if v
}
self.report_maps_all = {
k: v
for k, v in iteritems(self.report_maps_all) if v
}
self.report_maps_end = {
k: v
for k, v in iteritems(self.report_maps_end) if v
}
def _extend(self, parent):
if isinstance(parent, basestring):
parent = self.loader.import_(parent)
p_inst = parent(self._context)
p_globals = p_inst.__globals__
# Find overrides
for k, v in iteritems(self.__globals__):
if k == '__main__':
continue
if not isinstance(v, TplFunc):
continue
p_globals[k] = v
# Find inherited funcs
for k, v in iteritems(p_inst.__globals__):
if k == '__main__':
continue
if not isinstance(v, TplFunc):
continue
if k not in self.__globals__:
self.__globals__[k] = v
if not hasattr(self, k):
def _(k=k):
'''Capture the 'k' variable in a closure'''
def trampoline(*a, **kw):
global parent
return getattr(parent, k)(*a, **kw)
return trampoline
setattr(self, k, TplFunc(_()).bind_instance(self))
p_globals['child'] = self
p_globals['local'] = p_inst
p_globals['self'] = self.__globals__['self']
self.__globals__['parent'] = p_inst
self.__globals__['local'] = self
return p_inst
def __init__(self, uid):
from .zusatz import iterOpenNetcdf
self.uid = uid
self.data = {}
settings = LisSettings.instance()
binding = settings.binding
try:
# using ncdftemplate
filename = os.path.splitext(binding['netCDFtemplate'])[0] + '.nc'
nf1 = iterOpenNetcdf(
filename, "Trying to get metadata from netcdf template \n",
'r')
for var in nf1.variables:
self.data[var] = {
k: v
for k, v in iteritems(nf1.variables[var].__dict__)
if k != '_FillValue'
}
nf1.close()
return
except (KeyError, IOError, IndexError, Exception):
pass
# if no template .nc is given the e.nc file is used
filename = os.path.splitext(binding['E0Maps'])[0] + '.nc'
nf1 = iterOpenNetcdf(filename,
"Trying to get metadata from E0 maps \n", 'r')
for var in nf1.variables:
self.data[var] = {
k: v
for k, v in iteritems(nf1.variables[var].__dict__)
if k != '_FillValue'
}
nf1.close()
def __init__(self, settings_file):
dom = xml.dom.minidom.parse(settings_file)
self.settings_dir = os.path.normpath(
os.path.dirname((os.path.abspath(settings_file))))
self.settings_path = os.path.normpath(os.path.abspath(settings_file))
user_settings, bindings = self._bindings(dom)
self.timestep_init = None if not bindings.get(
'timestepInit') else bindings['timestepInit']
self._check_timestep_init()
self.output_dir = self._out_dir(user_settings)
self.ncores = self._ncores(user_settings)
self.binding = bindings
self.options = self._options(dom)
self.flags = self._flags()
self.model_steps = self._model_steps()
self.report_steps = self._report_steps(user_settings, bindings)
self.filter_steps = self._filter_steps(user_settings)
self.ens_members = self._ens_members(user_settings)
self.report_timeseries = self._report_tss()
self.report_maps_steps, self.report_maps_all, self.report_maps_end = self._reported_maps(
)
self.report_timeseries = {
k: v
for k, v in iteritems(self.report_timeseries) if v
}
self.report_maps_steps = {
k: v
for k, v in iteritems(self.report_maps_steps) if v
}
self.report_maps_all = {
k: v
for k, v in iteritems(self.report_maps_all) if v
}
self.report_maps_end = {
k: v
for k, v in iteritems(self.report_maps_end) if v
}
self.enkf_set, self.mc_set = self.montecarlo_kalman_settings()
self.step_start, self.step_end = self.binding[
'StepStart'], self.binding['StepEnd']
self.step_start_int, self.step_end_int = self.binding[
'StepStartInt'], self.binding['StepEndInt']
ref_date_start = calendar(self.binding['CalendarDayStart'],
self.binding['calendar_type'])
self.step_start_dt = inttodate(self.step_start_int - 1,
ref_date_start,
binding=self.binding)
self.step_end_dt = inttodate(self.step_end_int - 1,
ref_date_start,
binding=self.binding)
def compile(self):
body = list(self._compile_node(self.doc.firstChild))
# Never emit doctypes on fragments
if not self.is_fragment and not self.is_child:
if self.doc._dtd:
dtd = self.doc._dtd
elif self.mode == 'html5':
dtd = '<!DOCTYPE html>'
else:
dtd = None
if dtd:
dtd = ir.TextNode(dtd)
dtd.filename = self.filename
dtd.lineno = 1
body.insert(0, dtd)
self.functions['__main__()'] = body
defs = []
for k, v in iteritems(self.functions):
node = ir.DefNode(k, *v)
node.lineno = self.function_lnos.get(k)
defs.append(node)
node = ir.TemplateNode(self.mod_py, defs)
node.filename = self.filename
node.lineno = 0
return node
def enabled(self):
# settings = self.settings
# for name, plugin in iteritems(self.config.registry.all_plugins):
# if settings['plugins.' + name].lower() != 'disabled':
# yield name, plugin
return {name: plugin for name, plugin in iteritems(self.all)
if self.is_enabled(name)}
def compile(self):
body = list(self._compile_node(self.doc.firstChild))
# Never emit doctypes on fragments
if not self.is_fragment and not self.is_child:
if self.doc._dtd:
dtd = self.doc._dtd
elif self.mode == 'html5':
dtd = '<!DOCTYPE html>'
else:
dtd = None
if dtd:
dtd = ir.TextNode(dtd)
dtd.filename = self.filename
dtd.lineno = 1
body.insert(0, dtd)
self.functions['__main__()'] = body
defs = []
for k, v in iteritems(self.functions):
node = ir.DefNode(k, *v)
node.lineno = self.function_lnos.get(k)
defs.append(node)
node = ir.TemplateNode(self.mod_py, defs)
node.filename = self.filename
node.lineno = 0
return node
def __init__(self, handle, deps='', **kw):
assert isinstance(handle, basestring)
self.handle = handle
self.dep_handles = list(uncommafy(deps))
self.deps = None # This is only computed on close()
for k, v in iteritems(kw):
setattr(self, k, v)
def build_reportedmaps_dicts(self):
self.report_timeseries = self._report_tss()
self.report_maps_steps, self.report_maps_all, self.report_maps_end = self._reported_maps(
)
self.report_maps_steps = {
k: v
for k, v in iteritems(self.report_maps_steps) if v
}
self.report_maps_all = {
k: v
for k, v in iteritems(self.report_maps_all) if v
}
self.report_maps_end = {
k: v
for k, v in iteritems(self.report_maps_end) if v
}
return self.report_timeseries, self.report_maps_steps, self.report_maps_all, self.report_maps_end
def enabled(self):
# settings = self.settings
# for name, plugin in iteritems(self.config.registry.all_plugins):
# if settings['plugins.' + name].lower() != 'disabled':
# yield name, plugin
return {
name: plugin
for name, plugin in iteritems(self.all) if self.is_enabled(name)
}
def __init__(self, handle, deps='', **kw):
'''You can store whatever attributes you like by providing keyword
arguments. The only required argument is a name for this dependency.
'''
assert isinstance(handle, basestring)
self.handle = handle
self.dep_handles = list(uncommafy(deps))
self.deps = None # This is only computed on close()
for k, v in iteritems(kw):
setattr(self, k, v)
def __init__(self, handle, deps='', **kw):
'''You can store whatever attributes you like by providing keyword
arguments. The only required argument is a name for this dependency.
'''
assert isinstance(handle, basestring)
self.handle = handle
self.dep_handles = list(uncommafy(deps))
self.deps = None # This is only computed on close()
for k, v in iteritems(kw):
setattr(self, k, v)
def compile(self):
"""Compile the document provided by :class:`._Parser`.
Returns as :class:`kajiki.ir.TemplateNode` instance representing
the whole tree of nodes as their intermediate representation.
The returned template will include at least a ``__main__``
function which is the document itself including a DOCTYPE and
any function declared through ``py:def`` or as a ``py:block``.
The ``TemplateNode`` will also include the module level
code specified through ``<?py %``.
If the compiled document didn't specify a DOCTYPE provides
one at least for HTML5.
.. note::
As this alters the functions and mode wide code
registries of the compiler ``compile`` should
never be called twice or might lead to unexpected results.
"""
templateNodes = [
n for n in self.doc.childNodes if not isinstance(n, dom.Comment)
]
if len(templateNodes) != 1:
raise XMLTemplateCompileError(
'expected a single root node in document', self.doc,
self.filename, 0)
body = list(self._compile_node(templateNodes[0]))
# Never emit doctypes on fragments
if not self.is_fragment and not self.is_child:
if self.doc._dtd:
dtd = self.doc._dtd
elif self.mode == 'html5':
dtd = '<!DOCTYPE html>'
else:
dtd = None
if dtd:
dtd = ir.TextNode(dtd.strip() + '\n')
dtd.filename = self.filename
dtd.lineno = 1
body.insert(0, dtd)
self.functions['__main__()'] = body
defs = []
for k, v in iteritems(self.functions):
node = ir.DefNode(k, *v)
node.lineno = self.function_lnos.get(k)
defs.append(node)
node = ir.TemplateNode(self.mod_py, defs)
node.filename = self.filename
node.lineno = 0
return node
def compile(self):
"""Compile the document provided by :class:`._Parser`.
Returns as :class:`kajiki.ir.TemplateNode` instance representing
the whole tree of nodes as their intermediate representation.
The returned template will include at least a ``__main__``
function which is the document itself including a DOCTYPE and
any function declared through ``py:def`` or as a ``py:block``.
The ``TemplateNode`` will also include the module level
code specified through ``<?py %``.
If the compiled document didn't specify a DOCTYPE provides
one at least for HTML5.
.. note::
As this alters the functions and mode wide code
registries of the compiler ``compile`` should
never be called twice or might lead to unexpected results.
"""
templateNodes = [n for n in self.doc.childNodes if not isinstance(n, dom.Comment)]
if len(templateNodes) != 1:
raise XMLTemplateCompileError('expected a single root node in document',
self.doc, self.filename, 0)
body = list(self._compile_node(templateNodes[0]))
# Never emit doctypes on fragments
if not self.is_fragment and not self.is_child:
if self.doc._dtd:
dtd = self.doc._dtd
elif self.mode == 'html5':
dtd = '<!DOCTYPE html>'
else:
dtd = None
if dtd:
dtd = ir.TextNode(dtd.strip()+'\n')
dtd.filename = self.filename
dtd.lineno = 1
body.insert(0, dtd)
self.functions['__main__()'] = body
defs = []
for k, v in iteritems(self.functions):
node = ir.DefNode(k, *v)
node.lineno = self.function_lnos.get(k)
defs.append(node)
node = ir.TemplateNode(self.mod_py, defs)
node.filename = self.filename
node.lineno = 0
return node
def initial(self):
""" initial part of the inflow module
"""
# ************************************************************
# ***** INFLOW INIT
# ************************************************************
settings = LisSettings.instance()
option = settings.options
if option['inflow']:
self.var.InflowPoints = loadmap('InflowPoints')
self.var.QInM3Old = np.where(self.var.InflowPoints > 0,
self.var.ChanQ * self.var.DtSec, 0)
# read inflow map
inflowmapprc = loadmap('InflowPoints', pcr=True)
inflowmapnp = pcr2numpy(inflowmapprc, -9999)
inflowmapnp = np.where(inflowmapnp > 0, inflowmapnp, 0)
# get outlets ids from outlets map
inflow_ids = np.unique(inflowmapnp)
# drop negative values (= missing data in pcraster map)
inflow_ids = inflow_ids[inflow_ids > 0]
# read tss ids from tss file
settings = LisSettings.instance()
tss_ids = read_tss_header(settings.binding['QInTS'])
# create a dictionary of tss id : tss id index
id_dict = {}
for i in range(len(tss_ids)):
id_dict[tss_ids[i]] = tss_ids.index(tss_ids[i]) + 1
# remove inflow point if not available in tss file
for inf_id in inflow_ids:
if inf_id not in tss_ids:
id_dict[inf_id] = 0
print(
LisfloodWarning("Inflow point was removed ID: %d\n" %
inf_id))
# substitute indexes to id in map
self.var.InflowPointsMap = np.copy(inflowmapnp)
for k, v in iteritems(id_dict):
self.var.InflowPointsMap[inflowmapnp == k] = v
# convert map to pcraster format
self.var.InflowPointsMap = numpy2pcr(Nominal,
self.var.InflowPointsMap,
-9999)
def sorted_countries(arg, top_entry=True): # TODO memoized version
"""*arg* may be either the desired locale code or the request object,
from which the locale will be discovered.
Returns a list of tuples like ``('BR', 'Brazil')``, already sorted,
ready for inclusion in your web form.
"""
code = arg if isinstance(arg, basestring) else get_locale_name(arg)
def generator(territories):
if top_entry:
yield (native_str(""), _("- Choose -")) # TODO translate somehow
for tup in territories:
if len(tup[0]) == 2: # Keep only countries
yield tup
return sorted(generator(iteritems(Locale(code).territories)), key=lambda x: x[1])
def sorted_countries(arg, top_entry=True): # TODO memoized version
'''*arg* may be either the desired locale code or the request object,
from which the locale will be discovered.
Returns a list of tuples like ``('BR', 'Brazil')``, already sorted,
ready for inclusion in your web form.
'''
code = arg if isinstance(arg, basestring) else get_locale_name(arg)
def generator(territories):
if top_entry:
yield (native_str(''), _("- Choose -")) # TODO translate somehow
for tup in territories:
if len(tup[0]) == 2: # Keep only countries
yield tup
return sorted(generator(iteritems(Locale(code).territories)),
key=lambda x: x[1])
def link_static_dirs(self, destination_dir):
from inspect import getsourcefile
from .pyramid_starter import makedirs
destination_dir = os.path.abspath(destination_dir)
makedirs(destination_dir)
for name, gilpun in iteritems(self.all):
source = getattr(gilpun, 'static_dir', None)
if source is None:
# Calculate the static dir if not provided
package_dir = os.path.dirname(getsourcefile(gilpun.__class__))
source = os.path.join(package_dir, 'static')
if not os.path.isdir(source):
continue
# print('symlinking', source)
dest = os.path.join(destination_dir, name.replace(' ', '_'))
if os.path.exists(dest):
os.remove(dest)
os.symlink(source, dest)
def link_static_dirs(self, destination_dir):
from inspect import getsourcefile
from .pyramid_starter import makedirs
destination_dir = os.path.abspath(destination_dir)
makedirs(destination_dir)
for name, gilpun in iteritems(self.all):
source = getattr(gilpun, 'static_dir', None)
if source is None:
# Calculate the static dir if not provided
package_dir = os.path.dirname(getsourcefile(gilpun.__class__))
source = os.path.join(package_dir, 'static')
if not os.path.isdir(source):
continue
# print('symlinking', source)
dest = os.path.join(destination_dir, name.replace(' ', '_'))
if os.path.exists(dest):
os.remove(dest)
os.symlink(source, dest)
def parse(self):
body = list(self._parse_body())
self.functions['__main__()'] = body[:-1]
defs = [ir.DefNode(k, *v) for k, v in iteritems(self.functions)]
return ir.TemplateNode(self.mod_py, defs)
def py(self):
yield self.line(
'local.__kj__.push_with(locals(), %s)' % self.vars_text)
for k, v in iteritems(self.vars):
yield self.line('%s = %s' % (k, v))
def __init__(self, **kw):
for k, v in iteritems(kw):
setattr(self, k, v)
def py(self):
yield self.line(
'local.__kj__.push_with(locals(), %s)' % self.vars_text)
for k, v in iteritems(self.vars):
yield self.line('%s = %s' % (k, v))
def parse(self):
body = list(self._parse_body())
self.functions['__main__()'] = body[:-1]
defs = [ir.DefNode(k, *v) for k, v in iteritems(self.functions)]
return ir.TemplateNode(self.mod_py, defs)
def get_iteritems():
return iteritems({})
