def getSettingInjectionListFromSettingValue(settingValue): if ObjectHelper.isList(settingValue): allElements = [] for element in settingValue: elements = getSettingInjectionListFromSettingValue(element) if ObjectHelper.isList(elements): allElements += elements return allElements elif ObjectHelper.isNotNone(settingValue) and StringHelper.isNotBlank( settingValue): splitedSettingValue = settingValue.split(OPEN_SETTING_INJECTION) settingValueList = [] completeSettingValue = c.NOTHING for segment in splitedSettingValue if settingValue.startswith( OPEN_SETTING_INJECTION) else splitedSettingValue[1:]: if ObjectHelper.isNotNone(segment) and StringHelper.isNotBlank( segment): if ObjectHelper.isNotNone(segment.count( c.OPEN_DICTIONARY)) and not segment.count( c.OPEN_DICTIONARY) == segment.count( c.CLOSE_DICTIONARY) and 0 < segment.count( c.OPEN_DICTIONARY): completeSettingValue += segment else: splitedSegment = segment.split(CLOSE_SETTING_INJECTION) completeSettingValue += splitedSegment[0] if ObjectHelper.isNotNone( completeSettingValue) and StringHelper.isNotBlank( completeSettingValue): settingValueList.append( f'{OPEN_SETTING_INJECTION}{completeSettingValue}{CLOSE_SETTING_INJECTION}' ) completeSettingValue = c.NOTHING return settingValueList return []
def getValue(value): filteredValue = StringHelper.filterString(value) if isSettingValue(filteredValue): if StringHelper.isNotBlank(filteredValue): if c.OPEN_LIST == filteredValue[0]: return getList(filteredValue) elif c.OPEN_TUPLE == filteredValue[0]: return getTuple(filteredValue) elif c.OPEN_DICTIONARY == filteredValue[0]: return getDictionary(filteredValue) elif c.OPEN_SET == filteredValue[0]: return getSet(filteredValue) parsedValue = None try: parsedValue = int(filteredValue) except: try: parsedValue = float(filteredValue) except: try: parsedValue = filteredValue if not filteredValue is None: if filteredValue == c.TRUE: parsedValue = True elif filteredValue == c.FALSE: parsedValue = False except: parsedValue = filteredValue return parsedValue return filteredValue
def prettyJson( origin, message, dictionaryInstance, quote = c.DOUBLE_QUOTE, tabCount = 0, nullValue = c.NULL_VALUE, trueValue = c.TRUE_VALUE, falseValue = c.FALSE_VALUE, logLevel = LOG, condition = True ) : if condition : stdout, stderr = EnvironmentHelper.getCurrentSoutStatus() prettyJsonValue = StringHelper.prettyJson( dictionaryInstance, quote = quote, tabCount = tabCount, nullValue = nullValue, trueValue = trueValue, falseValue = falseValue, withColors = SettingHelper.activeEnvironmentIsLocal(), joinAtReturn = False ) LogHelperHelper.softLog(origin, StringHelper.join([message, c.COLON_SPACE, *prettyJsonValue]), logLevel) EnvironmentHelper.overrideSoutStatus(stdout, stderr)
def appendSettingKey(nodeKey, settingKey): if StringHelper.isNotBlank(nodeKey): if StringHelper.isNotBlank(settingKey): return f'{nodeKey}{c.DOT}{settingKey}' else: return nodeKey elif StringHelper.isNotBlank(settingKey): return settingKey else: return None
def keepSearching(keywordQuery, tree, querySet, history=None): if ObjectHelper.isDictionary(tree): for key in tree.keys(): if StringHelper.isNotBlank(history): newHistory = f'{history}.{key}' else: newHistory = f'{key}' if StringHelper.isNotBlank(keywordQuery) and key == keywordQuery: querySet[newHistory] = tree[key] keepSearching(keywordQuery, tree[key], querySet, history=newHistory)
def getFilteredSetting(settingKey, settingValue, nodeKey, settingTree): # print(f'getFilteredSetting: settingValue: "{settingValue}"') if StringHelper.isNotBlank(settingValue): settingEvaluationList = settingValue.split(c.COLON) if len(settingEvaluationList) > 1: defaultSettingValue = c.COLON.join( settingValue.split(c.COLON)[1:]).strip() # print(f' defaultSettingValue: {defaultSettingValue}') else: defaultSettingValue = c.NONE if isSettingInjection(defaultSettingValue): return getSettingInjectionValue(settingKey, defaultSettingValue, nodeKey, settingTree) return StringHelper.filterString(defaultSettingValue) # print(f' settingValue: {settingValue}') return settingValue
def softLog(origin, message, level, exception=None, muteStackTrace=False, newLine=False): if ObjectHelper.isNotNone(exception): hardLog(origin, message, exception, level, muteStackTrace=muteStackTrace) elif c.TRUE == getStatus(level): firstLayerColor, secondLayerColor, tirdLayerColor, resetColor = getColors( level) LogHelper.logIt( StringHelper.join([ firstLayerColor, LEVEL_DICTIONARY[level][LOG_TEXT], *getOriginPortion(origin, tirdLayerColor, resetColor), secondLayerColor, message, resetColor, getNewLine(newLine, exception=exception, muteStackTrace=muteStackTrace) ])) elif not c.FALSE == getStatus(level): levelStatusError(method, level)
def containsValidSettingInjection(settingValue): if ObjectHelper.isNotNone(settingValue) and StringHelper.isNotBlank( settingValue) and 0 < settingValue.count( OPEN_SETTING_INJECTION) and settingValue.count( c.OPEN_DICTIONARY) == settingValue.count( c.CLOSE_DICTIONARY): splitedSettingValue = settingValue.split(OPEN_SETTING_INJECTION) settingValueList = [] completeSettingValue = c.NOTHING for segment in splitedSettingValue if settingValue.startswith( OPEN_SETTING_INJECTION) else splitedSettingValue[1:]: if ObjectHelper.isNotNone(segment): if ObjectHelper.isNotNone(segment.count( c.OPEN_DICTIONARY)) and not segment.count( c.OPEN_DICTIONARY) == segment.count( c.CLOSE_DICTIONARY) and 0 < segment.count( c.OPEN_DICTIONARY): completeSettingValue += segment else: splitedSegment = segment.split(CLOSE_SETTING_INJECTION) completeSettingValue += splitedSegment[0] settingValueList.append( f'{OPEN_SETTING_INJECTION}{completeSettingValue}{CLOSE_SETTING_INJECTION}' ) completeSettingValue = c.NOTHING return len(splitedSettingValue) == len( settingValueList) if settingValue.startswith( OPEN_SETTING_INJECTION) else len( splitedSettingValue) == len(settingValueList) + 1 elif ObjectHelper.isList(settingValue): return containsValidSettingInjection(str(settingValue)) return False
def lineAproved(settingLine): approved = True if c.NEW_LINE == settingLine: approved = False if c.HASH_TAG in settingLine: filteredSettingLine = StringHelper.filterString(settingLine) if filteredSettingLine is None or c.NOTHING == filteredSettingLine or c.NEW_LINE == filteredSettingLine: approved = False return approved
def getTracebackMessage(muteStackTrace) : tracebackMessage = c.BLANK try : tracebackMessage = traceback.format_exc() except : tracebackMessage = f'{c.NEW_LINE}' if muteStackTrace : return StringHelper.join(tracebackMessage.split(c.NEW_LINE)[-2:], character=c.NEW_LINE) return LogHelperHelper.NO_TRACEBACK_PRESENT_MESSAGE if LogHelperHelper.NO_TRACEBACK_PRESENT == str(tracebackMessage) else tracebackMessage
def update(environmentKey, environmentValue, default=None) : if ObjectHelper.isNotEmpty(environmentKey) : associatedValue = None if not environmentValue is None : associatedValue = str(StringHelper.filterString(environmentValue)) OS.environ[environmentKey] = associatedValue elif not default is None : associatedValue = str(StringHelper.filterString(default)) OS.environ[environmentKey] = associatedValue else : try: delete(environmentKey) except Exception as exception : LogHelper.warning(update, f'Failed to delete "{environmentKey}" enviroment variable key', exception=exception) return associatedValue else : LogHelper.debug(update, f'arguments: environmentKey: {environmentKey}, environmentValue: {environmentValue}, default: {default}') raise Exception(f'Error associating environment variable "{environmentKey}" key to environment variable "{environmentValue}" value')
def logEnvironmentSettings(): try: LogHelper.setting(logEnvironmentSettings, StringHelper.prettyJson(EnvironmentHelper.getSet())) except Exception as exception: LogHelper.failure( logEnvironmentSettings, 'Not possible do get a pretty json from EnvironmentHelper.getSet()', exception) LogHelper.setting(logEnvironmentSettings, EnvironmentHelper.getSet())
def querySetting(keywordQuery, tree): if StringHelper.isBlank(keywordQuery) or ObjectHelper.isNotDictionary( tree): LogHelper.warning( querySetting, f'''Not possible to parse "{tree}". It's either is not a dictionary or "{keywordQuery}" keyword query is blank''' ) querySet = {} SettingHelperHelper.keepSearching(keywordQuery, tree, querySet) return querySet
def updateSettingValue(settingKey, settingValue, nodeKey, settingTree, isSameDepth=False, isSettingInjection=False): # print(f'settingKey: {settingKey}, settingValue: {settingValue}, nodeKey: {nodeKey}, settingTree: {settingTree}, isSameDepth: {isSameDepth}') if StringHelper.isNotBlank(settingKey) and ObjectHelper.isNotNone( settingKey): # print(f'accessTree({nodeKey},{settingTree})[{settingKey}]: {accessTree(nodeKey,settingTree)}[{settingKey}]') # print(f'type(accessTree(nodeKey,settingTree)): {type(accessTree(nodeKey,settingTree))}') accessTree(nodeKey, settingTree)[settingKey] = getSettingValueOrNewNode( nodeKey, settingKey, settingValue, isSameDepth=isSameDepth, isSettingInjection=isSettingInjection) elif StringHelper.isNotBlank(nodeKey) and ObjectHelper.isNotNone(nodeKey): splittedNodeKey = nodeKey.split(c.DOT) if 1 < len(splittedNodeKey): accessSettingKey = splittedNodeKey[-1] accessNodeKey = c.DOT.join(splittedNodeKey[:-1]) else: accessSettingKey = splittedNodeKey[-1] accessNodeKey = None accessTree(accessNodeKey, settingTree)[accessSettingKey] = getSettingValueOrNewNode( nodeKey, settingKey, settingValue, isSameDepth=isSameDepth, isSettingInjection=isSettingInjection) else: errorMessage = 'Node key and setting key cannot be None at the same time' exception = Exception(errorMessage) LogHelper.error( updateSettingValue, f'Error parsing settingKey: "{settingKey}", settingValue: {settingValue}, nodeKey: {nodeKey}, settingTree: {StringHelper.prettyPython(settingTree)}', errorMessage) raise exception
def getSetting(nodeKey, settingTree): setting = None try: setting = SettingHelperHelper.accessTree(nodeKey, settingTree) except Exception as exception: LogHelper.failure( getSetting, f'Not possible to get {nodeKey} node key. Returning "{setting}" by default', exception) return StringHelper.filterString(setting) if isinstance(setting, str) else setting
def parseToPattern(given, pattern=DEFAULT_DATETIME_PATTERN, timedelta=False): given = given.strip() if StringHelper.isNotBlank(given): parsed = datetime.datetime.strptime(given, pattern) if timedelta and pattern in TIME_PATTERN_LIST: return datetime.timedelta(hours=parsed.hour, minutes=parsed.minute, seconds=parsed.second, milliseconds=0, microseconds=0) if pattern in DATETIME_PATTERN_LIST: return parsed elif pattern in DATE_PATTERN_LIST: return parsed.date() elif pattern in TIME_PATTERN_LIST: return parsed.time()
def updateSettingTree(toUpdateSettingTree, gatheringSettingTree): if ObjectHelper.isNotEmpty(gatheringSettingTree): if ObjectHelper.isNone(toUpdateSettingTree) or StringHelper.isBlank( toUpdateSettingTree): toUpdateSettingTree = {} if ObjectHelper.isCollection( gatheringSettingTree) and ObjectHelper.isDictionary( gatheringSettingTree): for key, value in gatheringSettingTree.items(): if ObjectHelper.isNotEmpty(value) and ObjectHelper.isNotNone( value): if key not in toUpdateSettingTree or ObjectHelper.isEmpty( toUpdateSettingTree[key]): toUpdateSettingTree[key] = value else: updateSettingTree(toUpdateSettingTree[key], gatheringSettingTree[key]) elif key not in toUpdateSettingTree: toUpdateSettingTree[key] = value
def handleLongStringOrSetting(settingKey, settingValue, nodeKey, settingTree, longStringCapturing, quoteType, longStringList, settingInjectionList, isSameDepth): # print(f'handleLongStringOrSetting: settingValue: {settingValue}') if StringHelper.isLongString(settingValue): longStringCapturing = True splitedSettingValueAsString = settingValue.split(c.TRIPLE_SINGLE_QUOTE) if c.TRIPLE_SINGLE_QUOTE in settingValue and splitedSettingValueAsString and c.TRIPLE_DOUBLE_QUOTE not in splitedSettingValueAsString[ 0]: quoteType = c.TRIPLE_SINGLE_QUOTE else: quoteType = c.TRIPLE_DOUBLE_QUOTE longStringList = [settingValue + c.NEW_LINE] else: nodeKey = updateSettingTreeAndReturnNodeKey(settingKey, settingValue, nodeKey, settingTree, isSameDepth) filteredSettingValue = getFilteredSetting(settingKey, settingValue, nodeKey, settingTree) return settingKey, filteredSettingValue, nodeKey, longStringCapturing, quoteType, longStringList
def getDictionary(value): splitedValue = value[1:-1].split(c.COLON) keyList = [] for index in range(len(splitedValue) - 1): keyList.append( StringHelper.filterString(splitedValue[index].split( c.COMA)[-1].strip())) valueList = [] valueListSize = len(splitedValue) - 1 for index in range(valueListSize): if index == valueListSize - 1: correctValue = splitedValue[index + 1].strip() else: correctValue = c.COMA.join(splitedValue[index + 1].split( c.COMA)[:-1]).strip() valueList.append(getValue(correctValue)) resultantDictionary = dict() for index in range(len(keyList)): resultantDictionary[keyList[index]] = valueList[index] return resultantDictionary
def getColors(level): if SettingHelper.LOCAL_ENVIRONMENT == EnvironmentHelper.get( SettingHelper.ACTIVE_ENVIRONMENT): firstLayerColor = LEVEL_DICTIONARY.get(level).get( FIRST_LAYER_COLOR ) if LEVEL_DICTIONARY.get(level) and LEVEL_DICTIONARY.get(level).get( FIRST_LAYER_COLOR) else c.NOTHING secondLayerColor = LEVEL_DICTIONARY.get(level).get( SECOND_LAYER_COLOR ) if LEVEL_DICTIONARY.get(level) and LEVEL_DICTIONARY.get(level).get( SECOND_LAYER_COLOR) else c.NOTHING tirdLayerColor = c.MUTTED_COLOR if c.MUTTED_COLOR else c.NOTHING resetColor = c.RESET_COLOR if c.RESET_COLOR else c.NOTHING else: firstLayerColor = c.NOTHING secondLayerColor = c.NOTHING tirdLayerColor = c.NOTHING resetColor = c.NOTHING return (firstLayerColor, secondLayerColor, tirdLayerColor, resetColor) if StringHelper.isNotBlank(firstLayerColor) else ( c.NOTHING, c.NOTHING, c.NOTHING, c.NOTHING)
def printMessageLog(level, message, condition=False, muteStackTrace=False, newLine=True, margin=True, exception=None): if condition: firstLayerColor, secondLayerColor, tirdLayerColor, resetColor = getColors( level) LogHelper.logIt( StringHelper.join([ c.TAB if margin else c.NOTHING, firstLayerColor, LEVEL_DICTIONARY[level][LOG_TEXT], secondLayerColor, message, *getErrorPortion(exception, muteStackTrace, firstLayerColor, secondLayerColor, tirdLayerColor, resetColor), resetColor, getNewLine(newLine, exception=exception, muteStackTrace=muteStackTrace) ]))
def accessTree(nodeKey, tree): if ObjectHelper.isNotNone(tree): strippedNodeKey = nodeKey.strip() if ObjectHelper.isEmpty(nodeKey): returnTree = None try: returnTree = StringHelper.filterString(tree) except Exception as exception: LogHelper.failure( accessTree, f'Failed to get filtered string from {tree} tree. Returning it the way it is by default', exception) returnTree = tree return returnTree elif isinstance(nodeKey, str): nodeKeyList = nodeKey.split(c.DOT) if len(nodeKeyList) == 1: nextNodeKey = c.NOTHING else: nextNodeKey = c.DOT.join(nodeKeyList[1:]) return accessTree(nextNodeKey, tree.get(nodeKeyList[0]))
def getArgsOrder(targetClass): noneArgs = [] noneInstance = instanciateItWithNoArgsConstructor(targetClass, amountOfNoneArgs=0, args=noneArgs) strArgs = [] for arg in range(len(noneArgs)): strArgs.append(RandomHelper.string(minimum=10)) try: instance = targetClass(*strArgs) instanceDataDictionary = getAttributeDataDictionary(instance) argsOrderDictionary = {} for key, value in instanceDataDictionary.items(): if StringHelper.isNotBlank(value): argsOrderDictionary[strArgs.index(value)] = key argsOrder = [ argsOrderDictionary[key] for key in sorted(argsOrderDictionary) ] except Exception as exception: errorMessage = f'Not possible to get args order from "{getName(targetClass)}" target class' LogHelper.error(getArgsOrder, errorMessage, exception) raise Exception(errorMessage) return argsOrder
def getTestModuleNames(runOnly, ignore, globalsInstance): testsToRun = [] if ObjectHelper.isNone( runOnly) or ObjectHelper.isNotCollection(runOnly) else runOnly testsToIgnore = [] if ObjectHelper.isNone( ignore) or ObjectHelper.isNotCollection(ignore) else ignore runSpecificTests = ObjectHelper.isNotEmpty(testsToRun) LogHelper.prettyPython(getTestModuleNames, f'runSpecificTests: {runSpecificTests}, testsToRun', testsToRun, logLevel=LogHelper.TEST) testModuleNames = [] if ObjectHelper.isEmpty(testsToRun): testQueryTree = SettingHelper.querySetting(TEST_PACKAGE, globalsInstance.apiTree) LogHelper.prettyPython(getTestModuleNames, 'Test query tree', testQueryTree, logLevel=LogHelper.TEST) testModuleNames += getTestModuleNamesFromQuerryTree( testQueryTree, runOnly, ignore) else: for testName in testsToIgnore: if testName in testsToRun: testModuleNames, testsToRun, runSpecificTests.remove(testName) for testName in testsToRun: testNameSplitted = testName.split(c.DOT) testModuleName = c.NOTHING if 2 == len(testNameSplitted): testModuleName = testNameSplitted[-2] if testModuleName not in testModuleNames and StringHelper.isNotBlank( testName): testModuleNames.append(testModuleName) LogHelper.prettyPython(getTestModuleNames, 'Test module names', testModuleNames, logLevel=LogHelper.TEST) return testModuleNames, testsToRun, runSpecificTests
def getStrReturn( key, value, collectionType, quote, prettyFunction, tabCount, nullValue, trueValue, falseValue, withColors ) : valueValue = prettyFunction( value, quote = quote, tabCount = tabCount, nullValue = nullValue, trueValue = trueValue, falseValue = falseValue, withColors = withColors, joinAtReturn = False ) if c.TYPE_DICT == collectionType : filteredAndColoredQuote = getFilteredAndColoredQuote(key, quote, prettyFunction, withColors, c.QUOTE_PROMPT_COLOR) filteredAndColoredColonSpace = getItAsColoredString(c.COLON_SPACE, prettyFunction, withColors, color=c.COLON_PROMPT_COLOR) return [tabCount * c.TAB, *filteredAndColoredQuote, *getItAsColoredString(key if StringHelper.prettyPython==prettyFunction else StringHelper.filterString(prettyFunction(key, quote=quote, tabCount=tabCount, nullValue=nullValue, trueValue=trueValue, falseValue=falseValue)), prettyFunction, withColors), *filteredAndColoredQuote, *filteredAndColoredColonSpace, *valueValue] else : return [tabCount * c.TAB, *valueValue]
def returnStr(strReturn, joinAtReturn) : return strReturn if not joinAtReturn else StringHelper.join(strReturn)
def getStatus(level): status = LogHelper.LOG_HELPER_SETTINGS.get(level) return status if isinstance( status, str) and StringHelper.isNotBlank(status) else c.TRUE
def isEmpty(thing): return StringHelper.isBlank(thing) if isinstance( thing, str) else isNone(thing) or isEmptyCollection(thing)
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
def getAttibuteValue(settingLine): possibleValue = StringHelper.filterString(settingLine) return getValue(c.COLON.join(possibleValue.split(c.COLON)[1:]))