Пример #1
0
 def getSetting(self, nodeKey, settingTree=None):
     if not settingTree:
         settingTree = self.settingTree
     settingValue = SettingHelper.getSetting(nodeKey, settingTree)
     if ObjectHelper.isEmpty(settingValue):
         return SettingHelper.getSetting(nodeKey, self.defaultSettingTree)
     return settingValue
Пример #2
0
def mustLogEnvironmentSettings():
    # Arrange

    # Act
    SettingHelper.logEnvironmentSettings()

    # Assert
    assert SettingHelper.LOCAL_ENVIRONMENT == EnvironmentHelper.get(
        SettingHelper.ACTIVE_ENVIRONMENT)
    assert SettingHelper.LOCAL_ENVIRONMENT == SettingHelper.getActiveEnvironment(
    )
    assert SettingHelper.activeEnvironmentIsLocal()
    assert "some value" == EnvironmentHelper.get('SOME_PARTICULAR_SETTING')
Пример #3
0
def getJwtMannager(appInstance,
                   jwtSecret,
                   algorithm=None,
                   headerName=None,
                   headerType=None):
    if not jwtSecret:
        log.warning(
            getJwtMannager,
            f'Not possible to instanciate sessionManager{c.DOT_SPACE_CAUSE}Missing jwt secret at {ConfigurationKeyConstant.API_SESSION_SECRET}'
        )
    else:
        jwtManager = JwtManager(
            jwtSecret,
            ConverterStatic.getValueOrDefault(
                algorithm, JwtConstant.DEFAULT_JWT_SESSION_ALGORITHM),
            ConverterStatic.getValueOrDefault(
                headerName, JwtConstant.DEFAULT_JWT_SESSION_HEADER_NAME),
            ConverterStatic.getValueOrDefault(
                headerType, JwtConstant.DEFAULT_JWT_SESSION_HEADER_TYPE))
        if SettingHelper.activeEnvironmentIsLocal():
            info = {
                'secret': jwtManager.secret,
                'algorithm': jwtManager.algorithm,
                'headerName': jwtManager.headerName,
                'headerType': jwtManager.headerType
            }
            log.prettyJson(getJwtMannager,
                           f'JWT session',
                           info,
                           logLevel=log.SETTING)
        return jwtManager
Пример #4
0
 def getSettingTree(self,
                    settingFilePath=None,
                    defaultSettingFilePath=None,
                    settingTree=None):
     if ObjectHelper.isEmpty(settingTree):
         settingTree = {}
     fallbackSettingFilePath = defaultSettingFilePath if not settingFilePath == defaultSettingFilePath else None
     if ObjectHelper.isNone(settingFilePath) or StringHelper.isBlank(
             settingFilePath
     ) or not EnvironmentHelper.OS.path.isfile(settingFilePath):
         self.failure(
             f'The "{settingFilePath}" setting file path was not found',
             None)
         return self.getSettingTree(settingFilePath=fallbackSettingFilePath,
                                    settingTree=settingTree)
     try:
         settingTree = SettingHelper.getSettingTree(
             settingFilePath,
             fallbackSettingFilePath=fallbackSettingFilePath,
             fallbackSettingTree=settingTree,
             keepDepthInLongString=True)
     except Exception as exception:
         if ObjectHelper.isNone(fallbackSettingFilePath):
             self.error(
                 f'Failed to load setting tree from "{settingFilePath}" setting file path. Returning {settingTree} by default',
                 exception)
         else:
             self.failure(
                 f'Failed to load setting tree from "{settingFilePath}" setting file path and "{fallbackSettingFilePath}" default setting file path. Only setting file path will be loadded now',
                 exception)
             try:
                 settingTree = SettingHelper.getSettingTree(
                     settingFilePath, keepDepthInLongString=True)
             except Exception as exception:
                 self.failure(
                     f'Failed to load setting tree from "{settingFilePath}" setting file path as well. Returning {settingTree} by default',
                     exception)
     return settingTree
