def onStop(self):
mqttManager = self._managers.pop(
'MqttManager', None) # Mqtt goes down last with bug reporter
bugReportManager = self._managers.pop(
'BugReportManager', None) # bug reporter goes down as last
skillManager = self._managers.pop(
'SkillManager',
None) # Skill manager goes down first, to tell the skills
if skillManager:
try:
skillManager.onStop()
except Exception as e:
Logger().logError(f'Error stopping SkillManager: {e}')
for managerName, manager in self._managers.items():
try:
if manager.isActive:
manager.onStop()
except Exception as e:
Logger().logError(
f'Error while shutting down manager **{managerName}**: {e}'
)
if mqttManager:
try:
mqttManager.onStop()
except Exception as e:
Logger().logError(f'Error stopping MqttManager: {e}')
if bugReportManager:
try:
bugReportManager.onStop()
except Exception as e:
Logger().logError(f'Error stopping BugReportManager: {e}')
class State:
name: str
currentState: StateType = StateType.BORN
logger: Logger = Logger(prepend='[State]')
callbacks: list = field(default_factory=list)
def subscribe(self, callback: Callable):
self.callbacks.append(callback)
def unsubscribe(self, callback: Callable):
self.callbacks.remove(callback)
def setState(self, newState: StateType):
oldState = self.currentState
self.currentState = newState
for callback in self.callbacks:
try:
callback(oldState, newState)
except:
self.logger.logWarning(
f'Failed callback for state {self.name}')
def __repr__(self) -> str:
return f'State "{self.name}" Current state "{self.currentState.value}"'
def __init__(self, host: str, port: int, hotwordName: str):
super().__init__()
self._logger = Logger(prepend='[HotwordDownloadThread]')
self._host = host
self._port = int(port)
self._hotwordName = hotwordName
self.setDaemon(True)
def __init__(self, restartHandler: callable):
Singleton.__init__(self, self.NAME)
self._logger = Logger(prepend='[Project Alice]')
self._logger.logInfo('Starting Alice main unit')
self._booted = False
self._isUpdating = False
self._shuttingDown = False
self._restart = False
self._restartHandler = restartHandler
if not self.checkDependencies():
self._restart = True
self._restartHandler()
else:
with Stopwatch() as stopWatch:
self._superManager = SuperManager(self)
self._superManager.initManagers()
self._superManager.onStart()
if self._superManager.configManager.getAliceConfigByName(
'useHLC'):
self._superManager.commons.runRootSystemCommand(
['systemctl', 'start', 'hermesledcontrol'])
self._superManager.onBooted()
self._logger.logInfo(f'Started in {stopWatch} seconds')
self._booted = True
def __init__(self, name):
super().__init__()
if self.INSTANCE:
Logger().logFatal(f'Trying to instanciate {name} but instance already exists')
raise KeyboardInterrupt
else:
self.INSTANCE = self
def onStop(self):
managerName = constants.UNKNOWN_MANAGER
try:
for managerName, manager in self._managers.items():
manager.onStop()
except Exception as e:
Logger().logError(
f'Error while shutting down manager "{managerName}": {e}')
def onStop(self):
managerName = constants.UNKNOWN_MANAGER
try:
mqttManager = self._managers.pop('MqttManager')
for managerName, manager in self._managers.items():
manager.onStop()
managerName = mqttManager.name
mqttManager.onStop()
except KeyError as e:
Logger().logWarning(
f'Manager **{managerName}** was not running: {e}')
except Exception as e:
Logger().logError(
f'Error while shutting down manager **{managerName}**: {e}')
traceback.print_exc()
def __init__(self, host: str, port: int, zipPath: str):
super().__init__()
self._logger = Logger()
self.setDaemon(True)
self._host = host
self._port = port
self._zipPath = Path(zipPath)
def __init__(self,
message: str = None,
status: int = None,
context: list = None):
self._logger = Logger()
self._message = message
self._status = status
self._context = context
super().__init__(message)
def __init__(self, host: str, port: int, zipPath: str):
super().__init__()
self._logger = Logger(prepend='[HotwordUploadThread]')
self.setDaemon(True)
self._host = host
self._port = port
self._zipPath = Path(zipPath)
def exceptionDecorator(*args, **kwargs):
try:
return func(*args, **kwargs)
except exceptions as e:
Logger(depth=6).logWarning(msg=e, printStack=printStack)
return _exceptHandler(*args,
text=text,
exceptHandler=exceptHandler,
returnText=returnText,
**kwargs)
def restartManager(self, manager: str):
if not manager in self._managers:
Logger().logWarning(
f'Was asking to restart manager **{manager}** but it doesn\'t exist'
)
return
self._managers[manager].onStop()
self._managers[manager].onStart()
self._managers[manager].onBooted()
def onBooted(self):
self.mqttManager.playSound(soundFilename='boot')
manager = None
try:
for manager in self._managers.values():
if manager:
manager.onBooted()
except Exception as e:
Logger().logError(
f'Error while sending onBooted to manager **{manager.name}**: {e}'
)
def onStop(self):
managerName = constants.UNKNOWN_MANAGER
try:
mqttManager = self._managers.pop('MqttManager')
for managerName, manager in self._managers.items():
manager.onStop()
managerName = mqttManager.name
mqttManager.onStop()
except Exception as e:
Logger().logError(
f'Error while shutting down manager **{managerName}**: {e}')
def onBooted(self):
manager = None
try:
for manager in self._managers.values():
if manager:
manager.onBooted()
except Exception as e:
Logger().logError(
f'Error while sending onBooted to manager **{manager.name}**: {e}'
)
deviceList = self.deviceManager.getDevicesWithAbilities(
[DeviceAbility.IS_SATELITTE, DeviceAbility.IS_CORE])
self.mqttManager.playSound(soundFilename='boot', deviceUid=deviceList)
def settingDecorator(*args, **kwargs): if not settingName: Logger().logWarning(msg='Cannot use IfSetting decorator without settingName') return None configManager = SuperManager.getInstance().configManager value = configManager.getSkillConfigByName(skillName, settingName) if skillName else configManager.getAliceConfigByName(settingName) if value is None: return None if (not inverted and value == settingValue) or \ (inverted and value != settingValue): return func(*args, **kwargs)
def __init__(self, restartHandler: callable):
Singleton.__init__(self, self.NAME)
self._logger = Logger()
self._logger.logInfo('Starting up Project Alice')
self._booted = False
with Stopwatch() as stopWatch:
self._restart = False
self._restartHandler = restartHandler
self._superManager = SuperManager(self)
self._superManager.initManagers()
self._superManager.onStart()
if self._superManager.configManager.getAliceConfigByName('useHLC'):
self._superManager.commons.runRootSystemCommand(
['systemctl', 'start', 'hermesledcontrol'])
self._superManager.onBooted()
self._logger.logInfo(f'- Started Project Alice in {stopWatch} seconds')
self._booted = True
def onStart(self):
try:
commons = self._managers.pop('CommonsManager')
commons.onStart()
configManager = self._managers.pop('ConfigManager')
configManager.onStart()
languageManager = self._managers.pop('LanguageManager')
languageManager.onStart()
locationManager = self._managers.pop('LocationManager')
locationManager.onStart()
deviceManager = self._managers.pop('DeviceManager')
deviceManager.onStart()
audioServer = self._managers.pop('AudioManager')
audioServer.onStart()
internetManager = self._managers.pop('InternetManager')
internetManager.onStart()
databaseManager = self._managers.pop('DatabaseManager')
databaseManager.onStart()
userManager = self._managers.pop('UserManager')
userManager.onStart()
mqttManager = self._managers.pop('MqttManager')
mqttManager.onStart()
talkManager = self._managers.pop('TalkManager')
skillManager = self._managers.pop('SkillManager')
assistantManager = self._managers.pop('AssistantManager')
dialogTemplateManager = self._managers.pop('DialogTemplateManager')
nluManager = self._managers.pop('NluManager')
nodeRedManager = self._managers.pop('NodeRedManager')
for manager in self._managers.values():
if manager:
manager.onStart()
talkManager.onStart()
nluManager.onStart()
skillManager.onStart()
dialogTemplateManager.onStart()
assistantManager.onStart()
nodeRedManager.onStart()
self._managers[configManager.name] = configManager
self._managers[audioServer.name] = audioServer
self._managers[languageManager.name] = languageManager
self._managers[locationManager.name] = locationManager
self._managers[deviceManager.name] = deviceManager
self._managers[talkManager.name] = talkManager
self._managers[databaseManager.name] = databaseManager
self._managers[userManager.name] = userManager
self._managers[mqttManager.name] = mqttManager
self._managers[skillManager.name] = skillManager
self._managers[dialogTemplateManager.name] = dialogTemplateManager
self._managers[assistantManager.name] = assistantManager
self._managers[nluManager.name] = nluManager
self._managers[internetManager.name] = internetManager
self._managers[nodeRedManager.name] = nodeRedManager
except Exception as e:
import traceback
traceback.print_exc()
Logger().logFatal(f'Error while starting managers: {e}')
def __init__(self, logDepth: int = 3, *args, **kwargs):
self._depth = logDepth
self._logger = Logger(logDepth)
def __init__(self, *args, **kwargs):
self._logger = Logger(*args, **kwargs)
def init(self, lightId: int, bridgeInstance: Bridge):
self.id = lightId
self.bridge = bridgeInstance
self.name = self.name.lower()
self.logger = Logger(prepend='[Phue Light]')
class Light(object):
state: dict
swupdate: dict
type: str
name: str
modelid: str
manufacturername: str
productname: str
capabilities: dict
config: dict
uniqueid: str
swversion: str
swconfigid: str = ''
productid: str = ''
id: int = 0
bridge: Optional[Bridge] = None
myScenes: list = field(default_factory=list)
logger: Logger = Logger(prepend='[Phue Light]')
def init(self, lightId: int, bridgeInstance: Bridge):
self.id = lightId
self.bridge = bridgeInstance
self.name = self.name.lower()
def __str__(self) -> str:
return f'Light id {self.id} named "{self.name}" of type {self.type}.'
def on(self): #NOSONAR
self.request(url=f'/{self.id}/state', method='PUT', data={'on': True})
def off(self):
self.request(url=f'/{self.id}/state', method='PUT', data={'on': False})
@property
def isOn(self) -> bool:
return self.state['on']
@property
def isOff(self) -> bool:
return not self.state['on']
def alert(self, state: str = 'lselect'):
self.request(url=f'/{self.id}/state', method='PUT', data={'alert': state})
def effect(self, effect: str = 'colorloop'):
self.request(url=f'/{self.id}/state', method='PUT', data={'effect': effect})
def configure(self, data: dict, sendToBridge: bool = True):
for key, value in data.items():
if not key in self.state:
continue
self.state[key] = value
if sendToBridge:
self.request(url=f'/{self.id}/state', method='PUT', data=data)
@property
def brightness(self) -> int:
return self.state['bri']
# noinspection DuplicatedCode
@brightness.setter
def brightness(self, value: int):
if value == 0:
self.off()
self.state['bri'] = 0
return
value = sorted((1, value, 254))[1]
self.state['bri'] = value
self.request(url=f'/{self.id}/state', method='PUT', data={'bri': value})
@property
def saturation(self) -> int:
return self.state['sat']
@saturation.setter
def saturation(self, value: int):
value = sorted((1, value, 254))[1]
self.state['sat'] = value
self.request(url=f'/{self.id}/state', method='PUT', data={'sat': value})
@property
def hue(self) -> int:
return self.state['hue']
@hue.setter
def hue(self, value: int):
value = sorted((0, value, 65535))[1]
self.state['hue'] = value
self.request(url=f'/{self.id}/state', method='PUT', data={'hue': value})
@property
def xy(self) -> list: #NOSONAR
return self.state['xy']
@xy.setter
def xy(self, value: list): #NOSONAR
x = sorted((0, value[0], 1))[1] #NOSONAR
y = sorted((0, value[1], 1))[1] #NOSONAR
self.state['xy'] = [x, y]
self.request(url=f'/{self.id}/state', method='PUT', data={'xy': value})
@property
def mired(self) -> int:
return self.state['ct']
@mired.setter
def mired(self, value: int):
self.state['ct'] = value
self.request(url=f'/{self.id}/state', method='PUT', data={'ct': value})
@property
def colormode(self) -> str:
return self.state.get('colormode', None)
@colormode.setter
def colormode(self, mode: str):
if 'colormode' not in self.state:
self.logger.logWarning(f'Light {self.name} with id {self.id} does not support colormode changing')
return
if mode not in ('hs', 'xy', 'ct'):
mode = 'ct'
self.logger.logWarning('Invalid color mode specified. Allowed value are "hs", "ct", "xy"')
self.state['colormode'] = mode
self.request(url=f'/{self.id}/state', method='PUT', data={'colormode': mode})
@property
def reachable(self) -> bool:
return self.state['reachable']
def delete(self):
self.request(url=f'/{self.id}', method='DELETE')
def request(self, url: str, data: dict = None, method: str = 'GET'):
if not self.reachable or not self.bridge:
raise LightNotReachable
self.bridge.sendAuthRequest(url=f'/lights{"/" if not url.startswith("/") else ""}{url}', method=method, data=data)