def dumpStandardObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpStandardObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpStandardObject.__name__,
message=argsStr)
# encode standard object
ugradedObject = copy(rawObject)
for attributeName, attributeValue in ugradedObject.__dict__.items():
jsonAttributValue = ComplexJsonEncoder.dumpComplexObject(
attributeValue)
setattr(ugradedObject, attributeName, jsonAttributValue)
pass
# add module & class references
setattr(ugradedObject, EncryptionMarkup.CLASS.value,
rawObject.__class__.__name__)
setattr(ugradedObject, EncryptionMarkup.MODULE.value,
rawObject.__module__)
# encode object
jsonObject = dumps(ugradedObject.__dict__)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpStandardObject.__name__,
message=jsonObject)
# return
return jsonObject
def loadIterableObject(jsonObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadIterableObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadIterableObject.__name__,
message=argsStr)
# initialize decode attributs
instantiatedObject = list()
# execute recursive decode
for rawAttributElement in jsonObject:
instantiatedAttributElement = ComplexJsonDecoder.loadComplexObject(
rawAttributElement)
instantiatedObject.append(instantiatedAttributElement)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadIterableObject.__name__,
message=instantiatedObject)
# return
return instantiatedObject
def dumpDictionnaryObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpDictionnaryObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpDictionnaryObject.__name__,
message=argsStr)
# initialize encoded attributs
jsonObject = dict()
# execute recursive encryption
for rawAttributKey, rawAttributValue in rawObject.items():
# INFO: in JSON, keys are always string when it can be everything in python
jsonKey = str(uuid4())
encodedAttributKey = ComplexJsonEncoder.dumpComplexObject(
rawAttributKey)
encodedAttributValue = ComplexJsonEncoder.dumpComplexObject(
rawAttributValue)
jsonObject[jsonKey] = [encodedAttributKey, encodedAttributValue]
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpDictionnaryObject.__name__,
message=jsonObject)
# return
return jsonObject
def status(pidFile):
# logger context
argsStr = methodArgsStringRepresentation(
signature(status).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
functionOrmethod=status.__name__,
message=argsStr)
# initialize state set
stateSet = set()
# only if a PID is registered
if isfile(pidFile):
# read PID file
with open(pidFile) as pidFileContent:
pidTuple = tuple(pidFileContent.readlines())
# check process
stateSet = set()
for pidString in pidTuple:
pidNumber = int(pidString)
state = None
# only if a process is associated to PID
if pid_exists(pidNumber):
process = Process(pidNumber)
state = process.status
stateSet.add(state)
# set state frozen set
stateFrozenset = frozenset(stateSet)
# logger output
logger.loadedLogger.output(__name__,
functionOrmethod=status.__name__,
message=stateFrozenset)
# return state
return stateFrozenset
def dumpUnserializablePrimitiveObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpUnserializablePrimitiveObject).
parameters, locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpUnserializablePrimitiveObject.__name__,
message=argsStr)
# encode with surrogate
rawObjectType = type(rawObject)
surrogateClass = UNSERIALIZABLE_TYPES[rawObjectType]
surrogateValue = surrogateClass(rawObject)
# (frozen)set is iterable
if surrogateClass in (SetSurrogate, FrozensetSurrogate):
surrogateValue.list = ComplexJsonEncoder.dumpIterableObject(
surrogateValue.list)
# encode object
jsonObject = dumps(surrogateValue.__dict__)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpUnserializablePrimitiveObject.__name__,
message=jsonObject)
# return
return jsonObject
def loadDictionaryObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadDictionaryObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadDictionaryObject.__name__,
message=argsStr)
# initialize encoded attributs
instantiatedObject = dict()
# execute recursive encryption
for rawAttributKey, rawAttributValue in rawObject.items():
instantiatedAttributPair = ComplexJsonDecoder.loadComplexObject(
rawAttributValue)
instantiatedAttributKey = instantiatedAttributPair[0]
instantiatedAttributValue = instantiatedAttributPair[1]
instantiatedObject[
instantiatedAttributKey] = instantiatedAttributValue
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadDictionaryObject.__name__,
message=instantiatedObject)
# return
return instantiatedObject
def loadStandardObject(dictObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadStandardObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadStandardObject.__name__,
message=argsStr)
# initialize encoded attributs
# instanciate object
instantiationClass = ComplexJsonDecoder.loadClass(
dictObject[EncryptionMarkup.MODULE.value],
dictObject[EncryptionMarkup.CLASS.value])
instantiatedObject = instantiationClass()
# remove markups
del dictObject[EncryptionMarkup.MODULE.value]
del dictObject[EncryptionMarkup.CLASS.value]
# instanciate all attributes recursively
for attributeName, attributeValue in dictObject.items():
instantiatedAttributValue = ComplexJsonDecoder.loadComplexObject(
attributeValue)
setattr(instantiatedObject, attributeName,
instantiatedAttributValue)
pass
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadStandardObject.__name__,
message=instantiatedObject)
# return
return instantiatedObject
def start(commandName, **commandArguments):
# logger context
argsStr = methodArgsStringRepresentation(
signature(start).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
functionOrmethod=start.__name__,
message=argsStr)
# parse arguments
argumentsParser = ArgumentParser()
argumentsParser.add_argument("module")
argumentsParser.add_argument(runMarkup,
help="running (not unit test)",
action="store_true")
argumentsParser.add_argument("--port")
argumentsParser.add_argument("--verbosity")
arguments = argumentsParser.parse_args()
# run if specified
if arguments.r:
commandName(**commandArguments)
else:
logger.loadedLogger.info(__name__,
functionOrmethod=start.__name__,
message="running as unit test")
# logger output
logger.loadedLogger.output(__name__, functionOrmethod=start.__name__)
def daemonize(customStart, customStop, customStatus):
# logger context
argsStr = methodArgsStringRepresentation(
signature(daemonize).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
functionOrmethod=daemonize.__name__,
message=argsStr)
# parse parameters
parser = ArgumentParser()
parser.add_argument("action", help="start|stop|status", type=str)
args = parser.parse_args()
# start
if args.action == "start":
customStart()
# stop
elif args.action == "stop":
customStop()
# status
elif args.action == "status":
customStatus()
# bad action
else:
raise Exception("Unknown command")
# logger output
logger.loadedLogger.output(__name__, functionOrmethod=daemonize.__name__)
def dumpIterableObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpIterableObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpIterableObject.__name__,
message=argsStr)
# initialize encoded attributs
jsonObject = list()
# execute recursive encryption
for rawAttributElement in rawObject:
encodedAttributElement = ComplexJsonEncoder.dumpComplexObject(
rawAttributElement)
jsonObject.append(encodedAttributElement)
# encode tuple with surrogate
if type(rawObject) == tuple:
surrogateTuple = TupleSurrogate(jsonObject)
jsonObject = dumps(surrogateTuple.__dict__)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpIterableObject.__name__,
message=jsonObject)
# return
return jsonObject
def loadComplexObject(jsonObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadComplexObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadComplexObject.__name__,
message=argsStr)
# type of JSON object
jsonObjectType = type(jsonObject)
# filter the kind of string : primitive or complexe
stringComplexeFilterage = frozenset([
encryptionMarkup in str(jsonObject)
for encryptionMarkup in EncryptionMarkup.listValues()
])
# decode None object
if jsonObject == NONE:
instantiatedObject = ComplexJsonDecoder.loadNoneObject()
# decode JSON primitive object
elif jsonObjectType in (bool, int, float) or (
jsonObjectType == str and True not in stringComplexeFilterage):
instantiatedObject = ComplexJsonDecoder.loadJsonPrimitiveObject(
jsonObject)
# decode iterable object
elif jsonObjectType == list:
instantiatedObject = ComplexJsonDecoder.loadIterableObject(
jsonObject)
# decode dictionnary object
elif jsonObjectType == dict:
instantiatedObject = ComplexJsonDecoder.loadDictionaryObject(
jsonObject)
# decode standard or 'unserializable primitive' object
else:
dictObject = loads(jsonObject)
# decode unserializable primitive object
if EncryptionMarkup.SURROGATE_TYPE.value in dictObject:
instantiatedObject = ComplexJsonDecoder.loadUnserializablePrimitiveObject(
dictObject)
# decode standard object
else:
instantiatedObject = ComplexJsonDecoder.loadStandardObject(
dictObject)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadComplexObject.__name__,
message=instantiatedObject)
# return instantiated object
return instantiatedObject
def dumpNoneObject():
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpNoneObject).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpNoneObject.__name__,
message=argsStr)
# encode identical
jsonObject = NONE
# logger output
logger.loadedLogger.output(__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpNoneObject.__name__,
message=jsonObject)
# return
return jsonObject
def loadNoneObject():
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadNoneObject).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadNoneObject.__name__,
message=argsStr)
# encode identical
instantiatedObject = None
# logger output
logger.loadedLogger.output(__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadNoneObject.__name__,
message=instantiatedObject)
# return
return instantiatedObject
def __init__(self, width=0, height=0, image=[], label="", pattern=""):
# logger context
argsStr = methodArgsStringRepresentation(
signature(TestData.__init__).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
TestData.__name__,
TestData.__init__.__name__,
message=argsStr)
# construct object
self.width = width
self.height = height
self.image = image
self.label = label
self.pattern = pattern
# logger output
logger.loadedLogger.output(__name__, TestData.__name__,
TestData.__init__.__name__)
def loadClass(moduleName, className):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadClass).parameters, locals())
# logger input
logger.loadedLogger.input(
__name__,
functionOrmethod=ComplexJsonDecoder.loadClass.__name__,
message=argsStr)
# load class
importedModule = import_module(moduleName)
loadedClass = getattr(importedModule, className)
# logger output
logger.loadedLogger.output(
__name__,
functionOrmethod=ComplexJsonDecoder.loadClass.__name__,
message=loadedClass)
# return
return loadedClass
def load(fileName):
# logger context
argsStr = methodArgsStringRepresentation(
signature(TestData.__init__).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
TestData.__name__,
TestData.__init__.__name__,
message=argsStr)
# construct object
file = open(fileName, "rt")
jsonTestData = file.read()
file.close()
testData = ComplexJsonDecoder.loadComplexObject(jsonTestData)
# logger output
logger.loadedLogger.output(__name__, TestData.__name__,
TestData.__init__.__name__, testData)
# return
return testData
def dumpComplexObject(rawObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonEncoder.dumpComplexObject).parameters,
locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpComplexObject.__name__,
message=argsStr)
# encode None object
if rawObject is None:
jsonObject = ComplexJsonEncoder.dumpNoneObject()
# encode JSON primitive object
elif type(rawObject) in (bool, int, float, str):
jsonObject = ComplexJsonEncoder.dumpJsonPrimitiveObject(rawObject)
# encode unserializable primitive object
elif type(rawObject) in UNSERIALIZABLE_TYPES.keys():
jsonObject = ComplexJsonEncoder.dumpUnserializablePrimitiveObject(
rawObject)
# encode iterable object
elif type(rawObject) in (list, tuple):
jsonObject = ComplexJsonEncoder.dumpIterableObject(rawObject)
# encode dictionnary object
elif type(rawObject) == dict:
jsonObject = ComplexJsonEncoder.dumpDictionnaryObject(rawObject)
# encode standard object
else:
jsonObject = ComplexJsonEncoder.dumpStandardObject(rawObject)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonEncoder.__name__,
ComplexJsonEncoder.dumpComplexObject.__name__,
message=jsonObject)
# return
return jsonObject
def stop(pidFile):
# logger context
argsStr = methodArgsStringRepresentation(
signature(stop).parameters, locals())
# logger input
logger.loadedLogger.input(__name__,
functionOrmethod=stop.__name__,
message=argsStr)
# only if a PID is registered
if isfile(pidFile):
# read PID file
with open(pidFile) as pidFileContent:
pidTuple = tuple(pidFileContent.readlines())
# kill process (if exists)
for pidString in pidTuple:
pidNumber = int(pidString)
# only if a process is associated to PID
if pid_exists(pidNumber):
kill(pidNumber, SIGTERM)
# remove files
remove(pidFile)
# logger output
logger.loadedLogger.output(__name__, functionOrmethod=stop.__name__)
def loadUnserializablePrimitiveObject(dictObject):
# logger context
argsStr = methodArgsStringRepresentation(
signature(ComplexJsonDecoder.loadUnserializablePrimitiveObject).
parameters, locals())
# logger input
logger.loadedLogger.input(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadUnserializablePrimitiveObject.__name__,
message=argsStr)
# load class
instantiationClass = ComplexJsonDecoder.loadClass(
__name__, dictObject[EncryptionMarkup.SURROGATE_TYPE.value])
# decode with surrogate
instantiatedObject = instantiationClass.convertToFinalObject(
dictObject)
# (frozen)set and tuple are iterable
if instantiationClass in (SetSurrogate, FrozensetSurrogate,
TupleSurrogate):
instantiatedObject = ComplexJsonDecoder.loadIterableObject(
instantiatedObject)
if instantiationClass == SetSurrogate:
instantiatedObject = set(instantiatedObject)
elif instantiationClass == FrozensetSurrogate:
instantiatedObject = frozenset(instantiatedObject)
else:
instantiatedObject = tuple(instantiatedObject)
# logger output
logger.loadedLogger.output(
__name__,
ComplexJsonDecoder.__name__,
ComplexJsonDecoder.loadUnserializablePrimitiveObject.__name__,
message=instantiatedObject)
# return
return instantiatedObject