Пример #5
0
 def loadLocalConfiguration(self, loadLocalConfig, printRootPathStatus,
                            globalsEverything):
     self.loadLocalConfig = loadLocalConfig
     self.localConfiguration = {}
     if self.loadLocalConfig:
         try:
             self.localConfiguration = self.getSettingTree(
                 settingFilePath=Globals.LOCAL_CONFIGURATION_FILE_NAME,
                 settingTree=None)
         except Exception as exception:
             self.log(
                 f'Failed to load {Globals.LOCAL_CONFIGURATION_FILE_NAME} settings',
                 exception=exception)
         keyQuery = SettingHelper.querySetting(AttributeKey.KW_KEY,
                                               self.localConfiguration)
         keyValueQuery = {}
         for key, value in keyQuery.items():
             KW_DOT_KEY = f'{c.DOT}{AttributeKey.KW_KEY}'
             if key.endswith(KW_DOT_KEY):
                 environmentInjection = SettingHelper.getSetting(
                     key[:-len(KW_DOT_KEY)], self.localConfiguration)
                 if (ObjectHelper.isDictionary(environmentInjection)
                         and AttributeKey.KW_KEY in environmentInjection
                         and AttributeKey.KW_VALUE in environmentInjection
                         and 2 == len(environmentInjection)):
                     EnvironmentHelper.update(
                         environmentInjection[AttributeKey.KW_KEY],
                         environmentInjection[AttributeKey.KW_VALUE])
     log.loadSettings()
     self.printRootPathStatus = printRootPathStatus
     self.globalsEverything = globalsEverything
     self.ignoreModules = IGNORE_MODULES
     self.ignoreResources = IGNORE_REOURCES
     self.activeEnvironment = SettingHelper.getActiveEnvironment()
     if ObjectHelper.isNotEmpty(
             self.localConfiguration) and SettingHelper.getSetting(
                 'print-status', self.localConfiguration):
         SettingHelper.printSettings(self.localConfiguration,
                                     "Local Configuration")
         basicSettingsAsDictionary = {
             'activeEnvironment': self.activeEnvironment,
             'successStatus': self.successStatus,
             'settingStatus': self.settingStatus,
             'debugStatus': self.debugStatus,
             'warningStatus': self.warningStatus,
             'failureStatus': self.failureStatus,
             'errorStatus': self.errorStatus,
             'wrapperStatus': self.wrapperStatus,
             'infoStatus': self.infoStatus,
             'statusStatus': self.statusStatus,
             'logStatus': self.logStatus,
             'globalsEverything': self.globalsEverything,
             'printRootPathStatus': self.printRootPathStatus
         }
         log.prettyPython(self.__class__,
                          f'Basic settings',
                          basicSettingsAsDictionary,
                          logLevel=log.SETTING)
Пример #6
0
def shouldHandleMissingEnvironmentSettings():
    # Arrange
    exception = None
    globalsInstance = None

    # Act
    try:
        globalsInstance = globals.newGlobalsInstance(__file__,
                                                     loadLocalConfig=False)
    except Exception as ext:
        exception = ext

    # Assert
    assert ObjectHelper.isNotNone(globalsInstance)
    assert ObjectHelper.isNone(exception)
    assert 'missing_setting_file' == EnvironmentHelper.get(
        SettingHelper.ACTIVE_ENVIRONMENT)
    assert 'missing_setting_file' == SettingHelper.getActiveEnvironment()
Пример #7
0
def initialize(
    rootName,
    refferenceModel,
):

    app = Flask(rootName)
    api = Api(app)
    addGlobalsTo(api)
    SchedulerManager.addScheduler(api, app)
    securityKey = api.globals.getApiSetting('api.security.secret')
    if SettingHelper.LOCAL_ENVIRONMENT == SettingHelper.getActiveEnvironment():
        log.setting(initialize, f'JWT secret: {securityKey}')
    jwt = Security.getJwtMannager(app, securityKey)

    args = [api, app, jwt]
    for resourceType in FlaskManager.KW_RESOURCE_LIST:
        args.append(getResourceList(api, resourceType))
    args.append(refferenceModel)
    addFlaskApiResources(*args)
    api.app = app
    return api, app, jwt
