def get_components_inv_dep_order(working_repo,
platform,
top,
code_root=None,
branch='trunk',
revision=None,
aspect=component.CODE_ASPECT_NAME,
debug=False,
use_master=False,
check_vcs=True):
'''
Return a list of components in inverse dependency order, using the specified
component as the starting point of the dependency graph. Inverse dependency
order means that the components with no dependencies (the leaves) are listed
first, and the most dependent component is last. This is valid build order.
@param top The name of the topmost component.
@param code_root Optional. The fully qualified path to the code root of an
existing sandbox. If specified, then the metadata.txt files for components
in the coderoot are used to override/pre-empt the checked-in versions.
@param branch The branch of the components. All components in the dependency
tree must share this branch.
@param revision The revision of the topmost component; None = latest.
@param aspect The aspect of the topmost component.
'''
already_analyzed = {}
comp = component.Component(top, branch, revision, aspect)
dep_tree = _get_deps(working_repo, platform, comp, code_root,
{str(comp): comp}, already_analyzed, use_master,
check_vcs)
# At this point dep_tree is a single Component object that has embedded child
# nodes in its .dependencies member. If our topmost component is terminal,
# we won't have buildscripts in the code folder unless we artificially
# inject the dependency here...
if not has_component(dep_tree, 'buildscripts'):
c = component.Component('buildscripts',
dep_tree.branch,
None,
component.CODE_ASPECT_NAME,
parent=dep_tree)
dep_tree.dependencies.append(c)
if debug:
tree = dep_tree
_detect_conflicts(working_repo, dep_tree, branch, top, [], debug)
components = _trim_tree(dep_tree)
deps = sorted(components, key=attrgetter('rank', 'name'))
if debug:
print('\nDependencies:')
for comp in deps:
print comp
print('-----------------------------------')
print('\nFull dependence tree')
print_tree(tree)
print('-----------------------------------')
unnecessary_dependencies(tree)
return deps
def currentDirectoryModule():
c = component.Component(os.getcwd())
if not c:
logging.error(str(c.error))
logging.error('The current directory does not contain a valid module.')
return None
return c
def setUp(self):
self.e = entity.Entity()
self.e.add_component(components.mortal.Mortal())
c = component.Component()
c.attributes = [("test", True)]
c.handlers = [("handler", lambda e, p: e.add_attribute("handled"))]
self.e.add_component(c)
def setFromDict(self, designObject, myShipDict):
"""setup this ship according to the design object and ship dictionary info given"""
self.myDesign = designObject
self.designID = designObject.id
self.componentdata = designObject.componentdata
self.weapondata = designObject.weapondata
self.myShipHull = designObject.myShipHull
designAttrDict = designObject.getMyInfoAsDict()
self.currentISP = myShipDict['currentISP']
for position, dQuad in myShipDict['quads'].iteritems():
newQuad = quad.Quad(dQuad)
newQuad.setMyParent(self)
# weapons have to be created first
for id, dWeap in dQuad['weapons'].iteritems():
newWeap = weapon.Weapon(dWeap)
newWeap.setMyQuad(newQuad)
for id, dComp in dQuad['components'].iteritems():
newComp = component.Component(dComp)
newComp.setMyQuad(newQuad)
newQuad.setMyStatus()
self.quads[newQuad.position] = newQuad
newQuad.resetDefences()
newQuad.reloadAmmo()
self.setMyStatus()
self.name = designObject.name + '-' + self.id
self.randomizeJunkTrail()
def searchPathsForComponent(name, version_required, search_paths):
for path in search_paths:
component_path = os.path.join(path, name)
logger.debug("check path %s for %s" % (component_path, name))
local_component = component.Component(
component_path,
installed_previously=True,
installed_linked=fsutils.isLink(component_path),
latest_suitable_version=None)
if local_component:
return local_component
return None
def currentDirectoryModule():
try:
c = component.Component(os.getcwd())
except pack.InvalidDescription as e:
logging.error(e)
return None
if not c:
logging.error(str(c.error))
logging.error('The current directory does not contain a valid module.')
return None
return c
def __call__(self, word_emb):
num_words = self._num_words
num_samples = self._num_samples
counts = self._counts
prefix = self._name + '/' if self._name else ''
with tf.device('/cpu:0'):
with tf.variable_scope(prefix + 'context'):
context_word = tf.placeholder(dtype=tf.int64,
shape=[None],
name='word')
context_word_ = tf.reshape(context_word, [-1, 1], name='word_')
loss = skipgram_nce_loss(num_words, num_samples, counts,
word_emb, context_word_)
word2id_extractor = Word2Id(self._words, prefix + 'context/')
return component.Component([context_word],
loss,
feature_extractor=word2id_extractor)
def build(self, sb, options, targets):
'''
Make all enumerated targets.
'''
err = 0
if targets == ['config']:
self.config(sb, options)
else:
if options.timeout is None:
options.timeout = 120
cc = sb.get_cached_components()
if not cc:
print(
'%s/dependencies.txt not found; do you need to do a "bzr sb update"?'
% sb.get_name())
print('Proceeding with implied component list.')
cc = sb.get_on_disk_components()
br = sb.get_branch()
cc = [
component.Component(c, br, None,
component.CODE_ASPECT_NAME)
for c in sb.get_on_disk_components()
if sb.get_component_reused_aspect(c) ==
component.CODE_ASPECT_NAME
]
for c in cc:
if c.reused_aspect == 'code':
makefile = sb.get_component_path(
c.name,
component.CODE_ASPECT_NAME) + self.get_build_file()
if os.path.isfile(makefile):
cmd = 'python %s' % self.get_build_file()
if targets:
cmd += ' ' + ' '.join(targets)
print('Building %s...' % c.name)
err2, stdout = run_make_command(
cmd,
timeout=options.timeout,
cwd=os.path.dirname(makefile))
if err2:
err = 1
print('... FAILED')
else:
print('... OK')
return err
def __init__(self, specs, bias=0.0):
"""Initializes a decomposition object. Demeter: save copies of
component elements for wrapper-level querying."""
self._components = []
self.bias = bias
self.specs = specs
for spec in specs:
# For historical reasons, given as: (amp, decay, freq, phase)
amp, decay, freq, ph = spec
self._components.append(c.Component(amp, decay, freq, phase=ph))
self.freqs = [comp.freq for comp in self._components]
self.amps = [comp.amp for comp in self._components]
self.decays = [comp.decay for comp in self._components]
self.periods = [comp.period for comp in self._components]
self.phases = [comp.phase for comp in self._components]
self.offsets = [comp.offset for comp in self._components]
def _satisfyVersionByInstallingVersion(name, version_required,
working_directory, version):
''' installs and returns a Component for the specified version requirement into
'working_directory' using the provided remote version object.
This function is not normally called via `satisfyVersionByInstalling',
which looks up a suitable remote version object.
'''
assert (version)
logger.info('download ' + name)
version.unpackInto(working_directory)
r = component.Component(working_directory)
if not r:
raise Exception('Dependency "%s":"%s" is not a valid component.' %
(name, version_required))
if name != r.getName():
raise Exception(
'Component %s (specification %s) has incorrect name %s' %
(name, version_required, r.getName()))
return r
def keyboard():
if window.keyboard:
return window.keyboard
system_keyboard = component.get_primary(
"keyboard").address if component.is_available("keyboard") else None
screen = window.screen
if not screen:
return "no_system_keyboard"
if component.is_available("screen") and component.get_primary(
"screen").address == screen:
window.keyboard = system_keyboard
else:
window.keyboard = component.Component(
screen).getKeyboards() or system_keyboard
return window.keyboard
def currentDirectoryModuleOrTarget():
wd = os.getcwd()
errors = []
p = None
try:
p = component.Component(wd)
except pack.InvalidDescription as e:
errors.append(e)
if not p:
try:
p = target.Target(wd)
except pack.InvalidDescription as e:
errors.append(e)
if not p:
for e in errors:
logging.debug(e)
logging.error(
'The current directory does not contain a valid module or target.')
return None
return p
def setMyDesign(self, designObject):
"""Copy the Ship Design Attributes, Quads to ship"""
self.myDesign = designObject
self.designID = designObject.id
self.componentdata = designObject.componentdata
self.weapondata = designObject.weapondata
self.myShipHull = designObject.myShipHull
designAttrDict = designObject.getMyInfoAsDict()
self.currentISP = self.myShipHull.maxISP
self.currentPower = designAttrDict['maxPower']
self.maxBattery = designAttrDict['maxBattery']
self.thrust = designAttrDict['thrust']
self.rotation = designAttrDict['rotation']
self.radar = designAttrDict['radar']
self.jamming = designAttrDict['jamming']
self.repair = designAttrDict['repair']
self.maxAssault = designAttrDict['maxAssault']
self.mass = self.myShipHull.mass
for position, dQuad in designObject.quads.iteritems():
newQuad = quad.Quad(dQuad.getMyInfoAsDict())
newQuad.setMyParent(self)
# weapons have to be created first
for id, weap in dQuad.weapons.iteritems():
newWeap = weapon.Weapon(weap.getMyInfoAsDict())
newWeap.setMyQuad(newQuad)
for id, comp in dQuad.components.iteritems():
newComp = component.Component(comp.getMyInfoAsDict())
newComp.setMyQuad(newQuad)
newQuad.setMyStatus()
self.quads[newQuad.position] = newQuad
newQuad.resetDefences()
newQuad.reloadAmmo()
self.name = designObject.name + '-' + self.id
self.setMyStrength()
if 'AS' in self.myShipHull.abr:
self.isAssault = 1
else:
self.isAssault = 0
def setUp(self):
self.e = entity.Entity()
self.c = component.Component()
def add_component(self, path):
comp = component.Component()
#try:
comp.read(path)
self.components.append(comp)
def noise_removal(self):
# print("\n----------before noise_removal-----------")
# self.print_im()
self.image_graph = graph.Image_graph(self.image)
self.image_graph.search_connected_components()
components = []
# print("")
# self.pr(im)
for c in self.image_graph.connected_components:
cm = component.Component(c)
components.append(cm)
# cm.delete(im)
# self.pr(im)
if len(components) <= 1:
return
sizes = []
for i in components:
sizes += [-max(i.width, i.height)]
sizes.sort()
min_letter_size = sizes[len(sizes) - 1]
for i in range(1, len(sizes)):
if (float(sizes[i - 1]) / float(sizes[i]) > 1.5):
min_letter_size = sizes[i - 1]
break
min_letter_size = -min_letter_size
#
# print("min_letter_size", min_letter_size)
# self.print_im()
for c in components:
# print("delete")
if (max(c.width, c.height) < min_letter_size):
c.delete(self.image)
# print("THERE")
# for point in c.points:
#
# print(point)
# self.image[point[0]][point[1]] = BLACK
# self.print_im()
# self.print_im()
# print("\n----------after noise_removal-----------")
# self.print_im()
self.image_graph = graph.Image_graph(self.image)
self.image_graph.search_connected_components()
components = []
# print("")
# self.pr(im)
for c in self.image_graph.connected_components:
cm = component.Component(c)
components.append(cm)
# cm.delete(im)
# self.pr(im)
# print("c count", len(components))
if len(components) <= 1:
return
sizes = []
for i in components:
sizes += [-i.points_count]
sizes.sort()
min_letter_size = sizes[len(sizes) - 1]
for i in range(1, len(sizes)):
if (float(sizes[i - 1]) / float(sizes[i]) > 2):
min_letter_size = sizes[i - 1]
break
min_letter_size = -min_letter_size
#
# print("min_letter_size", min_letter_size)
# self.print_im()
for c in components:
# print("delete")
if (c.points_count < min_letter_size):
# print("THERE")
for point in c.points:
# print(point)
self.image[point[0]][point[1]] = BLACK
def setUp(self):
self.e = entity.Entity()
self.c = component.Component()
self.c.got_added = lambda e: e.add_attribute("added")
self.c.got_removed = lambda e: e.add_attribute("removed")
self.c.update = lambda e, p: e.add_attribute("updated")
def _get_deps(working_repo,
platform,
top_component,
code_root,
read_deps,
already_analyzed,
use_master=False,
check_vcs=True):
if top_component.name == 'buildscripts':
top_component.reused_aspect = component.CODE_ASPECT_NAME
##TODO julie why would we do this?
## if top_component.reused_aspect == component.BUILT_ASPECT_NAME:
## interesting_branches = [b for b in working_repo.branches if b[1] == top_component.name and b[2].startswith(component.BUILT_ASPECT_NAME) and b[0] == top_component.branch]
## if not interesting_branches:
## top_component.reused_aspect = component.CODE_ASPECT_NAME
folder = ''
if (not top_component.revision) and code_root:
fldr = os.path.join(code_root, top_component.name)
if os.path.isdir(fldr):
if check_vcs and vcs.folder_is_tied_to_vcs(fldr):
output = vcs.get_status(fldr,
status_filter=lambda lbl: lbl ==
'modified' or lbl == 'added')
if output:
if 'modified' in output:
if METADATA_FILE in output['modified']:
folder = fldr
if 'added' in output:
if METADATA_FILE in output['added']:
folder = fldr
else:
folder = fldr
if folder:
if folder in already_analyzed:
return top_component #sections = already_analyzed[folder]
else:
print('\nLoading %s from %s.' % (METADATA_FILE, folder))
x = get_section_info_from_disk(MISC_SECTION, folder)
if 'terminal dependency' in x and top_component.reused_aspect.startswith(
component.BUILT_ASPECT_NAME):
return top_component
sections = get_section_info_from_disk(DEPENDENCIES_SECTION, folder)
already_analyzed[folder] = sections
elif check_vcs:
key = '%s:%s' % (top_component.name, top_component.reused_aspect
) #str(top_component)
if key in already_analyzed:
return top_component #sections = already_analyzed[key]
else:
x = get_section_info_from_vcs(MISC_SECTION, top_component,
working_repo, platform, use_master)
if 'terminal dependency' in x and top_component.reused_aspect.startswith(
component.BUILT_ASPECT_NAME):
return top_component
sections = get_section_info_from_vcs(DEPENDENCIES_SECTION,
top_component, working_repo,
platform, use_master)
already_analyzed[key] = sections
else:
return top_component
compOldDeps = False
for componentname, info in sections.iteritems():
componentname = componentname.strip()
aspect, revision, old = component.parse_component_info(info)
if aspect == component.BUILT_ASPECT_NAME:
aspect += "." + platform
if old:
compOldDeps = True
componentname, ignored, branch, task = working_repo.normalize(
componentname, aspect, top_component.branch)
if revision:
m = _TAG_PAT.match(revision)
if not m:
raise Exception(
'%s is not a valid tag for pinning dependencies.' %
revision)
assert (aspect)
top_component.dependencies.append(
component.Component(componentname,
branch,
revision,
aspect,
parent=top_component))
if compOldDeps:
print('''Component %s/%s/%s has the old format for dependencies.
Please update dependencies in metadata.txt to match format found at:
https:// ... /working-with-code/concepts/dependencies''' %
(top_component.name, top_component.reused_aspect,
top_component.branch)) # TODO KIM refer to doc site
top_component.rank += len(top_component.dependencies)
for dep in top_component.dependencies:
if top_component.reused_aspect.startswith(component.BUILT_ASPECT_NAME):
dep.reused_aspect = top_component.reused_aspect
# We are suspicious that this optimization isn't working
if str(dep) not in read_deps or read_deps[str(dep)] != dep:
read_deps[str(dep)] = dep
dep = _get_deps(working_repo, platform, dep, code_root, read_deps,
already_analyzed, use_master, check_vcs)
top_component.rank += dep.rank
return top_component
def read_xml(
path='/Users/massimosferza/LRZ Sync+Share/TUM/TUM SoSe16/Courses/Software Lab/Git_repository/no-block-example.xml'
):
"""It creates a structure object for the OoD problem to solve, given a
proper .xml file"""
# create a tree object, given the correct address of the .xml file
tree = et.parse(path)
# create a variable that contains the root
root = tree.getroot()
#############################################################
# create a structure
new_structure = structure.Structure()
#############################################################
# create all the loadpaths
# loop over the element <level> </level> contained in root
for level in root.iter('level'):
# create a loadpath
level_id = int(level.find('id').text)
loadpath_obj = lp.Loadpath(level_id)
#############################################################
# add nodes to each loadpath
for component in level.iter('component'):
# for every component in the level, get x1
x_position = float(component.find('x1').text)
# check if the loadpath already contains a node corresponding to x1
already_contained = False
for node in loadpath_obj.node_list:
if x_position == node.x_position:
already_contained = True
break
if not already_contained:
# if not add it
loadpath_obj.node_list.append(nd.Node(x_position))
# for every component, that is not a connection
if not 'X' in component.find('name').text:
# get also x2
x_position = float(component.find('x2').text)
# and again
# check if the loadpath already contains a node corresponding to
# x2
already_contained = False
for node in loadpath_obj.node_list:
if x_position == node.x_position:
already_contained = True
break
if not already_contained:
# if not add it
loadpath_obj.node_list.append(nd.Node(x_position))
#############################################################
# add members to each loadpath
for component in level.iter('component'):
# for every component, that is not a connection
if not 'X' in component.find('name').text:
# get the previously created nodes
x1 = float(component.find('x1').text)
x2 = float(component.find('x2').text)
for node in loadpath_obj.node_list:
if x1 == node.x_position:
node1 = node
if x2 == node.x_position:
node2 = node
# create a member
member_obj = c.Component(
component.find('name').text, node1, node2,
float(component.find('defoLength').text),
float(component.find('defoRatio').text))
# add the member to the loadpath
loadpath_obj.component_list.append(member_obj)
# add the loadpath to the structure
new_structure.path_list.append(loadpath_obj)
#############################################################
# neglect all the connectionpaths
#############################################################
return new_structure
#########################################################
# #
# This is main function for this application #
# #
#########################################################
import component
node1 = component.Component("NODE1","sender")
node2 = component.Component("NODE2","receiver")
if __name__ == "__main__":
print("Running heart of ROS ...")
def parse_scrp(path, debug=False):
parser = scrp_yacc.ParseScrp()
parser.parse_scrp(path)
component_list = parser.component
for temp_component in parser.component_list:
component_name = temp_component['component_name']
component = cp.Component(component_name)
for elem in temp_component['in_out_signals']:
(signal_type, width, name) = elem
if signal_type == "input":
component.add_input(name, width)
elif signal_type == "output":
component.add_output(name, width)
elif signal_type == "inout":
component.add_inout(name, width)
else:
raise Exception("Definition error in_out_signals")
for elem in temp_component['option_signals']:
(signal_type, width, name) = elem
if signal_type == "reg":
component.add_reg(name, width)
elif signal_type == "wire":
component.add_wire(name, width)
else:
raise Exception("Definition error option_signals")
for communication in temp_component['communication']:
(dummy, com_type) = communication[0]
if com_type == "xillybus":
com_obj = com.Xillybus_fifo()
for elem in communication:
(specifier, paramter) = elem
if specifier == "rcv_cycle":
com_obj.set_rcv_cycle(paramter)
elif specifier == "snd_cycle":
com_obj.set_snd_cycle(paramter)
elif specifier == "condition":
com_obj.set_condition(paramter)
elif specifier == "fifo_width":
com_obj.set_fifo_width(paramter)
elif specifier == "rcv":
com_obj.assign("rcv", paramter)
elif specifier == "snd":
com_obj.assign("snd", paramter)
component.add_com(com_obj)
for userlogic in temp_component['userlogic']:
(dummy, userlogic_path) = userlogic[0]
(dummy, uut) = userlogic[1]
ul_in = ul.Info()
ul_in.get_userlogicinfo(userlogic_path)
ul_obj = ul.UserlogicBase(ul_in.name, uut)
ul_obj.ports = ul_in.ports
ul_obj.filepath = userlogic_path
for elem in userlogic:
(signame_u, signame_c) = elem
if signame_u != "userlogic_path" and signame_u != "instance_name":
ul_obj.assign(signame_u, signame_c)
component.add_ul(ul_obj)
if temp_component['generate_ros_package']:
component.ros_packaging()
component.show_info()
component.componentize()
def test_dependencies(self):
tmpdir = tempfile.mkdtemp()
#print('running test in temporary repo %s' % tmpdir)
cwd = os.getcwd()
try:
template1 = '[%s]' % metadata.DEPENDENCIES_SECTION
template2 = template1 + '''
%s: code,%s.trunk.1.1 use: reusable
%s: code,%s.trunk.1.1 use: reusable
'''
template3 = template1 + '''
%s: code,%s.trunk.2.1 use: reusable
%s: code,%s.trunk.1.1 use: reusable
'''
files = {
'a': template2 % ('b', 'b', 'c', 'c'),
'b': template1,
'c': template3 % ('b', 'b', 'd', 'd'),
'd': template1
}
testRepos = ['a', 'b', 'c', 'd']
for t in testRepos:
repoPath = os.path.join(tmpdir, 'trunk', t)
os.makedirs(os.path.join(tmpdir, 'trunk', t))
branchPath = repoPath + '/code'
#print('init %s' % branchPath)
vcs.init(branchPath, False)
filePath = branchPath + '/' + metadata.METADATA_FILE
save(filePath, files[t])
os.chdir(branchPath)
#print('adding %s' % filePath)
vcs.add(filePath)
#print('checking in %s' % filePath)
vcs.checkin(filePath, 'Test', True)
vcs.tag('%s.trunk.1.1 use: reusable' % t)
if t == 'b':
#subprocess.Popen(['bzr', 'tag', 'first'], stdout=subprocess.PIPE, stdin=subprocess.PIPE, stderr=subprocess.PIPE)
filePath = branchPath + '/dependencies2.txt'
save(filePath, files[t])
vcs.add(filePath)
vcs.checkin(filePath, 'Test', True)
vcs.tag('%s.trunk.2.1 use: reusable' % t)
#subprocess.Popen(['bzr', 'tags'])
working_repo = vcs.WorkingRepository()
working_repo._init(tmpdir, tmpdir, tmpdir)
prob = metadata.get_components_inv_dep_order(
working_repo, 'win_x64', 'a', tmpdir, 'trunk', '')
comp = [
component.Component('b', 'trunk', 'b.trunk.1.1 use: reusable',
'code'),
component.Component('d', 'trunk', 'd.trunk.1.1 use: reusable',
'code'),
component.Component('c', 'trunk', 'c.trunk.1.1 use: reusable',
'code'),
component.Component('a', 'trunk', 'a.trunk.1.1 use: reusable',
'code')
]
if False:
for c in comp:
print("comp = " + str(c))
for c in prob:
print("prob = " + str(c))
# prob will have buildscripts; comp doesn't
prob = [p for p in prob if p.name != 'buildscripts']
self.assertEquals(len(comp), len(prob))
for i in range(len(comp)):
self.assertEquals(comp[i].name, prob[i].name)
finally:
os.chdir(cwd)
shutil.rmtree(tmpdir)
def getComps(nodes):
""
comps = []
for i in nodes:
comp = component.Component()
keys = i.getElementsByTagName('data')
cId = ''
cName = ''
cOwner = ''
cUser = ''
cLang = ''
cUIcom = ''
cSanit = ''
cTransform = ''
cTransfer = ''
cTrust = ''
cDBint = ''
cTime = ''
cMaxmin = ''
cCalltpf = ''
cSpoof = ''
cTamper = ''
cEncryp = ''
cAttach = ''
cUError = ''
cCliSer = ''
cWeb = ''
cLogB = ''
cPCWS = ''
cAS = ''
cIS = ''
cNC = ''
cPC = ''
try:
for j in keys:
att = j.attributes["key"].value
if att == "id":
cId = j.childNodes[0].data
if att == "name":
cName = j.childNodes[0].data
if att == "owner":
cOwner = j.childNodes[0].data
if att == "user":
cUser = j.childNodes[0].data
if att == "language":
cLang = j.childNodes[0].data
if att == "userInterface":
cUIcom = j.childNodes[0].data
if att == "sanitize":
cSanit = j.childNodes[0].data
if att == "transformData":
cTransform = j.childNodes[0].data
if att == "transferData":
cTransfer = j.childNodes[0].data
if att == "trust":
cTrust = j.childNodes[0].data
if att == "databaseInteraction":
cDBint = j.childNodes[0].data
if att == "timeoutOperations":
cTime = j.childNodes[0].data
if att == "maxMinOperations":
cMaxmin = j.childNodes[0].data
if att == "remote3PartyCall":
cCalltpf = j.childNodes[0].data
if att == "spoofing":
cSpoof = j.childNodes[0].data
if att == "tampering":
cTamper = j.childNodes[0].data
if att == "encryption":
cEncryp = j.childNodes[0].data
if att == "attachment":
cAttach = j.childNodes[0].data
if att == "errorHandling":
cUError = j.childNodes[0].data
if att == "clientServer":
cCliSer = j.childNodes[0].data
if att == "webService":
cWeb = j.childNodes[0].data
if att == "logBackupCapability":
cLogB = j.childNodes[0].data
if att == "attackSurface":
cAS = j.childNodes[0].data
if att == "impactSurface":
cIS = j.childNodes[0].data
if att == "antecesores":
cPC = j.childNodes[0].data
if att == "predecesores":
cNC = j.childNodes[0].data
comp.attrib(cId, cName, cOwner, cUser, cLang, cUIcom, cSanit,
cTransform, cTransfer, cTrust, cDBint, cTime, cMaxmin,
cCalltpf, cSpoof, cTamper, cEncryp, cAttach, cUError,
cCliSer, cWeb, cLogB, 0, cAS, cIS, cNC, cPC)
comps.append(comp)
except:
print "Sorry:", sys.exc_info()[1]
print traceback.print_exc(file=sys.stdout)
return comps
