def prettifyPerformance():
# arrange
TEST_SIZE = 100
dictionaryToPrettify = {}
for index in range(TEST_SIZE):
dictionaryToPrettify[f'key_{index}'] = DICTIONARY_INSTANCE
# act
performanceTime = 0
performanceTimeInit = time.time()
toAssertPython = StringHelper.prettyPython(dictionaryToPrettify,
tabCount=1,
withColors=True)
toAssertJson = StringHelper.prettyJson(dictionaryToPrettify,
tabCount=1,
withColors=True)
performanceTime += time.time() - performanceTimeInit
###- 10000 returning f'{strInstance}{strInstance}' : 365.3402144908905 seconds
###- 10000 returning ''.join([strInstance, strInstance]) : 46.94538736343384 seconds
# assert
assert ObjectHelper.isNotNone(toAssertPython) and StringHelper.isNotBlank(
toAssertPython)
assert ObjectHelper.isNotNone(toAssertJson) and StringHelper.isNotBlank(
toAssertJson)
log.test(
prettifyPerformance,
f'performance time on a {len(str(dictionaryToPrettify))} dictionary size: {performanceTime} seconds',
None)
def __init__(self,
message=None,
logMessage=None,
status=None,
logResource=None,
logResourceMethod=None,
verb=None,
url=None,
logPayload=None,
logHeaders=None,
context=None):
self.timeStamp = DateTimeHelper.now()
self.status = HttpStatus.map(DEFAULT_STATUS if ObjectHelper.
isNone(status) else status).enumValue
self.message = message if ObjectHelper.isNotEmpty(
message
) and StringHelper.isNotBlank(
message
) else DEFAULT_MESSAGE if 500 <= self.status else self.status.enumName
self.verb = verb if ObjectHelper.isNotNone(
verb) else self.getRequestVerb()
self.url = url if ObjectHelper.isNotNone(url) else self.getRequestUrl()
self.logMessage = DEFAULT_LOG_MESSAGE if ObjectHelper.isNone(
logMessage) or StringHelper.isBlank(logMessage) else logMessage
self.logResource = DEFAULT_LOG_RESOURCE if ObjectHelper.isNone(
logResource) else logResource
self.logResourceMethod = DEFAULT_LOG_RESOURCE_METHOD if ObjectHelper.isNone(
logResourceMethod) else logResourceMethod
self.logPayload = logPayload if ObjectHelper.isNotNone(
logPayload) else self.getRequestBody()
self.logHeaders = logHeaders if ObjectHelper.isNotNone(
logHeaders) else self.getRequestHeaders()
self.context = HttpDomain.CONTROLLER_CONTEXT if ObjectHelper.isNone(
context) else context
def getErrorMessage(clientResponse, exception=None):
completeErrorMessage = f'{HttpClientConstant.ERROR_AT_CLIENT_CALL_MESSAGE}{c.DOT_SPACE}{HttpClientConstant.CLIENT_DID_NOT_SENT_ANY_MESSAGE}'
errorMessage = HttpClientConstant.CLIENT_DID_NOT_SENT_ANY_MESSAGE
possibleErrorMessage = None
bodyAsJson = {}
try :
bodyAsJson = clientResponse.json()
except Exception as innerException :
bodyAsJsonException = FlaskUtil.safellyGetResponseJson(clientResponse)
log.log(getErrorMessage, f'Invalid client response: {bodyAsJsonException}', exception=innerException)
log.debug(getErrorMessage, f'Not possible to get error message from client response: {bodyAsJsonException}. Proceeding with value {bodyAsJson} by default', exception=innerException, muteStackTrace=True)
try:
if ObjectHelper.isNotNone(clientResponse):
if ObjectHelper.isDictionary(bodyAsJson):
possibleErrorMessage = bodyAsJson.get('message', bodyAsJson.get('error')).strip()
if ObjectHelper.isList(bodyAsJson) and 0 < len(bodyAsJson):
possibleErrorMessage = bodyAsJson[0].get('message', bodyAsJson[0].get('error')).strip()
if ObjectHelper.isNotNone(possibleErrorMessage) and StringHelper.isNotBlank(possibleErrorMessage):
errorMessage = f'{c.LOG_CAUSE}{possibleErrorMessage}'
else:
log.debug(getErrorMessage, f'Client response {FlaskUtil.safellyGetResponseJson(clientResponse)}')
exceptionPortion = HttpClientConstant.ERROR_AT_CLIENT_CALL_MESSAGE if ObjectHelper.isNone(exception) or StringHelper.isBlank(exception) else str(exception)
completeErrorMessage = f'{exceptionPortion}{c.DOT_SPACE}{errorMessage}'
except Exception as exception:
log.warning(getErrorMessage, f'Not possible to get error message. Returning {completeErrorMessage} by default', exception=exception)
return completeErrorMessage
def buildApplicationPath(self):
if ObjectHelper.isNotEmpty(self.filePath):
self.currentPath = f'{str(Path(self.filePath).parent.absolute())}{EnvironmentHelper.OS_SEPARATOR}'
else:
self.currentPath = f'{str(Path(__file__).parent.absolute())}{EnvironmentHelper.OS_SEPARATOR}'
self.log(f'{self.__class__.__name__}{c.DOT}filePath: {self.filePath}')
self.log(
f'{self.__class__.__name__}{c.DOT}currentPath: {self.currentPath}')
self.localPath = str(Path.home())
if not self.localPath[-1] == str(EnvironmentHelper.OS_SEPARATOR):
self.localPath = f'{self.localPath}{EnvironmentHelper.OS_SEPARATOR}'
self.log(
f'{self.__class__.__name__}{c.DOT}localPath: {self.localPath}')
self.baseApiPath = Globals.BASE_API_PATH
self.apiPath = self.currentPath.split(self.baseApiPath)[0]
self.log(f'{self.__class__.__name__}{c.DOT}apiPath: {self.apiPath}')
lastLocalPathPackage = self.localPath.split(
EnvironmentHelper.OS_SEPARATOR)[-2]
firstBaseApiPath = self.baseApiPath.split(
EnvironmentHelper.OS_SEPARATOR)[0]
lastLocalPathPackageNotFound = True
self.apiPackage = c.NOTHING
for currentPackage in self.currentPath.split(
EnvironmentHelper.OS_SEPARATOR):
if lastLocalPathPackageNotFound:
if currentPackage == lastLocalPathPackage:
lastLocalPathPackageNotFound = False
elif not currentPackage or currentPackage == firstBaseApiPath:
break
else:
self.apiPackage = currentPackage
self.log(
f'{self.__class__.__name__}{c.DOT}apiPackage: {self.apiPackage}')
if StringHelper.isNotBlank(self.apiPackage):
if len(
self.currentPath.split(self.localPath)[1].split(
self.apiPackage)) > 1:
self.apisRoot = self.currentPath.split(
self.localPath)[1].split(self.apiPackage)[0]
self.apisPath = f'{self.currentPath.split(self.apiPackage)[0]}'
else:
self.apisRoot = c.NOTHING
self.apisPath = c.NOTHING
self.log(f'{self.__class__.__name__}{c.DOT}apisRoot: {self.apisRoot}')
self.log(f'{self.__class__.__name__}{c.DOT}apisPath: {self.apisPath}')
def getDefaultBodyException(exception=None):
try:
bodyErrorResponse = {
'message': exception.message,
'timestamp': str(exception.timeStamp)
}
except:
bodyErrorResponse = {
'message': DEFAULT_MESSAGE,
'timestamp': str(DateTimeHelper.now())
}
uriIfAny = FlaskUtil.safellyGetPath()
if ObjectHelper.isNotNone(uriIfAny) and StringHelper.isNotBlank(uriIfAny):
bodyErrorResponse['uri'] = uriIfAny
return bodyErrorResponse
def innerMethodWrapper(resourceInstanceMethod, *innerMethodArgs,
**innerMethodKwargs):
log.debug(SchedulerMethod,
f'''wrapping {resourceInstanceMethod.__name__}''')
apiInstance = FlaskManager.getApi()
methodClassName = ReflectionHelper.getMethodClassName(
resourceInstanceMethod)
methodName = ReflectionHelper.getName(resourceInstanceMethod)
methodKwargs['id'] = methodKwargs.get(
'id', f'{methodClassName}{c.DOT}{methodName}')
instancesUpTo = methodKwargs.pop('instancesUpTo', 1)
weekDays = methodKwargs.pop('weekDays', None)
if ObjectHelper.isNotEmpty(
methodArgs
) and SchedulerType.CRON == methodArgs[0] and ObjectHelper.isNotNone(
weekDays) and StringHelper.isNotBlank(weekDays):
methodKwargs['day_of_week'] = weekDays
if ObjectHelper.isNotNone(instancesUpTo):
methodKwargs['max_instances'] = instancesUpTo
shedulerArgs = [*methodArgs]
shedulerKwargs = {**methodKwargs}
@apiInstance.scheduler.task(*shedulerArgs, **shedulerKwargs)
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstanceName = methodClassName[:-len(
FlaskManager.KW_SCHEDULER_RESOURCE)]
resourceInstanceName = f'{resourceInstanceName[0].lower()}{resourceInstanceName[1:]}'
args = FlaskManager.getArgumentInFrontOfArgs(
args,
ReflectionHelper.getAttributeOrMethod(
apiInstance.resource.scheduler, resourceInstanceName))
resourceInstance = args[0]
methodReturn = None
try:
FlaskManager.validateArgs(args, requestClass,
innerResourceInstanceMethod)
methodReturn = resourceInstanceMethod(*args, **kwargs)
except Exception as exception:
FlaskManager.raiseGlobalException(exception, resourceInstance,
resourceInstanceMethod)
log.log(innerResourceInstanceMethod,
f'Not possible to run {shedulerId} properly',
exception=exception)
return methodReturn
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceInstanceMethod)
return innerResourceInstanceMethod
def getText(self, tag):
text = StringHelper.join([
str(t) for t in tag.strings if StringHelper.isNotBlank(
StringHelper.join(str(t).split(), character=c.BLANK).replace(
c.SPACE, c.BLANK))
],
character=c.NEW_LINE)
constant = 40
for i in range(constant):
if i < constant - 1:
text = text.replace(
GoogleSearchConstants.TOKENT_TEXT_SEPARATOR *
(constant - i), c.BLANK)
else:
text = text.replace(
GoogleSearchConstants.TOKENT_TEXT_SEPARATOR, c.SPACE)
return text
def wrapedFunction(*args, **kwargs):
try:
functionReturn = function(*args, **kwargs)
except Exception as exception:
if isinstance(exception, GlobalException):
raise exception
logMessage = str(exception) if StringHelper.isNotBlank(
str(exception)) else LOG_MESSAGE_NOT_PRESENT
functionName = ReflectionHelper.getName(
function, typeName=c.TYPE_FUNCTION)
log.wrapper(
EncapsulateItWithGlobalException,
f'''Failed to execute "{functionName}(args={args}, kwargs={kwargs})" {c.TYPE_FUNCTION} call''',
exception)
raise GlobalException(
message=message,
logMessage=logMessage,
logResource=ReflectionHelper.getParentClass(function),
logResourceMethod=function,
status=HttpStatus.map(
encapsulateItWithGlobalExceptionStatus).enumValue)
return functionReturn
def innerMethodWrapper(resourceMethod, *innerMethodArgs,
**innerMethodKwargs):
log.wrapper(SchedulerMethod, f'''wrapping {resourceMethod.__name__}''')
apiInstance = FlaskManager.getApi()
methodClassName = ReflectionHelper.getMethodClassName(resourceMethod)
methodName = ReflectionHelper.getName(resourceMethod)
methodKwargs['id'] = methodKwargs.get(
'id', f'{methodClassName}{c.DOT}{methodName}')
instancesUpTo = methodKwargs.pop('instancesUpTo', 1)
weekDays = methodKwargs.pop('weekDays', None)
resourceMethod.disabled = disable
resourceMethod.shedulerId = methodKwargs['id']
resourceMethod.muteLogs = muteLogs or ConverterStatic.getValueOrDefault(
apiInstance.globals.getApiSetting(
ConfigurationKeyConstant.API_SCHEDULER_MUTE_LOGS),
DEFAUTL_MUTE_LOGS)
if ObjectHelper.isNotEmpty(
methodArgs
) and SchedulerType.CRON == methodArgs[0] and ObjectHelper.isNotNone(
weekDays) and StringHelper.isNotBlank(weekDays):
methodKwargs['day_of_week'] = weekDays
if ObjectHelper.isNotNone(instancesUpTo):
methodKwargs['max_instances'] = instancesUpTo
shedulerArgs = [*methodArgs]
shedulerKwargs = {**methodKwargs}
@apiInstance.schedulerManager.task(*shedulerArgs, **shedulerKwargs)
def innerResourceInstanceMethod(*args, **kwargs):
resourceInstanceName = methodClassName[:-len(
FlaskManager.KW_SCHEDULER_RESOURCE)]
resourceInstanceName = f'{resourceInstanceName[0].lower()}{resourceInstanceName[1:]}'
args = FlaskManager.getArgumentInFrontOfArgs(
args,
ReflectionHelper.getAttributeOrMethod(
apiInstance.resource.scheduler, resourceInstanceName))
resourceInstance = args[0]
muteLogs = resourceInstance.muteLogs or resourceMethod.muteLogs
if resourceInstance.enabled and not resourceInstance.disabled and not resourceMethod.disabled:
if not muteLogs:
log.debug(
resourceMethod,
f'{resourceMethod.shedulerId} scheduler started with args={methodArgs} and kwargs={methodKwargs}'
)
methodReturn = None
try:
FlaskManager.validateArgs(args, requestClass,
innerResourceInstanceMethod)
methodReturn = resourceMethod(*args, **kwargs)
except Exception as exception:
if not muteLogs:
log.warning(
resourceMethod,
f'Not possible to run {resourceMethod.shedulerId} properly',
exception=exception,
muteStackTrace=True)
FlaskManager.raiseAndPersistGlobalException(
exception, resourceInstance, resourceMethod)
if not muteLogs:
log.debug(
resourceMethod,
f'{resourceMethod.shedulerId} scheduler finished')
return methodReturn
if not muteLogs:
log.warning(
resourceMethod,
f'{resourceMethod.shedulerId} scheduler didn{c.SINGLE_QUOTE}t started. {"Schedulers are disabled" if not resourceInstance.enabled else "This scheduler is disabled" if resourceInstance.disabled else "This scheduler method is disabled"}'
)
ReflectionHelper.overrideSignatures(innerResourceInstanceMethod,
resourceMethod)
resourceMethod.shedulerId = methodKwargs.get('id')
innerResourceInstanceMethod.disable = resourceMethodDisable
innerResourceInstanceMethod.muteLogs = resourceMethodMuteLogs
return innerResourceInstanceMethod
def isNeitherNoneNorBlank(thing):
return ObjectHelper.isNotNone(thing) and StringHelper.isNotBlank(
str(thing))
def handleLogErrorException(exception,
resourceInstance,
resourceInstanceMethod,
context,
apiInstance=None):
if not (isinstance(exception, GlobalException)
or GlobalException.__name__ == exception.__class__.__name__):
log.debug(
handleLogErrorException,
f'Failed to excecute {resourceInstanceMethod.__name__} method due to {exception.__class__.__name__} exception',
exception=exception)
message = None
status = None
logMessage = None
if (isinstance(exception, NoAuthorizationError) or
NoAuthorizationError.__name__ == exception.__class__.__name__
or isinstance(exception, RevokedTokenError)
or RevokedTokenError.__name__ == exception.__class__.__name__
or isinstance(exception, InvalidSignatureError) or
InvalidSignatureError.__name__ == exception.__class__.__name__
or isinstance(exception, ExpiredSignatureError)
or ExpiredSignatureError.__name__
== exception.__class__.__name__):
message = 'Unauthorized' if ObjectHelper.isNone(
exception) or StringHelper.isBlank(
str(exception)) else str(exception)
status = HttpStatus.UNAUTHORIZED
if ObjectHelper.isNotNone(exception) and StringHelper.isNotBlank(
str(exception)):
logMessage = str(exception)
else:
logMessage = DEFAULT_LOG_MESSAGE
exception = GlobalException(message=message,
logMessage=logMessage,
logResource=resourceInstance,
logResourceMethod=resourceInstanceMethod,
status=status)
try:
if not context == exception.context:
exception = GlobalException(
message=exception.message,
logMessage=exception.logMessage,
logResource=resourceInstance,
logResourceMethod=resourceInstanceMethod,
status=exception.status,
context=context)
else:
if not exception.logResource or c.NOTHING == exception.logResource or not resourceInstance == exception.logResource:
exception.logResource = resourceInstance
if not exception.logResourceMethod or c.NOTHING == exception.logResourceMethod or not resourceInstanceMethod == exception.logResourceMethod:
exception.logResourceMethod = resourceInstanceMethod
httpErrorLog = ErrorLog.ErrorLog()
httpErrorLog.override(exception)
if ObjectHelper.isNone(apiInstance):
from python_framework import FlaskManager
apiInstance = FlaskManager.getApi()
else:
apiInstance = apiInstance
try:
apiInstance.repository.commit()
except Exception as preCommitException:
log.warning(
handleLogErrorException,
f'Failed to pre commit before persist {ErrorLog.ErrorLog.__name__}',
exception=preCommitException)
apiInstance.repository.saveAndCommit(httpErrorLog)
except Exception as errorLogException:
log.warning(handleLogErrorException,
f'Failed to persist {ErrorLog.ErrorLog.__name__}',
exception=errorLogException)
return exception