def handle(self, *args, **options): now = datetime.datetime.now() current_time = now - datetime.timedelta( minutes=int(now.strftime("%M")), seconds=int(now.strftime("%S")), microseconds=int(now.strftime("%f"))) r = requests.get( "http://desktopfw.weather.com/weather/local/FIXX0001?hbhf=48&ut=C") data = r.text data = xmltodict.parse(data) data = json.loads(json.dumps(data)) for hour in data["weather"]["hbhf"]["hour"]: current_hour = int(hour["@h"]) delta_to_processing_time = datetime.timedelta(hours=current_hour) timestamp = current_time + delta_to_processing_time Weather.objects.filter(date=timestamp, hour=int( timestamp.strftime("%H"))).delete() a = Weather(date=timestamp, hour=timestamp.hour, icon=hour["icon"], ppcp=int(hour["ppcp"]), dewpoint=int(hour["dewp"]), feels_like=int(hour["flik"]), humidity=int(hour["hmid"]), temperature=int(hour["tmp"]), description=hour["t"], wind_direction=hour["wind"]["t"], wind_gust=hour["wind"]["gust"], wind_speed=int(hour["wind"]["s"])) a.save() publish_ws("weather", get_weather_data())
def post(self, request, *args, **kwargs): action = kwargs.get("action") command = kwargs.get("command") if command == "update": start_time = request.POST.get("start_time").split(":") duration = request.POST.get("duration").replace("+", "").split(":") start_time = datetime.time(int(start_time[0]), int(start_time[1])) duration = int(duration[0]) * 3600 + int(duration[1]) * 60 current_settings = json.loads(redis_instance.get("lightcontrol-program-%s" % action)) current_settings["duration"] = duration current_settings["start_at"] = start_time.strftime("%H:%M") redis_instance.set("lightcontrol-program-%s" % action, json.dumps(current_settings)) if "running" in request.POST: running = request.POST.get("running") running = running in ("true", "True", "1") redis_instance.set("lightprogram-%s-running" % action, running) if running: for group in range(1, 5): redis_instance.set("lightcontrol-state-%s-auto" % group, True) send_lightcontrol_command("program-sync", 0) data = get_lightprogram(action) publish_ws("lightcontrol-timed-%s" % action, data) return HttpResponse(json.dumps(data), content_type="application/json") elif command == "override-resume": for group in range(1, 5): redis_instance.set("lightcontrol-state-{group}-auto".format(group=group), True) send_lightcontrol_command("program-sync", 0) publish_ws("lightcontrol-timed-override", {"action": "resume"}) # TODO: get and serialize program details item = get_lightprogram(action) return HttpResponse(json.dumps(item), content_type="application/json")
def update_lightstate(group, brightness, color=None, on=True, **kwargs): if group == 0: for group_num in range(1, 5): update_lightstate(group_num, brightness, color, on, **kwargs) return logger.debug("Updating lightstate: group=%s, brightness=%s, color=%s, on=%s, kwargs=%s", group, brightness, color, on, kwargs) timed_ends_at = is_any_timed_running() if kwargs.get("important", True) != False: if timed_ends_at != False: time_until_ends = (timed_ends_at - timezone.now()).total_seconds() + 65 logger.info("Setting timed lightcontrol override for %s until %s", group, time_until_ends) redis_instance.setex("lightcontrol-no-automatic-%s" % group, int(time_until_ends), True) publish_ws("lightcontrol_timed_override", {"action": "pause"}) (state, _) = LightGroup.objects.get_or_create(group_id=group) if color is not None: state.color = color if brightness is not None: if state.color == "white": state.white_brightness = brightness else: state.rgbw_brightness = brightness state.on = on state.save() return state
def handle(self, *args, **options): hsl = HSLApi(settings.HSL_USERNAME, settings.HSL_PASSWORD) now = timezone.now() Data.objects.filter(time__lte=now).delete() data = [] for stop in Stop.objects.all(): lines = Line.objects.filter(show_line=True, stop=stop) fetch_stop = False for line in lines: if line.is_valid(): fetch_stop = True break if fetch_stop: departures = hsl.get_timetable(stop.stop_number) # O(n*m), this could be optimized. for line in lines: for departure in departures: if departure["line_number"] == line.line_number_raw: timezone_aware = timezone.make_aware( departure["timestamp"], timezone.get_current_timezone()) a, created = Data.objects.get_or_create( line=line, time=timezone_aware) if created: a.save() publish_ws("public-transportation", get_departures())
def handle(self, *args, **options): co2 = float(open(settings.CO2_FILE).read()) temperature = float(open(settings.TEMPERATURE_FILE).read()) r.rpush("air-quality-co2", co2) r.rpush("air-quality-temperature", temperature) publish_ws("indoor_temperature", {"value": temperature}) publish_ws("indoor_co2", {"value": co2})
def run_timed_actions(): """ Runs light programs """ led = LedController(settings.MILIGHT_IP) now = timezone.now() allowed_groups = set() for group in range(1, 5): if redis_instance.get("lightcontrol-no-automatic-%s" % group) is None: allowed_groups.add(group) for item in LightAutomation.objects.filter(running=True): if not item.is_running(now): continue percent_done = item.percent_done(now) logger.debug("Running %s, done %s%%", item.action, percent_done) brightness = None # Set brightness if item.action == "evening" or item.action == "evening-weekend": brightness = int((1-percent_done)*100) elif item.action == "morning" or item.action == "morning-weekend": brightness = int(percent_done * 100) if not item.action_if_off: # Don't turn on lights for group in list(allowed_groups): # cast to list to avoid "Set changed size during iteration" group_item, _ = LightGroup.objects.get_or_create(group_id=group) if group_item.on == False: allowed_groups.remove(group) logger.debug("Only run on %s", allowed_groups) if item.set_white: for group in allowed_groups: led.white(group) logger.debug("Set %s to white", group) update_lightstate(group, None, "white", important=False) if brightness: logger.debug("Setting brightness to %s%%", brightness) publish_ws("lightcontrol-timed-brightness-%s" % item.action, brightness) for group in allowed_groups: group_brightness = brightness group_item, _ = LightGroup.objects.get_or_create(group_id=group) if item.no_brighten: logger.debug("Current brightness: %s%%", group_item.current_brightness) if group_item.current_brightness is not None: group_brightness = min(group_item.current_brightness, group_brightness) if item.no_dimming: logger.debug("Current brightness: %s%%", group_item.current_brightness) if group_item.current_brightness is not None: group_brightness = max(group_item.current_brightness, group_brightness) if group_item.current_brightness: if led.get_brightness_level(group_brightness) == led.get_brightness_level(group_item.current_brightness): logger.debug("Not sending brightness update to %s: no difference in brightness level", group) continue logger.debug("Setting %s to %s", (group, group_brightness)) led.set_brightness(group_brightness, group) update_lightstate(group, group_brightness, important=False) set_destination_brightness()
def initiate_delayed_shutdown(): """ Initiate delayed shutdown Automatically cancel possible other delayed shutdowns. """ cancel_delayed_shutdown() redis_instance.setex("display-control-command", 120, "off") display_task = run_display_command_task.apply_async( countdown=30, expires=120) redis_instance.set("display-control-task", display_task.task_id) publish_ws("shutdown", "delayed-shutdown")
def initiate_delayed_shutdown(): """ Initiate delayed shutdown Automatically cancel possible other delayed shutdowns. """ cancel_delayed_shutdown() redis_instance.setex("display-control-command", 120, "off") display_task = run_display_command_task.apply_async(countdown=30, expires=120) redis_instance.set("display-control-task", display_task.task_id) publish_ws("shutdown", "delayed-shutdown")
def cancel_delayed_shutdown(): """ Cancels delayed shutdown, if one is running """ display_task = redis_instance.get("display-control-task") redis_instance.delete("display-control-command") publish_ws("shutdown", "cancel-delayed") if display_task: celery_app.control.revoke(display_task) redis_instance.delete("display-control-task") logger.info("cancel_delayed_shutdown revoked %s", display_task) return display_task logger.info("cancel_delayed_shutdown did not find task to be revoked") return False
def cancel_delayed_shutdown(): """ Cancels delayed shutdown, if one is running """ display_task = redis_instance.get("display-control-task") redis_instance.delete("display-control-command") publish_ws("shutdown", "cancel-delayed") if display_task: celery_app.control.revoke(display_task) redis_instance.delete("display-control-task") logger.info("cancel_delayed_shutdown revoked %s", display_task) return display_task logger.info("cancel_delayed_shutdown did not find task to be revoked") return False
def run_display_command(cmd): """ Runs xset command. This method does not validate command, but it is escaped properly. """ env = {"DISPLAY": ":0"} logger.info("Running display command %s", cmd) process = subprocess.Popen(["xset", "dpms", "force", cmd], env=env) content = None if cmd == "off": content = "display-off" elif cmd == "on": content = "display-on" process.wait() if content: cancel_delayed_shutdown() logger.info("Broadcasting display status: %s", content) publish_ws("shutdown", content)
def post(self, request, *args, **kwargs): action = kwargs.get("action") command = kwargs.get("command") if command == "update": start_time = request.POST.get("start_time").split(":") duration = request.POST.get("duration").replace("+", "").split(":") running = request.POST.get("running") if running == "true": running = True else: running = False start_time = datetime.time(int(start_time[0]), int(start_time[1])) duration = int(duration[0]) * 3600 + int(duration[1]) * 60 item, created = LightAutomation.objects.get_or_create( action=action, defaults={ "start_time": start_time, "duration": duration, "running": running }) if not created: item.start_time = start_time item.duration = duration item.running = running item.save() if is_any_timed_running() == False: # No timed lightcontrol is running (anymore). Delete overrides. for group in range(1, 5): redis_instance.delete("lightcontrol-no-automatic-%s" % group) publish_ws("lightcontrol_timed_override", {"action": "resume"}) else: run_timed_actions() return HttpResponse(json.dumps(get_serialized_timed_action(item)), content_type="application/json") elif command == "override-resume": for group in range(1, 5): redis_instance.delete("lightcontrol-no-automatic-%s" % group) publish_ws("lightcontrol_timed_override", {"action": "resume"}) run_timed_actions() instance = get_object_or_404(LightAutomation, action=action) item = get_serialized_timed_action(instance) return HttpResponse(json.dumps(item), content_type="application/json")
def run_display_command(cmd): """ Runs xset command. This method does not validate command, but it is escaped properly. """ env = {"DISPLAY": ":0"} logger.info("Running display command %s", cmd) if settings.RUN_XSET is False: logger.warn("Skipping xset, as RUN_XSET is False") else: process = subprocess.Popen(["xset", "dpms", "force", cmd], env=env) process.wait() content = None if cmd == "off": content = "display-off" elif cmd == "on": content = "display-on" if content: cancel_delayed_shutdown() logger.info("Broadcasting display status: %s", content) publish_ws("shutdown", content)
def handle(self, *args, **options): status = huawei_b593_status.HuaweiStatus() data = status.read() age_threshold = datetime.timedelta(minutes=2) try: latest_data = Internet.objects.latest() if now() - latest_data.timestamp > age_threshold: latest_data = Internet() except Internet.DoesNotExist: latest_data = Internet() latest_data.wifi = data["WIFI"] != "off" latest_data.signal = int(data["SIG"]) latest_data.mode = data["Mode"] latest_data.sim = data["SIM"] latest_data.connect_status = data["Connect"] latest_data.update_timestamp = now() latest_data.save() publish_ws("internet", get_latest_serialized())
def post(self, request, *args, **kwargs): status = sp.is_alive() sp.shutdown() redis_instance.setex("server_power_in_progress", 60, status) publish_ws("server_power", {"status": status, "in_progress": status}) return HttpResponse("ok")
def publish_timer_deleted(sender, instance, using, **kwargs): publish_ws("timer-%s" % instance.pk, "delete")
def publish_lightgroup_saved(sender, instance, *args, **kwargs): publish_ws("lightcontrol", get_serialized_lightgroups())
def post(self, request, *args, **kwargs): publish_ws("rdio-control", kwargs)
def publish_changes(): publish_ws("timer-labels", get_labels())
def publish_items(): publish_ws("printer-labels", json.loads(get_serialized_labels()))
def publish_changes(): for k in ("today", "tomorrow", "all"): publish_ws("repeating_tasks_%s" % k, get_repeating_data(k, True))
def publish_changes(): for k in ("today", "tomorrow", "all"): publish_ws("birthdays_%s" % k, get_birthdays(k))
def publish_items(): publish_ws("printer-labels", json.loads(get_serialized_labels()))
def publish_timer_saved(sender, instance, created, *args, **kwargs): if created: publish_ws("timers", get_serialized_timer(instance)) else: publish_ws("timer-%s" % instance.pk, get_serialized_timer(instance))
def publish_lightautomation_saved(sender, instance, *args, **kwargs): publish_ws("lightcontrol_timed_%s" % instance.action, get_serialized_timed_action(instance))
def post(self, request, *args, **kwargs): publish_ws("rdio-control", kwargs)
def handle(self, *args, **options): publish_ws("reload", time.time())