def settingTreeInnerLoop(settingLine, nodeKey, settingTree,
longStringCapturing, quoteType, longStringList,
settingInjectionList, lazyLoad, isSameDepth):
# print(f'settingTreeInnerLoop: nodeKey: {nodeKey}')
# print(f' isSameDepth: {isSameDepth}')
settingKey, settingValue = getAttributeKeyValue(settingLine)
# print(f' settingKey: {settingKey}, settingValue: {settingValue}')
# print(f' value:{settingLine}')
if containsSettingInjection(settingValue):
try:
settingKey, settingValue, nodeKey, longStringCapturing, quoteType, longStringList = handleSettingInjection(
settingKey, settingValue, nodeKey, settingTree,
longStringCapturing, quoteType, longStringList,
settingInjectionList, lazyLoad, isSameDepth)
except Exception as exception:
LogHelper.log(
settingTreeInnerLoop,
f'Not possible to handle association of "{nodeKey}{c.DOT}{settingKey}" setting key to "{settingValue}" setting value',
exception=exception)
settingInjectionList.append({
SETTING_KEY: settingKey,
SETTING_VALUE: settingValue,
SETTING_NODE_KEY: nodeKey
})
return settingKey, settingValue, nodeKey, longStringCapturing, quoteType, longStringList
else:
# print(f' nodeKey: {nodeKey}')
settingKey, filteredSettingValue, nodeKey, longStringCapturing, quoteType, longStringList = handleLongStringOrSetting(
settingKey, settingValue, nodeKey, settingTree,
longStringCapturing, quoteType, longStringList,
settingInjectionList, isSameDepth)
# print(f'----------> nodeKey: {nodeKey}')
return settingKey, filteredSettingValue, nodeKey, longStringCapturing, quoteType, longStringList
def safelyAccessTree(nodeKey, settingTree):
setting = None
try:
setting = accessTree(nodeKey, settingTree)
except Exception as exception:
LogHelper.log(
safelyAccessTree,
f'Not possible to safely access "{nodeKey}" node key while looping through setting tree. Returning "{setting}" by default',
exception=exception)
return setting
def handleSettingInjectionListByCallingHandler(done, stuck,
isSettingInjectionCount,
containsSettingInjectionCount,
settingInjection, settingTree,
settingInjectionList,
fallbackSettingTree, handler):
try:
if isSettingInjection(settingInjection[SETTING_VALUE]):
settingInjection[SETTING_VALUE] = handler(
settingInjection[SETTING_KEY],
settingInjection[SETTING_VALUE],
settingInjection[SETTING_NODE_KEY],
settingTree,
fallbackSettingTree=fallbackSettingTree)
settingInjectionArgs = list(
settingInjection.values()) + [settingTree]
updateSettingValue(*settingInjectionArgs, isSettingInjection=True)
if not containsSettingInjection(settingInjection[SETTING_VALUE]):
settingInjectionList.remove(settingInjection)
isSettingInjectionCount += 1
stuck = False
elif containsSettingInjection(settingInjection[SETTING_VALUE]):
settingInjectionListFromSettingValue = getSettingInjectionListFromSettingValue(
settingInjection[SETTING_VALUE])
newSettingInjection = settingInjection[SETTING_VALUE]
for settingValue in settingInjectionListFromSettingValue:
newSettingValue = handler(
settingInjection[SETTING_KEY],
settingValue,
settingInjection[SETTING_NODE_KEY],
settingTree,
fallbackSettingTree=fallbackSettingTree)
if ObjectHelper.isList(newSettingInjection):
for index, element in enumerate(newSettingInjection):
if settingValue == element:
newSettingInjection[index] = newSettingValue
else:
newSettingInjection = newSettingInjection.replace(
settingValue, str(newSettingValue))
settingInjection[SETTING_VALUE] = newSettingInjection
settingInjectionArgs = list(
settingInjection.values()) + [settingTree]
updateSettingValue(*settingInjectionArgs, isSettingInjection=True)
if not containsSettingInjection(settingInjection[SETTING_VALUE]):
settingInjectionList.remove(settingInjection)
containsSettingInjectionCount += 1
stuck = False
except Exception as exception:
LogHelper.log(
handleSettingInjectionListByCallingHandler,
f'Ignored exception while handling {StringHelper.prettyPython(settingInjection)} setting injection list',
exception=exception)
return done, stuck, isSettingInjectionCount, containsSettingInjectionCount
def safelyGetSettingInjectionValue(settingKey,
settingValue,
nodeKey,
settingTree,
fallbackSettingTree=None):
exception = None
newSettingValue = None
try:
newSettingValue = getSettingInjectionValue(settingKey, settingValue,
nodeKey, settingTree)
except Exception as e:
exception = e
LogHelper.log(
safelyGetSettingInjectionValue,
f'Not possible to load "{settingKey}" setting key from setting tree. Now trying to load it from fallback setting tree',
exception=exception)
if ObjectHelper.isNone(newSettingValue) and ObjectHelper.isNotNone(
fallbackSettingTree):
return getSettingInjectionValue(settingKey, settingValue, nodeKey,
fallbackSettingTree)
if ObjectHelper.isNotNone(exception):
raise exception
return newSettingValue
def equals(expected,
toAssert,
ignoreKeyList=None,
ignoreCharactereList=None,
visitedIdInstances=None,
muteLogs=True):
if isNone(expected) or isNone(toAssert):
return expected is None and toAssert is None
if isNativeClass(type(expected)):
return expected == toAssert
if isNone(visitedIdInstances):
visitedIdInstances = []
if isDictionary(expected) and isDictionary(toAssert):
innerIgnoreCharactereList = [c.SPACE]
if isNotNone(ignoreCharactereList):
innerIgnoreCharactereList += ignoreCharactereList
filteredResponse = StringHelper.filterJson(
str(sortIt(filterIgnoreKeyList(expected, ignoreKeyList))),
extraCharacterList=innerIgnoreCharactereList)
filteredExpectedResponse = StringHelper.filterJson(
str(sortIt(filterIgnoreKeyList(toAssert, ignoreKeyList))),
extraCharacterList=innerIgnoreCharactereList)
return filteredResponse == filteredExpectedResponse
elif isCollection(expected) and isCollection(toAssert):
areEquals = True
try:
for a, b in zip(expected, toAssert):
areEquals = equals(a,
b,
ignoreKeyList=ignoreKeyList,
ignoreCharactereList=ignoreCharactereList,
visitedIdInstances=visitedIdInstances,
muteLogs=muteLogs)
if not areEquals:
break
return areEquals
except Exception as exception:
areEquals = False
LogHelper.log(
equals,
f'Different arguments in {expected} and {toAssert}. Returning "{areEquals}" by default',
exception=exception)
else:
if isNotNone(toAssert) and id(toAssert) not in visitedIdInstances:
areEquals = True
try:
if not muteLogs:
LogHelper.prettyPython(equals,
f'expected',
expected,
logLevel=LogHelper.DEBUG,
condition=not muteLogs)
LogHelper.prettyPython(equals,
f'toAssert',
toAssert,
logLevel=LogHelper.DEBUG,
condition=not muteLogs)
areEquals = True and ObjectHelperHelper.leftEqual(
expected, toAssert, visitedIdInstances,
muteLogs=muteLogs) and ObjectHelperHelper.leftEqual(
toAssert,
expected,
visitedIdInstances,
muteLogs=muteLogs)
except Exception as exception:
areEquals = False
LogHelper.log(
equals,
f'Different arguments in {expected} and {toAssert}. Returning "{areEquals}" by default',
exception=exception)
visitedIdInstances.append(id(toAssert))
return areEquals
else:
return True
