def _registerOnBridge(self):
try:
self._bridge.register()
self._bridgeConnectTries = 0
self.ThreadManager.doLater(
interval=3,
func=self.say,
args=[self.randomTalk('pressBridgeButtonConfirmation')])
except LinkButtonNotPressed:
if self._bridgeConnectTries < 3:
self.say(text=self.randomTalk('pressBridgeButton'))
self._bridgeConnectTries += 1
self.logWarning(
'Bridge not registered, please press the bridge button, retry in 20 seconds'
)
time.sleep(20)
self._registerOnBridge()
else:
self.ThreadManager.doLater(
interval=3,
func=self.say,
args=[self.randomTalk('pressBridgeButtonTimeout')])
raise SkillStartingFailed(skillName=self.name,
error=f"Couldn't reach bridge")
except PhueRegistrationError as e:
raise SkillStartingFailed(skillName=self.name,
error=f'Error connecting to bridge: {e}')
def __init__(self, supportedIntents: Iterable = None, databaseSchema: dict = None):
super().__init__(logDepth=4)
try:
path = Path(inspect.getfile(self.__class__)).with_suffix('.install')
self._install = json.loads(path.read_text())
except FileNotFoundError:
raise SkillStartingFailed(error=f'[{type(self).__name__}] Cannot find install file')
except Exception as e:
raise SkillStartingFailed(error=f'[{type(self).__name__}] Failed loading skill: {e}')
self._name = self._install['name']
self._author = self._install['author']
self._version = self._install['version']
self._updateAvailable = False
self._active = True
self._delayed = False
self._required = False
self._databaseSchema = databaseSchema
self._widgets = dict()
self._intentsDefinitions = dict()
self._scenarioNodeName = ''
self._scenarioNodeVersion = Version(mainVersion=0, updateVersion=0, hotfix=0)
self._supportedIntents: Dict[str, Intent] = self.buildIntentList(supportedIntents)
self.loadIntentsDefinition()
self._utteranceSlotCleaner = re.compile('{(.+?):=>.+?}')
self.loadWidgets()
self.loadScenarioNodes()
def __init__(self,
supportedIntents: Iterable = None,
databaseSchema: dict = None,
**kwargs):
super().__init__(**kwargs)
try:
self._skillPath = Path(inspect.getfile(self.__class__)).parent
self._installFile = Path(inspect.getfile(
self.__class__)).with_suffix('.install')
self._installer = json.loads(self._installFile.read_text())
except FileNotFoundError:
raise SkillStartingFailed(
skillName=constants.UNKNOWN,
error=f'[{type(self).__name__}] Cannot find install file')
except Exception as e:
raise SkillStartingFailed(
skillName=constants.UNKNOWN,
error=f'[{type(self).__name__}] Failed loading skill: {e}')
instructionsFile = self.getResource(
f'instructions/{self.LanguageManager.activeLanguage}.md')
if not instructionsFile.exists():
instructionsFile = self.getResource(f'instructions/en.md')
self._instructions = instructionsFile.read_text(
) if instructionsFile.exists() else ''
self._name = self._installer['name']
self._author = self._installer.get('author', constants.UNKNOWN)
self._version = self._installer.get('version', '0.0.1')
self._icon = self._installer.get('icon', 'fas fa-biohazard')
self._aliceMinVersion = Version.fromString(
self._installer.get('aliceMinVersion', '1.0.0-b4'))
self._maintainers = self._installer.get('maintainers', list())
self._description = self._installer.get('desc', '')
self._category = self._installer.get('category', constants.UNKNOWN)
self._conditions = self._installer.get('conditions', dict())
self._updateAvailable = False
self._modified = False
self._active = False
self._delayed = False
self._required = False
self._failedStarting = False
self._databaseSchema = databaseSchema
self._widgets = list()
self._widgetTemplates = dict()
self._deviceTypes = list()
self._intentsDefinitions = dict()
self._scenarioPackageName = ''
self._scenarioPackageVersion = Version(mainVersion=0,
updateVersion=0,
hotfix=0)
self._supportedIntents: Dict[str, Intent] = self.buildIntentList(
supportedIntents)
self.loadIntentsDefinition()
self._utteranceSlotCleaner = re.compile('{(.+?):=>.+?}')
self._myDevicesTemplates = dict()
self._myDevices: Dict[str, Device] = dict()
def onStart(self):
super().onStart()
self._bridge = Bridge(ip=self.getConfig('phueBridgeIp'),
confFile=self._hueConfigFile)
if not self.delayed:
try:
if self._bridge.connect(autodiscover=not self.getAliceConfig(
'stayCompletlyOffline')):
self.logInfo('Connected to Philips Hue bridge')
except UnauthorizedUser:
try:
self._bridge.register()
except LinkButtonNotPressed:
self.logInfo('User is not authorized')
self.delayed = True
raise SkillStartDelayed(self.name)
except NoPhueIP:
raise SkillStartingFailed(
skillName=self.name,
error=
'Bridge IP not set and stay completly offline set to True, cannot auto discover Philips Hue bridge'
)
else:
if not self.ThreadManager.isThreadAlive('PHUERegister'):
self.ThreadManager.newThread(name='PHUERegister',
target=self._registerOnBridge)
def onStart(self):
super().onStart()
redQueenIdentityFile = self._getRedQueenIdentityFileName()
redQueenIdentityFileTemplate = redQueenIdentityFile + '.dist'
if not os.path.isfile(redQueenIdentityFile):
if os.path.isfile(redQueenIdentityFileTemplate):
shutil.copyfile(redQueenIdentityFileTemplate,
redQueenIdentityFile)
self.logInfo('New Red Queen is born')
with open(self._getRedQueenIdentityFileName(), 'r') as f:
self._redQueen = json.load(f)
self._redQueen['infos']['born'] = time.strftime("%d.%m.%Y")
self._saveRedQueenIdentity()
else:
self.logInfo('Cannot find Red Queen identity template')
raise SkillStartingFailed(skillName=self.name)
else:
self.logInfo('Found existing Red Queen identity')
with open(self._getRedQueenIdentityFileName(), 'r') as f:
self._redQueen = json.load(f)
return self.supportedIntents
def _connectAccount(self):
try:
self._bring = self.bring()
except BringApi.AuthentificationFailed:
raise SkillStartingFailed(
skillName=self._name,
error='Please check your account login and password')
def onStart(self) -> dict:
super().onStart()
if not self.getConfig('password'):
raise SkillStartingFailed(skillName=self.name,
error='No credentials provided')
if not self._auth():
raise SkillStartingFailed(skillName=self.name,
error='Authentication failed')
try:
self._weatherData = lnetatmo.WeatherStationData(self._netatmoAuth)
except lnetatmo.NoDevice:
raise SkillStartingFailed(skillName=self.name,
error='No Netatmo device found')
return self.supportedIntents
def __init__(self,
supportedIntents: Iterable = None,
databaseSchema: dict = None,
**kwargs):
super().__init__(**kwargs)
try:
self._skillPath = Path(inspect.getfile(self.__class__)).parent
self._installFile = Path(inspect.getfile(
self.__class__)).with_suffix('.install')
self._installer = json.loads(self._installFile.read_text())
except FileNotFoundError:
raise SkillStartingFailed(
skillName=constants.UNKNOWN,
error=f'[{type(self).__name__}] Cannot find install file')
except Exception as e:
raise SkillStartingFailed(
skillName=constants.UNKNOWN,
error=f'[{type(self).__name__}] Failed loading skill: {e}')
self._name = self._installer['name']
self._author = self._installer['author']
self._version = self._installer['version']
self._icon = self._installer['icon']
self._description = self._installer['desc']
self._category = self._installer[
'category'] if 'category' in self._installer else 'undefined'
self._conditions = self._installer['conditions']
self._updateAvailable = False
self._active = False
self._delayed = False
self._required = False
self._databaseSchema = databaseSchema
self._widgets = dict()
self._deviceTypes = dict()
self._intentsDefinitions = dict()
self._scenarioNodeName = ''
self._scenarioNodeVersion = Version(mainVersion=0,
updateVersion=0,
hotfix=0)
self._supportedIntents: Dict[str, Intent] = self.buildIntentList(
supportedIntents)
self.loadIntentsDefinition()
self._utteranceSlotCleaner = re.compile('{(.+?):=>.+?}')
def onStart(self):
super().onStart()
if not self.getConfig('token'):
raise SkillStartingFailed(
skillName=self._name,
error='Please provide your bot token in the skill settings')
self._bot = telepot.Bot(self.getConfig('token'))
try:
self._me = self._bot.getMe()
except:
raise SkillStartingFailed(skillName=self._name,
error='Your token seems incorrect')
self.loadUsers()
self.logInfo(f'Loaded {len(self._users)} user', plural='users')
def onStart(self):
super().onStart()
self._sonosPlayers = {
device.player_name.lower(): device
for device in soco.discover()
}
if not self._sonosPlayers:
raise SkillStartingFailed(skillName=self.name,
error='No Sonos device found')
else:
self.heartbeat()
def onStart(self):
super().onStart()
gpioPin = self.getConfig('gpioPin')
if gpioPin:
self._gpioPin = int(gpioPin)
else:
raise SkillStartingFailed(
skillName=self.name,
error='Failed fetching gpio pin definition')
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self._gpioPin, GPIO.OUT)
GPIO.output(self._gpioPin, GPIO.LOW)
def onStart(self):
super().onStart()
redQueenIdentityFile = self._getRedQueenIdentityFile()
redQueenIdentityFileTemplate = redQueenIdentityFile.with_suffix(redQueenIdentityFile.suffix + '.dist')
if redQueenIdentityFile.exists():
self._me = json.loads(redQueenIdentityFile.read_text())
if not self._me:
self.logWarning('Red Queen identity file seems corrupted, rebuilding it')
redQueenIdentityFile.unlink()
if not redQueenIdentityFile.exists():
if redQueenIdentityFileTemplate.exists():
shutil.copyfile(str(redQueenIdentityFileTemplate), str(redQueenIdentityFile))
self.logInfo('New Red Queen is born')
self._me = json.loads(redQueenIdentityFile.read_text())
self._me['infos']['born'] = time.strftime("%d.%m.%Y")
self._saveRedQueenIdentity()
else:
raise SkillStartingFailed(skillName=self.name, error='Cannot find Red Queen identity template')
else:
self.logInfo('Found existing Red Queen identity')
self._me = json.loads(redQueenIdentityFile.read_text())
def onStart(self):
super().onStart()
self._youtube = YouTubeDataAPI(self.getConfig('youtubeApiKey'))
if not self._youtube.verify_key():
raise SkillStartingFailed('Youtube api key not valid')
def __init__(self):
super().__init__()
try:
self._youtube: Optional[YouTubeDataAPI] = None
except ValueError:
raise SkillStartingFailed('Youtube api key not valid')
def onStart(self):
super().onStart()
if not self.getConfig('apiKey'):
raise SkillStartingFailed('Missing API key')