Пример #8
0
def getJwtMannager(appInstance,
                   jwtSecret,
                   algorithm=None,
                   headerName=None,
                   headerType=None):
    if ObjectHelper.isNone(jwtSecret):
        log.warning(
            getJwtMannager,
            f'Not possible to instanciate securityManager{c.DOT_SPACE_CAUSE}Missing jwt secret at {ConfigurationKeyConstant.API_SECURITY_SECRET}'
        )
    else:
        jwtMannager = JWTManager(appInstance)
        appInstance.config[JwtConstant.KW_JWT_SECRET_KEY] = jwtSecret
        appInstance.config[JwtConstant.KW_JWT_BLACKLIST_ENABLED] = True
        appInstance.config[
            JwtConstant.KW_JWT_ALGORITHM] = ConverterStatic.getValueOrDefault(
                algorithm, JwtConstant.DEFAULT_JWT_SECURITY_ALGORITHM)
        appInstance.config[
            JwtConstant.
            KW_JWT_HEADER_NAME] = ConverterStatic.getValueOrDefault(
                headerName, JwtConstant.DEFAULT_JWT_SECURITY_HEADER_NAME)
        appInstance.config[
            JwtConstant.
            KW_JWT_HEADER_TYPE] = ConverterStatic.getValueOrDefault(
                headerType, JwtConstant.DEFAULT_JWT_SECURITY_HEADER_TYPE)
        if SettingHelper.activeEnvironmentIsLocal():
            info = {
                'secret': jwtSecret,
                'algorithm': appInstance.config[JwtConstant.KW_JWT_ALGORITHM],
                'headerName':
                appInstance.config[JwtConstant.KW_JWT_HEADER_NAME],
                'headerType':
                appInstance.config[JwtConstant.KW_JWT_HEADER_TYPE]
            }
            log.prettyJson(getJwtMannager,
                           f'JWT security',
                           info,
                           logLevel=log.SETTING)
        return jwtMannager
Пример #9
0
 def printTree(self, tree, name, depth=1):
     SettingHelper.printSettings(tree, name, depth=depth)
Пример #10
0
 def accessTree(self, nodeKey, tree):
     return SettingHelper.getSetting(nodeKey, tree)
Пример #11
0
 def getActiveEnvironment(self):
     return SettingHelper.getActiveEnvironment()
Пример #12
0
def mustLogWithColors():
    # Arrange
    noExceptionThrown = 'exception not thrown'
    someLogMessage = 'some log message'
    someExceptionMessage = 'some exception message'
    someInnerExceptionMessage = 'some inner exception message'
    exception = None
    someExceptionMessageWithStackTrace = f'{someExceptionMessage} with stacktrace'
    someExceptionMessageWithoutStackTrace = f'{someExceptionMessage} without stacktrace'

    def controlableException(logType, muteStackTrace=False):
        try:
            raise Exception(
                someExceptionMessageWithoutStackTrace
                if muteStackTrace else someExceptionMessageWithStackTrace)
        except Exception as exception:
            if logType in OPTIONAL_EXCEPTION_LOG_TYPES:
                logType(logType,
                        someLogMessage,
                        exception=exception,
                        muteStackTrace=muteStackTrace)
            else:
                logType(logType,
                        someLogMessage,
                        exception,
                        muteStackTrace=muteStackTrace)

    # Act
    log.success(log.success, someLogMessage)
    log.setting(log.setting, someLogMessage)
    log.debug(log.debug, someLogMessage)
    log.warning(log.warning, someLogMessage)

    controlableException(log.log)
    controlableException(log.debug)
    controlableException(log.warning)
    controlableException(log.wraper)
    controlableException(log.failure)
    controlableException(log.error)
    controlableException(log.test)

    controlableException(log.log, muteStackTrace=True)
    controlableException(log.debug, muteStackTrace=True)
    controlableException(log.warning, muteStackTrace=True)
    controlableException(log.wraper, muteStackTrace=True)
    controlableException(log.failure, muteStackTrace=True)
    controlableException(log.error, muteStackTrace=True)
    controlableException(log.test, muteStackTrace=True)

    log.log(log.log, someLogMessage, None)
    log.debug(log.debug, someLogMessage, None)
    log.warning(log.warning, someLogMessage, None)
    log.wraper(log.wraper, noExceptionThrown, None)
    log.failure(log.failure, noExceptionThrown, None)
    log.error(log.error, noExceptionThrown, None)
    log.test(log.test, someLogMessage, None)

    # Assert
    assert SettingHelper.LOCAL_ENVIRONMENT == EnvironmentHelper.get(
        SettingHelper.ACTIVE_ENVIRONMENT)
    assert SettingHelper.activeEnvironmentIsLocal()
