def validate_stream_defs(self, in_stream_definition_id,
out_stream_definition_id):
stream_def_in = self.read_stream_definition(in_stream_definition_id)
stream_def_out = self.read_stream_definition(out_stream_definition_id)
if not stream_def_in.available_fields:
log.info("no available fields on input stream definition")
return False
incoming_pdict_dump = stream_def_in.parameter_dictionary
outgoing_pdict_dump = stream_def_out.parameter_dictionary
incoming_pdict = ParameterDictionary.load(incoming_pdict_dump)
outgoing_pdict = ParameterDictionary.load(outgoing_pdict_dump)
incoming_ctxt = [pc for name, (n, pc) in incoming_pdict.iteritems()]
outgoing_ctxt = [pc for name, (n, pc) in outgoing_pdict.iteritems()]
incoming_ctxt_af = [
pc for name, (n, pc) in incoming_pdict.iteritems()
if name in stream_def_in.available_fields
]
pfv = ParameterFunctionValidator(incoming_ctxt_af, incoming_ctxt,
outgoing_ctxt)
try:
for name in stream_def_out.available_fields:
pfv.validate(name)
except ParameterFunctionException, e:
log.info('validation failed %s to %s is not reachable' %
(stream_def_in.available_fields,
stream_def_out.available_fields))
log.info(e)
return False
def validate_stream_defs(self, in_stream_definition_id, out_stream_definition_id):
stream_def_in = self.read_stream_definition(in_stream_definition_id)
stream_def_out = self.read_stream_definition(out_stream_definition_id)
if not stream_def_in.available_fields:
log.info("no available fields on input stream definition")
return False
incoming_pdict_dump = stream_def_in.parameter_dictionary
outgoing_pdict_dump = stream_def_out.parameter_dictionary
incoming_pdict = ParameterDictionary.load(incoming_pdict_dump)
outgoing_pdict = ParameterDictionary.load(outgoing_pdict_dump)
incoming_ctxt = [pc for name,(n,pc) in incoming_pdict.iteritems()]
outgoing_ctxt = [pc for name,(n,pc) in outgoing_pdict.iteritems()]
incoming_ctxt_af = [pc for name,(n,pc) in incoming_pdict.iteritems() if name in stream_def_in.available_fields]
pfv = ParameterFunctionValidator(incoming_ctxt_af, incoming_ctxt, outgoing_ctxt)
try:
for name in stream_def_out.available_fields:
pfv.validate(name)
except ParameterFunctionException, e:
log.info('validation failed %s to %s is not reachable' % (stream_def_in.available_fields,stream_def_out.available_fields))
log.info(e)
return False
def _create_coverage(self, dataset_id, description, parameter_dict, spatial_domain,temporal_domain):
pdict = ParameterDictionary.load(parameter_dict)
sdom = GridDomain.load(spatial_domain)
tdom = GridDomain.load(temporal_domain)
file_root = FileSystem.get_url(FS.CACHE,'datasets')
scov = SimplexCoverage(file_root,dataset_id,description or dataset_id,parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom, inline_data_writes=self.inline_data_writes)
return scov
def _create_coverage(self, dataset_id, description, parameter_dict):
#file_root = FileSystem.get_url(FS.CACHE,'datasets')
temporal_domain, spatial_domain = time_series_domain()
pdict = ParameterDictionary.load(parameter_dict)
scov = self._create_simplex_coverage(dataset_id, pdict, spatial_domain, temporal_domain, self.inline_data_writes)
#vcov = ViewCoverage(file_root, dataset_id, description or dataset_id, reference_coverage_location=scov.persistence_dir)
scov.close()
return scov
def _create_coverage(self, dataset_id, parameter_dict_id, time_dom, spatial_dom):
pd = self.dataset_management_client.read_parameter_dictionary(parameter_dict_id)
pdict = ParameterDictionary.load(pd)
sdom = GridDomain.load(spatial_dom.dump())
tdom = GridDomain.load(time_dom.dump())
file_root = FileSystem.get_url(FS.CACHE,'datasets')
scov = SimplexCoverage(file_root, dataset_id, dataset_id, parameter_dictionary=pdict, temporal_domain=tdom, spatial_domain=sdom)
return scov
def _create_coverage(self, dataset_id, description, parameter_dict, spatial_domain,temporal_domain):
file_root = FileSystem.get_url(FS.CACHE,'datasets')
pdict = ParameterDictionary.load(parameter_dict)
sdom = GridDomain.load(spatial_domain)
tdom = GridDomain.load(temporal_domain)
scov = self._create_simplex_coverage(dataset_id, pdict, sdom, tdom, self.inline_data_writes)
vcov = ViewCoverage(file_root, dataset_id, description or dataset_id, reference_coverage_location=scov.persistence_dir)
scov.close()
return vcov
def _create_coverage(self, dataset_id, description, parameter_dict):
#file_root = FileSystem.get_url(FS.CACHE,'datasets')
temporal_domain, spatial_domain = time_series_domain()
pdict = ParameterDictionary.load(parameter_dict)
scov = self._create_simplex_coverage(dataset_id, pdict, spatial_domain,
temporal_domain)
#vcov = ViewCoverage(file_root, dataset_id, description or dataset_id, reference_coverage_location=scov.persistence_dir)
scov.close()
return scov
def _create_complex_coverage(cls, dataset_id, description, parameter_dict):
pdict = ParameterDictionary.load(parameter_dict)
file_root = FileSystem.get_url(FS.CACHE, 'datasets')
ccov = ComplexCoverage(
file_root,
dataset_id,
'Complex Coverage for %s' % dataset_id,
parameter_dictionary=pdict,
complex_type=ComplexCoverageType.TEMPORAL_AGGREGATION)
return ccov
def _create_coverage(self, description, parameter_dict, spatial_domain,temporal_domain):
#--------------------------------------------------------------------------------
# Create coversions and deserialization then craft the coverage
#--------------------------------------------------------------------------------
pdict = ParameterDictionary.load(parameter_dict)
sdom = GridDomain.load(spatial_domain)
tdom = GridDomain.load(temporal_domain)
scov = SimplexCoverage(description, parameter_dictionary=pdict, spatial_domain=sdom, temporal_domain=tdom)
return scov
def dataset_temporal_bounds(self, dataset_id):
dataset = self.read_dataset(dataset_id)
if not dataset:
return {}
pdict = ParameterDictionary.load(dataset.parameter_dictionary)
temporal_parameter = pdict.temporal_parameter_name
units = pdict.get_temporal_context().uom
bounds = self.dataset_bounds(dataset_id)
if not bounds:
return {}
bounds = bounds[temporal_parameter or 'time']
bounds = [TimeUtils.units_to_ts(units, i) for i in bounds]
return bounds
def has_lookup_values(self, stream_definition_id=''):
stream_definition = self.read_stream_definition(stream_definition_id)
pdict = ParameterDictionary.load(stream_definition.parameter_dictionary)
ret = []
for key in pdict.keys():
p_context = pdict.get_context(key)
if hasattr(p_context, 'lookup_value'):
if stream_definition.available_fields and key in stream_definition.available_fields:
ret.append(p_context.name)
elif not stream_definition.available_fields:
ret.append(p_context.name)
return ret
def _create_coverage(self, dataset_id, description, parameter_dict,
spatial_domain, temporal_domain):
file_root = FileSystem.get_url(FS.CACHE, 'datasets')
pdict = ParameterDictionary.load(parameter_dict)
sdom = GridDomain.load(spatial_domain)
tdom = GridDomain.load(temporal_domain)
scov = self._create_simplex_coverage(dataset_id, pdict, sdom, tdom,
self.inline_data_writes)
vcov = ViewCoverage(file_root,
dataset_id,
description or dataset_id,
reference_coverage_location=scov.persistence_dir)
scov.close()
return vcov
def _create_coverage(self, dataset_id, description, parameter_dict,
spatial_domain, temporal_domain):
pdict = ParameterDictionary.load(parameter_dict)
sdom = GridDomain.load(spatial_domain)
tdom = GridDomain.load(temporal_domain)
file_root = FileSystem.get_url(FS.CACHE, 'datasets')
scov = SimplexCoverage(file_root,
dataset_id,
description or dataset_id,
parameter_dictionary=pdict,
temporal_domain=tdom,
spatial_domain=sdom,
inline_data_writes=self.inline_data_writes)
return scov
def _create_coverage(self, dataset_id, parameter_dict_id, time_dom,
spatial_dom):
pd = self.dataset_management_client.read_parameter_dictionary(
parameter_dict_id)
pdict = ParameterDictionary.load(pd)
sdom = GridDomain.load(spatial_dom.dump())
tdom = GridDomain.load(time_dom.dump())
file_root = FileSystem.get_url(FS.CACHE, 'datasets')
scov = SimplexCoverage(file_root,
dataset_id,
dataset_id,
parameter_dictionary=pdict,
temporal_domain=tdom,
spatial_domain=sdom)
return scov
def has_lookup_values(self, stream_definition_id=''):
stream_definition = self.read_stream_definition(stream_definition_id)
pdict = ParameterDictionary.load(
stream_definition.parameter_dictionary)
ret = []
for key in pdict.keys():
p_context = pdict.get_context(key)
if hasattr(p_context, 'lookup_value'):
if stream_definition.available_fields and key in stream_definition.available_fields:
ret.append(p_context.name)
elif not stream_definition.available_fields:
ret.append(p_context.name)
return ret
def _create_complex_coverage(cls, dataset_id, description, parameter_dict):
pdict = ParameterDictionary.load(parameter_dict)
file_root = FileSystem.get_url(FS.CACHE, 'datasets')
ccov = ComplexCoverage(file_root, dataset_id, 'Complex Coverage for %s' % dataset_id, parameter_dictionary=pdict, complex_type=ComplexCoverageType.TEMPORAL_AGGREGATION)
return ccov
def _compare_pdicts(cls, pdict1, pdict2):
if pdict1:
pdict1 = ParameterDictionary.load(pdict1) or {}
if pdict2:
pdict2 = ParameterDictionary.load(pdict2) or {}
return bool(pdict1 == pdict2)
def _compare_pdicts(cls, pdict1, pdict2):
if pdict1:
pdict1 = ParameterDictionary.load(pdict1) or {}
if pdict2:
pdict2 = ParameterDictionary.load(pdict2) or {}
return bool(pdict1 == pdict2)
