FCL/sftools/dev/build: comparison buildframework/helium/sf/python/pythoncore/lib/symrec.py

equal deleted inserted replaced

-:c7c26511138f
+:7c4a911dc066
 import csv
 LOGGER = logging.getLogger("symrec")
 logging.basicConfig(level=logging.INFO)
-def _cleanup_list(input):
+def _cleanup_list(input_):
 """cleanup  list"""
 result = []
-for chars in input:
+for chars in input_:
 if chars is not None and chars.strip() != "":
 result.append(chars)
 return result
 def xml_setattr(node, attr, value):
 the output in a structure way.
 indent = current indentation
 addindent = indentation to add to higher levels
 newl = newline string
 """
+# pylint: disable=W0212
 writer.write(indent + "<" + self.tagName)
 attrs = self._get_attributes()
 a_names = attrs.keys()
 a_names.sort()
 """instructions"""
 result = []
 for instr in self.__xml.getElementsByTagName('instructions'):
 result.append(instr.getAttribute('name'))
 return result
 class ReleaseMetadata(object):
 """ Create or read Metadata XML from SYMREC/SYMDEC. """
 def __init__(self, filename, service=None, product=None, release=None):
 self.service = service
 if product != None:
 self.product = product
 if release != None:
 self.release = release
-elif service!=None and product!=None and release!=None:
+elif service != None and product != None and release != None:
 self._xml = xml.dom.minidom.Document()
 self._releaseInformation = self._xml.createElement(u"releaseInformation")
 self._xml.appendChild(self._releaseInformation)
 self._releaseDetails = self._xml.createElement(u'releaseDetails')
 self._releaseInformation.appendChild(self._releaseDetails)
 self._releaseInformation.appendChild(self._releaseFiles)
 #    releaseFiles
 self._releaseInformation.appendChild(self._xml.createElement(u'externalFiles'))
 else:
-raise Exception("Error metadata file doesn't exists.")
+raise IOError("Error metadata file doesn't exists.")
 def get_dependsof(self):
 """ Return a ReleaseMetada object pointing to the dependency release. """
 if self.dependsof_service != None and self.dependsof_product != None and self.dependsof_release != None:
 filename = os.path.join(os.path.dirname(self._filename), "../../..",
 self.dependsof_release)
 return ReleaseMetadata(find_latest_metadata(filename))
 else:
 return None
 def set_dependsof(self, filename):
 """ Setting the dependency release. """
 metadata  = ReleaseMetadata(filename)
 self.dependsof_service  = metadata.service
 self.dependsof_product  = metadata.product
 self.dependsof_release  = metadata.release
-def add_package(self, name, type=None, default=True, filters=None, extract="single", md5checksum=None, size=None):
+def add_package(self, name, type_=None, default=True, filters=None, extract="single", md5checksum=None, size=None):
 """ Adding a package to the metadata file. """
 # check if update mode
 package = None
 for pkg in self._xml.getElementsByTagName('package'):
 if package is None:
 package = self._xml.createElement(u'package')
 self._releaseFiles.appendChild(package)
 xml_setattr(package, 'name', os.path.basename(name))
-if type != None:
+if type_ != None:
-xml_setattr(package, 'type', type)
+xml_setattr(package, 'type', type_)
 else:
 xml_setattr(package, 'type', os.path.splitext(name)[1].lstrip('.'))
 xml_setattr(package, 'default', str(default).lower())
 xml_setattr(package, 'extract', extract)
 if filters and len(filters)>0:
 xml_setattr(package, 's60filter', '')
 if md5checksum != None:
 xml_setattr(package, unicode("md5checksum"), unicode(md5checksum))
 if size != None:
 xml_setattr(package, unicode("size"), unicode(size))
 def keys(self):
 """keys"""
 keys = []
 for pkg in self._releaseFiles.getElementsByTagName('package'):
 md5checksum = pkg.getAttribute('md5checksum')
 if pkg.hasAttribute(u'size'):
 size = pkg.getAttribute('size')
 return {'type': pkg.getAttribute('type'), 'extract': pkg.getAttribute('extract'), 'default': (pkg.getAttribute('default')=="true"), \
 'filters': filters, 's60filter': s60filters, 'md5checksum': md5checksum, 'size': size}
-raise Exception("Key '%s' not found." % key)
+raise KeyError("Key '%s' not found." % key)
 def __setitem__(self, key, value):
 self.add_package(key, value['type'], value['default'], value['filters'], value['extract'], value['md5checksum'], value['size'])
 def set_releasedetails_info(self, name, value, details="releaseID"):
 dependency = self.get_dependsof()
 if dependency != None:
 return ValidateReleaseMetadata(dependency.filename).is_valid(checkmd5)
 return True
 class MetadataMerger(object):
 """ Merge packages definition to the root metadata. """
 def __init__(self, metadata):
 """ Construct a metadata merger providing root metadata filename. """
 return self._metadata.xml()
 def save(self, filename = None):
 """ Saving the XML into the provided filename. """
 return self._metadata.save(filename)
 class Metadata2TDD(ReleaseMetadata):
 """ Convert Metadata to a TDD file """
 def __init__(self, filename, includes=None, excludes=None):
 ReleaseMetadata.__init__(self, filename)
 metadatas.append(filename)
 # reverse the order...
 metadatas.sort(reverse=True)
 if len(metadatas) > 0:
 return os.path.normpath(os.path.join(releasedir, metadatas[0]))
-except Exception, exc:
+except (IOError, OSError), exc:
 LOGGER.error(exc)
 return None
 return None
 class ValidateReleaseMetadataCached(ValidateReleaseMetadata):
 """ Cached version of the metadata validation. """
 def __init__(self, filename, cachefile=None):
 ValidateReleaseMetadata.__init__(self, filename)
 f_file = open(self.__cachefile, "wb")
 writer = csv.writer(f_file)
 writer.writerows(metadatas)
 f_file.close()
 class ValidateTicklerReleaseMetadata(ValidateReleaseMetadataCached):
 """ This class validate if a metadata file is stored in the correct location and
 if all deps exists.
 """
 def __init__(self, filename):
-ReleaseMetadata.__init__(self, filename)
+ValidateReleaseMetadataCached.__init__(self, filename)
 self.location = os.path.dirname(filename)
 def is_valid(self, checkmd5=True):
 """ Run the validation mechanism. """
 tickler_path = os.path.join(self.location,"TICKLER")

changeset 628	7c4a911dc066
parent 588	c7c26511138f
child 645	b8d81fa19e7d