def ready(self) -> None:
if "celery" in sys.argv and strtobool(os.environ.get("RUN_MAIN", "0")):
# if the development celery process starts,
# have it import all modules containing celery tasks
# this way, its autoreload is notified on changes in these modules
for module in conf.CELERY_IMPORTS:
assert isinstance(module, str)
__import__(module)
return
# ready is called for every management command and for autoreload
# only start raveberry when
# in debug mode and the main application is run (not autoreload)
# or in prod mode (run by daphne)
start_raveberry = (strtobool(os.environ.get("RUN_MAIN", "0"))
if "runserver" in sys.argv else
sys.argv[0].endswith("daphne"))
if conf.TESTING:
from core.musiq import controller
# when MopidyAPI instances are created too often,
# mopidy runs into a "Set changed size during iteration" error.
# Thus we initialize the interface once and not for every testcase
controller.start()
if start_raveberry:
from core import tasks
from core import redis
from core.musiq import musiq
from core.musiq import playback
from core.settings import basic
from core.settings import platforms
from core.lights import worker
logging.info("starting raveberry")
redis.start()
tasks.start()
worker.start()
musiq.start()
basic.start()
platforms.start()
def stop_workers() -> None:
# wake up the playback thread and stop it
redis.put("stop_playback_loop", True)
playback.queue_changed.set()
# wake the buzzer thread so it exits
playback.buzzer_stopped.set()
# wake up the listener thread with an instruction to stop the lights worker
redis.connection.publish("lights_settings_changed", "stop")
atexit.register(stop_workers)
def _handle_monochrome_request(device: str,
request: WSGIRequest) -> HttpResponse:
value, response = extract_value(request.POST)
assert device in ["ring", "strip", "wled", "screen"]
storage.put(cast(DeviceMonochrome, f"{device}_monochrome"),
strtobool(value))
_notify_settings_changed(device)
return response
def get(key: str) -> Union[bool, int, float, str, List, Dict, Tuple]:
"""This method returns the value for the given :param key: from redis.
Vaules of non-existing keys are set to their respective default value."""
# values are stored as string in redis
# cast the value to its respective type, defined by the default value, before returning it
default = defaults[key]
value = connection.get(key)
if value is None:
return default
if type(default) is bool:
return strtobool(value)
if type(default) in (list, dict, tuple):
# evaluate the stored literal
return literal_eval(value)
return type(default)(value)
def set_lights_shortcut(request: WSGIRequest) -> HttpResponse:
"""Stores the current lights state and restores the previous one."""
value, response = extract_value(request.POST)
should_enable = strtobool(value)
is_enabled = (storage.get("ring_program") != "Disabled"
or storage.get("wled_program") != "Disabled"
or storage.get("strip_program") != "Disabled")
if should_enable == is_enabled:
return HttpResponse()
if should_enable:
for device in ["ring", "wled", "strip"]:
set_program(
device,
storage.get(cast(DeviceProgram, f"last_{device}_program")))
else:
for device in ["ring", "wled", "strip"]:
set_program(device, "Disabled")
return response
def get(key: str) -> Union[bool, int, float, str, tuple]:
"""This method returns the value for the given :param key:.
Values of non-existing keys are set to their respective default value."""
# values are stored as string in the database
# cast the value to its respective type, defined by the default value, before returning it
default = defaults[key]
value = models.Setting.objects.get_or_create(
key=key, defaults={"value": str(default)}
)[0].value
if type(default) is str:
return str(value)
if type(default) is int:
return int(value)
if type(default) is float:
return float(value)
if type(default) is bool:
return strtobool(value)
if type(default) is tuple:
# evaluate the stored literal
return literal_eval(value)
raise ValueError(f"{key} not defined")
def set_online_suggestions(request: WSGIRequest) -> HttpResponse:
"""Enables or disables online suggestions based on the given value."""
value, response = extract_value(request.POST)
storage.put("online_suggestions", strtobool(value))
return response
def set_dynamic_embedded_stream(request: WSGIRequest) -> HttpResponse:
"""Enables or disables dynamic streaming based on the given value."""
value, response = extract_value(request.POST)
storage.put("dynamic_embedded_stream", strtobool(value))
return response
def set_embed_stream(request: WSGIRequest) -> HttpResponse:
"""Enables or disables logging of requests and play logs based on the given value."""
value, response = extract_value(request.POST)
storage.put("embed_stream", strtobool(value))
return response
def set_ip_checking(request: WSGIRequest) -> HttpResponse:
"""Enables or disables ip checking based on the given value."""
value, response = extract_value(request.POST)
storage.put("ip_checking", strtobool(value))
return response
def set_enqueue_first(request: WSGIRequest) -> HttpResponse:
"""Enables or disables the new music only mode based on the given value."""
value, response = extract_value(request.POST)
storage.put("enqueue_first", strtobool(value))
return response
def set_dynamic_resolution(request: WSGIRequest) -> HttpResponse:
"""Sets whether the resolution should be dynamically adjusted depending on the performance."""
value, response = extract_value(request.POST)
storage.put("dynamic_resolution", strtobool(value))
_notify_settings_changed("base")
return response
"""This module configures django."""
import logging.config
import os
import pathlib
import subprocess
import sys
from typing import List
import yaml
from django.core.management.utils import get_random_secret_key
from core.util import strtobool
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DEMO = strtobool(os.environ.get("DJANGO_DEMO", "0"))
try:
with open(os.path.join(BASE_DIR, "config/secret_key.txt"),
encoding="utf-8") as f:
SECRET_KEY = f.read().strip()
except FileNotFoundError:
SECRET_KEY = get_random_secret_key()
with open(os.path.join(BASE_DIR, "config/secret_key.txt"),
"w",
encoding="utf-8") as f:
f.write(SECRET_KEY)
print("created secret key")
try:
with open(os.path.join(BASE_DIR, "VERSION"), encoding="utf-8") as f:
def set_youtube_enabled(request: WSGIRequest) -> HttpResponse:
"""Enables or disables youtube to be used as a song provider."""
value, response = extract_value(request.POST)
storage.put("youtube_enabled", strtobool(value))
return response
def set_jamendo_enabled(request: WSGIRequest) -> HttpResponse:
"""Enables or disables jamendo to be used as a song provider.
Makes sure mopidy has correct jamendo configuration."""
value, _ = extract_value(request.POST)
return _set_extension_enabled("jamendo", strtobool(value))
