def __set__(self, instance, value): def set_value(new_value): if len(new_value) < self.minimum_length: msg = 'Attribute {} of class {} is an float list of size {},\n\t' \ 'and must have size at least {}.'.format( self.name, instance.__class__.__name__, value.size, self.minimum_length) if self.strict: raise ValueError(msg) else: logger.info(msg) if len(new_value) > self.maximum_length: msg = 'Attribute {} of class {} is a float list of size {},\n\t' \ 'and must have size no larger than {}.'.format( self.name, instance.__class__.__name__, value.size, self.maximum_length) if self.strict: raise ValueError(msg) else: logger.info(msg) self.data[instance] = new_value if super(FloatListDescriptor, self).__set__(instance, value): # the None handler...kinda hacky return if isinstance(value, float): set_value([value, ]) elif isinstance(value, ElementTree.Element): set_value([float(get_node_value(value)), ]) elif isinstance(value, list): if len(value) == 0 or isinstance(value[0], float): set_value(value) elif isinstance(value[0], ElementTree.Element): set_value([float(get_node_value(nod)) for nod in value]) else: raise TypeError(_type_text.format(self.name, instance.__class__.__name__, type(value)))
def __set__(self, instance, value): def set_value(new_val): if len(new_val) < self.minimum_length: msg = 'Attribute {} of class {} is a double array of size {},\n\t' \ 'and must have size at least {}.'.format( self.name, instance.__class__.__name__, value.size, self.minimum_length) if self.strict: raise ValueError(msg) else: logger.error(msg) if len(new_val) > self.maximum_length: msg = 'Attribute {} of class {} is a double array of size {},\n\t' \ 'and must have size no larger than {}.'.format( self.name, instance.__class__.__name__, value.size, self.maximum_length) if self.strict: raise ValueError(msg) else: logger.error(msg) self.data[instance] = new_val if super(FloatArrayDescriptor, self).__set__(instance, value): # the None handler...kinda hacky return if isinstance(value, numpy.ndarray): if not (len(value) == 1) and (numpy.dtype.name == 'float64'): raise ValueError('Only one-dimensional ndarrays of dtype float64 are supported here.') set_value(value) elif isinstance(value, ElementTree.Element): xml_ns = getattr(instance, '_xml_ns', None) # noinspection PyProtectedMember if hasattr(instance, '_child_xml_ns_key') and self.name in instance._child_xml_ns_key: # noinspection PyProtectedMember xml_ns_key = instance._child_xml_ns_key[self.name] else: xml_ns_key = getattr(instance, '_xml_ns_key', None) size = int_func(value.attrib['size']) child_nodes = find_children(value, self.child_tag, xml_ns, xml_ns_key) if len(child_nodes) != size: raise ValueError( 'Field {} of double array type functionality belonging to class {} got a ElementTree element ' 'with size attribute {}, but has {} child nodes with tag {}.'.format( self.name, instance.__class__.__name__, size, len(child_nodes), self.child_tag)) new_value = numpy.empty((size,), dtype=numpy.float64) for i, node in enumerate(child_nodes): new_value[i] = float(get_node_value(node)) set_value(new_value) elif isinstance(value, list): # user or json deserialization set_value(numpy.array(value, dtype=numpy.float64)) else: raise TypeError( 'Field {} of class {} got incompatible type {}.'.format( self.name, instance.__class__.__name__, type(value)))
def from_node(cls, node, xml_ns, ns_key=None, kwargs=None): dim1 = int(node.attrib['size']) dim2 = int(node.attrib['numLuts']) arr = numpy.zeros((dim1, dim2), dtype=numpy.uint16) lut_key = cls._child_xml_ns_key.get('LUTValues', ns_key) lut_nodes = find_children(node, 'LUTValues', xml_ns, lut_key) for i, lut_node in enumerate(lut_nodes): arr[:, i] = [str(el) for el in get_node_value(lut_node)] if numpy.max(arr) < 256: arr = numpy.cast[numpy.uint8](arr) return cls(LUTValues=arr)
def from_node(cls, node, xml_ns, ns_key=None, kwargs=None): num_phasings = int(node.attrib['numPhasings']) num_points = int(node.attrib['numPoints']) coefs = numpy.zeros((num_phasings+1, num_points+1), dtype=numpy.float64) ckey = cls._child_xml_ns_key.get('Coefs', ns_key) coef_nodes = find_children(node, 'Coef', xml_ns, ckey) for cnode in coef_nodes: ind1 = int(cnode.attrib['phasing']) ind2 = int(cnode.attrib['point']) val = float(get_node_value(cnode)) coefs[ind1, ind2] = val return cls(Coefs=coefs)
def from_node(cls, node, xml_ns, ns_key=None, kwargs=None): if kwargs is None: kwargs = OrderedDict() # parse the ModuleName mn_key = cls._child_xml_ns_key.get('ModuleName', ns_key) mn_node = find_first_child(node, 'ModuleName', xml_ns, mn_key) kwargs['ModuleName'] = get_node_value(mn_node) kwargs['name'] = mn_node.attrib.get('name', None) # parse the ProcessingModule children pm_key = cls._child_xml_ns_key.get('ProcessingModules', ns_key) kwargs['ProcessingModules'] = find_children(node, 'ProcessingModule', xml_ns, pm_key) return super(ProcessingModuleType, cls).from_node(node, xml_ns, ns_key=ns_key, kwargs=kwargs)
def __set__(self, instance, value): def set_value(new_value): if len(new_value) < self.minimum_length: msg = 'Attribute {} of class {} is a string list of size {},\n\t' \ 'and must have length at least {}.'.format( self.name, instance.__class__.__name__, value.size, self.minimum_length) if self.strict: raise ValueError(msg) else: logger.error(msg) if len(new_value) > self.maximum_length: msg = 'Attribute {} of class {} is a string list of size {},\n\t' \ 'and must have length no greater than {}.'.format( self.name, instance.__class__.__name__, value.size, self.maximum_length) if self.strict: raise ValueError(msg) else: logger.error(msg) self.data[instance] = new_value if super(StringListDescriptor, self).__set__(instance, value): # the None handler...kinda hacky return if isinstance(value, string_types): set_value([value, ]) elif isinstance(value, ElementTree.Element): set_value([get_node_value(value), ]) elif isinstance(value, list): if len(value) == 0 or isinstance(value[0], string_types): set_value(value) elif isinstance(value[0], ElementTree.Element): set_value([get_node_value(nod) for nod in value]) else: raise TypeError( 'Field {} of class {} got incompatible type {}.'.format( self.name, instance.__class__.__name__, type(value)))
def NODATA(self, value): if value is None: self._NODATA = None return if isinstance(value, ElementTree.Element): value = get_node_value(value) if isinstance(value, str): self._NODATA = value elif isinstance(value, bytes): self._NODATA = value.decode('utf-8') elif isinstance(value, int): raise NotImplementedError elif isinstance(value, float): raise NotImplementedError else: raise TypeError('Got unexpected type {}'.format(type(value)))
def from_node(cls, node, xml_ns, ns_key=None, kwargs=None): if kwargs is None: kwargs = {} lut_key = cls._child_xml_ns_key.get('RemapLUT', ns_key) lut_node = find_first_child(node, 'RemapLUT', xml_ns, lut_key) if lut_node is not None: dim1 = int_func(lut_node.attrib['size']) arr = numpy.zeros((dim1, ), dtype=numpy.uint8) entries = get_node_value(lut_node).split() i = 0 for entry in entries: if len(entry) == 0: continue arr[i] = int(entry) i += 1 kwargs['RemapLUT'] = arr return super(MonochromeDisplayRemapType, cls).from_node(node, xml_ns, ns_key=ns_key, **kwargs)
def from_node(cls, node, xml_ns, ns_key=None, kwargs=None): lut_key = cls._child_xml_ns_key.get('RemapLUT', ns_key) lut_node = find_first_child(node, 'RemapLUT', xml_ns, lut_key) if lut_node is not None: dim1 = int_func(lut_node.attrib['size']) dim2 = 3 arr = numpy.zeros((dim1, dim2), dtype=numpy.uint16) entries = get_node_value(lut_node).split() i = 0 for entry in entries: if len(entry) == 0: continue sentry = entry.split(',') if len(sentry) != 3: logger.error( 'Parsing RemapLUT is likely compromised.\n\t' 'Got entry {}, which we are skipping.'.format(entry)) continue arr[i, :] = [int(el) for el in entry] i += 1 if numpy.max(arr) < 256: arr = numpy.cast[numpy.uint8](arr) return cls(RemapLUT=arr) return cls()
def _get_value(node, tag, xml_ns, ns_key): t_node = find_first_child(node, tag, xml_ns, ns_key) if t_node is None: return None else: return float(get_node_value(t_node))
def _from_node_0_5(cls, node, xml_ns, ns_key): """ Helper method, not really for public usage. For XML deserialization from SICD version prior to 1.0. Parameters ---------- node : ElementTree.Element dom element for serialized class instance xml_ns : dict The xml namespace dictionary ns_key : str The namespace key in the dictionary Returns ------- Serializable corresponding class instance """ def get_element(tid, cid, cname, params): return { 'TypeID': tid, 'CurrentIndex': cid, 'MatchCollections': [ { 'CoreName': cname, 'Parameters': params }, ] } # Note that this is NOT converting the MatchType.MatchCollection in spirit. # There isn't enough structure to guarantee that you actually can. This will # always yield MatchType.MatchCollection length 1, because the collection details are stuffed # into the parameters free form, while CurrentIndex is extracted and actually yields the # collection index number (likely larger than 1). This is at least confusing, but more likely # completely misleading. match_types = [] coll_key = cls._child_xml_ns_key.get('Collect', ns_key) cnodes = find_children(node, 'Collect', xml_ns, coll_key) for cnode in cnodes: # assumed non-empty # this describes one series of collects, possibly with more than one MatchType = TypeID # It is not clear how it would be possible to deconflict a repeat of MatchType between # Collect tags, so I will not. core_key = cls._child_xml_ns_key.get('CoreName', ns_key) core_name = get_node_value( find_first_child(cnode, 'CoreName', xml_ns, core_key)) current_index = None parameters = [] pkey = cls._child_xml_ns_key.get('Parameters', ns_key) pnodes = find_children(cnode, 'Parameter', xml_ns, pkey) for pnode in pnodes: name = pnode.attrib['name'] value = get_node_value(pnode) if name == 'CURRENT_INSTANCE': current_index = int( value) # extract the current index (and exclude) else: parameters.append({ 'name': name, 'value': value }) # copy the parameter if current_index is None: continue # I don't know what we would do? mt_key = cls._child_xml_ns_key.get('MatchType', ns_key) mtypes = find_children(cnode, 'MatchType', xml_ns, mt_key) for tnode in mtypes: type_id = get_node_value(tnode) match_types.append( get_element(type_id, current_index, core_name, parameters)) if len(match_types) > 0: # noinspection PyTypeChecker return cls(MatchTypes=match_types) else: return None