Пример #13
0
def mustPrintMessageLog_withColors():
    # Arrange
    mustLogWithNewLine = 'must log with new line'
    mustNotLogWithNewLine = 'must not log with new line'
    mustLogWithoutNewLine = 'must log without new line'
    mustNotLogWithoutNewLine = 'must not log without new line'
    mustLogWithNewLineWithException = 'must log with new line with exception'
    mustNotLogWithNewLineWithException = 'must not log with new line with exception'
    mustLogWithoutNewLineWithException = 'must log without new line with exception'
    mustNotLogWithoutNewLineWithException = 'must not log without new line with exception'
    someExceptionMessage = 'some exception message'
    thrownException = None
    try:
        raise Exception(someExceptionMessage)
    except Exception as exception:
        thrownException = exception

    # Act
    log.printLog(mustLogWithNewLine, condition=True, newLine=True)
    log.printSuccess(mustLogWithNewLine, condition=True, newLine=True)
    log.printSetting(mustLogWithNewLine, condition=True, newLine=True)
    log.printDebug(mustLogWithNewLine,
                   condition=True,
                   newLine=True,
                   exception=None)
    log.printWarning(mustLogWithNewLine,
                     condition=True,
                     newLine=True,
                     exception=None)
    log.printWarper(mustLogWithNewLine,
                    condition=True,
                    newLine=True,
                    exception=None)
    log.printFailure(mustLogWithNewLine,
                     condition=True,
                     newLine=True,
                     exception=None)
    log.printError(mustLogWithNewLine,
                   condition=True,
                   newLine=True,
                   exception=None)
    log.printTest(mustLogWithNewLine,
                  condition=True,
                  newLine=True,
                  exception=None)

    log.printLog(mustNotLogWithNewLine, condition=False, newLine=True)
    log.printSuccess(mustNotLogWithNewLine, condition=False, newLine=True)
    log.printSetting(mustNotLogWithNewLine, condition=False, newLine=True)
    log.printDebug(mustNotLogWithNewLine,
                   condition=False,
                   newLine=True,
                   exception=None)
    log.printWarning(mustNotLogWithNewLine,
                     condition=False,
                     newLine=True,
                     exception=None)
    log.printWarper(mustNotLogWithNewLine,
                    condition=False,
                    newLine=True,
                    exception=None)
    log.printFailure(mustNotLogWithNewLine,
                     condition=False,
                     newLine=True,
                     exception=None)
    log.printError(mustNotLogWithNewLine,
                   condition=False,
                   newLine=True,
                   exception=None)
    log.printTest(mustNotLogWithNewLine,
                  condition=False,
                  newLine=True,
                  exception=None)

    log.printLog(mustLogWithoutNewLine, condition=True, newLine=False)
    log.printSuccess(mustLogWithoutNewLine, condition=True, newLine=False)
    log.printSetting(mustLogWithoutNewLine, condition=True, newLine=False)
    log.printDebug(mustLogWithoutNewLine,
                   condition=True,
                   newLine=False,
                   exception=None)
    log.printWarning(mustLogWithoutNewLine,
                     condition=True,
                     newLine=False,
                     exception=None)
    log.printWarper(mustLogWithoutNewLine,
                    condition=True,
                    newLine=False,
                    exception=None)
    log.printFailure(mustLogWithoutNewLine,
                     condition=True,
                     newLine=False,
                     exception=None)
    log.printError(mustLogWithoutNewLine,
                   condition=True,
                   newLine=False,
                   exception=None)
    log.printTest(mustLogWithoutNewLine,
                  condition=True,
                  newLine=False,
                  exception=None)

    log.printLog(mustNotLogWithoutNewLine, condition=False, newLine=False)
    log.printSuccess(mustNotLogWithoutNewLine, condition=False, newLine=False)
    log.printSetting(mustNotLogWithoutNewLine, condition=False, newLine=False)
    log.printDebug(mustNotLogWithoutNewLine,
                   condition=False,
                   newLine=False,
                   exception=None)
    log.printWarning(mustNotLogWithoutNewLine,
                     condition=False,
                     newLine=False,
                     exception=None)
    log.printWarper(mustNotLogWithoutNewLine,
                    condition=False,
                    newLine=False,
                    exception=None)
    log.printFailure(mustNotLogWithoutNewLine,
                     condition=False,
                     newLine=False,
                     exception=None)
    log.printError(mustNotLogWithoutNewLine,
                   condition=False,
                   newLine=False,
                   exception=None)
    log.printTest(mustNotLogWithoutNewLine,
                  condition=False,
                  newLine=False,
                  exception=None)

    log.printLog(mustLogWithNewLineWithException,
                 condition=True,
                 newLine=True,
                 exception=thrownException)
    log.printDebug(mustLogWithNewLineWithException,
                   condition=True,
                   newLine=True,
                   exception=thrownException)
    log.printWarning(mustLogWithNewLineWithException,
                     condition=True,
                     newLine=True,
                     exception=thrownException)
    log.printWarper(mustLogWithNewLineWithException,
                    condition=True,
                    newLine=True,
                    exception=thrownException)
    log.printFailure(mustLogWithNewLineWithException,
                     condition=True,
                     newLine=True,
                     exception=thrownException)
    log.printError(mustLogWithNewLineWithException,
                   condition=True,
                   newLine=True,
                   exception=thrownException)
    log.printTest(mustLogWithNewLineWithException,
                  condition=True,
                  newLine=True,
                  exception=thrownException)

    log.printLog(mustLogWithoutNewLineWithException,
                 condition=True,
                 newLine=False,
                 exception=thrownException)
    log.printDebug(mustLogWithoutNewLineWithException,
                   condition=True,
                   newLine=False,
                   exception=thrownException)
    log.printWarning(mustLogWithoutNewLineWithException,
                     condition=True,
                     newLine=False,
                     exception=thrownException)
    log.printWarper(mustLogWithoutNewLineWithException,
                    condition=True,
                    newLine=False,
                    exception=thrownException)
    log.printFailure(mustLogWithoutNewLineWithException,
                     condition=True,
                     newLine=False,
                     exception=thrownException)
    log.printError(mustLogWithoutNewLineWithException,
                   condition=True,
                   newLine=False,
                   exception=thrownException)
    log.printTest(mustLogWithoutNewLineWithException,
                  condition=True,
                  newLine=False,
                  exception=thrownException)

    log.printLog(mustNotLogWithNewLineWithException,
                 condition=False,
                 newLine=True,
                 exception=thrownException)
    log.printDebug(mustNotLogWithNewLineWithException,
                   condition=False,
                   newLine=True,
                   exception=thrownException)
    log.printWarning(mustNotLogWithNewLineWithException,
                     condition=False,
                     newLine=True,
                     exception=thrownException)
    log.printWarper(mustNotLogWithNewLineWithException,
                    condition=False,
                    newLine=True,
                    exception=thrownException)
    log.printFailure(mustNotLogWithNewLineWithException,
                     condition=False,
                     newLine=True,
                     exception=thrownException)
    log.printError(mustNotLogWithNewLineWithException,
                   condition=False,
                   newLine=True,
                   exception=thrownException)
    log.printTest(mustNotLogWithNewLineWithException,
                  condition=False,
                  newLine=True,
                  exception=thrownException)

    log.printLog(mustNotLogWithoutNewLineWithException,
                 condition=False,
                 newLine=False,
                 exception=thrownException)
    log.printDebug(mustNotLogWithoutNewLineWithException,
                   condition=False,
                   newLine=False,
                   exception=thrownException)
    log.printWarning(mustNotLogWithoutNewLineWithException,
                     condition=False,
                     newLine=False,
                     exception=thrownException)
    log.printWarper(mustNotLogWithoutNewLineWithException,
                    condition=False,
                    newLine=False,
                    exception=thrownException)
    log.printFailure(mustNotLogWithoutNewLineWithException,
                     condition=False,
                     newLine=False,
                     exception=thrownException)
    log.printError(mustNotLogWithoutNewLineWithException,
                   condition=False,
                   newLine=False,
                   exception=thrownException)
    log.printTest(mustNotLogWithoutNewLineWithException,
                  condition=False,
                  newLine=False,
                  exception=thrownException)

    # Assert
    assert True == SettingHelper.activeEnvironmentIsLocal()
    assert SettingHelper.LOCAL_ENVIRONMENT == EnvironmentHelper.get(
        SettingHelper.ACTIVE_ENVIRONMENT)
    assert SettingHelper.LOCAL_ENVIRONMENT == SettingHelper.getActiveEnvironment(
    )
