def verifyConfiguration(self, mesh): """ Verify compatibility of configuration. """ OutputManager.verifyConfiguration(self, mesh) ModuleOutputSolnSubset.verifyConfiguration(self, mesh) return
def verifyConfiguration(self, mesh):
"""
Verify compatibility of configuration.
"""
OutputManager.verifyConfiguration(self, mesh)
ModuleOutputSolnSubset.verifyConfiguration(self, mesh)
return
def _getVersionInfo(self, noteId, output=True):
'''
prints and returns a list of the versions of the given note
:param noteId:
:param output:
:return:
'''
# a list with a list of objects that start with "v"
allVersions = self._downloadAllNoteVersions()
self._swiftMngr.downloadNotes()
# a list with the content for each object
noteList = self._swiftMngr.getDownloadedNotes()
note = self._swiftMngr.getNote(noteId)
title = note.getTitle()
# a list of all the versions with a continuos Id
versions = self.historyList(noteId,
self.arrangeNoteVersions(allVersions),
title)
# rearanges the ids so each note's versions start counting from 1
# rearangedVersions = self.rearangeVersionID(versions)
if output:
# nicely prints the versions list
OutputManager.listPrint(versions, 3)
return note, title, versions, noteList
def setup():
"""Setup the Connection Node"""
log("Setup Starting")
global discovery_service # pylint: disable=C0103
global output_manger # pylint: disable=C0103
global uid # pylint: disable=C0103
# Capture exit signals and run cleanup
for sig in (signal.SIGABRT, signal.SIGILL, signal.SIGINT, \
signal.SIGSEGV, signal.SIGTERM):
signal.signal(sig, cleanup)
# Generate ID
uid = uuid.uuid4()
log("UUID generated: " + str(uid), level=0)
# Start Descovery Service
discovery_service = DiscoveryService(uid, DISCOVERY_PORT)
discovery_service.daemon = True
discovery_service.start()
threads.append(discovery_service)
# Start Output Manager
output_manger = OutputManager()
output_manger.daemon = True
output_manger.start()
threads.append(output_manger)
def searchInMushroom(self, substr):
elementList = self._searchInMushroomImpl(substr)
for element in elementList:
OutputManager.searchMDPrint(
element[0] +
" - " +
element[1],
element[2])
def _configure(self):
"""
Set members based using inventory.
"""
OutputManager._configure(self)
self.vertexDataFields = self.inventory.vertexDataFields
self.cellInfoFields = self.inventory.cellInfoFields
return
def searchInTitle(self, subString):
elementList = self._searchInTitleImpl(subString)
elementDict = {}
for elements in elementList:
id = elements[0]
elementDict[id] = elements
sorted(elementDict)
OutputManager.listPrint(elementDict, OutputManager.HEADER_FULL)
def _configure(self):
"""
Set members based using inventory.
"""
OutputManager._configure(self)
self.vertexDataFields = self.inventory.vertexDataFields
self.cellInfoFields = self.inventory.cellInfoFields
return
def _configure(self):
"""
Set members based using inventory.
"""
try:
OutputManager._configure(self)
except ValueError, err:
aliases = ", ".join(self.aliases)
raise ValueError("Error while configuring output over points "
"(%s):\n%s" % (aliases, err.message))
def __init__(self, name="outputsoln"):
"""
Constructor.
"""
OutputManager.__init__(self, name)
self.availableFields = {
"vertex": {"info": [], "data": ["displacement", "velocity"]},
"cell": {"info": [], "data": []},
}
return
def _configure(self):
"""
Set members based using inventory.
"""
try:
OutputManager._configure(self)
ModuleOutputSolnSubset.label(self, self.label)
except ValueError, err:
aliases = ", ".join(self.aliases)
raise ValueError("Error while configuring output over boundary " "(%s):\n%s" % (aliases, err.message))
def _configure(self):
"""
Set members based using inventory.
"""
try:
OutputManager._configure(self)
except ValueError, err:
aliases = ", ".join(self.aliases)
raise ValueError("Error while configuring output over points "
"(%s):\n%s" % (aliases, err.message))
def _configure(self):
"""
Set members based using inventory.
"""
try:
OutputManager._configure(self)
ModuleOutputSolnSubset.label(self, self.label)
except ValueError, err:
aliases = ", ".join(self.aliases)
raise ValueError("Error while configuring output over boundary "
"(%s):\n%s" % (aliases, err.message))
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
self.submesh = self.subdomainMesh(mesh)
OutputManager.initialize(self, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
self.submesh = self.subdomainMesh(mesh)
OutputManager.initialize(self, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="outputsolnpoints"):
"""
Constructor.
"""
OutputManager.__init__(self, name)
self.availableFields = \
{'vertex': \
{'info': [],
'data': ["displacement","velocity"]},
'cell': \
{'info': [],
'data': []}}
return
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
import weakref
self.mesh = weakref.ref(mesh)
OutputManager.initialize(self, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
import weakref
self.mesh = weakref.ref(mesh)
OutputManager.initialize(self, normalizer)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="outputsolnsubset"):
"""
Constructor.
"""
OutputManager.__init__(self, name)
self.availableFields = \
{'vertex': \
{'info': [],
'data': ["displacement","velocity"]},
'cell': \
{'info': [],
'data': []}}
return
def listNotesAndMeta(self):
list = self._swiftManager.downloadObjectIds()
soDict = {}
sort = Configuration.entriessort
for element in list:
# exclude versions and deleted notes, that always begin with 'v'
if VersionManager.isVersionOrDeleted(element):
continue
id = SwiftManager.objIdToId(element)
if id is None:
raise RuntimeError(
"Can not get the ID from " +
element +
" ... should not happen, really")
metamngr = self._swiftManager.metaManagerFactory(element)
id = int(id)
crdate = metamngr.getCreateDate()
lastmod = metamngr.getLastModifiedDate()
tags = metamngr.getTags()
name = SwiftManager.objIdToTitle(element)
soDict[id] = [id, name, crdate, lastmod, tags]
if sort == "name":
soDict = OrderedDict(
sorted(
soDict.items(),
key=lambda k_v: k_v[1][1]))
elif sort == "crdate":
soDict = OrderedDict(
sorted(
soDict.items(),
key=lambda k_v1: datetime.strptime(
k_v1[1][2],
"%H:%M:%S, %d/%m/%Y").isoformat(),
reverse=True))
elif sort == "id":
sorted(soDict)
else:
soDict = OrderedDict(
sorted(
soDict.items(),
key=lambda k_v2: datetime.strptime(
k_v2[1][3],
"%H:%M:%S, %d/%m/%Y").isoformat(),
reverse=True))
OutputManager.listPrint(soDict, OutputManager.HEADER_FULL)
def diffVersions(self, noteId):
'''
creates the diff of two versions of a note
:param noteId:
:return:
'''
if self._swiftManager.doesNoteExist(noteId) == True:
note, title, versions, noteList = self._versionMngr._getVersionInfo(
noteId)
# user input for id, if the input is not an integer the error
# message will be displayed
try:
diff1 = int(
raw_input("ID of base version? (0 is the current version) > "))
diff2 = int(
raw_input("ID of target version? (0 is the current version) > "))
except (ValueError):
print "invalid input"
sys.exit(1)
# check if the user wants to diff with the current note
if diff1 == 0:
diff1Content = self._swiftManager.getNote(noteId).getContent()
elif diff2 == 0:
diff2Content = self._swiftManager.getNote(noteId).getContent()
# append 0, because it's valid but not a key
self._keyList.append(0)
for key, value in versions.iteritems():
self._keyList.append(key)
diffTitle = versions[key][1]
# check which input is which note
if key == diff1:
diff1Content = noteList[diffTitle]
elif key == diff2:
diff2Content = noteList[diffTitle]
# as an information for the user, that the version doesn't exist
if diff1 not in self._keyList:
print str(diff1) + " doesn't exist"
elif diff2 not in self._keyList:
print str(diff2) + " doesn't exist"
OutputManager.printDiff(diff1Content, diff2Content)
# as an information for the user
else:
print "Note #" + str(noteId) + " doesn't exist"
def searchInTags(self, substr):
'''
for every object in list check for tags
check if tags are the same
if tags in element meta
print element name
'''
elementList = self._searchInTagsImpl(substr)
dict = {}
for elements in elementList:
id = elements[0]
dict[id] = elements
sorted(dict)
OutputManager.listPrint(dict, OutputManager.HEADER_TAG)
def printMeta(self, metaId):
'''
prints the metadata of a single note
:param metaId:
:return:
'''
dict = {}
note = self.getNote(metaId)
mm = self.metaManagerFactory(note.getObjectId())
name = SwiftManager.objIdToTitle(note.getObjectId())
crDate = mm.getCreateDate()
lastmod = mm.getLastModifiedDate()
tags = mm.getTags()
dict[metaId] = [metaId, name, crDate, lastmod, tags]
sorted(dict)
OutputManager.listPrint(dict, OutputManager.HEADER_FULL)
def printMeta(self, metaId):
'''
prints the metadata of a single note
:param metaId:
:return:
'''
dict = {}
note = self.getNote(metaId)
mm = self.metaManagerFactory(note.getObjectId())
name = SwiftManager.objIdToTitle(note.getObjectId())
crDate = mm.getCreateDate()
lastmod = mm.getLastModifiedDate()
tags = mm.getTags()
dict[metaId] = [metaId, name, crDate, lastmod, tags]
sorted(dict)
OutputManager.listPrint(dict, OutputManager.HEADER_FULL)
def searchEverything(self, substr):
'''
this function searches for a substring, it doesn't matter if it is in title, content or tags, if there are results
they will be printed.
:param substr:
:return:
'''
titleMatch = self._searchInTitleImpl(substr)
tagMatch = self._searchInTagsImpl(substr)
contentMatch = self._searchInMushroomImpl(substr)
generalMatch = []
title = {}
tag = {}
content = {}
for element in titleMatch:
title[str(element[0])] = str(element[1])
for element in tagMatch:
tag[str(element[0])] = [str(element[1]), element[2]]
for element in contentMatch:
content[str(element[0])] = [str(element[1]), element[2]]
generalMatch = set(title.keys() + tag.keys() + content.keys())
for element in generalMatch:
if element in tag.keys() and element in content.keys():
OutputManager.searchEverythingPrint(
element,
content[element][0],
tag,
content[element][1])
elif element in content.keys():
OutputManager.searchEverythingPrint(
element,
content[element][0],
None,
content[element][1])
elif element in tag.keys():
OutputManager.searchEverythingPrint(
element,
tag.values()[0][0],
tag.values()[0][1])
elif element in title.keys():
OutputManager.searchEverythingPrint(element, title.values()[0])
else:
print "nothing found"
def getDeletedInfo(self, output=True):
'''
prints and returns a list of backed up notes
:param output:
:return:
'''
allDeleted = self._downloadAllDeleted()
deletedList = {}
deletedId = 0
for element in allDeleted:
# assign an id to all objects and save it in a dict
deletedId = deletedId + 1
deletedList[deletedId] = [deletedId, element]
if output:
# nicely prints the backed up notes list
OutputManager.listPrint(deletedList, 4)
return deletedList
def deleteList(self, idList):
nameList = []
for id in idList:
if self._swiftManager.doesNoteExist(id):
note = self._swiftManager.getNote(id)
title = str(note.getTitle())
nameList.append((str(id), title))
else:
print "Note #" + str(id) + " doesn't exist."
sys.exit(1)
action = "delete note(s)"
OutputManager.printListedNotes(nameList)
if self._swiftManager.confirmation(action):
for id, title in nameList:
# deleted versions are created here
self._versionMngr.deleteVersionCreator(id, title)
self._swiftManager.deleteNote(id, force=True)
print "Ok"
else:
print "Abort"
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
OutputManager.initialize(self, normalizer)
# Read points
self.stations,points = self.reader.read()
# Convert to mesh coordinate system
from spatialdata.geocoords.Converter import convert
convert(points, mesh.coordsys(), self.coordsys)
ModuleOutputSolnPoints.setupInterpolator(self, mesh, points, normalizer)
self.mesh = ModuleOutputSolnPoints.pointsMesh(self)
self._eventLogger.eventEnd(logEvent)
return
def readVersion(self, noteId):
'''
outputs the content of a note version
:param noteId:
:return:
'''
if self._swiftManager.doesNoteExist(noteId) == True:
note, title, versions, noteList = self._versionMngr._getVersionInfo(
noteId)
# user input for id, if the input is not an integer the error
# message will be displayed
try:
readingVersion = int(
raw_input("Which version do you wish to read (id)? >"))
except (ValueError):
print "invalid input"
sys.exit(1)
for key, value in versions.iteritems():
self._keyList.append(key)
if key == readingVersion:
versionTitle = versions[key][1]
# get the content of the object
content = noteList[versionTitle]
# create the note title, composing from "vTIMESTAMP-id -
# title"
noteTitle = versionTitle + \
OutputManager.ID_TITLE_SEPERATOR + title
OutputManager.markdownPrint(noteTitle, content)
else:
continue
# as an information for the user, that the version doesn't exist
if readingVersion not in self._keyList:
print str(readingVersion) + " doesn't exist"
# as an information for the user, that the note doesn't exist
else:
print "Note #" + str(noteId) + " doesn't exist"
def initialize(self, mesh, normalizer):
"""
Initialize output manager.
"""
logEvent = "%sinit" % self._loggingPrefix
self._eventLogger.eventBegin(logEvent)
OutputManager.initialize(self, normalizer)
# Read points
stations, points = self.reader.read()
# Convert to mesh coordinate system
from spatialdata.geocoords.Converter import convert
convert(points, mesh.coordsys(), self.coordsys)
ModuleOutputSolnPoints.setupInterpolator(self, mesh, points, stations,
normalizer)
self.mesh = ModuleOutputSolnPoints.pointsMesh(self)
self._eventLogger.eventEnd(logEvent)
return
def __init__(self, name="outputfaultimpulses"):
"""
Constructor.
"""
OutputManager.__init__(self, name)
return
def __init__(self, name="outputfaultkin"): """ Constructor. """ OutputManager.__init__(self, name) return
def __init__(self, name="outputmatelastic"): """ Constructor. """ OutputManager.__init__(self, name) return
def __init__(self, name="outputdirichlet"):
"""
Constructor.
"""
OutputManager.__init__(self, name)
return
def _readNote(self, note):
OutputManager.markdownPrint(note.getTitle(), note.getContent())
def preinitialize(self): """ Do """ OutputManager.preinitialize(self, dataProvider=self) return
def __init__(self, name="outputneumann"): """ Constructor. """ OutputManager.__init__(self, name) return
def __init__(self, name="outputdirichlet"): """ Constructor. """ OutputManager.__init__(self, name) return
def preinitialize(self):
"""
Do
"""
OutputManager.preinitialize(self, dataProvider=self)
return
