def main(): # when the -d/--debug flag is set, Kivy sets log level to debug level = Logger.getEffectiveLevel() in_debug = level == LOG_LEVELS.get('debug') reset() MainApp().run() print("Returned from run")
def LoadFonts(self, *, uDefinitionName: str, fSplashScreenPercentageStartValue: float) -> None: """ Load the fonts for a single definition """ aCommands: List[Dict[str, str]] if uDefinitionName == "": fSplashScreenPercentageRange: float = 10.0 fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / ( len(self) + 1) # Scheduling Loading Definition Fonts aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message we load Fonts', 'string': 'showsplashtext', 'maintext': 'Loading Definition Fonts' }]) #for definition for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Definition Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Load Fonts for Definition', 'string': 'loaddefinitionfonts', 'definitionname': oDefinition.uAlias }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) elif uDefinitionName == "ORCA": aFontsFolders: List[str] = Globals.oPathFonts.GetFolderList( bFullPath=True) for uFontFolder in aFontsFolders: oFnFontDefinition: cFileName = cFileName('').ImportFullPath( uFnFullName=uFontFolder + u"/fonts.xml") if not oFnFontDefinition.string in aLoadedFontFiles: Logger.info(u'Loading Global Fonts: ' + uFontFolder) aLoadedFontFiles.append(oFnFontDefinition.string) LoadFontFromXML(oET_Root=LoadXMLFile( oFile=oFnFontDefinition)) else: self[uDefinitionName].LoadFonts() return None
def main(): # when the -d/--debug flag is set, Kivy sets log level to debug level = Logger.getEffectiveLevel() in_debug = level == LOG_LEVELS.get('debug') client = configure_sentry(in_debug) try: MainApp().run() except Exception: if type(client) == Client: Logger.info( 'Errors will be sent to Sentry, run with "--debug" if you ' 'are a developper and want to the error in the shell.') client.captureException()
def LogAction(self,uTxt,oAction,uAddText=''): """ Logs an action """ if Logger.getEffectiveLevel()!=logging.DEBUG: return uTemp=self.CreateDebugLine(oAction,uTxt=uTxt) if uAddText: uTemp+=u"| "+uAddText try: Logger.debug (uTemp) except: Logger.error ("Cant Create Debugline")
def RegisterFonts(self, *, uFontName: str, fSplashScreenPercentageStartValue: float) -> None: """ Register the a specific font, or schedules the registration of all fonts """ fPercentage: float fSplashScreenPercentageRange: float = 10.0 uFontIndex: str aCommands: List[Dict] oFont: cFontDef if not uFontName: Logger.debug(u'TheScreen: Register Fonts') fPercentage = fSplashScreenPercentageStartValue fPercentageStep = fSplashScreenPercentageRange / len(self.dFonts) # Scheduling Loading Fonts aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message the we register the fonts', 'string': 'showsplashtext', 'maintext': '$lvar(417)' }]) for uFontIndex in self.dFonts: oFont = self.dFonts[uFontIndex] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Font Name', 'string': 'showsplashtext', 'subtext': oFont.uName, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Register the Font', 'string': 'registerfonts', 'fontname': oFont.uName }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) else: oFont = self.dFonts[uFontName] # todo: either we always load all fonts, or we need to check in widget if font is required in case we load elements as runtime if oFont.uName in self.dUsedFonts or True: oFont.Register()
def Orca_include(oElem, pLoader: Callable, uFileName: str = "") -> None: """ heavily customized loader for includes in xml files""" uAlias = oElem.get('definitionalias') oDef = None if uAlias is not None: oDef = Globals.oDefinitions[uAlias] oElem.set('linefilename', ShortenFileName(uFnFile=uFileName)) Orca_includesub(oElem=oElem, pLoader=pLoader, uOrgDefinitionContext=Globals.uDefinitionContext, oDef=oDef, uFileName=uFileName) if Logger.getEffectiveLevel() == logging.DEBUG: AddFileNames(oElem=oElem, uFnFile=uFileName) RestoreDefinitionContext()
def LoadGestures(self, *, uDefinitionName: str, fSplashScreenPercentageStartValue: float) -> None: """ Loads the gestures for a single definition, or creates the queue entries """ aCommands: List[Dict[str, str]] if uDefinitionName == "": fSplashScreenPercentageRange: float = 10.0 fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / len(self) # Scheduling Loading Definition Gestures aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message we load Gestures', 'string': 'showsplashtext', 'maintext': '$lvar(404)' }]) for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Definition Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Load Gestures for Definition', 'string': 'loaddefinitiongestures', 'definitionname': oDefinition.uAlias }) if oDefinition.bImportActions: Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) else: self[uDefinitionName].LoadGestures() return None
def ParseXmlFiles(self, *, uDefinitionName: str, fSplashScreenPercentageStartValue: float) -> None: """ Parses the definition file for a single definition """ aCommands: List[Dict[str, str]] fSplashScreenPercentageRange: float = 10.0 if not uDefinitionName: fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / len(self) aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message that we parse the XML Files', 'string': 'showsplashtext', 'maintext': '$lvar(412)' }]) # Scheduling Parsing of Definition XML Files for uDefinitionKey in self: oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Definitioon Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'And parse the definition', 'string': 'parsedefinitionxml', 'definitionname': oDefinition.uAlias }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) else: self[uDefinitionName].LoadXMLFile() return None
def LoadActions(self, *, fSplashScreenPercentageStartValue: float) -> None: """ Loads the action files for the definitions """ oDefinition: cDefinition aCommands: List[Dict[str, str]] fSplashScreenPercentageRange: float = 10.0 fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / len(self) aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message we load Actions', 'string': 'showsplashtext', 'maintext': '$lvar(403)' }]) for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if oDefinition.bImportActions: if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Definition Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Load the Definition Actions', "string": "loaddefinitionactions", "definitionname": oDefinition.uAlias }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) return None
def LogAction(self, *, uTxt: str, oAction: cAction, uAddText: str = '') -> None: """ Logs an action """ if Logger.getEffectiveLevel() != logging.DEBUG: return uTemp = self.CreateDebugLine(oAction=oAction, uTxt=uTxt) if uAddText: uTemp += u"| " + uAddText try: from ORCA.utils.TypeConvert import ToUnicode Logger.debug(ToUnicode(uTemp)) except Exception: try: Logger.debug(uTemp.encode("'UTF-8'", errors='replace')) except Exception as e: Logger.error("Cant Create Debugline:" + str(e))
def LoadSettings(self, *, uDefinitionName: str, fSplashScreenPercentageStartValue: float) -> None: """ Loads the settings for a specific definition """ oDefinition: cDefinition aCommands: List[Dict[str, str]] uHintKey: str fSplashScreenPercentageRange: float = 10.0 if not uDefinitionName: # Scheduling Loading Definition Settings fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / len(self) aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message that we load the settings', 'string': 'showsplashtext', 'maintext': '$lvar(414)' }]) for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Definition Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Load the settings for the Definition', 'string': 'loaddefinitionsettings', 'definitionname': oDefinition.uAlias }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) # Lets parse them (to init all default vars Globals.oEvents.AddToSimpleActionList( aActionList=aActions, aActions=[{ 'name': 'Parse all Settings and set defaults', 'string': 'loaddefinitionsettings', 'definitionname': 'PARSESETTINGS' }]) #Execute the Queue Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) #just to put it somewhere for uHintKey in self.dInstallationsHints: self.uInstallationHint += self.dInstallationsHints[uHintKey] SetVar(uVarName="INSTALLATIONHINT", oVarValue=self.uInstallationHint) else: oDefinition = self[uDefinitionName] SetDefinitionContext(uDefinitionName=oDefinition.uName) oDefinition.ParseSettings() RestoreDefinitionContext() return None
def InitInterFaceSettings( self, *, uDefinitionName: str, fSplashScreenPercentageStartValue: float) -> None: """ Init The Interface settings of a definition """ aCommands: List[Dict[str, str]] oInterface: cBaseInterFace fSplashScreenPercentageRange = 10.0 if not uDefinitionName: # Scheduling Initialize Interface settings fPercentage = fSplashScreenPercentageStartValue fPercentageStep = fSplashScreenPercentageRange / len(self) aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message the we initialize the interfaces', 'string': 'showsplashtext', 'maintext': '$lvar(418)' }]) for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and Interface Name', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] aCommands.append({ 'name': 'Initialize the Interface', 'string': 'initinterfacesettings', 'definitionname': oDefinition.uAlias }) Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.AddToSimpleActionList( aActionList=aActions, aActions=[{ 'name': 'Show Message the we write all interface settings', 'string': 'showsplashtext', 'subtext': "$lvar(456)", 'percentage': str(fPercentage) }, { 'name': 'Write all interface settings', 'string': 'initinterfacesettings', 'definitionname': 'WRITEALLSETTINGS' }]) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) elif uDefinitionName == "WRITEALLSETTINGS": for uInterfaceName in self.dInitInterfaceSettings: if uInterfaceName in Globals.oInterFaces.aObjectNameList: oInterface = Globals.oInterFaces.GetInterface( uInterfaceName) if oInterface is None: Logger.info( 'Need to load unrecognized Interface [%s] for configuration' % uInterfaceName) Globals.oInterFaces.LoadInterface(uInterfaceName) oInterface = Globals.oInterFaces.GetInterface( uInterfaceName) if oInterface is not None: for uConfigurationName in self.dInitInterfaceSettings[ uInterfaceName]: oInterface.oObjectConfig.WriteDefinitionConfig( uSectionName=uConfigurationName, dSettings=self.dInitInterfaceSettings[ uInterfaceName][uConfigurationName]) else: Logger.warning( 'Interface [%s] not on device, so it will not be configured!' % uInterfaceName) else: oDef: cDefinition = self[uDefinitionName] SetDefinitionContext(uDefinitionName=oDef.uName) oDef.InitInterFaceSettings(oXMLRoot=oDef.oET_Root) RestoreDefinitionContext() return None
def LoadLanguages(self, *, fSplashScreenPercentageStartValue: float) -> None: """ Loads the language files for the definitions """ # Scheduling Loading Definition Languages oDefinition: cDefinition aCommands: List[Dict[str, str]] fSplashScreenPercentageRange: float = 10.0 fPercentage: float = fSplashScreenPercentageStartValue fPercentageStep: float = fSplashScreenPercentageRange / len(self) aActions: List[cAction] = Globals.oEvents.CreateSimpleActionList( aActions=[{ 'name': 'Show Message to Load the Language', 'string': 'showsplashtext', 'maintext': '$lvar(413)' }]) for uDefinitionKey in reversed(self): oDefinition = self[uDefinitionKey] fPercentage += fPercentageStep if oDefinition.bImportLanguages: if Logger.getEffectiveLevel() != logging.DEBUG: aCommands = [] else: aCommands = [{ 'name': 'Update Percentage and DefinitionName', 'string': 'showsplashtext', 'subtext': oDefinition.uDefPublicTitle, 'percentage': str(fPercentage) }] if oDefinition.oDefinitionPathes.oFnDefinitionLanguageFallBack.Exists( ): aCommands.append({ 'name': 'Load Default Language File', 'string': 'loadlanguages', 'languagefilename': oDefinition.oDefinitionPathes. oFnDefinitionLanguageFallBack.string, 'definition': oDefinition.uName, 'definitionalias': oDefinition.uAlias }) if not Globals.uLanguage == u'English': oDefinition.oDefinitionPathes.LanguageChange() if oDefinition.oDefinitionPathes.oFnDefinitionLanguage.Exists( ): aCommands.append({ 'name': 'Load Requested Language File', 'string': 'loadlanguages', 'languagefilename': oDefinition.oDefinitionPathes. oFnDefinitionLanguage.string, 'definition': oDefinition.uName, 'definitionalias': oDefinition.uAlias }) if len(aCommands) > 0: Globals.oEvents.AddToSimpleActionList(aActionList=aActions, aActions=aCommands) Globals.oEvents.ExecuteActionsNewQueue(aActions=aActions, oParentWidget=None) return None
client.user_context({'android_os_build': android_os_build}) # Logger.error() to Sentry # https://docs.sentry.io/clients/python/integrations/logging/ handler = SentryHandler(client) handler.setLevel(LOG_LEVELS.get('error')) setup_logging(handler) return client class MainApp(App): theme_cls = ThemeManager() def build(self): self.icon = "docs/images/icon.png" if __name__ == '__main__': # when the -d/--debug flag is set, Kivy sets log level to debug level = Logger.getEffectiveLevel() in_debug = level == LOG_LEVELS.get('debug') client = configure_sentry(in_debug) try: MainApp().run() except Exception: if type(client) == Client: Logger.info( 'Errors will be sent to Sentry, run with "--debug" if you ' 'are a developper and want to the error in the shell.') client.captureException()