Пример #14
0
 def getUrl(self, dialect):
     log.log(self.getUrl, 'Loading repository configuration')
     url = EnvironmentHelper.get(self.ENV_DATABASE_URL)
     if isNeitherNoneNorBlank(url):
         dialect = None
         driver = None
         database = None
         username = None
         password = None
         host = None
         port = None
         schema = None
         log.log(
             self.getUrl,
             f'Prioritising repository url in {self.ENV_DATABASE_URL} environment variable'
         )
     else:
         url = self.globals.getSetting(
             f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_URL}'
         )
         if isNeitherNoneNorBlank(url):
             dialect = None
             driver = None
             database = None
             username = None
             password = None
             host = None
             port = None
             schema = None
             log.log(self.getUrl,
                     f'Prioritising repository url in yamel configuration')
         else:
             url = c.NOTHING
             driver = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_DRIVER}'
             )
             database = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_DATABASE}'
             )
             username = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_USERNAME}'
             )
             password = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_PASSWORD}'
             )
             host = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_HOST}'
             )
             port = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_PORT}'
             )
             schema = self.globals.getSetting(
                 f'{self.KW_API}{c.DOT}{self.KW_DATABASE}{c.DOT}{self.KW_REPOSITORY_SCHEMA}'
             )
             if isNeitherNoneNorBlank(username) and isNeitherNoneNorBlank(
                     password):
                 url += f'{username}{c.COLON}{password}'
             if isNeitherNoneNorBlank(host) and isNeitherNoneNorBlank(port):
                 url += f'{c.ARROBA}{host}{c.COLON}{port}'
             url += c.SLASH
             database = f'{database}' if isNeitherNoneNorBlank(
                 database
             ) else f'{self.DEFAULT_LOCAL_STORAGE_NAME if ObjectHelper.isNone(self.globals.apiName) else self.globals.apiName}{c.DOT}{self.EXTENSION}'
             if not isNeitherNoneNorBlank(dialect):
                 dialect = self.DEFAULT_DIALECT
             plusDriverOrNothing = f'{c.PLUS}{driver}' if isNeitherNoneNorBlank(
                 driver) else c.NOTHING
             dialectAndDriver = f'''{dialect}{plusDriverOrNothing}'''
             url = f'{dialectAndDriver}{c.COLON}{c.DOUBLE_SLASH}{url}{database}'
             log.log(self.getUrl,
                     'Prioritising repository yamel configuration')
     if SettingHelper.activeEnvironmentIsLocal():
         log.prettyJson(
             self.getUrl,
             'Repository configuations', {
                 **self.globals.getSetting(f'{self.KW_API}{c.DOT}{self.KW_DATABASE}'),
                 **{
                     'dialect': dialect,
                     'driver': driver,
                     'database': database,
                     'username': username,
                     'password': password,
                     'host': host,
                     'port': port,
                     'schema': schema,
                     'url': url
                 }
             },
             logLevel=log.SETTING)
     # log.prettyPython(self.getUrl, 'url', url, logLevel=log.LOG)
     return url
Пример #15
0
from python_helper import EnvironmentHelper, log

from python_helper import SettingHelper

import globals
globalsInstance = globals.newGlobalsInstance(__file__
    , loadLocalConfig = SettingHelper.activeEnvironmentIsDefault()

    , settingStatus = True
    , successStatus = True
    , errorStatus = True

    , debugStatus = True
    , failureStatus = True
    , warningStatus = True
    , wrapperStatus = True
    , logStatus = True
    # , testStatus = True
)

from python_framework.api.src.service.flask import FlaskManager
import TestApi
app = TestApi.app
api = TestApi.api
jwt = TestApi.jwt

@FlaskManager.initialize(api, defaultUrl = '/swagger', openInBrowser=False)
def runFlaskApplication(app=None):
    FlaskManager.runApi(debug=False, use_reloader=False)
    # app.run(debug=False, use_reloader=False)
    # app.run(debug=True)