class ProjectAliceObject: def __init__(self, logDepth: int = 3, *args, **kwargs): self._depth = logDepth self._logger = Logger(logDepth) def __repr__(self): return json.dumps(self.__dict__) def __str__(self): return json.dumps(self.__dict__) def broadcast(self, method: str, exceptions: list = None, manager=None, propagateToSkills: bool = False, **kwargs): if not exceptions: exceptions = list() if isinstance(exceptions, str): exceptions = [exceptions] if not exceptions and not manager: # Prevent infinite loop of broadcaster being broadcasted to re broadcasting self.logWarning( 'Cannot broadcast to itself, the calling method has to be put in exceptions' ) return if 'ProjectAlice' not in exceptions: exceptions.append('ProjectAlice') if not method.startswith('on'): method = f'on{method[0].capitalize() + method[1:]}' deadManagers = list() for name, man in SM.SuperManager.getInstance().managers.items(): if not man: deadManagers.append(name) continue if (manager and man.name != manager.name) or man.name in exceptions: continue try: func = getattr(man, method, None) if func: func(**kwargs) except TypeError as e: self.logWarning( f'- Failed to broadcast event {method} to {man.name}: {e}') if propagateToSkills: self.SkillManager.skillBroadcast(method=method, **kwargs) for name in deadManagers: del SM.SuperManager.getInstance().managers[name] def logInfo(self, msg: str): self._logger.doLog(function='info', msg=msg, printStack=False) def logError(self, msg: str): self._logger.doLog(function='error', msg=msg) def logDebug(self, msg: str): self._logger.doLog(function='debug', msg=msg, printStack=False) def logFatal(self, msg: str): self._logger.doLog(function='fatal', msg=msg) try: self.ProjectAlice.onStop() except: exit() def logWarning(self, msg: str, printStack: bool = False): self._logger.doLog(function='warning', msg=msg, printStack=printStack) def logCritical(self, msg: str): self._logger.doLog(function='critical', msg=msg) def onStart(self): pass def onStop(self): pass def onBooted(self): pass def onSkillInstalled(self, skill: str): pass def onSkillUpdated(self, skill: str): pass def onInternetConnected(self): pass def onInternetLost(self): pass def onHotword(self, siteId: str, user: str = constants.UNKNOWN_USER): pass def onHotwordToggleOn(self, siteId: str): pass def onSessionStarted(self, session): pass def onStartListening(self, session): pass def onStopListening(self, session): pass def onCaptured(self, session): pass def onNluQuery(self, session): pass def onIntentParsed(self, session): pass def onUserCancel(self, session): pass def onSessionTimeout(self, session): pass def onIntentNotRecognized(self, session): pass def onSessionError(self, session): pass def onSessionEnded(self, session): pass def onSay(self, session): pass def onSayFinished(self, session): pass def onSessionQueued(self, session): pass def onMessage(self, session) -> bool: """ Do not consume the intent by default """ return False def onSleep(self): pass def onWakeup(self): pass def onGoingBed(self): pass def onLeavingHome(self): pass def onReturningHome(self): pass def onEating(self): pass def onWatchingTV(self): pass def onCooking(self): pass def onMakeup(self): pass def onContextSensitiveDelete(self, sessionId: str): pass def onContextSensitiveEdit(self, sessionId: str): pass def onFullMinute(self): pass def onFiveMinute(self): pass def onQuarterHour(self): pass def onFullHour(self): pass def onWakeword(self, siteId: str, user: str = constants.UNKNOWN_USER): pass def onMotionDetected(self): pass def onMotionStopped(self): pass def onButtonPressed(self): pass def onButtonReleased(self): pass def onDeviceConnecting(self): pass def onDeviceDisconnecting(self): pass def onUVIndexAlert(self, *args, **kwargs): pass def onRaining(self, *args, **kwargs): pass def onTooMuchRain(self, *args, **kwargs): pass def onWindy(self, *args, **kwargs): pass def onFreezing(self, *args, **kwargs): pass def onTemperatureHighAlert(self, *args, **kwargs): pass def onTemperatureLowAlert(self, *args, **kwargs): pass def onCO2Alert(self, *args, **kwargs): pass def onHumidityHighAlert(self, *args, **kwargs): pass def onHumidityLowAlert(self, *args, **kwargs): pass def onNoiseAlert(self, *args, **kwargs): pass def onPressureHighAlert(self, *args, **kwargs): pass def onPressureLowAlert(self, *args, **kwargs): pass def onBroadcastingForNewDeviceStart(self, session): pass def onBroadcastingForNewDeviceStop(self): pass def onAuthenticated(self, session): pass def onAuthenticationFailed(self, session): pass def onAudioFrame(self, **kwargs): pass def onSnipsAssistantInstalled(self, **kwargs): pass def onSnipsAssistantFailedTraining(self, **kwargs): pass def onSkillInstallFailed(self, skill: str): pass def onNluTrained(self, **kwargs): pass def onPartialTextCaptured(self, session, text: str, likelihood: float, seconds: float): pass @property def ProjectAlice(self): return SM.SuperManager.getInstance().projectAlice @property def ConfigManager(self): return SM.SuperManager.getInstance().configManager @property def SkillManager(self): return SM.SuperManager.getInstance().skillManager @property def DeviceManager(self): return SM.SuperManager.getInstance().deviceManager @property def DialogSessionManager(self): return SM.SuperManager.getInstance().dialogSessionManager @property def MultiIntentManager(self): return SM.SuperManager.getInstance().multiIntentManager @property def ProtectedIntentManager(self): return SM.SuperManager.getInstance().protectedIntentManager @property def MqttManager(self): return SM.SuperManager.getInstance().mqttManager @property def SnipsServicesManager(self): return SM.SuperManager.getInstance().snipsServicesManager @property def UserManager(self): return SM.SuperManager.getInstance().userManager @property def DatabaseManager(self): return SM.SuperManager.getInstance().databaseManager @property def InternetManager(self): return SM.SuperManager.getInstance().internetManager @property def TelemetryManager(self): return SM.SuperManager.getInstance().telemetryManager @property def ThreadManager(self): return SM.SuperManager.getInstance().threadManager @property def TimeManager(self): return SM.SuperManager.getInstance().timeManager @property def ASRManager(self): return SM.SuperManager.getInstance().asrManager @property def LanguageManager(self): return SM.SuperManager.getInstance().languageManager @property def TalkManager(self): return SM.SuperManager.getInstance().talkManager @property def TTSManager(self): return SM.SuperManager.getInstance().ttsManager @property def WakewordManager(self): return SM.SuperManager.getInstance().wakewordManager @property def WebInterfaceManager(self): return SM.SuperManager.getInstance().webInterfaceManager @property def Commons(self): return SM.SuperManager.getInstance().commonsManager @property def SnipsWatchManager(self): return SM.SuperManager.getInstance().snipsWatchManager @property def SkillStoreManager(self): return SM.SuperManager.getInstance().skillStoreManager @property def NluManager(self): return SM.SuperManager.getInstance().nluManager @property def DialogTemplateManager(self): return SM.SuperManager.getInstance().dialogTemplateManager @property def SnipsAssistantManager(self): return SM.SuperManager.getInstance().snipsAssistantManager
class ProjectAliceObject: def __init__(self, *args, **kwargs): self._logger = Logger(*args, **kwargs) def __repr__(self) -> str: ret = copy(self.__dict__) ret.pop('_logger') return json.dumps(ret) def __str__(self) -> str: return self.__repr__() def broadcast(self, method: str, exceptions: list = None, manager=None, **kwargs): if not exceptions: exceptions = list() if isinstance(exceptions, str): exceptions = [exceptions] if not exceptions and not manager: # Prevent infinite loop of broadcaster being broadcasted to re broadcasting self.logWarning( 'Cannot broadcast to itself, the calling method has to be put in exceptions' ) return if 'ProjectAlice' not in exceptions: exceptions.append('ProjectAlice') if not method.startswith('on'): method = f'on{method[0].capitalize() + method[1:]}' deadManagers = list() for name, man in SM.SuperManager.getInstance().managers.items(): if not man: deadManagers.append(name) continue if (manager and man.name != manager.name) or man.name in exceptions: continue try: func = getattr(man, method, None) if func: func(**kwargs) except TypeError as e: self.logWarning( f'- Failed to broadcast event {method} to {man.name}: {e}') for name in deadManagers: del SM.SuperManager.getInstance().managers[name] def logInfo(self, msg: str): self._logger.doLog(function='info', msg=self.decorateLogs(msg), printStack=False) def logError(self, msg: str): self._logger.doLog(function='error', msg=self.decorateLogs(msg)) def logDebug(self, msg: str): self._logger.doLog(function='debug', msg=self.decorateLogs(msg), printStack=False) def logFatal(self, msg: str): self._logger.doLog(function='fatal', msg=self.decorateLogs(msg)) try: self.ProjectAlice.onStop() exit() except: exit() def logWarning(self, msg: str, printStack: bool = False): self._logger.doLog(function='warning', msg=self.decorateLogs(msg), printStack=printStack) def logCritical(self, msg: str): self._logger.doLog(function='critical', msg=self.decorateLogs(msg)) def decorateLogs(self, text: str) -> str: return f'[{self.__class__.__name__}] {text}' def onStart(self): pass def onStop(self): pass def onBooted(self): pass def onFullMinute(self): pass def onFiveMinute(self): pass def onQuarterHour(self): pass def onFullHour(self): pass @property def ProjectAlice(self): return SM.SuperManager.getInstance().projectAlice @property def ConfigManager(self): return SM.SuperManager.getInstance().configManager @property def MqttManager(self): return SM.SuperManager.getInstance().mqttManager @property def DatabaseManager(self): return SM.SuperManager.getInstance().databaseManager @property def ThreadManager(self): return SM.SuperManager.getInstance().threadManager @property def TimeManager(self): return SM.SuperManager.getInstance().timeManager @property def HotwordManager(self): return SM.SuperManager.getInstance().hotwordManager @property def Commons(self): return SM.SuperManager.getInstance().commonsManager @property def NetworkManager(self): return SM.SuperManager.getInstance().networkManager
class ProjectAliceObject(object): DEPENDENCIES = {'internal': {}, 'external': {}, 'system': [], 'pip': []} def __init__(self, *args, **kwargs): self._logger = Logger(*args, **kwargs) def __repr__(self) -> str: ret = copy(self.__dict__) ret.pop('_logger') return json.dumps(ret) def __str__(self) -> str: return self.__repr__() def broadcast(self, method: str, exceptions: list = None, manager=None, propagateToSkills: bool = False, **kwargs): # NOSONAR if not exceptions: exceptions = list() if isinstance(exceptions, str): exceptions = [exceptions] if not exceptions and not manager: # Prevent infinite loop of broadcaster being broadcasted to re broadcasting self.logWarning( 'Cannot broadcast to itself, the calling method has to be put in exceptions' ) return if 'ProjectAlice' not in exceptions: exceptions.append('ProjectAlice') if 'DialogManager' not in exceptions: exceptions.append('DialogManager') if not method.startswith('on'): method = f'on{method[0].capitalize() + method[1:]}' # Give absolute priority to DialogManager try: func = getattr( SM.SuperManager.getInstance().getManager('DialogManager'), method, None) if func: func(**kwargs) except TypeError as e: self.logWarning( f'Failed to broadcast event **{method}** to **DialogManager**: {e}' ) deadManagers = list() for name, man in SM.SuperManager.getInstance().managers.copy().items(): if not man: deadManagers.append(name) continue if (manager and man.name != manager.name) or man.name in exceptions: continue try: func = getattr(man, method, None) if func: func(**kwargs) except TypeError as e: self.logWarning( f'Failed to broadcast event **{method}** to **{man.name}**: {e}' ) if propagateToSkills: self.SkillManager.skillBroadcast(method=method, **kwargs) for name in deadManagers: del SM.SuperManager.getInstance().managers[name] if method == 'onAudioFrame': return # Now send the event over mqtt payload = dict() for item, value in kwargs.items(): try: payload[item] = json.dumps(value) except: # Cannot serialize that attribute, do nothing pass self.MqttManager.publish(topic=f'projectalice/events/{method}', payload=payload) def checkDependencies(self) -> bool: self.logInfo('Checking dependencies') for dep in { **self.DEPENDENCIES.get('internal', dict()), **self.DEPENDENCIES.get('external', dict()) }: result = self.Commons.runRootSystemCommand( ['dpkg-query', '-l', dep]) if result.returncode: self.logWarning(f'Found missing dependency: {dep}') return False for dep in self.DEPENDENCIES['pip']: match = re.match(r'^([a-zA-Z0-9-_]*)(?:([=><]{0,2})([\d.]*)$)', dep) if not match: continue packageName, operator, version = match.groups() if not packageName: self.logWarning('Wrongly declared PIP requirement') continue try: installedVersion = packageVersion(packageName) except PackageNotFoundError: self.logWarning(f'Found missing dependencies: {packageName}') return False if not installedVersion or not operator or not version: continue version = Version.fromString(version) installedVersion = Version.fromString(installedVersion) if (operator == '==' and version != installedVersion) or \ (operator == '>=' and installedVersion < version) or \ (operator == '>' and (installedVersion < version or installedVersion == version)) or \ (operator == '<' and (installedVersion > version or installedVersion == version)): self.logWarning( f'Dependency "{packageName}" is not conform with version requirements' ) return False for dep in self.DEPENDENCIES['system']: result = self.Commons.runRootSystemCommand( ['dpkg-query', '-l', dep]) if result.returncode: self.logWarning(f'Found missing dependency: {dep}') return False return True def installDependencies(self) -> bool: self.logInfo('Installing dependencies') try: for dep, link in self.DEPENDENCIES.get('internal', dict()).items(): self.logInfo(f'Installing "{dep}"') result = self.Commons.runRootSystemCommand( ['apt-get', 'install', '-y', f'./{link}']) if result.returncode: raise Exception(result.stderr) self.logInfo(f'Installed!') for dep, link in self.DEPENDENCIES.get('external', dict()).items(): self.logInfo(f'Downloading "{dep}"') if not self.Commons.downloadFile(link, link.rsplit('/')[-1]): return False self.logInfo(f'Installing "{dep}"') result = self.Commons.runRootSystemCommand( ['apt-get', 'install', '-y', f'./{link.rsplit("/")[-1]}']) if result.returncode: raise Exception(result.stderr) Path(link.rsplit('/')[-1]).unlink() self.logInfo(f'Installed!') for dep in self.DEPENDENCIES['system']: self.logInfo(f'Installing "{dep}"') result = self.Commons.runRootSystemCommand( ['apt-get', 'install', '-y', dep]) if result.returncode: raise Exception(result.stderr) self.logInfo(f'Installed!') for dep in self.DEPENDENCIES['pip']: self.logInfo(f'Installing "{dep}"') result = self.Commons.runSystemCommand( ['./venv/bin/pip', 'install', dep]) if result.returncode: raise Exception(result.stderr) self.logInfo(f'Installed!') return True except Exception as e: self.logError(f'Installing dependencies failed: {e}') return False def logInfo(self, msg: str, plural: Union[list, str] = None): self._logger.doLog(function='info', msg=self.decorateLogs(msg), printStack=False, plural=plural) def logError(self, msg: str, plural: Union[list, str] = None): self._logger.doLog(function='error', msg=self.decorateLogs(msg), plural=plural) def logDebug(self, msg: str, plural: Union[list, str] = None): self._logger.doLog(function='debug', msg=self.decorateLogs(msg), printStack=False, plural=plural) def logFatal(self, msg: str, plural: Union[list, str] = None): self._logger.doLog(function='fatal', msg=self.decorateLogs(msg), plural=plural) try: self.ProjectAlice.onStop() except: exit() def logWarning(self, msg: str, printStack: bool = False, plural: Union[list, str] = None): self._logger.doLog(function='warning', msg=self.decorateLogs(msg), printStack=printStack, plural=plural) def logCritical(self, msg: str, plural: Union[list, str] = None): self._logger.doLog(function='critical', msg=self.decorateLogs(msg), plural=plural) def decorateLogs(self, text: str) -> str: return f'[{self.__class__.__name__}] {text}' def onStart(self): pass # Super object function is overridden only if needed def onStop(self, **kwargs): pass # Super object function is overridden only if needed def onBooted(self): pass # Super object function is overridden only if needed def onSkillInstalled(self, skill: str): pass # Super object function is overridden only if needed def onSkillDeleted(self, skill: str): pass # Super object function is overridden only if needed def onSkillUpdated(self, skill: str): pass # Super object function is overridden only if needed def onSkillUpdating(self, skill: str): pass # Super object function is overridden only if needed def onSkillStarted(self, skill: str): pass # Super object function is overridden only if needed def onSkillStopped(self, skill: str): pass # Super object function is overridden only if needed def onSkillActivated(self, skill: str): pass # Super object function is overridden only if needed def onSkillDeactivated(self, skill: str): pass # Super object function is overridden only if needed def onInternetConnected(self): pass # Super object function is overridden only if needed def onInternetLost(self): pass # Super object function is overridden only if needed def onHotword(self, deviceUid: str, user: str = constants.UNKNOWN_USER): pass # Super object function is overridden only if needed def onHotwordToggleOn(self, deviceUid: str, session): pass # Super object function is overridden only if needed def onHotwordToggleOff(self, deviceUid: str, session): pass # Super object function is overridden only if needed def onSessionStarted(self, session): pass # Super object function is overridden only if needed def onContinueSession(self, session): pass # Super object function is overridden only if needed def onAsrToggleOn(self, deviceUid: str): pass # Super object function is overridden only if needed def onAsrToggleOff(self, deviceUid: str): pass # Super object function is overridden only if needed def onStartListening(self, session): pass # Super object function is overridden only if needed def onStopListening(self, session): pass # Super object function is overridden only if needed def onCaptured(self, session): pass # Super object function is overridden only if needed def onNluQuery(self, session): pass # Super object function is overridden only if needed def onIntentParsed(self, session): pass # Super object function is overridden only if needed def onIntent(self, session): pass # Super object function is overridden only if needed def onConfigureIntent(self, intents: list): pass # Super object function is overridden only if needed def onUserCancel(self, session): pass # Super object function is overridden only if needed def onSessionTimeout(self, session): pass # Super object function is overridden only if needed def onIntentNotRecognized(self, session): pass # Super object function is overridden only if needed def onNluIntentNotRecognized(self, session): pass # Super object function is overridden only if needed def onNluError(self, session): pass # Super object function is overridden only if needed def onSessionError(self, session): pass # Super object function is overridden only if needed def onStartSession(self, deviceUid: str, payload: dict): pass # Super object function is overridden only if needed def onSessionEnded(self, session): pass # Super object function is overridden only if needed def onSay(self, session): pass # Super object function is overridden only if needed def onSayFinished(self, session, uid: str = None): pass # Super object function is overridden only if needed def onSessionQueued(self, session): pass # Super object function is overridden only if needed def onMessage(self, session) -> bool: # NOSONAR """ Do not consume the intent by default """ return False def onSleep(self): pass # Super object function is overridden only if needed def onWakeup(self): pass # Super object function is overridden only if needed def onGoingBed(self): pass # Super object function is overridden only if needed def onLeavingHome(self): pass # Super object function is overridden only if needed def onReturningHome(self): pass # Super object function is overridden only if needed def onEating(self): pass # Super object function is overridden only if needed def onWatchingTV(self): pass # Super object function is overridden only if needed def onCooking(self): pass # Super object function is overridden only if needed def onMakeup(self): pass # Super object function is overridden only if needed def onContextSensitiveDelete(self, session): pass # Super object function is overridden only if needed def onContextSensitiveEdit(self, session): pass # Super object function is overridden only if needed def onFullMinute(self): pass # Super object function is overridden only if needed def onFiveMinute(self): pass # Super object function is overridden only if needed def onQuarterHour(self): pass # Super object function is overridden only if needed def onFullHour(self): pass # Super object function is overridden only if needed def onWakeword(self, deviceUid: str, user: str = constants.UNKNOWN_USER): pass # Super object function is overridden only if needed def onMotionDetected(self): pass # Super object function is overridden only if needed def onMotionStopped(self): pass # Super object function is overridden only if needed def onButtonPressed(self): pass # Super object function is overridden only if needed def onButtonReleased(self): pass # Super object function is overridden only if needed def onDeviceDiscovered(self, device, uid: str): pass # Super object function is overridden only if needed def onDeviceAdded(self, device, uid: str): pass # Super object function is overridden only if needed def onDeviceRemoved(self, device, uid: str): pass # Super object function is overridden only if needed def onDeviceConnecting(self): pass # Super object function is overridden only if needed def onDeviceDisconnecting(self): pass # Super object function is overridden only if needed def onUVIndexAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onRaining(self, *args, **kwargs): pass # Super object function is overridden only if needed def onTooMuchRain(self, *args, **kwargs): pass # Super object function is overridden only if needed def onWindy(self, *args, **kwargs): pass # Super object function is overridden only if needed def onFreezing(self, *args, **kwargs): pass # Super object function is overridden only if needed def onTemperatureHighAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onTemperatureLowAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onCOTwoAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onHumidityHighAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onHumidityLowAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onNoiseAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onPressureHighAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onGasAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onPressureLowAlert(self, *args, **kwargs): pass # Super object function is overridden only if needed def onBroadcastingForNewDeviceStart(self): pass # Super object function is overridden only if needed def onBroadcastingForNewDeviceStop(self, *args): pass # Super object function is overridden only if needed def onAuthenticated(self, session): pass # Super object function is overridden only if needed def onAuthenticationFailed(self, session): pass # Super object function is overridden only if needed def onAudioFrame(self, **kwargs): pass # Super object function is overridden only if needed def onAssistantInstalled(self, **kwargs): pass # Super object function is overridden only if needed def onAssistantFailedTraining(self, **kwargs): pass # Super object function is overridden only if needed def onSkillInstallFailed(self, skill: str): pass # Super object function is overridden only if needed def onNluTrained(self, **kwargs): pass # Super object function is overridden only if needed def onVadUp(self, **kwargs): pass # Super object function is overridden only if needed def onVadDown(self, **kwargs): pass # Super object function is overridden only if needed def onPlayBytes(self, payload: bytearray, deviceUid: str, sessionId: str = None): pass # Super object function is overridden only if needed def onPlayBytesFinished(self, deviceUid: str, sessionId: str = None): pass # Super object function is overridden only if needed def onToggleFeedbackOn(self, deviceUid: str): pass # Super object function is overridden only if needed def onToggleFeedbackOff(self, deviceUid: str): pass # Super object function is overridden only if needed def onPartialTextCaptured(self, session, text: str, likelihood: float, seconds: float): pass # Super object function is overridden only if needed def onEndSession(self, session, reason: str = 'nominal'): pass # Super object function is overridden only if needed def onDeviceHeartbeat(self, uid: str, deviceUid: str = None): pass # Super object function is overridden only if needed def onDeviceStatus(self, session): pass # Super object function is overridden only if needed @property def ProjectAlice(self) -> ProjectAlice: # NOSONAR return SM.SuperManager.getInstance().projectAlice @property def ConfigManager(self) -> ConfigManager: # NOSONAR return SM.SuperManager.getInstance().configManager @property def SkillManager(self) -> SkillManager: # NOSONAR return SM.SuperManager.getInstance().skillManager @property def DeviceManager(self) -> DeviceManager: # NOSONAR return SM.SuperManager.getInstance().deviceManager @property def MultiIntentManager(self) -> MultiIntentManager: # NOSONAR return SM.SuperManager.getInstance().multiIntentManager @property def MqttManager(self) -> MqttManager: # NOSONAR return SM.SuperManager.getInstance().mqttManager @property def UserManager(self) -> UserManager: # NOSONAR return SM.SuperManager.getInstance().userManager @property def DatabaseManager(self) -> DatabaseManager: # NOSONAR return SM.SuperManager.getInstance().databaseManager @property def InternetManager(self) -> InternetManager: # NOSONAR return SM.SuperManager.getInstance().internetManager @property def TelemetryManager(self) -> TelemetryManager: # NOSONAR return SM.SuperManager.getInstance().telemetryManager @property def ThreadManager(self) -> ThreadManager: # NOSONAR return SM.SuperManager.getInstance().threadManager @property def TimeManager(self) -> TimeManager: # NOSONAR return SM.SuperManager.getInstance().timeManager @property def ASRManager(self) -> ASRManager: # NOSONAR return SM.SuperManager.getInstance().asrManager @property def LanguageManager(self) -> LanguageManager: # NOSONAR return SM.SuperManager.getInstance().languageManager @property def TalkManager(self) -> TalkManager: # NOSONAR return SM.SuperManager.getInstance().talkManager @property def TTSManager(self) -> TTSManager: # NOSONAR return SM.SuperManager.getInstance().ttsManager @property def WakewordRecorder(self) -> WakewordRecorder: # NOSONAR return SM.SuperManager.getInstance().wakewordRecorder @property def ApiManager(self) -> ApiManager: # NOSONAR return SM.SuperManager.getInstance().apiManager @property def Commons(self) -> CommonsManager: # NOSONAR return SM.SuperManager.getInstance().commonsManager @property def SkillStoreManager(self) -> SkillStoreManager: # NOSONAR return SM.SuperManager.getInstance().skillStoreManager @property def NluManager(self) -> NluManager: # NOSONAR return SM.SuperManager.getInstance().nluManager @property def DialogTemplateManager(self) -> DialogTemplateManager: # NOSONAR return SM.SuperManager.getInstance().dialogTemplateManager @property def AssistantManager(self) -> AssistantManager: # NOSONAR return SM.SuperManager.getInstance().assistantManager @property def AliceWatchManager(self) -> AliceWatchManager: # NOSONAR return SM.SuperManager.getInstance().aliceWatchManager @property def AudioServer(self) -> AudioManager: # NOSONAR return SM.SuperManager.getInstance().audioManager @property def DialogManager(self) -> DialogManager: # NOSONAR return SM.SuperManager.getInstance().dialogManager @property def LocationManager(self) -> LocationManager: # NOSONAR return SM.SuperManager.getInstance().locationManager @property def WakewordManager(self) -> WakewordManager: # NOSONAR return SM.SuperManager.getInstance().wakewordManager @property def NodeRedManager(self) -> NodeRedManager: # NOSONAR return SM.SuperManager.getInstance().nodeRedManager @property def WidgetManager(self) -> WidgetManager: # NOSONAR return SM.SuperManager.getInstance().widgetManager @property def StateManager(self) -> StateManager: # NOSONAR return SM.SuperManager.getInstance().stateManager @property def WebUIManager(self) -> WebUIManager: # NOSONAR return SM.SuperManager.getInstance().webUiManager @property def SubprocessManager(self) -> SubprocessManager: # NOSONAR return SM.SuperManager.getInstance().subprocessManager @property def WebUINotificationManager(self) -> WebUINotificationManager: # NOSONAR return SM.SuperManager.getInstance().webUINotificationManager @property def BugReportManager(self) -> BugReportManager: # NOSONAR return SM.SuperManager.getInstance().bugReportManager