def __init__(self, config: ConfigHelper) -> None:
name_parts = config.get_name().split(maxsplit=1)
if len(name_parts) != 2:
raise config.error(f"Invalid Section Name: {config.get_name()}")
self.server = config.get_server()
self.name = name_parts[1]
self.type: str = config.get('type')
self.state: str = "init"
self.locked_while_printing = config.getboolean('locked_while_printing',
False)
self.off_when_shutdown = config.getboolean('off_when_shutdown', False)
self.off_when_shutdown_delay = 0.
if self.off_when_shutdown:
self.off_when_shutdown_delay = config.getfloat(
'off_when_shutdown_delay', 0., minval=0.)
self.shutdown_timer_handle: Optional[asyncio.TimerHandle] = None
self.restart_delay = 1.
self.klipper_restart = config.getboolean(
'restart_klipper_when_powered', False)
if self.klipper_restart:
self.restart_delay = config.getfloat('restart_delay', 1.)
if self.restart_delay < .000001:
raise config.error("Option 'restart_delay' must be above 0.0")
self.bound_service: Optional[str] = config.get('bound_service', None)
self.need_scheduled_restart = False
self.on_when_queued = config.getboolean('on_when_upload_queued', False)
def __init__(self: Strip, name: str, color_order: ColorOrder,
cfg: ConfigHelper):
self.server = cfg.get_server()
self.client = AsyncHTTPClient()
self.request_mutex = asyncio.Lock()
self.name = name
self.color_order = color_order
# Read the uri information
addr: str = cfg.get("address")
port: int = cfg.getint("port", 80)
protocol: str = cfg.get("protocol", "http")
self.url = f"{protocol}://{addr}:{port}/json"
self.timeout: float = cfg.getfloat("timeout", 2.)
self.initial_preset: int = cfg.getint("initial_preset", -1)
self.initial_red: float = cfg.getfloat("initial_red", 0.5)
self.initial_green: float = cfg.getfloat("initial_green", 0.5)
self.initial_blue: float = cfg.getfloat("initial_blue", 0.5)
self.initial_white: float = cfg.getfloat("initial_white", 0.5)
self.chain_count: int = cfg.getint("chain_count", 1)
self._chain_data = bytearray(self.chain_count *
color_order.Elem_Size())
self.onoff = OnOff.off
self.preset = self.initial_preset
def test_get_float_deprecate(self, test_config: ConfigHelper):
server = test_config.get_server()
test_config.getfloat("test_float", deprecate=True)
expected = (
f"[test_options]: Option 'test_float' is "
"deprecated, see the configuration documention "
"at https://moonraker.readthedocs.io/en/latest/configuration")
assert expected in server.warnings
def test_get_float_pass_all(self, test_config: ConfigHelper):
val = test_config.getfloat("test_float",
above=3.45,
below=3.55,
minval=3,
maxval=4)
assert 3.5 == pytest.approx(val)
def __init__(self, config: ConfigHelper) -> None:
super().__init__(config)
self.mqtt: MQTTClient = self.server.load_component(config, 'mqtt')
self.eventloop = self.server.get_event_loop()
self.cmd_topic: str = config.get('command_topic')
self.cmd_payload: JinjaTemplate = config.gettemplate('command_payload')
self.retain_cmd_state = config.getboolean('retain_command_state',
False)
self.query_topic: Optional[str] = config.get('query_topic', None)
self.query_payload = config.gettemplate('query_payload', None)
self.must_query = config.getboolean('query_after_command', False)
if self.query_topic is not None:
self.must_query = False
self.state_topic: str = config.get('state_topic')
self.state_timeout = config.getfloat('state_timeout', 2.)
self.state_response = config.load_template('state_response_template',
"{payload}")
self.qos: Optional[int] = config.getint('qos',
None,
minval=0,
maxval=2)
self.mqtt.subscribe_topic(self.state_topic, self._on_state_update,
self.qos)
self.query_response: Optional[asyncio.Future] = None
self.request_mutex = asyncio.Lock()
self.server.register_event_handler("mqtt:connected",
self._on_mqtt_connected)
self.server.register_event_handler("mqtt:disconnected",
self._on_mqtt_disconnected)
def __init__(self: Strip, name: str, cfg: ConfigHelper):
self.server = cfg.get_server()
self.request_mutex = asyncio.Lock()
self.name = name
self.initial_preset: int = cfg.getint("initial_preset", -1)
self.initial_red: float = cfg.getfloat("initial_red", 0.5)
self.initial_green: float = cfg.getfloat("initial_green", 0.5)
self.initial_blue: float = cfg.getfloat("initial_blue", 0.5)
self.initial_white: float = cfg.getfloat("initial_white", 0.5)
self.chain_count: int = cfg.getint("chain_count", 1)
# Supports rgbw always
self._chain_data = bytearray(self.chain_count * self._COLORSIZE)
self.onoff = OnOff.off
self.preset = self.initial_preset
def __init__(self: StripHttp, name: str, cfg: ConfigHelper):
super().__init__(name, cfg)
# Read the uri information
addr: str = cfg.get("address")
port: int = cfg.getint("port", 80)
protocol: str = cfg.get("protocol", "http")
self.url = f"{protocol}://{addr}:{port}/json"
self.timeout: float = cfg.getfloat("timeout", 2.)
self.client = AsyncHTTPClient()
def __init__(self,
config: ConfigHelper,
initial_val: Optional[int] = None) -> None:
super().__init__(config)
self.initial_state = config.getboolean('initial_state', False)
self.timer: Optional[float] = config.getfloat('timer', None)
if self.timer is not None and self.timer < 0.000001:
raise config.error(
f"Option 'timer' in section [{config.get_name()}] must "
"be above 0.0")
self.timer_handle: Optional[asyncio.TimerHandle] = None
if initial_val is None:
initial_val = int(self.initial_state)
self.gpio_out = config.getgpioout('pin', initial_value=initial_val)
def __init__(self, config: ConfigHelper) -> None:
name_parts = config.get_name().split(maxsplit=1)
if len(name_parts) != 2:
raise config.error(f"Invalid Section Name: {config.get_name()}")
self.server = config.get_server()
self.name = name_parts[1]
self.type: str = config.get('type')
self.state: str = "init"
self.locked_while_printing = config.getboolean('locked_while_printing',
False)
self.off_when_shutdown = config.getboolean('off_when_shutdown', False)
self.restart_delay = 1.
self.klipper_restart = config.getboolean(
'restart_klipper_when_powered', False)
if self.klipper_restart:
self.restart_delay = config.getfloat('restart_delay', 1.)
if self.restart_delay < .000001:
raise config.error("Option 'restart_delay' must be above 0.0")
def __init__(self, config: ConfigHelper) -> None:
self.server = config.get_server()
self.queued_jobs: Dict[str, QueuedJob] = {}
self.lock = asyncio.Lock()
self.load_on_start = config.getboolean("load_on_startup", False)
self.automatic = config.getboolean("automatic_transition", False)
self.queue_state: str = "ready" if self.automatic else "paused"
self.job_delay = config.getfloat("job_transition_delay", 0.01)
if self.job_delay <= 0.:
raise config.error(
"Value for option 'job_transition_delay' in section [job_queue]"
" must be above 0.0")
self.job_transition_gcode = config.get(
"job_transition_gcode", "").strip()
self.pop_queue_handle: Optional[asyncio.TimerHandle] = None
self.server.register_event_handler(
"server:klippy_ready", self._handle_ready)
self.server.register_event_handler(
"server:klippy_shutdown", self._handle_shutdown)
self.server.register_event_handler(
"job_state:complete", self._on_job_complete)
self.server.register_event_handler(
"job_state:error", self._on_job_abort)
self.server.register_event_handler(
"job_state:cancelled", self._on_job_abort)
self.server.register_notification("job_queue:job_queue_changed")
self.server.register_remote_method("pause_job_queue", self.pause_queue)
self.server.register_remote_method("start_job_queue",
self.start_queue)
self.server.register_endpoint(
"/server/job_queue/job", ['POST', 'DELETE'],
self._handle_job_request)
self.server.register_endpoint(
"/server/job_queue/pause", ['POST'], self._handle_pause_queue)
self.server.register_endpoint(
"/server/job_queue/start", ['POST'], self._handle_start_queue)
self.server.register_endpoint(
"/server/job_queue/status", ['GET'], self._handle_queue_status)
def __init__(self, config: ConfigHelper) -> None:
super().__init__(config)
if self.off_when_shutdown:
raise config.error(
"Option 'off_when_shutdown' in section "
f"[{config.get_name()}] is unsupported for 'klipper_device'")
if self.klipper_restart:
raise config.error(
"Option 'restart_klipper_when_powered' in section "
f"[{config.get_name()}] is unsupported for 'klipper_device'")
if (self.bound_service is not None
and self.bound_service.startswith("klipper")):
# Klipper devices cannot be bound to an instance of klipper or
# klipper_mcu
raise config.error(
f"Option 'bound_service' cannot be set to {self.bound_service}"
f" for 'klipper_device' [{config.get_name()}]")
self.is_shutdown: bool = False
self.update_fut: Optional[asyncio.Future] = None
self.request_mutex = asyncio.Lock()
self.timer: Optional[float] = config.getfloat('timer',
None,
above=0.000001)
self.timer_handle: Optional[asyncio.TimerHandle] = None
self.object_name = config.get('object_name')
obj_parts = self.object_name.split()
self.gc_cmd = f"SET_PIN PIN={obj_parts[-1]} "
if obj_parts[0] == "gcode_macro":
self.gc_cmd = obj_parts[-1]
elif obj_parts[0] != "output_pin":
raise config.error(
"Klipper object must be either 'output_pin' or 'gcode_macro' "
f"for option 'object_name' in section [{config.get_name()}]")
self.server.register_event_handler("server:status_update",
self._status_update)
self.server.register_event_handler("server:klippy_ready",
self._handle_ready)
self.server.register_event_handler("server:klippy_disconnect",
self._handle_disconnect)
def __init__(self, config: ConfigHelper) -> None:
self.server = config.get_server()
self.eventloop = self.server.get_event_loop()
self.name = config.get_name().split()[-1]
self.itransport: ITransport = self.server.lookup_component(
'internal_transport')
self.mutex = asyncio.Lock()
gpio: GpioFactory = self.server.load_component(config, 'gpio')
self.gpio_event = gpio.register_gpio_event(config.get('pin'),
self._on_gpio_event)
min_event_time = config.getfloat('minimum_event_time',
.05,
minval=.010)
self.gpio_event.setup_debounce(min_event_time, self._on_gpio_error)
self.press_template = config.gettemplate("on_press",
None,
is_async=True)
self.release_template = config.gettemplate("on_release",
None,
is_async=True)
if (self.press_template is None and self.release_template is None):
raise config.error(
f"[{config.get_name()}]: No template option configured")
self.notification_sent: bool = False
self.user_data: Dict[str, Any] = {}
self.context: Dict[str, Any] = {
'call_method': self.itransport.call_method,
'send_notification': self._send_notification,
'event': {
'elapsed_time': 0.,
'received_time': 0.,
'render_time': 0.,
'pressed': False,
},
'user_data': self.user_data
}
def test_get_float_fail_maxval(self, test_config: ConfigHelper):
with pytest.raises(ConfigError):
test_config.getfloat("test_float", maxval=3.45)
def test_get_float_fail_below(self, test_config: ConfigHelper):
with pytest.raises(ConfigError):
test_config.getfloat("test_float", below=3.45)
def test_get_float_fail_above(self, test_config: ConfigHelper):
with pytest.raises(ConfigError):
test_config.getfloat("test_float", above=3.55)
def test_get_float_default(self, test_config: ConfigHelper):
assert test_config.getfloat("invalid_option", None) is None
def test_get_float_fail(self, test_config: ConfigHelper):
with pytest.raises(ConfigError):
test_config.getfloat("invalid_option")
def test_get_float_exists(self, test_config: ConfigHelper):
val = test_config.getfloat("test_float")
assert 3.5 == pytest.approx(val)
def __init__(self, config: ConfigHelper) -> None:
super().__init__(config, default_port=8123)
self.device: str = config.get("device")
self.token: str = config.gettemplate("token").render()
self.domain: str = config.get("domain", "switch")
self.status_delay: float = config.getfloat("status_delay", 1.)
