def pulsatingLightCall(self, api, exceeded, bright_max, color):
#actual brightness
bright = 1.0
#when the maximum brigthness is reached
reachedmax = False
lamp = Config.get('Sensors', 'Lamp')
global goodRoom
#Loop to control the light
while (exceeded == True):
if bright <= bright_max and not reachedmax:
bright = bright + 1
if (bright == bright_max):
reachedmax = True
else:
if bright == 1:
exceeded = False
reachedmax = False
#Set global variable that one value is out of the defined borders
goodRoom = False
bright = bright - 1
#Call Home Assistant to set the light
remote.call_service(api, 'light', 'turn_on', {
'entity_id': lamp,
'brightness': bright,
'rgb_color': color
})
#Wait 0,1 seconds to make the brightness change smooth
time.sleep(0.1)
def cli(ctx, service, persist, title, message, notification_id):
"""Send a notification with a given service."""
import homeassistant.remote as remote
domain = 'notify'
data = {"title": title, "message": message}
if service and not persist:
if service in get_services(ctx.api, domain):
remote.call_service(ctx.api, domain, service, data)
ctx.vlog('Notification sent with %s at %s', service, timestamp())
ctx.vlog('Title %s, Message: %s', title, message)
else:
ctx.log('Service %s is not available', service)
if persist and not service:
if notification_id:
data['notification_id'] = notification_id
if 'create' in get_services(ctx.api, 'persistent_notification'):
remote.call_service(ctx.api, 'persistent_notification', 'create',
data)
ctx.vlog('Persistent Notification created on %s at %s', ctx.host,
timestamp())
ctx.vlog('Title %s, Message: %s', title, message)
else:
ctx.log('Service %s is not available', 'persistent_notification')
def setLightColor(self, api, values):
#Mimimum temprature
color = ast.literal_eval(Config.get('Sectors', 'Temp_Min_Color'))
pulsatingLightCall(api, values['temp_min'], values['temp_bright'],
color)
#Maximum temprature
color = ast.literal_eval(Config.get('Sectors', 'Temp_Max_Color'))
pulsatingLightCall(api, values['temp_max'], values['temp_bright'],
color)
#Minimum humidity
color = ast.literal_eval(Config.get('Sectors', 'Hum_Min_Color'))
pulsatingLightCall(api, values['hum_min'], values['hum_bright'], color)
#Maximum humidity
color = ast.literal_eval(Config.get('Sectors', 'Hum_Max_Color'))
pulsatingLightCall(api, values['hum_max'], values['hum_bright'], color)
#Maximum Co2
color = ast.literal_eval(Config.get('Sectors', 'Co2_Max_Color'))
pulsatingLightCall(api, values['Co2_max'], values['Co2_bright'], color)
#When no value border is exceeded set the light to default
if goodRoom:
color = ast.literal_eval(Config.get('Sectors', 'Default_Color'))
remote.call_service(
api, 'light', 'turn_on', {
'entity_id': Config.get('Sensors', 'Lamp'),
'brightness': 1,
'rgb_color': color
})
time.sleep(10)
def arp_handle(pkt):
global last_trigger
if (
ARP in pkt and pkt[ARP].op == 1 and # who-has (request)
abs(time.time() - last_trigger) > blackout_time
):
mac = pkt[ARP].hwsrc.lower()
logger.debug("Found ARP request")
if mac in config.sections():
if (
config.has_option(mac, 'domain') and
config.has_option(mac, 'action')
):
domain = config.get(mac, 'domain')
action = config.get(mac, 'action')
data = json.loads(config.get(mac, 'data', fallback=''))
logger.info(
"Found Button %s, will execute %s.%s with data %s",
mac, domain, action, data
)
ha.call_service(api, domain, action, data)
else:
logger.info(
"Found Button %s, will fire event for that mac", mac
)
ha.fire_event(api, 'dash_button_pressed', {'mac': mac})
last_trigger = time.time()
def mute(self):
#get the mute state of sonos, will be used in media_mute api.
sonos_state = remote.get_state(api,'media_player.{0}'.format(self.device_name))
mute_state = "false" if sonos_state.attributes['is_volume_muted'] else "true"
remote.call_service(api,'media_player','volume_mute',\
{'entity_id':'media_player.{0}'.format(self.device_name),\
"is_volume_muted":"{}".format(mute_state)})
def cycle(self):
url = "http://pegasus.cs.moravian.edu:8080/api/wemo" # Enter url here
api = remote.API('http://homeassistant.cs.moravian.edu:8123/states', 'raspberry')
for i in range(3):
remote.call_service(api, 'switch', 'turn_on')
time.sleep(3)
remote.call_service(api, 'switch', 'turn_off')
time.sleep(3)
async def off(self, entity: str):
"""Turn a light off"""
try:
domain = 'light'
state = 'turn_off'
remote.call_service(
api, domain, state,
{'entity_id': '{}'.format(domain) + '.{}'.format(entity)})
except:
await self.bot.say("There was an error!")
def callback(self):
if self.haevent.state == hasconst.STATE_OFF:
status = remote.call_service(self.api, "homeassistant", 'turn_on',
{'entity_id': self.haevent.entity_id})
else:
status = remote.call_service(self.api, "homeassistant", 'turn_off',
{'entity_id': self.haevent.entity_id})
# TODO: Fix time
self.update_hass_event()
def setswitchstatus(switchstatus):
if getswitchstatus() == switchstatus:
return('ALREADY')
else:
if switchstatus == 'on':
remote.call_service(api, domain, 'turn_on')
print('Switch set succefully to ' + switchstatus)
return('DONE')
elif switchstatus == 'off':
remote.call_service(api, domain, 'turn_off')
return('DONE')
else:
return('INVALID')
def call_service(self, domain, command, entity=None):
"""
Call a service with a given command.
"""
if entity is not None:
result = remote.call_service(self.api, domain, command, entity)
else:
result = remote.call_service(self.api, domain, command)
if result is True:
result = 'Ok.'
elif result is False:
result = 'Uh oh! Something went wrong.'
return result
def callback(self):
if self.haevent.state == hasconst.STATE_OFF:
status = remote.call_service(self.api, self.haevent.domain,
'turn_on',
{'entity_id': self.haevent.entity_id})
else:
status = remote.call_service(self.api, self.haevent.domain,
'turn_off',
{'entity_id': self.haevent.entity_id})
# TODO: Fix time
self.set_hass_event(remote.get_state(self.api, self.haevent.entity_id))
def test_call_service(self):
""" Test Python API call_service. """
test_value = []
def listener(service_call): # pylint: disable=unused-argument
""" Helper method that will verify that our service got called. """
test_value.append(1)
hass.services.register("test_domain", "test_service", listener)
remote.call_service(master_api, "test_domain", "test_service")
hass._pool.block_till_done()
self.assertEqual(1, len(test_value))
def test_call_service(self):
""" Test Python API call_service. """
test_value = []
def listener(service_call): # pylint: disable=unused-argument
""" Helper method that will verify that our service got called. """
test_value.append(1)
hass.services.register("test_domain", "test_service", listener)
remote.call_service(master_api, "test_domain", "test_service")
hass._pool.block_till_done()
self.assertEqual(1, len(test_value))
def turn_on_light(sets):
try:
if sets['norun']:
print(sets['norun'])
exit(0)
except KeyError:
pass
remote.call_service(
api, 'light', 'turn_on', {
'entity_id': 'light.hugo',
'rgb_color': sets['rgb'],
'brightness': sets['brightness']
})
print("w" + symb['state'])
exit(0)
def test_call_service(self):
""" Test Python API call_service. """
test_value = []
def listener(service_call): # pylint: disable=unused-argument
""" Helper method that will verify that our service got called. """
test_value.append(1)
self.hass.services.register("test_domain", "test_service", listener)
remote.call_service(self.api, "test_domain", "test_service")
# Allow the event to take place
time.sleep(1)
self.assertEqual(len(test_value), 1)
def test_call_service(self):
""" Test Python API services.call. """
test_value = []
def listener(service_call):
""" Helper method that will verify that our service got called. """
test_value.append(1)
hass.services.register("test_domain", "test_service", listener)
remote.call_service(master_api, "test_domain", "test_service")
hass.pool.block_till_done()
self.assertEqual(1, len(test_value))
# Should not raise an exception
remote.call_service(broken_api, "test_domain", "test_service")
def test_call_service(self):
""" Test Python API services.call. """
test_value = []
def listener(service_call):
""" Helper method that will verify that our service got called. """
test_value.append(1)
hass.services.register("test_domain", "test_service", listener)
remote.call_service(master_api, "test_domain", "test_service")
hass.pool.block_till_done()
self.assertEqual(1, len(test_value))
# Should not raise an exception
remote.call_service(broken_api, "test_domain", "test_service")
def turn_on_light(self, light_name, brightness=255):
data = {
'entity_id': 'light.{}'.format(light_name),
'brightness': brightness
}
return remote.call_service(self.api,
'light',
'turn_on',
service_data=data)
def create_reaction(self, menu, arguments, admin_access):
if menu == MENU_MEOW:
return COMMAND_CATS
if SPECIAL_MONKEY in menu or SPECIAL_MONKEY in arguments:
return SPECIAL_MONKEY
if SPECIAL_LAUGH in menu or SPECIAL_LAUGH in arguments:
return "🙉"
if not admin_access:
return ""
if menu == MENU_DIE:
return COMMAND_DIE
if menu == MENU_SWITCH_SUB:
for switch in self.sensors["switch"]:
if switch["id"] == arguments[0]:
return switch["state"]
if menu == COMMAND_STATE:
for sensortype in self.sensors:
for sensor in self.sensors[sensortype]:
if sensor["id"] == arguments[0]:
return sensor["state"]
if not len(arguments) < 2:
if menu == COMMAND_SWITCH and arguments[1] != ACTION_CANCEL:
action = ""
if arguments[1] == ACTION_ON:
action = "turn_on"
if arguments[1] == ACTION_OFF:
action = "turn_off"
remote.call_service(self.api, "switch", action,
{"entity_id": arguments[0]})
return "ok"
if menu == MENU_STATES or menu == MENU_SWITCHES \
or menu == MENU_STATES_SUB or menu == COMMAND_SWITCH:
return "What do you want to do?"
return ""
def xiaomi_gateway_light(self,
entity_id,
state='turn_on',
rgb_color=(255, 255, 255),
brightness=100):
assert state in ['turn_on', 'turn_off'
], 'inputted state must be turn_on or turn_off'
service_data = {}
if state == 'turn_on':
service_data = {
'rgb_color': rgb_color,
'brightness': brightness,
'entity_id': entity_id
}
domain = 'light' # state的前缀
remote.call_service(self._api,
domain,
state,
service_data=service_data)
def cli(ctx, domain, service, data):
"""Query and call services."""
import homeassistant.remote as remote
# If no service is given, we want to either print all services
# from the given domain, or everything if no domain is given
if service is None and data is None:
for serv in remote.get_services(ctx.api):
if domain is not None and domain != serv['domain']:
continue
print_service(ctx, serv)
return
if data is not None:
data = ast.literal_eval(data)
ctx.log("Calling %s.%s with data %s", domain, service, data)
res = remote.call_service(ctx.api, domain, service, data)
ctx.log("Return value: %s", res)
def toggle_button(info):
#toggles the button in the home assistant interface
#used to request breaks and turn lecture on and off
if info == "lectureOn":
remote.call_service(
api, 'input_boolean', 'turn_on',
{'entity_id': '{}'.format('input_boolean.stopwatch')})
elif info == "lectureOff":
remote.call_service(
api, 'input_boolean', 'turn_off',
{'entity_id': '{}'.format('input_boolean.stopwatch')})
elif info == "breakRequest":
remote.call_service(
api, 'input_boolean', 'toggle',
{'entity_id': '{}'.format('input_boolean.breakrequest')})
def handle_lights(args):
if args == 'toggle':
remote.call_service(api, DOMAIN_LIGHTS, 'toggle')
return 'Toggled lights'
if args == 'on':
remote.call_service(api, DOMAIN_LIGHTS, 'turn_on')
return 'Turned lights on'
if args == 'off':
remote.call_service(api, DOMAIN_LIGHTS, 'turn_off')
return 'Turned lights off'
light = 'light.made_lamp'
lamp = remote.get_state(api, light)
if args == '' or args == 'state':
return 'Made Lamp is ' + lamp.state
else:
return 'Unknown command ' + args + '. Supported commands: state, on, off, toggle'
def intent_request(session, user, request):
if request['intent']['name'] == "LocateIntent":
hass_devices = {}
user = request['intent']['slots']['User']['value']
allStates=remote.get_states(api)
for state in allStates:
if get_entity_type(state) == "device_tracker":
hass_devices[state.attributes['friendly_name']]=state.state
output_speech = user + " is at " + hass_devices[user]
return build_response(output_speech)
elif request['intent']['name'] == "LockIntent":
matched_lock = False
action = request['intent']['slots']['Action']['value']
requested_lock = request['intent']['slots']['LockName']['value']
allStates = remote.get_states(api)
for state in allStates:
if get_entity_type(state) == "lock":
friendly_name = state.attributes['friendly_name']
if friendly_name.lower() == requested_lock:
matched_lock = True
print(action)
if action == "lock":
remote.set_state(api, state.entity_id, new_state=STATE_LOCKED)
output_speech = "I have locked the " + requested_lock
elif action == "unlock":
remote.set_state(api, state.entity_id, new_state=STATE_UNLOCKED)
output_speech = "I have unlocked the " + requested_lock
if matched_lock == False:
output_speech = "I'm sorry, I have not found a lock by that name."
return build_response(output_speech)
elif request['intent']['name'] == "BedIntent":
who = request['intent']['slots']['Who']['value']
if who == "We are" or who == "We're":
script_name = "script.go_to_bed2"
else:
script_name = "script.go_to_bed1"
remote.call_service(api, 'script', 'turn_on', {'entity_id': '{}'.format(script_name)})
output_speech = "Goodnight"
return build_response(output_speech)
elif request['intent']['name'] == "WakeIntent":
script_name = "script.wake_up"
remote.call_service(api, 'script', 'turn_on', {'entity_id': '{}'.format(script_name)})
output_speech = "Good Morning"
return build_response(output_speech)
elif request['intent']['name'] == "CurrentEnergyIntent":
energy_usage = remote.get_state(api, 'sensor.energy_usage')
output_speech = 'Your {} is {} {}.'.format(energy_usage.attributes['friendly_name'], energy_usage.state, energy_usage.attributes['unit_of_measurement'])
return build_response(output_speech)
elif request['intent']['name'] == "MonthlyEnergyIntent":
energy_cost = remote.get_state(api, 'sensor.energy_cost')
output_speech = 'Your {} is ${}'.format(energy_cost.attributes['friendly_name'], energy_cost.state)
return build_response(output_speech)
elif request['intent']['name'] == "HelpIntent":
output_speech = "This is the HomeAssistant app. Right now, you can only ask where someone is, or ask about your energy usage. But I have big plans. "
output_type = "PlainText"
card_type = "Simple"
card_title = "HelloWorld - Title"
card_content = "HelloWorld - This is the Hello World help! Just say Hi"
response = {"outputSpeech": {"type":output_type,"text":output_speech},'shouldEndSession':False}
return response
else:
return launch_request(session, user, request) ##Just do the same thing as launch request
def stop_effect(self):
remote.call_service(api,'light','turn_on',\
{'entity_id':'light.{0}'.format(self.device_name),"effect":'{}'.format('Stop')})
def effect(self,effect):
remote.call_service(api,'light','turn_on',\
{'entity_id':'light.{0}'.format(self.device_name),"effect":'{}'.format(effect)})
client.connect(hiddenFields.MQTTServer, 1883, 60)
# Loop printing measurements every second.
print('Press Ctrl-C to quit.')
while True:
# Blocking call that processes network traffic, dispatches callbacks and
# handles reconnecting.
# Other loop*() functions are available that give a threaded interface and a
# manual interface.
if (newData):
try:
if currentTemp >= 250.0:
print('Over')
remote.call_service(
api, 'input_select', 'select_option', {
'entity_id': 'input_select.fireplace_burn_zone',
'option': 'Over Temperature'
})
#os.system('curl -s --data-binary \'{\"entity_id\":\"input_select.fireplace_burn_zone\",\"option\":\"Over Temperature\"}\' -H \'content-type: application/json;\' http://192.168.11.160:8123/api/services/input_select/select_option?api_password=turninTuna')
if currentTemp >= 135.0 and currentTemp < 250.0:
print('Optimal')
remote.call_service(
api, 'input_select', 'select_option', {
'entity_id': 'input_select.fireplace_burn_zone',
'option': 'Optimal Burn Zone'
})
#os.system('curl -s --data-binary \'{\"entity_id\":\"input_select.fireplace_burn_zone\",\"option\":\"Optimal Burn Zone\"}\' -H \'content-type: application/json;\' http://192.168.11.160:8123/api/services/input_select/select_option?api_password=turninTuna')
if currentTemp >= 50.0 and currentTemp < 135.0:
print('Under')
remote.call_service(
api, 'input_select', 'select_option', {
domain = 'light'
arguments = {
"entity_id": 'light.desk',
"color_temp": 375,
"brightness": 107,
}
while True:
alive = ping('192.168.0.60')
desk = remote.get_state(api, 'light.desk')
logger.debug('^^^^^^^^^^^')
logger.debug("{previous} - {alive} - {state}".format(previous=previous, alive=alive, state=desk.state))
if alive and desk.state == 'off':
logger.info('alive and light is off, turning on')
remote.call_service(api, domain, 'turn_on', arguments)
if alive and desk.state == 'on':
logger.debug('alive and light is on, pass')
pass
if not alive and desk.state == 'on':
if just_died(previous):
logger.info('just died and light is on, turning off')
remote.call_service(api, domain, 'turn_off')
if not alive and desk.state == 'off':
logger.debug('not alive and light is off, pass')
pass
previous.append(alive)
if len(previous) > 10:
del previous[-1]
sleep(3)
def hello_world():
message = request.form["message"]
remote.call_service(api, 'tts', 'google_say', {'message': message})
def play(self):
remote.call_service(api,'remote','send_command',\
{"entity_id":"remote.{}".format(self.device_name),"command":"play","device":""})
def get_latest_entry():
feed = feedparser.parse(FEED_URL)
return (feed.entries[0].enclosures[0].href, feed.entries[0].summary)
def download_file(url):
remote_file = urllib.request.urlopen(url)
local_name = 'daily-img.jpg'
local_path = os.path.expanduser(os.path.join(DOWNLOAD_FOLDER, local_name))
local_file = open(local_path, 'wb')
local_file.write(remote_file.read())
remote_file.close()
local_file.close()
return local_path
if __name__ == '__main__':
if not os.path.exists(os.path.expanduser(DOWNLOAD_FOLDER)):
os.makedirs(os.path.expanduser(DOWNLOAD_FOLDER))
(url, text) = get_latest_entry()
img_file = download_file(url)
average = misc.imread(img_file).mean(axis=(0, 1)).tolist()
api = remote.API('127.0.0.1', 'Waterloo!')
remote.call_service(api, 'light', 'turn_on', {
'entity_id': 'group.all_lights',
'rgb_color': average
})
print(average)
def color_name(self,color_name):
remote.call_service(api,'light','turn_on',\
{'entity_id':'light.{0}'.format(self.device_name),"color_name":'{}'.format(color_name)})
def color_temp(self,temp):
remote.call_service(api,'light','turn_on',\
{'entity_id':'light.{0}'.format(self.device_name),"color_temp":'{}'.format(temp)})
def flash(self,duration):
remote.call_service(api,'light','turn_on',\
{'entity_id':'light.{0}'.format(self.device_name),"flash":'{}'.format(duration)})
import socket
import sys
import homeassistant.remote as remote
api = remote.API('http://homeassistant.cs.moravian.edu:8123/states', 'raspberry')
UDP_IP = socket.gethostbyname(socket.gethostname())
UDP_Port = 8123
BUFFER_SIZE = 1024
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_Port))
while True:
data, addr = sock.recvfrom(1024)
remote.call_service(api, 'tts', 'google_say', {'message': data.decode()})
def service_call (domain, service, payload): remote.call_service(api, domain, service, payload)
def talk(self,message):
remote.call_service(api,'tts','google_say',\
{"entity_id":"media_player.{0}".format(self.device_name),"message":message, "language":"en"})
