def _doload(self): # Make sure the coverage directory exists if not os.path.exists(pth): raise SystemError('Cannot find specified coverage: {0}'.format(pth)) # All appears well - load it up! self._persistence_layer = PersistenceLayer(root_dir, persistence_guid, mode=self.mode) self.name = self._persistence_layer.name self.spatial_domain = self._persistence_layer.sdom self.temporal_domain = self._persistence_layer.tdom self._range_dictionary = ParameterDictionary() self._range_value = RangeValues() self._bricking_scheme = self._persistence_layer.global_bricking_scheme self._in_memory_storage = False auto_flush_values = self._persistence_layer.auto_flush_values inline_data_writes = self._persistence_layer.inline_data_writes from coverage_model.persistence import PersistedStorage for parameter_name in self._persistence_layer.parameter_metadata.keys(): md = self._persistence_layer.parameter_metadata[parameter_name] pc = md.parameter_context self._range_dictionary.add_context(pc) s = PersistedStorage(md, self._persistence_layer.brick_dispatcher, dtype=pc.param_type.storage_encoding, fill_value=pc.param_type.fill_value, mode=self.mode, inline_data_writes=inline_data_writes, auto_flush=auto_flush_values) self._range_value[parameter_name] = get_value_class(param_type=pc.param_type, domain_set=pc.dom, storage=s)
def __setitem__(self, name, vals): """ Set a parameter """ if name not in self._rd: raise KeyError(name) context = self._pdict.get_context(name) if self._shp is None: # Not initialized: if isinstance(vals, np.ndarray): self._shp = vals.shape elif isinstance(vals, list): self._shp = (len(vals),) else: raise BadRequest('No shape was defined') log.trace('Set shape to %s', self._shp) else: if isinstance(vals, np.ndarray): validate_equal(vals.shape, self._shp, 'Invalid shape on input') elif isinstance(vals, list): validate_equal(len(vals), self._shp[0], 'Invalid shape on input') dom = self.domain paramval = get_value_class(context.param_type, domain_set = dom) paramval[:] = vals paramval.storage._storage.flags.writeable = False self._rd[name] = paramval
def _do_build(self): # Reset things to ensure we don't munge everything self._reference_covs = collections.OrderedDict() self._range_dictionary = ParameterDictionary() self._range_value = RangeValues() self._reference_covs = self._build_ordered_coverage_dict() for parameter_name in self._persistence_layer.parameter_metadata: md = self._persistence_layer.parameter_metadata[parameter_name] mm = self._persistence_layer.master_manager pc = md.parameter_context # Assign the coverage's domain object(s) self._assign_domain(pc) # Get the callbacks for ParameterFunctionType parameters if hasattr(pc, '_pval_callback'): pc._pval_callback = self.get_parameter_values pc._pctxt_callback = self.get_parameter_context self._range_dictionary.add_context(pc) s = PostgresPersistedStorage(md, metadata_manager=mm, parameter_context=pc, dtype=pc.param_type.storage_encoding, fill_value=pc.param_type.fill_value, mode=self._persistence_layer.mode) self._persistence_layer.value_list[parameter_name] = s self._range_value[parameter_name] = get_value_class(param_type=pc.param_type, domain_set=pc.dom, storage=s)
def load_from_granule(cls, g): if isinstance(g.param_dictionary, str): instance = cls(stream_definition_id=g.param_dictionary, locator=g.locator) pdict = RecordDictionaryTool.pdict_from_stream_def(g.param_dictionary) instance._pdict = ParameterDictionary.load(pdict) else: instance = cls(param_dictionary=g.param_dictionary, locator=g.locator) instance._pdict = ParameterDictionary.load(g.param_dictionary) if g.domain: instance._shp = (g.domain[0],) for k,v in g.record_dictionary.iteritems(): if v is not None: ptype = instance._pdict.get_context(k).param_type paramval = get_value_class(ptype, domain_set = instance.domain) paramval[:] = v paramval.storage._storage.flags.writeable = False instance._rd[k] = paramval return instance
def get_pval(self, context): return get_value_class(context.param_type, SimpleDomainSet((20,)))
def _append_parameter(self, parameter_context): """ Appends a ParameterContext object to the internal set for this coverage. A <b>deep copy</b> of the supplied ParameterContext is added to self._range_dictionary. An AbstractParameterValue of the type indicated by ParameterContext.param_type is added to self._range_value. If the ParameterContext indicates that the parameter is a coordinate parameter, it is associated with the indicated axis of the appropriate CRS. @param parameter_context The ParameterContext to append to the coverage <b>as a copy</b> @throws StandardError If the ParameterContext.axis indicates that it is temporal and a temporal parameter already exists in the coverage """ if self.closed: raise IOError('I/O operation on closed file') if self.mode == 'r': raise IOError('Coverage not open for writing: mode == \'{0}\''.format(self.mode)) if not isinstance(parameter_context, ParameterContext): raise TypeError('\'parameter_context\' must be an instance of ParameterContext') # Create a deep copy of the ParameterContext pcontext = deepcopy(parameter_context) pname = pcontext.name no_sdom = self.spatial_domain is None ## Determine the correct array shape # Get the parameter variability; assign to VariabilityEnum.NONE if None pv=pcontext.variability or VariabilityEnum.NONE if no_sdom and pv in (VariabilityEnum.SPATIAL, VariabilityEnum.BOTH): log.warn('Provided \'parameter_context\' indicates Spatial variability, but coverage has no Spatial Domain') if pv == VariabilityEnum.TEMPORAL: # Only varies in the Temporal Domain pcontext.dom = DomainSet(self.temporal_domain.shape.extents, None) elif pv == VariabilityEnum.SPATIAL: # Only varies in the Spatial Domain pcontext.dom = DomainSet(None, self.spatial_domain.shape.extents) elif pv == VariabilityEnum.BOTH: # Varies in both domains # If the Spatial Domain is only a single point on a 0d Topology, the parameter's shape is that of the Temporal Domain only if no_sdom or (len(self.spatial_domain.shape.extents) == 1 and self.spatial_domain.shape.extents[0] == 0): pcontext.dom = DomainSet(self.temporal_domain.shape.extents, None) else: pcontext.dom = DomainSet(self.temporal_domain.shape.extents, self.spatial_domain.shape.extents) elif pv == VariabilityEnum.NONE: # No variance; constant # CBM TODO: Not sure we can have this constraint - precludes situations like a TextType with Variablity==None... # # This is a constant - if the ParameterContext is not a ConstantType, make it one with the default 'x' expr # if not isinstance(pcontext.param_type, ConstantType): # pcontext.param_type = ConstantType(pcontext.param_type) # The domain is the total domain - same value everywhere!! # If the Spatial Domain is only a single point on a 0d Topology, the parameter's shape is that of the Temporal Domain only if no_sdom or (len(self.spatial_domain.shape.extents) == 1 and self.spatial_domain.shape.extents[0] == 0): pcontext.dom = DomainSet(self.temporal_domain.shape.extents, None) else: pcontext.dom = DomainSet(self.temporal_domain.shape.extents, self.spatial_domain.shape.extents) else: # Should never get here...but... raise SystemError('Must define the variability of the ParameterContext: a member of VariabilityEnum') # Assign the pname to the CRS (if applicable) and select the appropriate domain (default is the spatial_domain) dom = self.spatial_domain if not pcontext.axis is None and AxisTypeEnum.is_member(pcontext.axis, AxisTypeEnum.TIME): dom = self.temporal_domain dom.crs.axes[pcontext.axis] = pcontext.name elif not no_sdom and (pcontext.axis in self.spatial_domain.crs.axes): dom.crs.axes[pcontext.axis] = pcontext.name self._range_dictionary.add_context(pcontext) s = self._persistence_layer.init_parameter(pcontext, self._bricking_scheme) self._range_value[pname] = get_value_class(param_type=pcontext.param_type, domain_set=pcontext.dom, storage=s)
def get_pval(self, context): return get_value_class(context.param_type, SimpleDomainSet((20, )))