class RecordDictionaryTool(object):
"""
A granule is a unit of information which conveys part of a coverage. It is composed of a taxonomy and a nested
structure of record dictionaries.
The record dictionary is composed of named value sequences and other nested record dictionaries.
The fact that all of the keys in the record dictionary are handles mapped by the taxonomy should never be exposed.
The application user refers to everything in the record dictionary by the unique nick name from the taxonomy.
"""
def __init__(self, taxonomy=None, param_dictionary=None, shape=None):
"""
@brief Initialize a new instance of Record Dictionary Tool with a taxonomy and an optional fixed length
@param taxonomy is an instance of a TaxonomyTool or Taxonomy (IonObject) used in this record dictionary
@param length is an optional fixed length for the value sequences of this record dictionary
"""
if not isinstance(shape, (_NoneType, int, tuple)):
raise TypeError('Invalid shape argument, received type "%s"; should be None or int or tuple' % type(shape))
self._rd = {}
self._shp = shape
if isinstance(self._shp, int):
self._shp = (self._shp,)
# hold onto the taxonomy - we need it to build the granule...
#Eventually Taxonomy and TaxyTool will go away, to be replaced with ParameterDictionary from coverage-model
#For now, keep Taxonomy stuff in until everyone can re-work their code.
if param_dictionary:
self._param_dict = param_dictionary
self._tx = None
elif isinstance(taxonomy, TaxyTool):
self._tx = taxonomy
self._param_dict = None
elif isinstance(taxonomy, Taxonomy):
self._tx = TaxyTool(taxonomy)
self._param_dict = None
else:
raise TypeError('Invalid taxonomy argument, received type "%s"; should be ParameterDictionary, Taxonomy or TaxyTool' % type(taxonomy))
@classmethod
def load_from_granule(cls, g):
"""
@brief return an instance of Record Dictionary Tool from a granule. Used when a granule is received in a message
"""
if g.param_dictionary:
result = cls(param_dictionary=ParameterDictionary.load(g.param_dictionary))
else:
result = cls(TaxyTool(g.taxonomy))
result._rd = g.record_dictionary
if result._rd.has_key(0):
result._shp = result._rd[0].shape
return result
def __setitem__(self, name, vals):
"""
Set an item by nick name in the record dictionary
"""
#This if block is used if RecordDictionaryTool was initialized using a ParameterDictionary.
#This is the long term solution using the coverage-model.
if self._param_dict:
if isinstance(vals, RecordDictionaryTool):
assert vals._param_dict == self._param_dict
self._rd[self._param_dict.ord_from_key(param_name=name)] = vals._rd
elif isinstance(vals, numpy.ndarray):
#Otherwise it is a value sequence which should have the correct length
# Matthew says: Assert only equal shape 5/17/12
if vals.ndim == 0:
raise ValueError('The rank of a value sequence array in a record dictionary must be greater than zero. Got name "%s" with rank "%d"' % (name, vals.ndim))
# Set _shp if it is None
if self._shp is None:
self._shp = vals.shape
# # Test new value sequence length
# if self._shp != vals.shape:
# raise ValueError('Invalid array shape "%s" for name "%s"; Record dictionary defined shape is "%s"' % (vals.shape, name, self._shp))
self._rd[self._param_dict.ord_from_key(param_name=name)] = vals
else:
raise TypeError('Invalid type "%s" in Record Dictionary Tool setitem with name "%s". Valid types are numpy.ndarray and RecordDictionaryTool' % (type(vals),name))
#This if block is used if RecordDictionaryTool was initialized using a Taxonomy or TaxyTool
#This block will eventually be removed.
if self._tx:
if isinstance(vals, RecordDictionaryTool):
assert vals._tx == self._tx
self._rd[self._tx.get_handle(name)] = vals._rd
elif isinstance(vals, numpy.ndarray):
#Otherwise it is a value sequence which should have the correct length
# Matthew says: Assert only equal shape 5/17/12
if vals.ndim == 0:
raise ValueError('The rank of a value sequence array in a record dictionary must be greater than zero. Got name "%s" with rank "%d"' % (name, vals.ndim))
# Set _shp if it is None
if self._shp is None:
self._shp = vals.shape
# # Test new value sequence length
# if self._shp != vals.shape:
# raise ValueError('Invalid array shape "%s" for name "%s"; Record dictionary defined shape is "%s"' % (vals.shape, name, self._shp))
self._rd[self._tx.get_handle(name)] = vals
else:
raise TypeError('Invalid type "%s" in Record Dictionary Tool setitem with name "%s". Valid types are numpy.ndarray and RecordDictionaryTool' % (type(vals),name))
def __getitem__(self, name):
"""
Get an item by nick name from the record dictionary.
"""
#This if block is used if RecordDictionaryTool was initialized using a ParameterDictionary.
#This is the long term solution using the coverage-model.
if self._param_dict:
if isinstance(self._rd[self._param_dict.ord_from_key(param_name=name)], dict):
result = RecordDictionaryTool(taxonomy=self._param_dict)
result._rd = self._rd[self._param_dict.ord_from_key(param_name=name)]
return result
else:
return self._rd[self._param_dict.ord_from_key(param_name=name)]
#This if block is used if RecordDictionaryTool was initialized using a Taxonomy or TaxyTool
#This block will eventually be removed.
if self._tx:
if isinstance(self._rd[self._tx.get_handle(name)], dict):
result = RecordDictionaryTool(taxonomy=self._tx)
result._rd = self._rd[self._tx.get_handle(name)]
return result
else:
return self._rd[self._tx.get_handle(name)]
def iteritems(self):
""" D.iteritems() -> an iterator over the (key, value) items of D """
#This if block is used if RecordDictionaryTool was initialized using a ParameterDictionary.
#This is the long term solution using the coverage-model.
if self._param_dict:
for k, v in self._rd.iteritems():
if isinstance(v, dict):
result = RecordDictionaryTool(param_dictionary=self._param_dict)
result._rd = v
yield self._param_dict.key_from_ord(k), result
else:
yield self._param_dict.key_from_ord(k), v
#This if block is used if RecordDictionaryTool was initialized using a Taxonomy or TaxyTool
#This block will eventually be removed.
if self._tx:
for k, v in self._rd.iteritems():
if isinstance(v, dict):
result = RecordDictionaryTool(taxonomy=self._tx)
result._rd = v
yield self._tx.get_nick_name(k), result
else:
yield self._tx.get_nick_name(k), v
def iterkeys(self):
""" D.iterkeys() -> an iterator over the keys of D """
#This if block is used if RecordDictionaryTool was initialized using a ParameterDictionary.
#This is the long term solution using the coverage-model.
if self._param_dict:
for k in self._rd.iterkeys():
yield self._param_dict.key_from_ord(k)
#This if block is used if RecordDictionaryTool was initialized using a Taxonomy or TaxyTool
#This block will eventually be removed.
if self._tx:
for k in self._rd.iterkeys():
yield self._tx.get_nick_name(k)
def itervalues(self):
""" D.itervalues() -> an iterator over the values of D """
#This if block is used if RecordDictionaryTool was initialized using a ParameterDictionary.
#This is the long term solution using the coverage-model.
if self._param_dict:
for v in self._rd.itervalues():
if isinstance(v, dict):
result = RecordDictionaryTool(taxonomy=self._param_dict)
result._rd = v
yield result
else:
yield v
#This if block is used if RecordDictionaryTool was initialized using a Taxonomy or TaxyTool
#This block will eventually be removed.
if self._tx:
for v in self._rd.itervalues():
if isinstance(v, dict):
result = RecordDictionaryTool(taxonomy=self._tx)
result._rd = v
yield result
else:
yield v
#TJG - This may need to be updated
def update(self, E=None, **F):
"""
@brief Dictionary update method exposed for Record Dictionaries
@param E is another record dictionary
@param F is a dictionary of nicknames and value sequences
"""
if E:
if hasattr(E, "keys"):
for k in E:
self[k] = E[k]
else:
for k, v in E.iteritems():
self[k] = v
if F:
for k in F.keys():
self[k] = F[k]
def __contains__(self, nick_name):
""" D.__contains__(k) -> True if D has a key k, else False """
handle = ''
try:
if self._param_dict:
handle = self._param_dict.ord_from_key(nick_name)
if self._tx:
handle = self._tx.get_handle(nick_name)
except KeyError as ke:
# if the nick_name is not in the taxonomy, it is certainly not in the record dictionary
return False
return handle in self._rd
def __delitem__(self, y):
""" x.__delitem__(y) <==> del x[y] """
#not sure if this is right, might just have to remove the name, not the whole handle
if self._param_dict:
del self._rd[self._param_dict.ord_from_key(y)]
if self._tx:
del self._rd[self._tx.get_handle(y)]
#will probably need to delete the name from _tx
def __iter__(self):
""" x.__iter__() <==> iter(x) """
return self.iterkeys()
def __len__(self):
""" x.__len__() <==> len(x) """
return len(self._rd)
def __repr__(self):
""" x.__repr__() <==> repr(x) """
result = "{"
for k, v in self.iteritems():
result += "\'{0}\': {1},".format(k, v)
if len(result) > 1:
result = result[:-1] + "}"
return result
def __str__(self):
result = "{"
for k, v in self.iteritems():
result += "\'{0}\': {1},".format(k, v)
if len(result) > 1:
result = result[:-1] + "}"
return result
__hash__ = None
def pretty_print(self):
"""
@brief Pretty Print the record dictionary for debug or log purposes.
"""
pass
# fid = StringIO.StringIO()
# # Use string IO inside a try block in case of exceptions or a large return value.
# try:
# fid.write('Start Pretty Print Record Dictionary:\n')
# self._pprint(fid,offset='')
# fid.write('End of Pretty Print')
# except Exception, ex:
# log.exception('Unexpected Exception in Pretty Print Wrapper!')
# fid.write('Exception! %s' % ex)
#
# finally:
# result = fid.getvalue()
# fid.close()
#
#
# return result
def _pprint(self, fid, offset=None):
pass
