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 __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 __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 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 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 get_iteritems(): return iteritems({})