def test_ExportArchiFolderModels(cleandir):
if __name__ == u"__main__":
cleandir()
assert (os.path.isfile(fileArchimateTest) is True)
al = ArchiLib(fileArchimateTest)
folder = u"Scenarios"
logger.info(u"Exporting Folder : %s" % folder)
listMTE = al.getModelsInFolder(folder)
assert (listMTE is not None)
logger.info(u"len(listMTE) = %d" % len(listMTE))
assert (len(listMTE) == 2)
concepts = Concepts(u"Export", u"Pickle")
for ModelToExport in listMTE:
logger.info(u" Model : %s" % ModelToExport)
d = concepts.addConceptKeyType(ModelToExport, u"Model")
al.recurseModel(ModelToExport)
al.outputCSVtoFile(concepts, fileExport=fileCSVExport)
assert (os.path.isfile(fileCSVExport) is True)
Concepts.saveConcepts(concepts, fileConceptsExport)
logger.info(u"Save Concepts : %s" % fileConceptsExport)
assert (os.path.isfile(fileConceptsExport) is True)
def test_ExportArchi(cleandir):
if __name__ == u"__main__":
cleandir()
logger.info(u"Using : %s" % fileArchimateTest)
assert (os.path.isfile(fileArchimateTest) is True)
al = None
concepts = None
al = ArchiLib(fileArchimateTest)
assert (al is not None)
concepts = Concepts(u"Node", u"Nodes")
assert (concepts is not None)
logger.info(u"Found %d Nodes" % len(al.dictNodes))
logger.info(u"Found %d Edges" % len(al.dictEdges))
assert (len(al.dictNodes) == 45)
assert (len(al.dictEdges) == 36)
count = 0
listTSort = list()
for x in al.dictEdges.keys():
logger.info(u"[%s]=%s" % (al.dictEdges[x][u"id"], x))
if u"source" in al.dictEdges[x]:
source = al.dictEdges[x][u"source"]
target = al.dictEdges[x][u"target"]
logger.info(u" Rel : %s" % (al.dictEdges[x][ARCHI_TYPE]))
sourceName = al.getNodeName(source)
targetName = al.getNodeName(target)
logger.info(
u" %s--%s--%s" %
(sourceName, al.dictEdges[x][ARCHI_TYPE][10:], targetName))
sc = concepts.addConceptKeyType(
sourceName, al.dictNodes[source][ARCHI_TYPE][10:])
# getWords(sourceName, sc)
tc = sc.addConceptKeyType(targetName,
al.dictNodes[target][ARCHI_TYPE][10:])
# getWords(sourceName, tc)
Concepts.saveConcepts(concepts, fileConceptsExport)
assert (len(concepts.cd) == 17)
assert (os.path.isfile(fileConceptsExport) is True)
assert (concepts.typeName == u"Nodes")
def __init__(self, fileArchimate):
self.fileArchimate = fileArchimate
logger.info(u"Using : %s" % self.fileArchimate)
self.al = ArchiLib(fileArchimate)
self.concepts = Concepts(u"BusinessProcess", u"archimate:BusinessProcess")
def exportArchiFolderModels(self, folder):
logger.info(u"Exporting Folder : %s" % folder)
listMTE = self.al.getModelsInFolder(folder)
concepts = Concepts(u"Export", u"Pickle")
for ModelToExport in listMTE:
logger.info(u" Model : %s" % ModelToExport)
d = concepts.addConceptKeyType(ModelToExport, u"Model")
self.al.recurseModel(ModelToExport, d)
self.al.outputCSVtoFile(concepts, fileCSVExport)
Concepts.saveConcepts(concepts, self.conceptsFile)
logger.info(u"Save Concepts : %s" % self.conceptsFile)
def test_ExportArchiModel(cleandir):
if __name__ == u"__main__":
cleandir()
assert (os.path.isfile(fileArchimateTest) is True)
al = ArchiLib(fileArchimateTest)
listMTE = list()
listMTE.append(u"01. Market to Leads")
concepts = Concepts(u"Export", u"Model")
for ModelToExport in listMTE:
al.recurseModel(ModelToExport)
Concepts.saveConcepts(concepts, fileConceptsExport)
assert (os.path.isfile(fileConceptsExport) is True)
al.outputCSVtoFile(concepts, fileCSVExport)
assert (os.path.isfile(fileCSVExport) is True)
def test_ArchimateConcepts(cleandir):
if __name__ == u"__main__":
cleandir()
logger.info(u"Using : %s" % fileArchimateTest)
assert (os.path.isfile(fileArchimateTest) is True)
concepts = Concepts(fileConceptsArch, u"Archimate")
al = ArchiLib(fileArchimateTest)
#
# Create Concepts from Archimate
#
al.folderConcepts(concepts)
Concepts.saveConcepts(concepts, fileConceptsArch)
logger.info(u"Saved concepts to : %s" % fileConceptsArch)
assert (os.path.isfile(fileConceptsArch) is True)
def __init__(self, fileCrawl, fileArchimate):
self.EMU = 914400.0
self.fileArchimate = fileArchimate
self.path_to_presentation = fileCrawl
self.dictNodes = dict()
self.dictEdges = dict()
self.dictText = dict()
self.dictNodeXY = dict()
self.dictTextXY = dict()
self.al = ArchiLib(fileArchimate)
self.graph = GraphVizGraph()
# self.graph = NetworkXGraph()
# self.graph = PatternGraph()
self.prs = Presentation(self.path_to_presentation)
self.concepts = Concepts(u"Application", u"Relations")
def analyzeNamedEntities(self):
rels = (u"archimate:AccessRelationship",
u"archimate:SpecialisationRelationship",
u"archimate:CompositionRelationship",
u"archimate:AggregationRelationship")
listType = (u"archimate:Requirement", )
dictEntities = self.al.getTypeNodes(listType)
concepts = Concepts(u"Entities", u"BusinessObject")
for x in self.al.dictEdges.keys():
try:
logger.debug(u"[%s]=%s" %
(x, self.al.dictEdges[x][ARCHI_TYPE]))
source = self.al.dictEdges[x][u"source"]
target = self.al.dictEdges[x][u"target"]
logger.debug(u" Source : %s" % source)
logger.debug(u" Target : %s" % target)
except:
logger.warn(u"[%s] ARCH_TYPE Exception" % (x))
continue
if self.al.dictEdges[x][ARCHI_TYPE] in rels:
logger.info(u"%s -> [ %s ] -> %s" %
(self.al.dictNodes[source][u"name"][:20],
self.al.dictEdges[x][ARCHI_TYPE],
self.al.dictNodes[target][u"name"][:20]))
listNodes = self.al.getEdgesForNode(source, rels)
for x in listNodes:
logger.debug(u" %s" % (x))
Concepts.saveConcepts(concepts, fileConceptsRelations)
def dependancyAnalysis(self, listTSort):
index = 0
for x in listTSort:
logger.debug(u"%d %s[%s] -%s-> %s[%s]" % (index, self.al.dictNodes[x[0]][u"name"], self.al.dictNodes[x[0]][ARCHI_TYPE], u"UsedBy",
self.al.dictNodes[x[1]][u"name"], self.al.dictNodes[x[1]][ARCHI_TYPE]))
index += 1
self.al.addToNodeDict(self.al.dictNodes[x[0]][u"name"], self.al.dictBP)
self.al.addToNodeDict(self.al.dictNodes[x[1]][u"name"], self.al.dictBP)
logger.info(u"Topic Sort Candidates : %d" % (len(listTSort)))
nodes = list()
index = 0
dictTasks = dict()
for x in listTSort:
sname = self.al.dictNodes[x[0]][u"name"]
tname = self.al.dictNodes[x[1]][u"name"]
index += 1
logger.debug(u"%d %s -%s-> %s" % (index, sname, u"UsedBy", tname))
if sname in dictTasks:
ln = dictTasks[sname]
ln.append(tname)
else:
ln = list()
ln.append(tname)
dictTasks[sname] = ln
for x in dictTasks.keys():
logger.debug(u"dictTasks[%s]=%s" % (x, dictTasks[x]))
a = Task(x, dictTasks[x])
nodes.append(a)
for x in self.al.dictBP.keys():
# for x in listBP:
if x not in dictTasks:
logger.debug(u"Add %s" % (x))
a = Task(x, list())
nodes.append(a)
self.format_nodes(nodes)
conceptBatches = Concepts(u"Batch", u"archimate:WorkPackage")
n = 0
logger.info(u"Batches:")
batches = self.get_task_batches(nodes)
for bundle in batches:
n += 1
name = u"Batch %d" % n
c = conceptBatches.addConceptKeyType(name, u"archimate:WorkPackage")
for node in bundle:
c.addConceptKeyType(node.name, u"archimate:BusinessProcess")
logger.info(u"%d : %s" % (n, ", ".join(node.name.lstrip() for node in bundle)))
Concepts.saveConcepts(conceptBatches, fileConceptsBatches)
return conceptBatches
def exportArchi(self):
m = hashlib.md5()
concepts = Concepts(u"Node", u"Nodes")
logger.info(u"Found %d Nodes" % len(self.al.dictNodes))
logger.info(u"Found %d Edges" % len(self.al.dictEdges))
count = 0
listTSort = list()
for x in self.al.dictEdges.keys():
logger.debug(u"Edge [%s]=%s" % (self.al.dictEdges[x], x))
if self.al.dictEdges[x].has_key(
u"source") and self.al.dictEdges[x].has_key(u"target"):
typeEdge = self.al.dictEdges[x][ARCHI_TYPE]
logger.debug(u"Edge : %s" % typeEdge)
source = self.al.dictEdges[x][u"source"]
logger.debug(u"Source : %s" % source)
target = self.al.dictEdges[x][u"target"]
logger.debug(u"Target : %s" % target)
logger.debug(u" Rel : %s" %
(self.al.dictEdges[x][ARCHI_TYPE]))
sourceName = self.al.getNodeName(source)
targetName = self.al.getNodeName(target)
logger.debug(
u" %s--%s--%s" %
(sourceName, self.al.dictEdges[x][ARCHI_TYPE][10:],
targetName))
if source in self.al.dictNodes:
l = list()
sc = concepts.addConceptKeyType(
sourceName, self.al.dictNodes[source][ARCHI_TYPE][10:])
# getWords(sourceName, sc)
nameEdge = u"(" + sourceName + u"," + targetName + u")"
logger.debug(u"nameEdge : %s[%d]" % (nameEdge, len(nameEdge)))
logger.debug(u"typeEdge : %s" % typeEdge[10:])
ne = str(self.al.cleanString(nameEdge))
hl = hashlib.sha224(str(ne)).hexdigest()
logger.debug(u"hash : %s" % hl)
nh = u"%s-%s" % (typeEdge[10:], hl)
rc = sc.addConceptKeyType(nh, typeEdge[10:])
if self.al.dictNodes.has_key(target):
tc = rc.addConceptKeyType(
targetName, self.al.dictNodes[target][ARCHI_TYPE][10:])
# getWords(sourceName, tc)
Concepts.saveConcepts(concepts, self.fileConceptsExport)
return concepts
