SYMBOL INDEX (1540 symbols across 83 files)

FILE: image_builder/image_builder.py
  function reporthook (line 91) | def reporthook(chunk_number, chunk_size, total_size):
  function ensure_directory (line 97) | def ensure_directory(directory):
  function run_emulator (line 103) | def run_emulator(command):
  function retry (line 125) | def retry(call, retries=3, sleep_time=1):
  function run_command (line 140) | def run_command(command, check=True, retries=1):
  function run_over_ssh (line 146) | def run_over_ssh(command, check=True, retries=1):
  function check_binary (line 151) | def check_binary(binary_name):
  function insert_from_file_before_line (line 160) | def insert_from_file_before_line(to_file, from_file, search=None, index=...
  function mount_image (line 186) | def mount_image(image_name, expand=False):
  function unmount_image (line 210) | def unmount_image(loop_device):
  function basic_image_setup (line 220) | def basic_image_setup():
  function build_image (line 236) | def build_image():
  function main (line 512) | def main():

FILE: prusa/link/__main__.py
  function excepthook (line 38) | def excepthook(exception_arguments, args, argv):
  function set_log_levels (line 58) | def set_log_levels(config: Config):
  class LogLevel (line 64) | class LogLevel(str):
    method __new__ (line 67) | def __new__(cls, level):
  function check_process (line 74) | def check_process(pid):
  function wait_process (line 83) | def wait_process(pid, timeout=1):
  function stop (line 93) | def stop(pid):
  function main (line 107) | def main():

FILE: prusa/link/camera_governor.py
  class CameraGovernor (line 18) | class CameraGovernor:
    method __init__ (line 21) | def __init__(self, camera_configurator: CameraConfigurator,
    method _govern (line 29) | def _govern(self) -> None:
    method start (line 37) | def start(self) -> None:
    method stop (line 53) | def stop(self) -> None:
    method wait_stopped (line 57) | def wait_stopped(self) -> None:

FILE: prusa/link/cameras/encoders.py
  function fopen (line 23) | def fopen(path, write=False):
  function opener (line 28) | def opener(path, flags):
  class Quality (line 33) | class Quality(Enum):
  class BufferDetails (line 42) | class BufferDetails:
    method __init__ (line 45) | def __init__(self, file_descriptor, length, offset):
    method __del__ (line 53) | def __del__(self):
  function get_appropriate_encoder (line 60) | def get_appropriate_encoder(resolution, pixel_format, use_mmap=False):
  class Encoder (line 77) | class Encoder:
    method __init__ (line 80) | def __init__(self):
    method start (line 91) | def start(self):
    method stop (line 94) | def stop(self):
    method quality (line 98) | def quality(self):
    method quality (line 103) | def quality(self, quality=Quality.HIGH):
    method encode (line 108) | def encode(self, bytes_used: int) -> bytes:
  class MJPEGEncoder (line 112) | class MJPEGEncoder(Encoder):
    method is_available (line 137) | def is_available(cls):
    method __init__ (line 155) | def __init__(self):
    method _pre_fill_format (line 172) | def _pre_fill_format(self, format_type, pixel_format):
    method _request_buffers (line 184) | def _request_buffers(self, buffer_type, memory, count=1):
    method _get_buffer (line 191) | def _get_buffer(self, buffer_type, memory):
    method _stream_on (line 203) | def _stream_on(self, buffer_type):
    method _stream_off (line 207) | def _stream_off(self, buffer_type):
    method start (line 211) | def start(self):
    method stop (line 288) | def stop(self):
    method encode (line 314) | def encode(self, bytes_used):
  class JPEGEncoder (line 354) | class JPEGEncoder(Encoder):
    method __init__ (line 364) | def __init__(self):
    method start (line 368) | def start(self):
    method encode (line 372) | def encode(self, bytes_used):
  class PassthroughEncoder (line 389) | class PassthroughEncoder(Encoder):
    method encode (line 393) | def encode(self, bytes_used: int) -> bytes:

FILE: prusa/link/cameras/picamera_driver.py
  function param_change (line 72) | def param_change(func):
  class PiCameraDriver (line 86) | class PiCameraDriver(CameraDriver):
    method _scan (line 94) | def _scan():
    method __init__ (line 113) | def __init__(self, camera_id: str, config: Dict[str, str],
    method get_resolutions (line 133) | def get_resolutions(camera: Camera, stream_role: StreamRole,
    method make_camera_configuration (line 164) | def make_camera_configuration(camera, still_resolution: Resolution,
    method _connect (line 192) | def _connect(self):
    method _start (line 235) | def _start(self):
    method _get_scalar_crop (line 248) | def _get_scalar_crop(raw_resolution, target_resolution):
    method set_resolution (line 274) | def set_resolution(self, resolution):
    method _set_resolution (line 278) | def _set_resolution(self, resolution):
    method _focus_transform (line 323) | def _focus_transform(self, value):
    method set_focus (line 331) | def set_focus(self, focus):
    method take_a_photo (line 336) | def take_a_photo(self):
    method _disconnect (line 366) | def _disconnect(self):

FILE: prusa/link/cameras/v4l2.py
  function _IOC (line 69) | def _IOC(dir_, type_, nr, size):
  function _IOC_TYPECHECK (line 77) | def _IOC_TYPECHECK(t):
  function _IO (line 81) | def _IO(type_, nr):
  function _IOW (line 85) | def _IOW(type_, nr, size):
  function _IOR (line 89) | def _IOR(type_, nr, size):
  function _IOWR (line 93) | def _IOWR(type_, nr, size):
  class timeval (line 109) | class timeval(ctypes.Structure):
  function v4l2_fourcc (line 140) | def v4l2_fourcc(a, b, c, d):
  function v4l2_fourcc2str (line 144) | def v4l2_fourcc2str(fourcc):
  function V4L2_FIELD_HAS_TOP (line 167) | def V4L2_FIELD_HAS_TOP(field):
  function V4L2_FIELD_HAS_BOTTOM (line 177) | def V4L2_FIELD_HAS_BOTTOM(field):
  function V4L2_FIELD_HAS_BOTH (line 187) | def V4L2_FIELD_HAS_BOTH(field):
  class v4l2_rect (line 299) | class v4l2_rect(ctypes.Structure):
  class v4l2_fract (line 308) | class v4l2_fract(ctypes.Structure):
  class v4l2_capability (line 319) | class v4l2_capability(ctypes.Structure):
  class v4l2_pix_format (line 368) | class v4l2_pix_format(ctypes.Structure):
  class v4l2_fmtdesc (line 474) | class v4l2_fmtdesc(ctypes.Structure):
  class v4l2_frmsize_discrete (line 500) | class v4l2_frmsize_discrete(ctypes.Structure):
  class v4l2_frmsize_stepwise (line 507) | class v4l2_frmsize_stepwise(ctypes.Structure):
  class v4l2_frmsizeenum (line 518) | class v4l2_frmsizeenum(ctypes.Structure):
    class _u (line 519) | class _u(ctypes.Union):
  class v4l2_frmival_stepwise (line 548) | class v4l2_frmival_stepwise(ctypes.Structure):
  class v4l2_frmivalenum (line 556) | class v4l2_frmivalenum(ctypes.Structure):
    class _u (line 557) | class _u(ctypes.Union):
  class v4l2_timecode (line 580) | class v4l2_timecode(ctypes.Structure):
  class v4l2_jpegcompression (line 605) | class v4l2_jpegcompression(ctypes.Structure):
  class v4l2_plane (line 629) | class v4l2_plane(ctypes.Structure):
    class _u (line 630) | class _u(ctypes.Union):
  class v4l2_requestbuffers (line 642) | class v4l2_requestbuffers(ctypes.Structure):
  class v4l2_buffer (line 651) | class v4l2_buffer(ctypes.Structure):
    class _u (line 652) | class _u(ctypes.Union):
  class v4l2_framebuffer (line 691) | class v4l2_framebuffer(ctypes.Structure):
  class v4l2_clip (line 717) | class v4l2_clip(ctypes.Structure):
  class v4l2_window (line 725) | class v4l2_window(ctypes.Structure):
  class v4l2_captureparm (line 741) | class v4l2_captureparm(ctypes.Structure):
  class v4l2_outputparm (line 756) | class v4l2_outputparm(ctypes.Structure):
  class v4l2_cropcap (line 771) | class v4l2_cropcap(ctypes.Structure):
  class v4l2_crop (line 780) | class v4l2_crop(ctypes.Structure):
  class v4l2_standard (line 848) | class v4l2_standard(ctypes.Structure):
  class v4l2_dv_preset (line 863) | class v4l2_dv_preset(ctypes.Structure):
  class v4l2_dv_enum_preset (line 874) | class v4l2_dv_enum_preset(ctypes.Structure):
  class v4l2_bt_timings (line 913) | class v4l2_bt_timings(ctypes.Structure):
  class v4l2_dv_timings (line 943) | class v4l2_dv_timings(ctypes.Structure):
    class _u (line 944) | class _u(ctypes.Union):
  class v4l2_input (line 967) | class v4l2_input(ctypes.Structure):
  class v4l2_output (line 1009) | class v4l2_output(ctypes.Structure):
  class v4l2_control (line 1033) | class v4l2_control(ctypes.Structure):
  class v4l2_ext_control (line 1040) | class v4l2_ext_control(ctypes.Structure):
    class _u (line 1041) | class _u(ctypes.Union):
  class v4l2_ext_controls (line 1058) | class v4l2_ext_controls(ctypes.Structure):
  function V4L2_CTRL_ID_MASK (line 1074) | def V4L2_CTRL_ID_MASK():
  function V4L2_CTRL_ID2CLASS (line 1078) | def V4L2_CTRL_ID2CLASS(id_):
  function V4L2_CTRL_DRIVER_PRIV (line 1082) | def V4L2_CTRL_DRIVER_PRIV(id_):
  class v4l2_queryctrl (line 1086) | class v4l2_queryctrl(ctypes.Structure):
  class v4l2_querymenu (line 1100) | class v4l2_querymenu(ctypes.Structure):
  class v4l2_tuner (line 1539) | class v4l2_tuner(ctypes.Structure):
  class v4l2_modulator (line 1555) | class v4l2_modulator(ctypes.Structure):
  class v4l2_frequency (line 1590) | class v4l2_frequency(ctypes.Structure):
  class v4l2_hw_freq_seek (line 1599) | class v4l2_hw_freq_seek(ctypes.Structure):
  class v4l2_rds_data (line 1613) | class v4l2_rds_data(ctypes.Structure):
  class v4l2_audio (line 1639) | class v4l2_audio(ctypes.Structure):
  class v4l2_audioout (line 1655) | class v4l2_audioout(ctypes.Structure):
  class v4l2_enc_idx_entry (line 1675) | class v4l2_enc_idx_entry(ctypes.Structure):
  class v4l2_enc_idx (line 1688) | class v4l2_enc_idx(ctypes.Structure):
  class v4l2_encoder_cmd (line 1705) | class v4l2_encoder_cmd(ctypes.Structure):
    class _u (line 1706) | class _u(ctypes.Union):
      class _s (line 1707) | class _s(ctypes.Structure):
  class v4l2_vbi_format (line 1729) | class v4l2_vbi_format(ctypes.Structure):
  class v4l2_sliced_vbi_format (line 1746) | class v4l2_sliced_vbi_format(ctypes.Structure):
  class v4l2_sliced_vbi_cap (line 1764) | class v4l2_sliced_vbi_cap(ctypes.Structure):
  class v4l2_sliced_vbi_data (line 1773) | class v4l2_sliced_vbi_data(ctypes.Structure):
  class v4l2_mpeg_vbi_itv0_line (line 1794) | class v4l2_mpeg_vbi_itv0_line(ctypes.Structure):
  class v4l2_mpeg_vbi_itv0 (line 1803) | class v4l2_mpeg_vbi_itv0(ctypes.Structure):
  class v4l2_mpeg_vbi_ITV0 (line 1812) | class v4l2_mpeg_vbi_ITV0(ctypes.Structure):
  class v4l2_mpeg_vbi_fmt_ivtv (line 1824) | class v4l2_mpeg_vbi_fmt_ivtv(ctypes.Structure):
    class _u (line 1825) | class _u(ctypes.Union):
  class v4l2_plane_pix_format (line 1844) | class v4l2_plane_pix_format(ctypes.Structure):
  class v4l2_sdr_format (line 1851) | class v4l2_sdr_format(ctypes.Structure):
  class v4l2_meta_format (line 1858) | class v4l2_meta_format(ctypes.Structure):
  class v4l2_pix_format_mplane (line 1864) | class v4l2_pix_format_mplane(ctypes.Structure):
    class _u (line 1865) | class _u(ctypes.Union):
  class v4l2_format (line 1886) | class v4l2_format(ctypes.Structure):
    class _u (line 1887) | class _u(ctypes.Union):
  class v4l2_streamparm (line 1905) | class v4l2_streamparm(ctypes.Structure):
    class _u (line 1906) | class _u(ctypes.Union):
  class v4l2_dbg_match (line 1929) | class v4l2_dbg_match(ctypes.Structure):
    class _u (line 1930) | class _u(ctypes.Union):
  class v4l2_dbg_register (line 1945) | class v4l2_dbg_register(ctypes.Structure):
  class v4l2_dbg_chip_ident (line 1956) | class v4l2_dbg_chip_ident(ctypes.Structure):

FILE: prusa/link/cameras/v4l2_driver.py
  class Info (line 40) | class Info(NamedTuple):
  class ImageFormat (line 53) | class ImageFormat(NamedTuple):
  class FrameType (line 61) | class FrameType(NamedTuple):
  class FocusInfo (line 68) | class FocusInfo(NamedTuple):
  function frame_sizes (line 81) | def frame_sizes(file_descriptor, pixel_formats):
  function read_capabilities (line 104) | def read_capabilities(file_descriptor):
  function read_info (line 111) | def read_info(filename):
  function fopen (line 192) | def fopen(path, write=False):
  function opener (line 197) | def opener(path, flags):
  function iter_video_files (line 202) | def iter_video_files(path="/dev"):
  function iter_devices (line 208) | def iter_devices(path="/dev"):
  function iter_video_capture_devices (line 213) | def iter_video_capture_devices(path="/dev"):
  class MediaDeviceInfo (line 225) | class MediaDeviceInfo(ctypes.Structure):
  function read_media_device_info (line 247) | def read_media_device_info(path):
  class V4L2Camera (line 260) | class V4L2Camera:
    method __init__ (line 267) | def __init__(self, path):
    method _ioctl (line 282) | def _ioctl(self, request, arg: Any = 0):
    method is_stopped (line 287) | def is_stopped(self):
    method _set_format (line 291) | def _set_format(self):
    method _set_fps (line 308) | def _set_fps(self):
    method _buffer_request (line 323) | def _buffer_request(self, count=1):
    method _v4l2_buffer (line 338) | def _v4l2_buffer(self):
    method start (line 346) | def start(self):
    method stop (line 387) | def stop(self):
    method next_frame (line 403) | def next_frame(self):
    method set_focus (line 418) | def set_focus(self, value):
  function get_media_device_path (line 436) | def get_media_device_path(device: V4L2Camera):
  function param_change (line 456) | def param_change(func):
  class V4L2Driver (line 472) | class V4L2Driver(CameraDriver):
    method _scan (line 481) | def _scan():
    method __init__ (line 516) | def __init__(self, camera_id, config, unavailable_cb):
    method _connect (line 525) | def _connect(self):
    method set_resolution (line 588) | def set_resolution(self, resolution):
    method _set_resolution (line 592) | def _set_resolution(self, resolution):
    method set_focus (line 607) | def set_focus(self, focus):
    method take_a_photo (line 611) | def take_a_photo(self):
    method _disconnect (line 617) | def _disconnect(self):

FILE: prusa/link/conditions.py
  function use_connect_errors (line 88) | def use_connect_errors(use_connect):
  function status (line 98) | def status():
  function printer_status (line 106) | def printer_status():
  function connect_status (line 114) | def connect_status():
  class LinkError (line 124) | class LinkError(RuntimeError):
    method __init__ (line 135) | def __init__(self, details: str = ""):
    method set_url (line 147) | def set_url(self, req):
    method gen_headers (line 151) | def gen_headers(self):
    method json_response (line 155) | def json_response(self):
    method text_response (line 167) | def text_response(self):
  class BadRequestError (line 179) | class BadRequestError(LinkError):
  class TemperatureTooLow (line 184) | class TemperatureTooLow(BadRequestError):
  class TemperatureTooHigh (line 191) | class TemperatureTooHigh(BadRequestError):
  class ValueTooLow (line 198) | class ValueTooLow(BadRequestError):
  class ValueTooHigh (line 205) | class ValueTooHigh(BadRequestError):
  class CantMoveAxis (line 212) | class CantMoveAxis(BadRequestError):
  class CantMoveAxisZ (line 219) | class CantMoveAxisZ(BadRequestError):
  class DestinationSameAsSource (line 226) | class DestinationSameAsSource(BadRequestError):
  class NoFileInRequest (line 233) | class NoFileInRequest(BadRequestError):
  class FileSizeMismatch (line 240) | class FileSizeMismatch(BadRequestError):
  class InvalidIniFileFormat (line 247) | class InvalidIniFileFormat(BadRequestError):
  class InvalidBooleanHeader (line 254) | class InvalidBooleanHeader(BadRequestError):
  class ForbiddenCharacters (line 261) | class ForbiddenCharacters(BadRequestError):
  class FilenameTooLong (line 268) | class FilenameTooLong(BadRequestError):
  class FoldernameTooLong (line 275) | class FoldernameTooLong(BadRequestError):
  class FileUploadFailed (line 282) | class FileUploadFailed(BadRequestError):
  class CantConnect (line 289) | class CantConnect(BadRequestError):
  class CantResolveHostname (line 296) | class CantResolveHostname(BadRequestError):
  class NotSupportedFileType (line 303) | class NotSupportedFileType(LinkError):
  class ForbiddenError (line 311) | class ForbiddenError(LinkError):
  class NotFoundError (line 319) | class NotFoundError(LinkError):
  class NotCurrentJob (line 327) | class NotCurrentJob(NotFoundError):
  class GoneError (line 333) | class GoneError(LinkError):
  class ThumbnailUnavailable (line 341) | class ThumbnailUnavailable(GoneError):
  class FileNotFound (line 347) | class FileNotFound(NotFoundError):
  class FolderNotFound (line 353) | class FolderNotFound(NotFoundError):
  class LocationNotFound (line 359) | class LocationNotFound(NotFoundError):
  class ConflictError (line 367) | class ConflictError(LinkError):
  class DirectoryNotEmpty (line 372) | class DirectoryNotEmpty(ConflictError):
  class CurrentlyPrinting (line 379) | class CurrentlyPrinting(ConflictError):
  class NotStateToPrint (line 385) | class NotStateToPrint(ConflictError):
  class NotPrinting (line 392) | class NotPrinting(ConflictError):
  class NotPaused (line 398) | class NotPaused(ConflictError):
  class FileCurrentlyPrinted (line 404) | class FileCurrentlyPrinted(ConflictError):
  class TransferConflict (line 412) | class TransferConflict(ConflictError):
  class TransferStopped (line 420) | class TransferStopped(ConflictError):
  class UnavailableUpdate (line 427) | class UnavailableUpdate(ConflictError):
  class UnableToUpdate (line 435) | class UnableToUpdate(ConflictError):
  class LengthRequired (line 443) | class LengthRequired(LinkError):
  class EntityTooLarge (line 451) | class EntityTooLarge(LinkError):
  class FileAlreadyExists (line 459) | class FileAlreadyExists(LinkError):
  class FolderAlreadyExists (line 467) | class FolderAlreadyExists(LinkError):
  class StorageNotExist (line 475) | class StorageNotExist(LinkError):
  class SDCardReadOnly (line 483) | class SDCardReadOnly(LinkError):
  class SDCardNotSupported (line 491) | class SDCardNotSupported(LinkError):
  class UnsupportedMediaError (line 499) | class UnsupportedMediaError(LinkError):
  class InternalServerError (line 507) | class InternalServerError(LinkError):
  class ResponseTimeout (line 516) | class ResponseTimeout(InternalServerError):
  class PrinterUnavailable (line 523) | class PrinterUnavailable(LinkError):
  class RequestTimeout (line 531) | class RequestTimeout(LinkError):

FILE: prusa/link/config.py
  function get_log_level_dict (line 27) | def get_log_level_dict(log_levels: Iterable[str]):
  function check_log_level (line 40) | def check_log_level(value):
  function check_server_type (line 46) | def check_server_type(value):
  class Model (line 52) | class Model(dict):
    method __getattr__ (line 57) | def __getattr__(self, key):
    method __setattr__ (line 63) | def __setattr__(self, key, val):
    method get (line 67) | def get(cfg, name, options):
  class FakeArgs (line 71) | class FakeArgs:
    method __init__ (line 74) | def __init__(self, path):
  class Config (line 89) | class Config(Get):
    method __init__ (line 93) | def __init__(self, args):
    method set_section (line 204) | def set_section(self, name, model):
    method update_sections (line 220) | def update_sections(self):
    method set_global_log_level (line 228) | def set_global_log_level(self, args):
    method get_log_handler (line 241) | def get_log_handler(self, args):
  class Settings (line 263) | class Settings(Get):
    method __init__ (line 271) | def __init__(self, settings_file):
    method set_section (line 321) | def set_section(self, name, model):
    method update_sections (line 328) | def update_sections(self, connect_skip=False):
    method is_wizard_needed (line 336) | def is_wizard_needed(self):
    method use_connect (line 346) | def use_connect(self):

FILE: prusa/link/const.py
  class LimitsFDM (line 157) | class LimitsFDM:
  class LimitsMK25 (line 195) | class LimitsMK25(LimitsFDM):
  class LimitsMK25S (line 204) | class LimitsMK25S(LimitsFDM):
  class LimitsMK3 (line 213) | class LimitsMK3(LimitsFDM):
  class LimitsMK3S (line 222) | class LimitsMK3S(LimitsFDM):

FILE: prusa/link/daemon.py
  class Daemon (line 18) | class Daemon:
    method __init__ (line 23) | def __init__(self, config, argv: List):
    method run (line 35) | def run(self, daemon=True):
    method restart (line 72) | def restart(argv: List):
    method sigterm (line 82) | def sigterm(self, *_):

FILE: prusa/link/interesting_logger.py
  class DecoySrcfile (line 17) | class DecoySrcfile:
    method __init__ (line 35) | def __init__(self):
    method __eq__ (line 38) | def __eq__(self, other):
    method __hash__ (line 41) | def __hash__(self):
  class InterestingLogRotator (line 49) | class InterestingLogRotator(metaclass=MCSingleton):
    method __init__ (line 55) | def __init__(self):
    method skip_logger (line 61) | def skip_logger(self, logger_to_skip):
    method is_skipped (line 75) | def is_skipped(self, logger_name):
    method process_log_entry (line 79) | def process_log_entry(self, got_printed, level, msg, *args, **kwargs):
    method _log (line 94) | def _log(level, msg, *args, **kwargs):
    method trigger (line 103) | def trigger(by_what: str):
    method instance_trigger (line 111) | def instance_trigger(self, by_what: str):
  class InterestingLogger (line 147) | class InterestingLogger(Logger):
    method __init__ (line 150) | def __init__(self, name, level=NOTSET):
    method is_skipped (line 156) | def is_skipped(self):
    method debug (line 180) | def debug(self, msg, *args, **kwargs):
    method info (line 190) | def info(self, msg, *args, **kwargs):
    method warning (line 200) | def warning(self, msg, *args, **kwargs):
    method error (line 210) | def error(self, msg, *args, **kwargs):
    method critical (line 220) | def critical(self, msg, *args, **kwargs):
    method log (line 230) | def log(self, level, msg, *args, **kwargs):

FILE: prusa/link/multi_instance/__main__.py
  function main_thread_exception (line 36) | def main_thread_exception(exc_type, exc_value, exc_traceback):
  function thread_exception (line 46) | def thread_exception(_):
  function get_logger_file_descriptors (line 56) | def get_logger_file_descriptors():
  class Manager (line 67) | class Manager:
    method __init__ (line 72) | def __init__(self, user_info, prepend_executables_with):
    method _sigterm_handler (line 96) | def _sigterm_handler(self, *_):
  class Server (line 102) | class Server:
    method __init__ (line 107) | def __init__(self, user_info):
    method _sigterm_handler (line 133) | def _sigterm_handler(self, *_):
  function get_username (line 140) | def get_username(username=None):
  function start (line 158) | def start(user_info, prepend_executables_with):
  function handle_process_stop (line 168) | def handle_process_stop(pid_file, name="Process", quiet=False):
  function stop (line 182) | def stop(quiet=False):
  function clean (line 207) | def clean(user_info, prepend_executables_with):
  function rescan (line 214) | def rescan():
  function main (line 223) | def main():

FILE: prusa/link/multi_instance/config_component.py
  class MultiInstanceConfig (line 37) | class MultiInstanceConfig(Get):
    method __init__ (line 40) | def __init__(self):
    method add (line 64) | def add(self, printer_number, serial_number, config_path):
    method add_from_section (line 81) | def add_from_section(self, section_name: str):
    method save (line 102) | def save(self):
  class ConfigComponent (line 130) | class ConfigComponent:
    method __init__ (line 133) | def __init__(self, multi_instance_config, user_info,
    method configure_instance (line 144) | def configure_instance(self, printer: PrinterDevice, printer_number):
    method remove_all_printers (line 178) | def remove_all_printers(self):
    method is_configured (line 184) | def is_configured(self, serial_number):
    method _get_highest_printer_number (line 192) | def _get_highest_printer_number(self):
    method configure_new (line 199) | def configure_new(self):
    method setup_connected_trigger (line 228) | def setup_connected_trigger(self):
    method teardown_connected_trigger (line 251) | def teardown_connected_trigger(self):
    method _create_udev_rule (line 258) | def _create_udev_rule(self, printer: PrinterDevice, printer_number):
    method _create_printer_config (line 291) | def _create_printer_config(self,
    method remove_printers (line 333) | def remove_printers(self, numbers_to_remove: List[int]):
    method refresh_udev_rules (line 399) | def refresh_udev_rules():
    method delete_file (line 405) | def delete_file(path):
    method delete_folder (line 414) | def delete_folder(path):
    method wait_for_symlink (line 423) | def wait_for_symlink(symlink_path):

FILE: prusa/link/multi_instance/controller.py
  class Controller (line 14) | class Controller:
    method __init__ (line 17) | def __init__(self, user_info, prepend_executables_with):
    method run (line 39) | def run(self):
    method rescan (line 49) | def rescan(self):
    method stop (line 59) | def stop(self):
    method remove_all_printers (line 64) | def remove_all_printers(self):
    method config_changed (line 68) | def config_changed(self, *_):

FILE: prusa/link/multi_instance/ipc_queue_adapter.py
  function get_queue_path (line 16) | def get_queue_path(queue_name):
  class IPCConsumer (line 24) | class IPCConsumer:
    method __init__ (line 27) | def __init__(self,
    method add_handler (line 46) | def add_handler(self, command: str, handler: Callable[[], None]):
    method start (line 51) | def start(self):
    method stop (line 57) | def stop(self):
    method _setup_queue (line 63) | def _setup_queue(self):
    method _read_commands (line 76) | def _read_commands(self):
  class IPCSender (line 107) | class IPCSender:
    method send_and_close (line 111) | def send_and_close(queue_name, command, *args, **kwargs):
    method __init__ (line 118) | def __init__(self, queue_name):
    method send (line 127) | def send(self, command, *args, **kwargs):
    method close (line 143) | def close(self):
    method __del__ (line 147) | def __del__(self):

FILE: prusa/link/multi_instance/runner_component.py
  class LoadedInstance (line 16) | class LoadedInstance:
    method __init__ (line 19) | def __init__(self, config: Config, config_path: str):
  class RunnerComponent (line 24) | class RunnerComponent:
    method __init__ (line 27) | def __init__(self, multi_instance_config, user_info,
    method start_configured (line 34) | def start_configured(self):
    method load_instance (line 51) | def load_instance(self, config_path: str):

FILE: prusa/link/multi_instance/web.py
  class InfoKeeper (line 28) | class InfoKeeper:
    class PrinterInfo (line 30) | class PrinterInfo:
      method __init__ (line 32) | def __init__(self, number, name, port):
    method __init__ (line 37) | def __init__(self):
    method refresh (line 45) | def refresh(self):
    method printer_info (line 50) | def printer_info(self):
  class MultInstanceApp (line 70) | class MultInstanceApp(Application):
  function single_instance_redirect (line 86) | def single_instance_redirect(func):
  function get_web_server (line 103) | def get_web_server(port):
  function index (line 113) | def index(req):
  function list_printers (line 122) | def list_printers(req):
  function get_content_length (line 138) | def get_content_length(headers):
  function file_data_generator (line 146) | def file_data_generator(file_like, length):
  function proxy (line 162) | def proxy(req, printer_number, path="/", use_proxy_headers=True):
  function fallback (line 209) | def fallback(req):

FILE: prusa/link/printer_adapter/auto_telemetry.py
  class AutoTelemetry (line 22) | class AutoTelemetry(ThreadedUpdatable):
    method __init__ (line 30) | def __init__(self, serial_parser: ThreadedSerialParser,
    method temps_recorded (line 52) | def temps_recorded(self, sender, match: Match):
    method positions_recorded (line 69) | def positions_recorded(self, sender, match: Match):
    method fans_recorded (line 83) | def fans_recorded(self, sender, match: Match):
    method update (line 100) | def update(self):
    method turn_reporting_on (line 112) | def turn_reporting_on(self):
    method proper_stop (line 122) | def proper_stop(self):
    method _reset_last_seen (line 132) | def _reset_last_seen(self):

FILE: prusa/link/printer_adapter/command.py
  class CommandFailed (line 27) | class CommandFailed(Exception):
  class NotStateToPrint (line 31) | class NotStateToPrint(CommandFailed):
  class FileNotFound (line 35) | class FileNotFound(CommandFailed):
  class Command (line 40) | class Command:
    method __init__ (line 47) | def __init__(self, command_id=None, source=Source.CONNECT) -> None:
    method wait_while_running (line 64) | def wait_while_running(self, instruction):
    method do_instruction (line 68) | def do_instruction(self, message):
    method do_matchable (line 77) | def do_matchable(self, message, regexp: re.Pattern):
    method wait_for_instruction (line 87) | def wait_for_instruction(self, instruction):
    method run_command (line 94) | def run_command(self) -> Dict[str, Any]:
    method _run_command (line 104) | def _run_command(self):
    method stop (line 107) | def stop(self):

FILE: prusa/link/printer_adapter/command_handlers.py
  function check_update_prusalink (line 52) | def check_update_prusalink():
  function update_prusalink (line 59) | def update_prusalink():
  function change_reset_mode (line 67) | def change_reset_mode(model, serial_adapter, serial_parser, quit_evt,
  class TryUntilState (line 115) | class TryUntilState(Command):
    method __init__ (line 119) | def __init__(self, command_id=None, source=Source.CONNECT):
    method _try_until_state (line 128) | def _try_until_state(self, gcode: str, desired_states: Set[State]):
    method _run_command (line 185) | def _run_command(self):
  class StopPrint (line 189) | class StopPrint(TryUntilState):
    method _run_command (line 193) | def _run_command(self):
  class PausePrint (line 209) | class PausePrint(TryUntilState):
    method _run_command (line 213) | def _run_command(self):
  class ResumePrint (line 227) | class ResumePrint(TryUntilState):
    method _run_command (line 231) | def _run_command(self):
  class StartPrint (line 248) | class StartPrint(Command):
    method __init__ (line 252) | def __init__(self, path: str, **kwargs):
    method _run_command (line 256) | def _run_command(self):
    method _start_file_print (line 304) | def _start_file_print(self, path):
    method _load_file (line 312) | def _load_file(self, raw_sd_path: str) -> None:
    method _start_print (line 326) | def _start_print(self):
  class ExecuteGcode (line 331) | class ExecuteGcode(Command):
    method __init__ (line 335) | def __init__(self, gcode, force=False, **kwargs):
    method _run_command (line 345) | def _run_command(self):
    method _get_state_change (line 396) | def _get_state_change(default_source):
  class FilamentCommand (line 400) | class FilamentCommand(Command):
    method __init__ (line 403) | def __init__(self, parameters: Optional[Dict], **kwargs):
    method prepare_for_load_unload (line 407) | def prepare_for_load_unload(self):
    method _run_command (line 443) | def _run_command(self):
  class LoadFilament (line 447) | class LoadFilament(FilamentCommand):
    method _run_command (line 452) | def _run_command(self):
  class UnloadFilament (line 464) | class UnloadFilament(FilamentCommand):
    method _run_command (line 469) | def _run_command(self):
  class ResetPrinter (line 476) | class ResetPrinter(Command):
    method _run_command (line 485) | def _run_command(self):
  class UpgradeLink (line 537) | class UpgradeLink(Command):
    method _run_command (line 541) | def _run_command(self):
  class JobInfo (line 559) | class JobInfo(Command):
    method _run_command (line 563) | def _run_command(self):
  class SetReady (line 595) | class SetReady(Command):
    method _run_command (line 599) | def _run_command(self):
  class CancelReady (line 612) | class CancelReady(Command):
    method _run_command (line 616) | def _run_command(self):
  class RePrint (line 630) | class RePrint(StartPrint):
    method __init__ (line 634) | def __init__(self, **kwargs):
    method _run_command (line 642) | def _run_command(self):
  class DisableResets (line 654) | class DisableResets(Command):
    method _run_command (line 659) | def _run_command(self):
  class EnableResets (line 665) | class EnableResets(Command):
    method _run_command (line 670) | def _run_command(self):
  class PPRecovery (line 676) | class PPRecovery(Command):
    method _run_command (line 680) | def _run_command(self):

FILE: prusa/link/printer_adapter/command_queue.py
  class CommandAdapter (line 23) | class CommandAdapter:
    method __init__ (line 27) | def __init__(self, command) -> None:
  class CommandQueue (line 34) | class CommandQueue:
    method __init__ (line 40) | def __init__(self) -> None:
    method start (line 49) | def start(self) -> None:
    method stop (line 54) | def stop(self) -> None:
    method enqueue_command (line 59) | def enqueue_command(self, command: Command) -> CommandAdapter:
    method do_command (line 69) | def do_command(self, command: Command):
    method force_command (line 92) | def force_command(self, command: Command):
    method process_queue (line 98) | def process_queue(self) -> None:
    method _stop_current (line 119) | def _stop_current(self):
    method clear_queue (line 124) | def clear_queue(self):

FILE: prusa/link/printer_adapter/file_printer.py
  class FilePrinter (line 39) | class FilePrinter(metaclass=MCSingleton):
    method __init__ (line 47) | def __init__(self, serial_queue: SerialQueue,
    method start (line 86) | def start(self) -> None:
    method stop (line 90) | def stop(self) -> None:
    method wait_stopped (line 95) | def wait_stopped(self) -> None:
    method pp_exists (line 101) | def pp_exists(self) -> bool:
    method print (line 105) | def print(self, os_path: str, from_gcode_number=None) -> None:
    method power_panic (line 130) | def power_panic(self) -> None:
    method _print (line 138) | def _print(self, from_gcode_number=None):
    method _print_pause (line 209) | def _print_pause(self):
    method _print_end (line 230) | def _print_end(self):
    method do_instruction (line 252) | def do_instruction(self, message):
    method print_gcode (line 261) | def print_gcode(self, gcode):
    method wait_for_queue (line 284) | def wait_for_queue(self) -> None:
    method react_to_gcode (line 302) | def react_to_gcode(self, gcode):
    method send_print_stats (line 314) | def send_print_stats(self):
    method to_print_stats (line 333) | def to_print_stats(self, gcode_number):
    method pause (line 346) | def pause(self):
    method resume (line 353) | def resume(self):
    method stop_print (line 366) | def stop_print(self):
    method write_file_stats (line 375) | def write_file_stats(self, file_path, message_number, gcode_number):
    method serial_message_number_changed (line 388) | def serial_message_number_changed(self, message_number):

FILE: prusa/link/printer_adapter/filesystem/sd_card.py
  function alternative_filename (line 45) | def alternative_filename(long_filename: str,
  function get_root (line 60) | def get_root():
  class FileTreeParser (line 65) | class FileTreeParser:
    method __init__ (line 70) | def __init__(self, matches):
    method check_uniqueness (line 98) | def check_uniqueness(self, path: Path):
    method parse_file (line 105) | def parse_file(self, groups):
    method parse_dir (line 171) | def parse_dir(self, groups):
  class SDCard (line 195) | class SDCard(ThreadedUpdatable):
    method __init__ (line 219) | def __init__(self, serial_queue: SerialQueue,
    method handle_special_menu (line 251) | def handle_special_menu(self, file_tree_parser):
    method update (line 269) | def update(self):
    method _set_files (line 325) | def _set_files(self, file_tree_parser: FileTreeParser):
    method set_flash_air (line 335) | def set_flash_air(self, is_flash_air):
    method _construct_file_tree (line 342) | def _construct_file_tree(self) -> FileTreeParser:
    method sd_inserted (line 371) | def sd_inserted(self, sender, match: re.Match):
    method sd_ejected (line 387) | def sd_ejected(self, sender, match: re.Match):
    method _sd_state_changed (line 398) | def _sd_state_changed(self, new_state):
    method decide_presence (line 422) | def decide_presence(self):

FILE: prusa/link/printer_adapter/filesystem/storage.py
  class Storage (line 29) | class Storage(ThreadedUpdatable):
    method __init__ (line 37) | def __init__(self, model: Model):
    method update (line 65) | def update(self):
    method filter_blacklisted_paths (line 86) | def filter_blacklisted_paths(candidate_list, black_list):
    method filter_blacklisted_names (line 96) | def filter_blacklisted_names(candidate_list, black_list):
    method is_path_blacklisted (line 106) | def is_path_blacklisted(candidate, black_list):
    method is_name_blacklisted (line 117) | def is_name_blacklisted(candidate, black_list):
    method _get_clean_paths (line 129) | def _get_clean_paths(dirty_paths):
    method get_differences (line 135) | def get_differences(self, new_storage_set: Set[str]):
    method get_storage (line 142) | def get_storage(self) -> Set[str]:
    method get_data_object (line 149) | def get_data_object(self) -> StorageData:
  class FilesystemStorage (line 156) | class FilesystemStorage(Storage):
    method __init__ (line 164) | def __init__(self, model: Model, cfg: Config):
    method get_data_object (line 184) | def get_data_object(self) -> StorageData:
    method get_storage (line 187) | def get_storage(self) -> Set[str]:
    method storage_belongs (line 213) | def storage_belongs(self, path, fs_type):
    method stop (line 219) | def stop(self):
  class FolderStorage (line 225) | class FolderStorage(Storage):
    method __init__ (line 231) | def __init__(self, model: Model, cfg: Config):
    method get_data_object (line 248) | def get_data_object(self) -> StorageData:
    method get_storage (line 255) | def get_storage(self) -> Set[str]:
    method dir_belongs (line 273) | def dir_belongs(directory: str):

FILE: prusa/link/printer_adapter/filesystem/storage_controller.py
  class StorageController (line 23) | class StorageController:
    method __init__ (line 30) | def __init__(self, cfg, serial_queue: SerialQueue,
    method folder_attached (line 58) | def folder_attached(self, sender, path: str):
    method folder_detached (line 63) | def folder_detached(self, sender, path: str):
    method sd_attached (line 68) | def sd_attached(self, sender, files: File):
    method sd_detached (line 73) | def sd_detached(self, sender):
    method menu_found (line 78) | def menu_found(self, _, menu_sfn):
    method update (line 82) | def update(self):
    method start (line 88) | def start(self):
    method stop (line 94) | def stop(self):
    method wait_stopped (line 100) | def wait_stopped(self):

FILE: prusa/link/printer_adapter/ip_updater.py
  class IPUpdater (line 25) | class IPUpdater(ThreadedUpdatable):
    method __init__ (line 33) | def __init__(self, model: Model, serial_queue: SerialQueue):
    method get_mac (line 53) | def get_mac(card):
    method update_additional_info (line 63) | def update_additional_info(self, ip):
    method update (line 102) | def update(self):
    method update_ip (line 118) | def update_ip(self):
    method update_ip6 (line 143) | def update_ip6(self):
    method send_ip_to_printer (line 161) | def send_ip_to_printer(self,
    method proper_stop (line 190) | def proper_stop(self):

FILE: prusa/link/printer_adapter/job.py
  class Job (line 26) | class Job(metaclass=MCSingleton):
    method __init__ (line 30) | def __init__(self,
    method file_opened (line 60) | def file_opened(self, _, match: re.Match):
    method process_mixed_path (line 67) | def process_mixed_path(self, mixed_path):
    method job_started (line 85) | def job_started(self, command_id=None):
    method job_ended (line 111) | def job_ended(self):
    method state_changed (line 122) | def state_changed(self, command_id=None):
    method tick (line 135) | def tick(self):
    method change_state (line 140) | def change_state(self, state: JobState):
    method write (line 147) | def write(self):
    method set_file_path (line 158) | def set_file_path(self, path, path_incomplete, prepend_sd_storage):
    method update_last_job_path (line 202) | def update_last_job_path(self):
    method get_job_info_data (line 208) | def get_job_info_data(self, for_connect=False):
    method progress_broken (line 232) | def progress_broken(self, progress_broken):
    method file_position (line 246) | def file_position(self, current, total):
    method job_info_updated (line 260) | def job_info_updated(self):
    method select_file (line 270) | def select_file(self, path):
    method deselect_file (line 281) | def deselect_file(self):
    method job_id_from_eeprom (line 289) | def job_id_from_eeprom(self, job_id):

FILE: prusa/link/printer_adapter/keepalive.py
  class KeepaliveMode (line 12) | class KeepaliveMode(Enum):
  class Keepalive (line 18) | class Keepalive(metaclass=MCSingleton):
    method __init__ (line 21) | def __init__(self, serial_queue: SerialQueue):
    method start (line 33) | def start(self):
    method set_use_connect (line 37) | def set_use_connect(self, use_connect: bool):
    method _keepalive (line 43) | def _keepalive(self):
    method stop (line 57) | def stop(self):
    method wait_stopped (line 62) | def wait_stopped(self):

FILE: prusa/link/printer_adapter/lcd_printer.py
  function through_queue (line 100) | def through_queue(func):
  class LCDPrinter (line 112) | class LCDPrinter(metaclass=MCSingleton):
    method __init__ (line 116) | def __init__(self,
    method start (line 200) | def start(self):
    method lcd_updated (line 204) | def lcd_updated(self, sender, match):
    method _message_and_disable (line 221) | def _message_and_disable(self, screen: Screen, message):
    method whats_going_on (line 228) | def whats_going_on(self):
    method _check_printing (line 239) | def _check_printing(self):
    method _filter_http (line 261) | def _filter_http(self, error):
    method _check_errors (line 277) | def _check_errors(self):
    method _check_wizard (line 333) | def _check_wizard(self):
    method _get_progress_graphic (line 359) | def _get_progress_graphic(self, progress, sync_type: TransferType):
    method _check_upload (line 395) | def _check_upload(self):
    method _check_ready (line 424) | def _check_ready(self):
    method _check_recovery (line 441) | def _check_recovery(self):
    method _check_idle (line 448) | def _check_idle(self):
    method get_wait_interval (line 479) | def get_wait_interval(self):
    method should_advance_carousel (line 489) | def should_advance_carousel(self):
    method _lcd_printer (line 500) | def _lcd_printer(self):
    method _print (line 521) | def _print(self, line: LCDLine, to_wait=None):
    method _reset_idle (line 550) | def _reset_idle(self):
    method stop (line 554) | def stop(self, fast=False):
    method wait_stopped (line 565) | def wait_stopped(self):
    method add_event (line 569) | def add_event(self, handler):
    method notify (line 574) | def notify(self):
    method reset_error_grace (line 578) | def reset_error_grace(self):
    method print_message (line 583) | def print_message(self, line: LCDLine):

FILE: prusa/link/printer_adapter/mmu_observer.py
  class MMUObserver (line 23) | class MMUObserver:
    method __init__ (line 27) | def __init__(self,
    method _prime_q0 (line 60) | def _prime_q0(self, _, match: Match) -> None:
    method _handle_mmu_progress (line 65) | def _handle_mmu_progress(self, _, match: Match):
    method _handle_active_slot (line 76) | def _handle_active_slot(self, _, match: Match):
    method _handle_mmu_error (line 90) | def _handle_mmu_error(self, error_code):
    method _handle_mmu_no_error (line 103) | def _handle_mmu_no_error(self):
    method _handle_q0_response (line 108) | def _handle_q0_response(self, _, match: Match):

FILE: prusa/link/printer_adapter/model.py
  class Model (line 18) | class Model(metaclass=MCSingleton):
    method __init__ (line 40) | def __init__(self) -> None:

FILE: prusa/link/printer_adapter/print_stat_doubler.py
  class PrintStatDoubler (line 13) | class PrintStatDoubler:
    method __init__ (line 22) | def __init__(self, serial_parser: ThreadedSerialParser,
    method reset (line 34) | def reset(self, sender, match):
    method matched (line 40) | def matched(self, sender, match):

FILE: prusa/link/printer_adapter/print_stats.py
  class PrintStats (line 13) | class PrintStats:
    method __init__ (line 19) | def __init__(self, model: Model):
    method track_new_print (line 30) | def track_new_print(self, file_path, from_gcode_number=None):
    method reset_stats (line 53) | def reset_stats(self):
    method end_time_segment (line 59) | def end_time_segment(self):
    method start_time_segment (line 68) | def start_time_segment(self):
    method get_stats (line 74) | def get_stats(self, gcode_number):
    method get_time_printing (line 104) | def get_time_printing(self):

FILE: prusa/link/printer_adapter/printer_polling.py
  class InfoGroup (line 72) | class InfoGroup(WatchedGroup):
    method __init__ (line 75) | def __init__(self, *args, **kwargs):
    method mark_for_send (line 79) | def mark_for_send(self):
  class PrinterPolling (line 88) | class PrinterPolling:
    method __init__ (line 94) | def __init__(self, serial_queue: SerialQueue,
    method start (line 371) | def start(self):
    method stop (line 375) | def stop(self):
    method wait_stopped (line 379) | def wait_stopped(self):
    method invalidate_printer_info (line 383) | def invalidate_printer_info(self):
    method invalidate_network_info (line 392) | def invalidate_network_info(self):
    method invalidate_serial_number (line 396) | def invalidate_serial_number(self):
    method invalidate_mbl (line 400) | def invalidate_mbl(self):
    method invalidate_statistics (line 404) | def invalidate_statistics(self):
    method schedule_printer_type_invalidation (line 409) | def schedule_printer_type_invalidation(self):
    method _change_interval (line 414) | def _change_interval(self, item: WatchedItem, interval):
    method polling_not_ok (line 422) | def polling_not_ok(self):
    method polling_ok (line 433) | def polling_ok(self):
    method ensure_job_id (line 444) | def ensure_job_id(self):
    method should_wait (line 461) | def should_wait(self):
    method do_matchable (line 465) | def do_matchable(self, gcode, regex, to_front=False, has_to_match=True):
    method do_multimatch (line 479) | def do_multimatch(self, gcode, regex, to_front=False):
    method _get_network_info (line 490) | def _get_network_info(self):
    method _get_printer_type (line 520) | def _get_printer_type(self):
    method _get_firmware_version (line 530) | def _get_firmware_version(self):
    method _get_nozzle_diameter (line 535) | def _get_nozzle_diameter(self):
    method _get_serial_number (line 540) | def _get_serial_number(self):
    method _get_sheet_settings (line 556) | def _get_sheet_settings(self) -> List[Sheet]:
    method get_active_sheet (line 589) | def get_active_sheet(self):
    method _get_mmu_version (line 600) | def _get_mmu_version(self):
    method _get_job_id (line 615) | def _get_job_id(self):
    method _get_mbl (line 622) | def _get_mbl(self):
    method _get_flash_air (line 642) | def _get_flash_air(self):
    method _get_print_mode (line 648) | def _get_print_mode(self):
    method _get_speed_multiplier (line 656) | def _get_speed_multiplier(self):
    method _get_flow_multiplier (line 660) | def _get_flow_multiplier(self):
    method _get_print_info (line 664) | def _get_print_info(self):
    method _get_m27 (line 672) | def _get_m27(self):
    method _parse_print_state (line 694) | def _parse_print_state(groups):
    method _parse_mixed_path (line 702) | def _parse_mixed_path(self, groups):
    method _parse_byte_position (line 708) | def _parse_byte_position(self, groups):
    method _parse_sd_seconds_printing (line 713) | def _parse_sd_seconds_printing(self, groups):
    method _get_progress_from_byte_position (line 720) | def _get_progress_from_byte_position(self, value):
    method _guess_time_remaining (line 726) | def _guess_time_remaining(self, _):
    method print_info_handler (line 750) | def print_info_handler(self, sender, matches: List[re.Match]):
    method _speed_adjust_time_value (line 813) | def _speed_adjust_time_value(self, value):
    method _eeprom_little_endian_uint32 (line 826) | def _eeprom_little_endian_uint32(self, dcode):
    method _get_total_filament (line 834) | def _get_total_filament(self):
    method _get_total_print_time (line 840) | def _get_total_print_time(self):
    method _validate_serial_number (line 848) | def _validate_serial_number(self, value):
    method _validate_printer_type (line 860) | def _validate_printer_type(self, value):
    method _validate_fw_version (line 875) | def _validate_fw_version(value):
    method _validate_mbl (line 883) | def _validate_mbl(value):
    method _validate_percent (line 895) | def _validate_percent(value):
    method _validate_progress (line 903) | def _validate_progress(value):
    method _validate_time_till (line 911) | def _validate_time_till(value):
    method _set_network_info (line 919) | def _set_network_info(self, value):
    method _set_printer_type (line 923) | def _set_printer_type(self, value):
    method _set_firmware_version (line 929) | def _set_firmware_version(self, value):
    method _set_nozzle_diameter (line 934) | def _set_nozzle_diameter(self, value):
    method _set_serial_number (line 938) | def _set_serial_number(self, value):
    method _set_job_id (line 944) | def _set_job_id(self, value):
    method _set_flash_air (line 948) | def _set_flash_air(self, value):
    method _set_speed_multiplier (line 952) | def _set_speed_multiplier(self, value):
    method _set_flow_multiplier (line 956) | def _set_flow_multiplier(self, value):
    method _set_print_progress (line 960) | def _set_print_progress(self, value):
    method _set_time_remaining (line 964) | def _set_time_remaining(self, value):
    method _set_filament_change_in (line 968) | def _set_filament_change_in(self, value):
    method _set_sd_seconds_printing (line 973) | def _set_sd_seconds_printing(self, value):
    method _set_progress_from_bytes (line 977) | def _set_progress_from_bytes(self, value):
    method _set_time_remaining_guesstimate (line 989) | def _set_time_remaining_guesstimate(self, value):
    method _set_total_filament (line 997) | def _set_total_filament(self, value):
    method _set_total_print_time (line 1001) | def _set_total_print_time(self, value):
    method _set_inaccurate_estimates (line 1005) | def _set_inaccurate_estimates(self, value):
    method set_progress_broken (line 1012) | def set_progress_broken(self, value: bool):
    method set_time_broken (line 1016) | def set_time_broken(self, value: bool):
    method _set_sn_condition (line 1021) | def _set_sn_condition(state: CondState):
    method _set_id_condition (line 1026) | def _set_id_condition(state: CondState):
    method _set_fw_condition (line 1031) | def _set_fw_condition(state: CondState):
    method _set_job_id_condition (line 1036) | def _set_job_id_condition(state: CondState):
    method _printer_type_became_valid (line 1040) | def _printer_type_became_valid(self, _):
    method _firmware_version_became_valid (line 1046) | def _firmware_version_became_valid(self, _):
    method _mmu_connected_became_valid (line 1053) | def _mmu_connected_became_valid(self, _):
    method _printer_info_became_valid (line 1061) | def _printer_info_became_valid(self, _):
    method _send_info_if_changed (line 1078) | def _send_info_if_changed(self):
    method _infer_estimate_accuracy (line 1085) | def _infer_estimate_accuracy(self):

FILE: prusa/link/printer_adapter/prusa_link.py
  class TransferCallbackState (line 117) | class TransferCallbackState(Enum):
  class PrusaLink (line 125) | class PrusaLink:
    method __init__ (line 133) | def __init__(self, cfg: Config, settings: Settings) -> None:
    method debug_shell (line 394) | def debug_shell(self) -> None:
    method stop (line 432) | def stop(self, fast: bool = False) -> None:
    method printed_file_cb (line 502) | def printed_file_cb(self) -> Optional[str]:
    method download_finished_cb (line 509) | def download_finished_cb(self, transfer):
    method execute_gcode (line 535) | def execute_gcode(self, caller: SDKCommand) -> CommandResult:
    method start_print (line 545) | def start_print(self, caller: SDKCommand) -> CommandResult:
    method pause_print (line 554) | def pause_print(self, caller: SDKCommand) -> CommandResult:
    method resume_print (line 561) | def resume_print(self, caller: SDKCommand) -> CommandResult:
    method stop_print (line 568) | def stop_print(self, caller: SDKCommand) -> CommandResult:
    method reset_printer (line 575) | def reset_printer(self, caller: SDKCommand) -> CommandResult:
    method upgrade_link (line 582) | def upgrade_link(self, caller: SDKCommand) -> CommandResult:
    method job_info (line 589) | def job_info(self, caller: SDKCommand) -> CommandResult:
    method load_filament (line 596) | def load_filament(self, caller: SDKCommand) -> CommandResult:
    method unload_filament (line 602) | def unload_filament(self, caller: SDKCommand) -> CommandResult:
    method set_printer_ready (line 608) | def set_printer_ready(self, caller: SDKCommand) -> CommandResult:
    method cancel_printer_ready (line 613) | def cancel_printer_ready(self, caller: SDKCommand) -> CommandResult:
    method fw_pause_print (line 620) | def fw_pause_print(self) -> None:
    method fw_resume_print (line 630) | def fw_resume_print(self) -> None:
    method fw_set_ready (line 639) | def fw_set_ready(self) -> None:
    method fw_cancel_ready (line 645) | def fw_cancel_ready(self) -> None:
    method fw_reprint (line 651) | def fw_reprint(self) -> None:
    method layer_trigger (line 658) | def layer_trigger(self, _):
    method mbl_data_changed (line 662) | def mbl_data_changed(self, data) -> None:
    method sheet_settings_changed (line 669) | def sheet_settings_changed(self, printer_sheets: List[Sheet]) -> None:
    method active_sheet_changed (line 686) | def active_sheet_changed(self, active_sheet) -> None:
    method mmu_connection_changed (line 696) | def mmu_connection_changed(self, _) -> None:
    method mmu_info_changed (line 703) | def mmu_info_changed(self, _) -> None:
    method mmu_error_changed (line 733) | def mmu_error_changed(self, _) -> None:
    method job_info_updated (line 737) | def job_info_updated(self, _) -> None:
    method job_id_updated (line 748) | def job_id_updated(self, _, job_id: int) -> None:
    method printer_type_changed (line 753) | def printer_type_changed(self, item: WatchedItem) -> None:
    method print_state_changed (line 780) | def print_state_changed(self, item: WatchedItem) -> None:
    method observed_print (line 791) | def observed_print(self) -> None:
    method observed_sd_pause (line 802) | def observed_sd_pause(self) -> None:
    method observed_serial_pause (line 811) | def observed_serial_pause(self) -> None:
    method observed_no_print (line 826) | def observed_no_print(self) -> None:
    method progress_broken (line 840) | def progress_broken(self, progress_broken: bool) -> None:
    method byte_position_changed (line 847) | def byte_position_changed(self, _, current: int, total: int) -> None:
    method mixed_path_changed (line 851) | def mixed_path_changed(self, path: str) -> None:
    method _reset_print_stats (line 855) | def _reset_print_stats(self) -> None:
    method file_printer_started_printing (line 866) | def file_printer_started_printing(self, _) -> None:
    method file_printer_stopped_printing (line 870) | def file_printer_stopped_printing(self, _) -> None:
    method file_printer_finished_printing (line 874) | def file_printer_finished_printing(self, _) -> None:
    method serial_failed (line 878) | def serial_failed(self, _) -> None:
    method serial_renewed (line 883) | def serial_renewed(self, _) -> None:
    method set_sn (line 888) | def set_sn(self, _, serial_number: str) -> None:
    method printer_registered (line 900) | def printer_registered(self, token: str) -> None:
    method ip_updated (line 912) | def ip_updated(self, _) -> None:
    method folder_attach (line 916) | def folder_attach(self, _, path: str) -> None:
    method folder_detach (line 920) | def folder_detach(self, _, path: str) -> None:
    method sd_attach (line 924) | def sd_attach(self, _, files: File) -> None:
    method sd_detach (line 928) | def sd_detach(self, _) -> None:
    method instruction_confirmed (line 932) | def instruction_confirmed(self, _) -> None:
    method serial_message_number_changed (line 938) | def serial_message_number_changed(self, message_number):
    method block_serial_queue (line 943) | def block_serial_queue(self, *_, **__) -> None:
    method unblock_serial_queue (line 947) | def unblock_serial_queue(self, *_, **__) -> None:
    method power_panic_observed (line 951) | def power_panic_observed(self, *_, **__):
    method recover_from_pp (line 962) | def recover_from_pp(self, *_, **__) -> None:
    method printer_reconnected (line 966) | def printer_reconnected(self, *_, **__) -> None:
    method sd_ready (line 992) | def sd_ready(self) -> bool:
    method pre_state_change (line 996) | def pre_state_change(self, _, command_id: int):
    method post_state_change (line 1003) | def post_state_change(self, _) -> None:
    method state_changed (line 1010) | def state_changed(self,
    method time_printing_updated (line 1074) | def time_printing_updated(self, _, time_printing: int) -> None:
    method serial_queue_failed (line 1079) | def serial_queue_failed(self, _) -> None:
    method connection_renewed (line 1089) | def connection_renewed(self, *_) -> None:
    method transfer_activity_observed (line 1093) | def transfer_activity_observed(self, *_) -> None:
    method log_tm_error (line 1098) | def log_tm_error(self, _, match: re.Match) -> None:

FILE: prusa/link/printer_adapter/special_commands.py
  class SpecialCommands (line 24) | class SpecialCommands:
    method __init__ (line 28) | def __init__(self, serial_parser: ThreadedSerialParser,
    method menu_folder_found (line 48) | def menu_folder_found(self, _, menu_sfn):
    method menu_folder_gone (line 53) | def menu_folder_gone(self, _):
    method _open_is_special (line 58) | def _open_is_special(self, match):
    method handle_file (line 73) | def handle_file(self, _, match):
    method handle_start (line 84) | def handle_start(self, _, match: re.Match):
    method handle_done (line 95) | def handle_done(self, _, match: re.Match):
    method set_ready (line 105) | def set_ready(self):

FILE: prusa/link/printer_adapter/state_manager.py
  class StateChange (line 30) | class StateChange:
    method __init__ (line 37) | def __init__(self,
  function state_influencer (line 59) | def state_influencer(state_change: Optional[StateChange] = None):
  class StateManager (line 93) | class StateManager(metaclass=MCSingleton):
    method __init__ (line 102) | def __init__(self, serial_parser: ThreadedSerialParser, model: Model):
    method new_attention_timer (line 211) | def new_attention_timer(self):
    method start_attention_timer (line 220) | def start_attention_timer(self):
    method stop_attention_timer (line 227) | def stop_attention_timer(self):
    method link_error_detected (line 233) | def link_error_detected(self, condition: Condition, old_value: CondSta...
    method link_error_resolved (line 244) | def link_error_resolved(self, condition: Condition, old_value: CondSta...
    method file_printer_started_printing (line 252) | def file_printer_started_printing(self):
    method get_state (line 261) | def get_state(self):
    method expect_change (line 273) | def expect_change(self, change: StateChange):
    method stop_expecting_change (line 281) | def stop_expecting_change(self):
    method is_expected (line 286) | def is_expected(self):
    method get_expected_source (line 299) | def get_expected_source(self):
    method state_may_have_changed (line 346) | def state_may_have_changed(self):
    method fan_error (line 404) | def fan_error(self, sender, match: re.Match):
    method mmu_error_changed (line 422) | def mmu_error_changed(self):
    method fan_error_resolver (line 441) | def fan_error_resolver(self, sender, match):
    method _cancel_fan_error (line 472) | def _cancel_fan_error(self):
    method error_handler (line 478) | def error_handler(self):
    method error_reason_handler (line 489) | def error_reason_handler(self, sender, match: re.Match):
    method attention_reason_handler (line 505) | def attention_reason_handler(self, sender, match: re.Match):
    method filter_pause_events (line 532) | def filter_pause_events(self):
    method clear_tm_error (line 543) | def clear_tm_error(self, _, match: re.Match):
    method power_panic_observed (line 548) | def power_panic_observed(self):
    method reset_power_panic (line 552) | def reset_power_panic(self):
    method parse_error_reason (line 557) | def parse_error_reason(groups):
    method error_reason_waiter (line 588) | def error_reason_waiter(self):
    method stopped_or_not_printing (line 604) | def stopped_or_not_printing(self):
    method reset (line 617) | def reset(self):
    method printing (line 630) | def printing(self):
    method not_printing (line 649) | def not_printing(self):
    method finished (line 659) | def finished(self):
    method ready (line 666) | def ready(self):
    method idle (line 672) | def idle(self):
    method busy (line 678) | def busy(self):
    method paused (line 685) | def paused(self):
    method resumed (line 695) | def resumed(self):
    method stopped (line 708) | def stopped(self):
    method instruction_confirmed (line 730) | def instruction_confirmed(self):
    method _attention_timer_handler (line 753) | def _attention_timer_handler(self):
    method _clear_attention (line 762) | def _clear_attention(self):
    method clear_attention (line 776) | def clear_attention(self):
    method attention (line 781) | def attention(self):
    method error (line 797) | def error(self):
    method error_resolved (line 803) | def error_resolved(self):
    method serial_error (line 813) | def serial_error(self):
    method serial_error_resolved (line 825) | def serial_error_resolved(self):

FILE: prusa/link/printer_adapter/structures/carousel.py
  class LCDLine (line 10) | class LCDLine:
    method __init__ (line 13) | def __init__(self, text: str, delay: float = 5.0,
    method reset_end (line 24) | def reset_end(self):
  class Screen (line 30) | class Screen:
    method __init__ (line 33) | def __init__(self, resets_idle=True, chime_gcode=None, order=0):
    method __str__ (line 63) | def __str__(self):
    method lines (line 66) | def lines(self):
  class Carousel (line 84) | class Carousel:
    method __init__ (line 89) | def __init__(self, screens: List[Screen]):
    method _lines (line 102) | def _lines(self):
    method get_next (line 117) | def get_next(self):
    method _rewind (line 132) | def _rewind(self):
    method set_rewind (line 137) | def set_rewind(self):
    method add_message (line 143) | def add_message(self, line: LCDLine):
    method verify_tracked (line 148) | def verify_tracked(self, screen):
    method set_text (line 154) | def set_text(self,
    method enable (line 188) | def enable(self, screen: Screen, silent=False):
    method set_priority (line 199) | def set_priority(self, screen: Screen, priority):
    method disable (line 209) | def disable(self, screen: Screen):
    method is_enabled (line 218) | def is_enabled(self, screen: Screen):
    method get_set_to_show (line 222) | def get_set_to_show(self):
    method _react (line 231) | def _react(self):

FILE: prusa/link/printer_adapter/structures/heap.py
  class HeapItem (line 9) | class HeapItem:
    method __init__ (line 11) | def __init__(self, value):
    method __gt__ (line 16) | def __gt__(self, other):
    method __ge__ (line 21) | def __ge__(self, other):
    method __lt__ (line 26) | def __lt__(self, other):
    method __le__ (line 31) | def __le__(self, other):
    method __eq__ (line 36) | def __eq__(self, other):
    method __hash__ (line 41) | def __hash__(self):
  class MinHeap (line 45) | class MinHeap:
    method __init__ (line 47) | def __init__(self) -> None:
    method __len__ (line 50) | def __len__(self):
    method __bool__ (line 53) | def __bool__(self):
    method __getitem__ (line 56) | def __getitem__(self, key):
    method __setitem__ (line 59) | def __setitem__(self, key, value):
    method push (line 62) | def push(self, item: HeapItem):
    method _push (line 67) | def _push(self, item):
    method pop (line 79) | def pop(self, index: int = 0) -> HeapItem:
    method sift_up (line 110) | def sift_up(self, pos):
    method sift_down (line 138) | def sift_down(self, startpos, pos):
  class MaxHeap (line 163) | class MaxHeap(MinHeap):
    method push (line 168) | def push(self, item: HeapItem):

FILE: prusa/link/printer_adapter/structures/item_updater.py
  class SideEffectOnly (line 18) | class SideEffectOnly(Exception):
  class Watchable (line 24) | class Watchable:
    method __init__ (line 27) | def __init__(self):
  class WatchedItem (line 35) | class WatchedItem(Watchable):
    method __init__ (line 44) | def __init__(self,
    method __repr__ (line 104) | def __repr__(self):
    method __lt__ (line 107) | def __lt__(self, other):
    method __eq__ (line 112) | def __eq__(self, other):
    method __hash__ (line 117) | def __hash__(self):
  class WatchedGroup (line 121) | class WatchedGroup(Watchable):
    method __init__ (line 127) | def __init__(self, items: Iterable[WatchedItem]):
    method __iter__ (line 150) | def __iter__(self):
    method invalid_handler (line 153) | def invalid_handler(self, item):
    method valid_handler (line 165) | def valid_handler(self, item):
  class ItemUpdater (line 178) | class ItemUpdater:
    method __init__ (line 189) | def __init__(self, quit_interval=0.2):
    method start (line 212) | def start(self):
    method stop (line 218) | def stop(self):
    method wait_stopped (line 224) | def wait_stopped(self):
    method add_item (line 230) | def add_item(self, item: WatchedItem, start_tracking=True):
    method invalidate_group (line 244) | def invalidate_group(self, group: WatchedGroup):
    method invalidate (line 251) | def invalidate(self, item: WatchedItem):
    method disable (line 280) | def disable(self, item: WatchedItem):
    method enable (line 290) | def enable(self, item: WatchedItem):
    method set_value (line 300) | def set_value(self, item: WatchedItem, value):
    method schedule_invalidation (line 329) | def schedule_invalidation(self, item: WatchedItem, interval=None,
    method cancel_scheduled_invalidation (line 374) | def cancel_scheduled_invalidation(self, item: WatchedItem):
    method _time_out (line 393) | def _time_out(item: WatchedItem):
    method _validate_is_tracked (line 405) | def _validate_is_tracked(self, item: WatchedItem):
    method _gather (line 410) | def _gather(self, item: WatchedItem):
    method _gather_error_reschedule (line 451) | def _gather_error_reschedule(self, item):
    method _set_value (line 463) | def _set_value(self, item, value):
    method _enqueue_refresh (line 487) | def _enqueue_refresh(self, item):
    method _refresher (line 504) | def _refresher(self):
    method _process_invalidations (line 519) | def _process_invalidations(self):
    method _process_timeouts (line 547) | def _process_timeouts(self):

FILE: prusa/link/printer_adapter/structures/mc_singleton.py
  class MCSingleton (line 4) | class MCSingleton(type):
    method __init__ (line 8) | def __init__(cls, name, bases, dic):
    method __call__ (line 13) | def __call__(cls, *args, **kwargs):

FILE: prusa/link/printer_adapter/structures/model_classes.py
  class IndividualSlot (line 12) | class IndividualSlot(BaseModel):
  class Slot (line 20) | class Slot(BaseModel):
    method dict (line 30) | def dict(self, **kwargs) -> Dict:
  class Telemetry (line 39) | class Telemetry(BaseModel):
    method dict (line 74) | def dict(self, **kwargs) -> Dict:
  class NetworkInfo (line 81) | class NetworkInfo(BaseModel):
  class FileType (line 96) | class FileType(Enum):
  class JobState (line 103) | class JobState(Enum):
  class SDState (line 110) | class SDState(Enum):
  class PrintState (line 118) | class PrintState(Enum):
  class PrintMode (line 126) | class PrintMode(Enum):
  class EEPROMParams (line 133) | class EEPROMParams(Enum):
  class PPData (line 145) | class PPData(BaseModel):

FILE: prusa/link/printer_adapter/structures/module_data_classes.py
  class Port (line 16) | class Port(BaseModel):
    method __str__ (line 28) | def __str__(self):
  class SerialAdapterData (line 37) | class SerialAdapterData(BaseModel):
  class FilePrinterData (line 45) | class FilePrinterData(BaseModel):
  class StateManagerData (line 61) | class StateManagerData(BaseModel):
  class JobData (line 75) | class JobData(BaseModel):
    method get_job_id_for_api (line 93) | def get_job_id_for_api(self):
  class IPUpdaterData (line 103) | class IPUpdaterData(BaseModel):
  class SDCardData (line 116) | class SDCardData(BaseModel):
  class StorageData (line 130) | class StorageData(BaseModel):
  class MMUObserverData (line 138) | class MMUObserverData(BaseModel):
  class PrintStatsData (line 143) | class PrintStatsData(BaseModel):
  class Sheet (line 153) | class Sheet(BaseModel):

FILE: prusa/link/printer_adapter/telemetry_passer.py
  class Modifier (line 42) | class Modifier(Enum):
  class TelemetryPasser (line 84) | class TelemetryPasser(metaclass=MCSingleton):
    method __init__ (line 87) | def __init__(self, model: Model, printer: Printer):
    method start (line 109) | def start(self):
    method stop (line 113) | def stop(self):
    method wait_stopped (line 118) | def wait_stopped(self):
    method _keep_updating (line 122) | def _keep_updating(self):
    method _update (line 133) | def _update(self):
    method pass_telemetry (line 148) | def pass_telemetry(self):
    method _get_filtered_paths (line 177) | def _get_filtered_paths(self):
    method _get_modifiers (line 193) | def _get_modifiers(self, key_path):
    method set_telemetry (line 199) | def set_telemetry(self, new_telemetry: Telemetry):
    method _should_wake_up (line 250) | def _should_wake_up(self, modifiers):
    method reset_value (line 261) | def reset_value(self, key_path):
    method _set_multi (line 267) | def _set_multi(self, structure, key, value):
    method _get_multi (line 276) | def _get_multi(self, structure, key):
    method _get_correct_path (line 284) | def _get_correct_path(self, structure, key_path):
    method _update_by_path (line 292) | def _update_by_path(self, target, source, key_path,
    method _reset_by_path (line 327) | def _reset_by_path(self, target, key_path):
    method _get_by_path (line 338) | def _get_by_path(self, source, key_path):
    method _path_to_model (line 348) | def _path_to_model(self, key_path) -> tuple[Any, ...]:
    method _resend_telemetry_on_timer (line 365) | def _resend_telemetry_on_timer(self):
    method state_changed (line 371) | def state_changed(self):
    method activity_observed (line 396) | def activity_observed(self):
    method wipe_telemetry (line 403) | def wipe_telemetry(self):
    method resend_latest_telemetry (line 412) | def resend_latest_telemetry(self):

FILE: prusa/link/printer_adapter/updatable.py
  class Thread (line 15) | class Thread(_Thread):
    method profile_run (line 18) | def profile_run(self):
    method enable_profiling (line 29) | def enable_profiling():
    method disable_profiling (line 34) | def disable_profiling():
  class ThreadedUpdatable (line 39) | class ThreadedUpdatable:
    method __init__ (line 44) | def __init__(self):
    method start (line 55) | def start(self):
    method stop (line 59) | def stop(self):
    method wait_stopped (line 63) | def wait_stopped(self):
    method update (line 67) | def update(self):

FILE: prusa/link/sdk_augmentation/command_handler.py
  class CommandHandler (line 9) | class CommandHandler:
    method __init__ (line 12) | def __init__(self, sdk_command: Command):
    method handle_commands (line 23) | def handle_commands(self):
    method stop (line 36) | def stop(self):

FILE: prusa/link/sdk_augmentation/file.py
  class SDFile (line 7) | class SDFile(File):
    method add_node (line 10) | def add_node(self, is_dir, path: Path, name, sfn, **attrs):
    method add_directory (line 25) | def add_directory(self, path: Path, name, sfn, **attrs):
    method add_file (line 29) | def add_file(self, path, name, sfn, **attrs):

FILE: prusa/link/sdk_augmentation/printer.py
  class MyPrinter (line 30) | class MyPrinter(SDKPrinter, metaclass=MCSingleton):
    method __init__ (line 36) | def __init__(self, *args, **kwargs):
    method parse_command (line 52) | def parse_command(self, res):
    method get_info (line 68) | def get_info(self) -> Dict[str, Any]:
    method connection_from_settings (line 77) | def connection_from_settings(self, settings):
    method get_file_info (line 90) | def get_file_info(self, caller: Command) -> Dict[str, Any]:
    method from_path (line 109) | def from_path(self, path: Path):
    method start (line 129) | def start(self):
    method indicate_stop (line 141) | def indicate_stop(self):
    method wait_stopped (line 155) | def wait_stopped(self):
    method loop (line 167) | def loop(self):
    method inotify_loop (line 172) | def inotify_loop(self):
    method download_loop (line 182) | def download_loop(self):
    method snapshot_loop (line 187) | def snapshot_loop(self):
    method type_string (line 193) | def type_string(self):

FILE: prusa/link/serial/helpers.py
  function wait_for_instruction (line 15) | def wait_for_instruction(instruction,
  function enqueue_instruction (line 33) | def enqueue_instruction(queue: SerialQueue,
  function enqueue_matchable (line 52) | def enqueue_matchable(queue: SerialQueue,
  function enqueue_list_from_str (line 84) | def enqueue_list_from_str(queue: SerialQueue,

FILE: prusa/link/serial/instruction.py
  class Instruction (line 14) | class Instruction:
    method __init__ (line 16) | def __init__(self,
    method __str__ (line 52) | def __str__(self):
    method __repr__ (line 55) | def __repr__(self):
    method confirm (line 58) | def confirm(self, force=False) -> bool:
    method sent (line 69) | def sent(self):
    method output_captured (line 77) | def output_captured(self, sender, match):
    method wait_for_send (line 85) | def wait_for_send(self, timeout=None):
    method wait_for_confirmation (line 89) | def wait_for_confirmation(self, timeout=None):
    method is_sent (line 93) | def is_sent(self):
    method is_confirmed (line 97) | def is_confirmed(self):
    method reset (line 101) | def reset(self):
    method fill_data (line 106) | def fill_data(self, message_number: int):
    method get_checksum (line 126) | def get_checksum(data: bytes):
  class MatchableInstruction (line 139) | class MatchableInstruction(Instruction):
    method __init__ (line 143) | def __init__(self,
    method output_captured (line 155) | def output_captured(self, sender, match):
    method match (line 160) | def match(self, index=0):
    method get_matches (line 166) | def get_matches(self):
  class MandatoryMatchableInstruction (line 171) | class MandatoryMatchableInstruction(MatchableInstruction):
    method confirm (line 176) | def confirm(self, force=False) -> bool:

FILE: prusa/link/serial/is_planner_fed.py
  class HeapName (line 24) | class HeapName(Enum):
  class TimeValue (line 30) | class TimeValue(HeapItem):
    method __init__ (line 33) | def __init__(self, value: float) -> None:
  class IsPlannerFed (line 38) | class IsPlannerFed:
    method __init__ (line 66) | def __init__(self, threshold_path):
    method item_count (line 88) | def item_count(self):
    method threshold (line 93) | def threshold(self):
    method get_dynamic_threshold (line 103) | def get_dynamic_threshold(self):
    method __call__ (line 111) | def __call__(self):
    method process_value (line 117) | def process_value(self, value):
    method _remove_last (line 137) | def _remove_last(self) -> None:
    method _add (line 152) | def _add(self, value):
    method balance (line 178) | def balance(self):
    method _short_push (line 193) | def _short_push(self, item: TimeValue):
    method _long_push (line 200) | def _long_push(self, item: TimeValue):
    method save (line 207) | def save(self):

FILE: prusa/link/serial/serial.py
  class SerialException (line 16) | class SerialException(RuntimeError):
  class Serial (line 20) | class Serial:
    method __init__ (line 24) | def __init__(self, port: str, baudrate: int, timeout: int):
    method close (line 96) | def close(self):
    method __read (line 107) | def __read(self, timeout):
    method readline (line 120) | def readline(self):
    method write (line 141) | def write(self, data: bytes):
    method is_open (line 146) | def is_open(self):
    method dtr (line 151) | def dtr(self):
    method dtr (line 156) | def dtr(self, value: bool):

FILE: prusa/link/serial/serial_adapter.py
  class PortAdapter (line 44) | class PortAdapter:
    method __init__ (line 46) | def __init__(self, port: Port) -> None:
  class SerialAdapter (line 51) | class SerialAdapter(metaclass=MCSingleton):
    method is_rpi_port (line 60) | def is_rpi_port(port_path):
    method __init__ (line 80) | def __init__(self,
    method is_open (line 115) | def is_open(serial) -> bool:
    method _get_info (line 120) | def _get_info(port_adapter: PortAdapter):
    method _detect (line 159) | def _detect(port_adapter: PortAdapter):
    method _reopen (line 188) | def _reopen(self) -> bool:
    method close (line 249) | def close(self):
    method _renew_serial_connection (line 257) | def _renew_serial_connection(self, starting: bool = False):
    method _read_continually (line 297) | def _read_continually(self):
    method write (line 330) | def write(self, message: bytes):
    method disable_dtr_resets (line 359) | def disable_dtr_resets(self):
    method enable_dtr_resets (line 367) | def enable_dtr_resets(self):
    method _reset_pi (line 375) | def _reset_pi(self):
    method _blip_dtr (line 393) | def _blip_dtr(self):
    method reset_client (line 401) | def reset_client(self):
    method stop (line 412) | def stop(self):
    method wait_stopped (line 417) | def wait_stopped(self):
    method power_panic_observed (line 421) | def power_panic_observed(self):
    method power_panic_unblock (line 425) | def power_panic_unblock(self):

FILE: prusa/link/serial/serial_parser.py
  class RegexPairing (line 25) | class RegexPairing:
    method __init__ (line 31) | def __init__(self, regexp, priority=0) -> None:
    method __str__ (line 36) | def __str__(self) -> str:
    method __repr__ (line 43) | def __repr__(self) -> str:
    method fire (line 46) | def fire(self, match: Optional[Match] = None) -> None:
  class SerialParser (line 60) | class SerialParser(metaclass=MCSingleton):
    method __init__ (line 66) | def __init__(self) -> None:
    method decide (line 71) | def decide(self, line: str) -> None:
    method add_handler (line 90) | def add_handler(self,
    method remove_handler (line 126) | def remove_handler(self, regexp, handler) -> None:
  class ThreadedSerialParser (line 144) | class ThreadedSerialParser(SerialParser):
    method __init__ (line 148) | def __init__(self):
    method decoupled (line 158) | def decoupled(self, handler):
    method process (line 165) | def process(self):
    method add_decoupled_handler (line 172) | def add_decoupled_handler(self,
    method stop (line 179) | def stop(self):
    method wait_stopped (line 184) | def wait_stopped(self):

FILE: prusa/link/serial/serial_queue.py
  class SerialQueue (line 49) | class SerialQueue(metaclass=MCSingleton):
    method __init__ (line 59) | def __init__(self,
    method _keep_sending (line 130) | def _keep_sending(self):
    method block_sending (line 150) | def block_sending(self):
    method unblock_sending (line 154) | def unblock_sending(self):
    method _try_writing (line 160) | def _try_writing(self):
    method stop (line 166) | def stop(self):
    method wait_stopped (line 173) | def wait_stopped(self):
    method peek_next (line 177) | def peek_next(self):
    method _next_instruction (line 194) | def _next_instruction(self):
    method can_write (line 223) | def can_write(self):
    method is_empty (line 228) | def is_empty(self):
    method _hookup_output_capture (line 236) | def _hookup_output_capture(self):
    method _teardown_output_capture (line 247) | def _teardown_output_capture(self):
    method _send (line 256) | def _send(self):
    method set_message_number (line 309) | def set_message_number(self, number):
    method replenish_history (line 315) | def replenish_history(self, messages: List[str]):
    method _enqueue (line 325) | def _enqueue(self, instruction: Instruction, to_front=False):
    method enqueue_one (line 332) | def enqueue_one(self, instruction: Instruction, to_front=False):
    method enqueue_list (line 348) | def enqueue_list(self,
    method _confirmation_handler (line 369) | def _confirmation_handler(self, sender, match: re.Match):
    method _resend_handler (line 375) | def _resend_handler(self, sender, match: re.Match):
    method _resend (line 399) | def _resend(self, count):
    method _confirmed (line 420) | def _confirmed(self, force=False):
    method _rx_got_yeeted (line 457) | def _rx_got_yeeted(self):
    method reset_message_number (line 474) | def reset_message_number(self):
    method _reset_message_number (line 483) | def _reset_message_number(self):
    method flush_print_queue (line 488) | def flush_print_queue(self):
    method _flush_queues (line 505) | def _flush_queues(self):
    method _throw_out_current_instruction (line 524) | def _throw_out_current_instruction(self):
    method _worst_case_scenario (line 531) | def _worst_case_scenario(self):
    method printer_reconnected (line 541) | def printer_reconnected(self, was_printing, was_power_panic):
    method _printer_reconnected (line 548) | def _printer_reconnected(self, was_printing, was_power_panic):
  class MonitoredSerialQueue (line 586) | class MonitoredSerialQueue(SerialQueue):
    method __init__ (line 589) | def __init__(self,
    method get_current_delay (line 618) | def get_current_delay(self):
    method keep_monitoring (line 627) | def keep_monitoring(self):
    method check_status (line 633) | def check_status(self):
    method stop (line 652) | def stop(self):
    method wait_stopped (line 660) | def wait_stopped(self):
    method _confirmed (line 665) | def _confirmed(self, force=False):
    method _renew_timeout (line 670) | def _renew_timeout(self, unstuck=True):

FILE: prusa/link/service_discovery.py
  class ServiceDiscovery (line 22) | class ServiceDiscovery:
    method __init__ (line 28) | def __init__(self, port):
    method _get_port_part (line 44) | def _get_port_part(port):
    method is_on_port (line 48) | def is_on_port(self, port):
    method _register (line 59) | def _register(self):
    method unregister (line 90) | def unregister(self):
    method _register_service (line 94) | def _register_service(self, name, service_type, port):

FILE: prusa/link/static/main.9b8dc0068f6e6508dfd4.js
  function u (line 1) | async function u(e,t={},a,i){if("true"!=sessionStorage.getItem("auth"))t...
  function i (line 1) | function i(e,t=!0){e&&(t&&!e.hasAttribute("hidden")&&e.setAttribute("hid...
  function s (line 1) | function s(e,t=!0){i(e,!t)}
    method value (line 1) | set value(e){this._value=e,this.updateLabel()}
    method value (line 1) | get value(){return this._value}
    method constructor (line 1) | constructor(e,t,a){const i=this;this._label=t,this._ul=a,this._value=t...
    method _highlight (line 1) | _highlight(e){this._ul.childNodes.forEach((t=>{t===e?t.classList.add("...
    method destructor (line 1) | destructor(){window.removeEventListener("keypress",this._onKeyPress),w...
    method init (line 1) | static init(e,t){let a=(0,i.Z)(e);const n=document.getElementById("dro...
    method setOptions (line 1) | setOptions(e){this._options=e}
    method updateLabel (line 1) | updateLabel(){this._label.innerHTML=this._value}
    method select (line 1) | select(e){this._label.innerHTML=e}
    method open (line 1) | open(){this._ul.classList.contains("open")||(this._options.forEach((e=...
    method close (line 1) | close(){for(this._ul.classList.remove(["open"]);this._ul.firstChild;)t...
  function n (line 1) | function n(e,t=!0){e&&(t&&!e.hasAttribute("disabled")&&e.setAttribute("d...
  function r (line 1) | function r(e,t=!0){return n(e,!t)}
  function o (line 1) | function o(){s(document.querySelector("#job .loading-overlay"))}
  function l (line 1) | function l(){i(document.querySelector("#job .loading-overlay"))}
  function d (line 1) | function d(e,...t){const a=i=>{if(t)for(const e of t)if(e&&e.contains(i....
  function p (line 1) | function p(){return navigator.language||navigator.userLanguage||""}
  function m (line 1) | function m(e){const t=o.indexOf(e);return-1!==t&&(u=t,c=e,localStorage.s...
  function v (line 1) | function v(){return c}
  function g (line 1) | function g(){return[...o]}
  function h (line 1) | function h(e,t){let a=n()(l,`${e}.${u}`);if(!a)return a=n()(l,`${e}.${d}...
  function b (line 1) | function b(e,t){if(t)if(t.ref){t.ref.innerHTML=e}else if(t.query){let a=...
  function f (line 1) | function f(e){(0,i.Z)(e).querySelectorAll('[data-label]:not([data-label=...
  function p (line 1) | function p(e,t){if("move"===e){(e=>(0,r.LK)("/api/printer/printhead",{me...
  function m (line 1) | function m(e,t,a){function i(e){return Number.parseFloat(e.getAttribute(...
  function t (line 1) | function t(e,t){switch(e){case"bed":return i=t,(0,r.LK)("/api/printer/be...
  function f (line 1) | function f(e,t=!0,a=1){return e>0?t?e.toFixed(a):e:0}
  class s (line 1) | class s{set value(e){this._value=e,this.updateLabel()}get value(){return...
    method value (line 1) | set value(e){this._value=e,this.updateLabel()}
    method value (line 1) | get value(){return this._value}
    method constructor (line 1) | constructor(e,t,a){const i=this;this._label=t,this._ul=a,this._value=t...
    method _highlight (line 1) | _highlight(e){this._ul.childNodes.forEach((t=>{t===e?t.classList.add("...
    method destructor (line 1) | destructor(){window.removeEventListener("keypress",this._onKeyPress),w...
    method init (line 1) | static init(e,t){let a=(0,i.Z)(e);const n=document.getElementById("dro...
    method setOptions (line 1) | setOptions(e){this._options=e}
    method updateLabel (line 1) | updateLabel(){this._label.innerHTML=this._value}
    method select (line 1) | select(e){this._label.innerHTML=e}
    method open (line 1) | open(){this._ul.classList.contains("open")||(this._options.forEach((e=...
    method close (line 1) | close(){for(this._ul.classList.remove(["open"]);this._ul.firstChild;)t...
  function n (line 1) | function n(e,t){let a=e?.data?.title||t?.fallbackMessage?.title||"Error"...
  function i (line 1) | function i(e,t,a="right"){if(!e)return;const i=e.querySelector(".fill");...
  function h (line 1) | function h(e){const t=document.getElementById("api_key");t&&(t.innerText...
  function b (line 1) | function b(e,t){(0,s.ZP)("con-settings",e.link),function(e,t){const a=do...
  function f (line 1) | function f(e,t,a,s,n){e&&e.setAttribute("ok",Boolean(a)),t&&(t.innerHTML...
  function y (line 1) | function y(e){switch(e.toLowerCase()){case"python":return(0,i.Iu)("sys-v...
  function p (line 1) | function p(e){const t=document.querySelector("ul.logs");t&&(t.innerHTML=...
  function m (line 1) | function m(e){return`<li class="txt-md">${e}</li>`}
  function n (line 1) | function n({title:e,message:t,type:a,onClose:n,autoClose:r=!0}){const o=...
  function r (line 1) | function r(e,t,a,i=!0){n({type:"warning",title:e,message:t,onClose:a,aut...
  function o (line 1) | function o(e,t,a,i=!0){n({type:"success",title:e,message:t,onClose:a,aut...
  function l (line 1) | function l(e,t,a,i=!0){n({type:"error",title:e,message:t,onClose:a,autoC...
  function g (line 1) | function g(e){const t=p.Z.getContext(),a=u.cG.includes(e),i=document.que...
  function h (line 1) | function h(e){const t=e.data;if(![200,201,204].includes(e.code))return(0...
  function f (line 1) | function f(){y("choose"),function(e){const t=document.querySelector("#up...
  function y (line 1) | function y(e){m="uploading"==e;const t=document.getElementById("upld-rem...
  method isUploading (line 1) | get isUploading(){return m}
  function l (line 1) | function l(){const e=document.getElementById("graph");e&&(0==e.childElem...
  function d (line 1) | function d(e,t){!function(e,t){e.push(t);const a=(new Date).getTime();fo...
  function t (line 1) | function t(e){try{return JSON.parse(e)}catch{return}}
  function k (line 1) | function k(e,t,a,i,s){const n=document.querySelector(e);n&&(n.setAttribu...
  function w (line 1) | function w(){[document.querySelector('#upld-direct input[type="file"]'),...
  function x (line 1) | function x(e){f="uploading"===e;const t=document.getElementById("upld-di...
  function z (line 1) | function z(e){y=e;const t=document.getElementById("upld-progress");t&&(t...
  method isUploading (line 1) | get isUploading(){return f}
  method selected (line 1) | get selected(){return this._selected}
  method isLocked (line 1) | get isLocked(){return this._isLocked}
  method lock (line 1) | lock(){this._isLocked=!0,this._root&&this._root.querySelectorAll("[data-...
  method unlock (line 1) | unlock(){this._isLocked=!1,this._root&&this._root.querySelectorAll("[dat...
  method constructor (line 1) | constructor(){this._root=null,this._selected=null,this._isLocked=!1}
  method init (line 1) | init(e){this._root=e,this._root&&(e.querySelectorAll("[data-tab-btn]").f...
  method openTab (line 1) | openTab(e){if(this._root&&e){const t=this._root.querySelector(`[data-tab...
  method closeTab (line 1) | closeTab(){if(this._root&&this._selected){const e=this._root.querySelect...
  function N (line 1) | function N(){E.isUploading?(I.openTab("direct"),I.lock()):L?.isUploading...
  function V (line 1) | function V(e){return`inset(${100-e}% 0% 0% 0%)`}
  function te (line 1) | function te(e){e.classList.remove("open")}
  function ve (line 1) | function ve(){const e=me.origin;return me.storages[e]}
  function ge (line 1) | function ge(){return me.current_path.map((e=>e.path)).join("/")}
  function he (line 1) | function he(e){const t=ve(),a=ge();return be(t.path,a,e)}
  function be (line 1) | function be(e,t,a){const i=["/api/v1/files",e,t,a].filter((e=>!!e)).join...
  function xe (line 1) | function xe(e,t,a){const i=document.getElementById(e).content,s=document...
  function ze (line 1) | function ze(e,t){const a=e.display_name||e.name,i=e.name,s=he(i),n=xe("n...
  function Ee (line 1) | function Ee(e){const t=xe("node-file",e.display_name||e.name,(t=>Se(e)))...
  function Pe (line 1) | function Pe(e,t){const a=xe("node-file",e.display_name||e.name,(e=>{})),...
  function Le (line 1) | function Le(e){if(e in me.storages){const t=me.storages[e];me.origin=e,m...
  function Te (line 1) | function Te(e,t=!1){const a=je(e,t);Ne&&Ne.state!==e.state&&(Ne=null),a&...
  function je (line 1) | function je(e,t){const a=document.getElementById("job");if(!a)return!1;c...
  function Ce (line 1) | function Ce(e,t){const a=t?e.files.selected:e.job,s=a?.file?.resource;e....
  method constructor (line 1) | constructor(){this.state=void 0,this.printer=void 0,this.job=void 0,this...
  method updateConnection (line 1) | updateConnection(){return(0,m.LK)("/api/connection",{method:"GET"}).then...
  method update (line 1) | update({status:e,printer:t}){e?.ok&&e.payload&&this.updateStatus(e.paylo...
  method updateStatus (line 1) | updateStatus(e){this.updateTelemetry(e.printer),this.updateJob(e.job),th...
  method updatePrinter (line 1) | updatePrinter(e){this.printer={name:e.name,location:e.location,farmMode:...
  method updateTelemetry (line 1) | updateTelemetry(e){this.state=h.PT.fromApi(e.state.toUpperCase()),this.t...
  method updateJob (line 1) | updateJob(e){const t=this.job?.id||null,a=e?.id||null;if(t!==a||this.job...
  method updateJobDetails (line 1) | updateJobDetails(){return(0,m.LK)("/api/v1/job").then((e=>{const t=e.dat...
  method updateStorage (line 1) | updateStorage(e){Object.keys(e).forEach((e=>{const t={path:e.path,name:e...
  method updateTransfer (line 1) | updateTransfer(e){const t=this.transfer?.id||null,a=e?.id||null;if(t!==a...
  method updateCamera (line 1) | updateCamera(e){this.camera={id:e?.id}}
  method selectFile (line 1) | selectFile(e){if(!e)return void(this.files.selected=null);const t=e.refs...
  function o (line 1) | function o(e,t){const a=n(e),r=s.Z.routes.find((e=>e.path===a));if(!r)re...
  function a (line 1) | function a(i){var s=t[i];if(void 0!==s)return s.exports;var n=t[i]={expo...
  function n (line 1) | function n(){document.getElementById("menu").classList.remove("burger-op...
  function p (line 1) | async function p(e){const t=(new Date).getTime(),a=Object.fromEntries(Ob...
  function m (line 1) | async function m(e){let a=!1;for(;;){let i=!1;try{const t=await p(a);t.s...
  function v (line 1) | function v(a){try{t.Z.init(a),window.onpopstate=t=>t&&(0,e.g9)(t.current...
  function g (line 1) | function g(e){try{t.Z.update(e)}catch(e){h(e)}}
  function h (line 1) | function h(e){(0,o.S)(e,{fallbackMessage:{title:"Application error",mess...

FILE: prusa/link/util.py
  function prctl_name (line 37) | def prctl_name():
  function loop_until (line 44) | def loop_until(loop_evt: Event, run_every_sec: Callable[[], float], to_run,
  function get_local_ip (line 69) | def get_local_ip():
  function get_local_ip6 (line 84) | def get_local_ip6():
  function get_clean_path (line 98) | def get_clean_path(path):
  function ensure_directory (line 106) | def ensure_directory(directory, chown_username=None):
  function get_checksum (line 116) | def get_checksum(message: str):
  function persist_file (line 127) | def persist_file(file: typing.TextIO):
  function get_gcode (line 137) | def get_gcode(line):
  function file_is_on_sd (line 150) | def file_is_on_sd(path_parts):
  function make_fingerprint (line 157) | def make_fingerprint(sn):
  function fat_datetime_to_tuple (line 166) | def fat_datetime_to_tuple(fat_datetime):
  function get_print_stats_gcode (line 191) | def get_print_stats_gcode(quiet_percent=-1,
  function get_d3_code (line 202) | def get_d3_code(address: int, byte_count: int):
  function round_to_five (line 218) | def round_to_five(number: float):
  function decode_line (line 233) | def decode_line(line: bytes):
  function is_potato_cpu (line 238) | def is_potato_cpu():
  class PrinterDevice (line 243) | class PrinterDevice:
    method __init__ (line 246) | def __init__(self, vendor_id: str,
  function get_usb_printers (line 256) | def get_usb_printers():
  function walk_dict (line 293) | def walk_dict(data: dict, key_path=None):
  function slots_with_param (line 304) | def slots_with_param(model, key, default, value):
  function _parse_little_endian_uint32 (line 323) | def _parse_little_endian_uint32(match):
  function power_panic_delay (line 330) | def power_panic_delay(cfg):

FILE: prusa/link/web/__init__.py
  function init_web_app (line 27) | def init_web_app(daemon):
  class WebServer (line 58) | class WebServer:
    method __init__ (line 61) | def __init__(self, application, address, port, exit_on_error=False):
    method start (line 71) | def start(self):
    method run (line 77) | def run(self):
    method stop (line 105) | def stop(self):

FILE: prusa/link/web/cameras.py
  function format_header (line 29) | def format_header(header):
  function photo_by_camera_id (line 34) | def photo_by_camera_id(camera_id, req):
  function default_camera_snap (line 84) | def default_camera_snap(req):
  function list_cameras (line 98) | def list_cameras(_):
  function set_order (line 135) | def set_order(req):
  function get_photo_by_camera_id (line 145) | def get_photo_by_camera_id(req, camera_id):
  function take_photo_by_camera_id (line 152) | def take_photo_by_camera_id(_, camera_id):
  function camera_config (line 176) | def camera_config(_, camera_id):
  function add_camera (line 203) | def add_camera(req, camera_id):
  function delete_camera (line 233) | def delete_camera(_, camera_id):
  function set_settings (line 249) | def set_settings(req, camera_id):
  function reset_settings (line 270) | def reset_settings(_, camera_id):
  function register_camera (line 283) | def register_camera(_, camera_id):
  function unregister_camera (line 310) | def unregister_camera(_, camera_id):

FILE: prusa/link/web/connection.py
  function compose_register_url (line 18) | def compose_register_url(printer, connect_url, name, location):
  function api_connection (line 39) | def api_connection(req):
  function api_connection_set (line 91) | def api_connection_set(req):
  function api_connection_delete (line 138) | def api_connection_delete(req):

FILE: prusa/link/web/controls.py
  function check_temperature_limits (line 22) | def check_temperature_limits(temperature, min_temperature, max_temperatu...
  function check_value_limits (line 30) | def check_value_limits(value, min_value, max_value):
  function jog (line 38) | def jog(req, serial_queue):
  function home (line 91) | def home(req, serial_queue):
  function set_speed (line 102) | def set_speed(req, serial_queue):
  function disable_steppers (line 112) | def disable_steppers(serial_queue):
  function extrude (line 118) | def extrude(req, serial_queue):
  function api_printhead (line 138) | def api_printhead(req):
  function api_tool (line 177) | def api_tool(req):
  function api_bed (line 220) | def api_bed(req):

FILE: prusa/link/web/errors.py
  function response_error (line 16) | def response_error(req, error: conditions.LinkError):
  function internal_server_error (line 33) | def internal_server_error(req):
  function forbidden (line 64) | def forbidden(req):
  function not_found (line 71) | def not_found(req):
  function no_file_in_request (line 77) | def no_file_in_request(req):
  function file_size_mismatch (line 83) | def file_size_mismatch(req):
  function forbidden_characters (line 89) | def forbidden_characters(req):
  function filename_too_long (line 95) | def filename_too_long(req):
  function foldername_too_long (line 101) | def foldername_too_long(req):
  function sdcard_not_supported (line 107) | def sdcard_not_supported(req):
  function location_not_found (line 113) | def location_not_found(req):
  function file_currently_printed (line 119) | def file_currently_printed(req):
  function transfer_conflict (line 125) | def transfer_conflict(req):
  function unavailable_update (line 131) | def unavailable_update(req):
  function unable_to_update (line 137) | def unable_to_update(req):
  function entity_too_large (line 143) | def entity_too_large(req):
  function unsupported_media_type (line 149) | def unsupported_media_type(req):
  function response_timeout (line 155) | def response_timeout(req):
  function cant_connect (line 161) | def cant_connect(req):
  function cant_move_axis (line 167) | def cant_move_axis(req):
  function cant_move_axis_z (line 173) | def cant_move_axis_z(req):
  function cant_resolve_hostname (line 179) | def cant_resolve_hostname(req):
  function destination_same_as_source (line 185) | def destination_same_as_source(req):
  function directory_not_empty (line 191) | def directory_not_empty(req):
  function file_already_exists (line 197) | def file_already_exists(req):
  function file_upload_failed (line 203) | def file_upload_failed(req):
  function folder_already_exists (line 209) | def folder_already_exists(req):
  function invalid_boolean_header (line 215) | def invalid_boolean_header(req):
  function length_required (line 221) | def length_required(req):
  function not_state_to_print (line 227) | def not_state_to_print(req):
  function storage_not_exist (line 233) | def storage_not_exist(req):
  function temperature_too_high (line 239) | def temperature_too_high(req):
  function temperature_too_low (line 245) | def temperature_too_low(req):
  function transfer_stopped (line 251) | def transfer_stopped(req):
  function value_too_high (line 257) | def value_too_high(req):
  function value_too_low (line 263) | def value_too_low(req):
  function gone (line 269) | def gone(req):
  function service_unavailable (line 283) | def service_unavailable(req):
  function link_error_handler (line 293) | def link_error_handler(req, error):

FILE: prusa/link/web/files.py
  function storage_info (line 51) | def storage_info(req):
  function head_file_info (line 93) | def head_file_info(req, storage, path=None):
  function file_info (line 117) | def file_info(req, storage, path=None):
  function file_upload (line 191) | def file_upload(req, storage, path):
  function file_delete (line 308) | def file_delete(req, storage, path):
  function file_start_print (line 334) | def file_start_print(req, storage, path):
  function transfer_info (line 351) | def transfer_info(req):
  function transfer_abort (line 375) | def transfer_abort(req):

FILE: prusa/link/web/files_legacy.py
  function api_files (line 64) | def api_files(req, path=''):
  function api_upload (line 136) | def api_upload(req, storage):
  function api_start_print (line 220) | def api_start_print(req, storage, path):
  function api_downloads (line 258) | def api_downloads(req, storage, path):
  function api_file_info (line 271) | def api_file_info(req, storage, path):
  function api_delete (line 326) | def api_delete(req, storage, path):
  function api_transfer_info (line 340) | def api_transfer_info(req):
  function api_download (line 367) | def api_download(req, storage):
  function api_create_folder (line 418) | def api_create_folder(req, storage, path):
  function api_delete_folder (line 435) | def api_delete_folder(req, storage, path):
  function api_modify (line 452) | def api_modify(req, storage):
  function api_download_abort (line 487) | def api_download_abort(req):
  function api_thumbnails (line 497) | def api_thumbnails(req, path, wanted_format):

FILE: prusa/link/web/lib/__init__.py
  function try_int (line 4) | def try_int(value):

FILE: prusa/link/web/lib/auth.py
  function check_digest (line 31) | def check_digest(req):
  function check_api_digest (line 54) | def check_api_digest(func):
  function check_config (line 78) | def check_config(func):
  function set_digest (line 93) | def set_digest(username, password):
  function valid_credentials (line 98) | def valid_credentials(username, new_password, new_repassword, errors):
  function valid_digests (line 117) | def valid_digests(digest, old_digest, new_digest, errors):

FILE: prusa/link/web/lib/classes.py
  class ThreadingServer (line 15) | class ThreadingServer(ThreadingMixIn, WSGIServer):
    method handle_error (line 23) | def handle_error(self, request, client_address):
  class LinkHandler (line 27) | class LinkHandler(ServerHandler):
    method log_exception (line 33) | def log_exception(self, exc_info):
  class RequestHandler (line 38) | class RequestHandler(WSGIRequestHandler):
    method log_message (line 43) | def log_message(self, format, *args):
    method log_error (line 47) | def log_error(self, *args):
    method handle (line 51) | def handle(self):

FILE: prusa/link/web/lib/core.py
  class LinkWebApp (line 16) | class LinkWebApp(Application):

FILE: prusa/link/web/lib/files.py
  function get_os_path (line 40) | def get_os_path(abs_path):
  function local_simple_refs (line 61) | def local_simple_refs(path: str):
  function sdcard_simple_refs (line 68) | def sdcard_simple_refs():
  function local_refs (line 75) | def local_refs(path: str, meta: FDMMetaData):
  function sdcard_refs (line 91) | def sdcard_refs():
  function gcode_analysis (line 100) | def gcode_analysis(meta):
  function fill_file_data (line 115) | def fill_file_data(path: str, storage: str):
  function fill_printfile_data (line 126) | def fill_printfile_data(path: str, os_path: str, storage: str,
  function file_to_api (line 166) | def file_to_api(node, origin: str = 'local', path: str = '/',
  function sort_files (line 276) | def sort_files(files, sort_by='folder,date'):
  function check_filename (line 296) | def check_filename(filename: str):
  function check_foldername (line 311) | def check_foldername(foldername: str):
  function check_os_path (line 323) | def check_os_path(os_path: str):
  function check_storage (line 330) | def check_storage(func):
  function check_read_only (line 340) | def check_read_only(func):
  function check_job (line 350) | def check_job(job: Job, path: str):
  function storage_display_name (line 358) | def storage_display_name(storage: str):
  function storage_display_path (line 368) | def storage_display_path(storage: str, path: str):
  function partfilepath (line 376) | def partfilepath(filename):
  function get_local_free_space (line 382) | def get_local_free_space(path: str):
  function get_files_size (line 391) | def get_files_size(files: dict, file_type: str):
  class GCodeFile (line 400) | class GCodeFile(FileIO):
    method __init__ (line 403) | def __init__(self, filepath: str, transfer: Transfer):
    method uploaded (line 415) | def uploaded(self):
    method write (line 419) | def write(self, data):
    method close (line 435) | def close(self):
  function callback_factory (line 447) | def callback_factory(req: Request):
  function make_headers (line 487) | def make_headers(storage: str, path: str) -> dict:
  function get_last_modified (line 497) | def get_last_modified(file_system: Filesystem) -> datetime:
  function generate_etag (line 506) | def generate_etag(last_modified_str: str) -> str:
  function make_cache_headers (line 512) | def make_cache_headers(last_modified: datetime) -> dict:
  function check_cache_headers (line 526) | def check_cache_headers(req_headers: Headers, headers: dict,
  function get_boolean_header (line 542) | def get_boolean_header(headers, variable):

FILE: prusa/link/web/lib/view.py
  function printer_type (line 18) | def printer_type(type_):
  function add_prefix (line 32) | def add_prefix(prefix, uri):
  function prefix_filter (line 43) | def prefix_filter(context: Context, uri):
  function redirect_with_proxy (line 49) | def redirect_with_proxy(req, uri):
  function package_to_api (line 69) | def package_to_api(pkg):
  function generate_page (line 78) | def generate_page(request, template, **kwargs):

FILE: prusa/link/web/lib/wizard.py
  function valid_sn_format (line 28) | def valid_sn_format(serial):
  function new_sn_format (line 33) | def new_sn_format(serial):
  function sn_write_success (line 38) | def sn_write_success() -> bool:
  function execute_sn_gcode (line 60) | def execute_sn_gcode(serial_number: str, serial_queue):
  class Wizard (line 72) | class Wizard:
    method __init__ (line 76) | def __init__(self, _app):
    method set_digest (line 117) | def set_digest(self, password):
    method serial_number (line 122) | def serial_number(self):
    method check_username (line 126) | def check_username(self):
    method check_credentials (line 136) | def check_credentials(self, password, repassword):
    method check_serial (line 152) | def check_serial(self):
    method check_connect (line 162) | def check_connect(self):
    method write_settings (line 179) | def write_settings(self, settings):

FILE: prusa/link/web/link_info.py
  function link_info (line 9) | def link_info(req):

FILE: prusa/link/web/main.py
  function instance (line 72) | def instance(req):
  function index (line 83) | def index(req):
  function websocket (line 90) | def websocket(req):
  function api_logs (line 98) | def api_logs(req):
  function api_log (line 132) | def api_log(req, filename):
  function api_info (line 168) | def api_info(req):
  function api_status (line 192) | def api_status(req):
  function api_version (line 280) | def api_version(req):
  function api_login (line 320) | def api_login(req):
  function api_printer (line 332) | def api_printer(req):
  function api_printer_sd (line 402) | def api_printer_sd(req):
  function api_set_ready (line 410) | def api_set_ready(req):
  function api_cancel_ready (line 423) | def api_cancel_ready(req):
  function api_timelapse (line 435) | def api_timelapse(req):
  function api_job (line 446) | def api_job(req):
  function api_job_command (line 519) | def api_job_command(req):
  function job_info (line 570) | def job_info(req):
  function job_stop (line 608) | def job_stop(req, job_id):
  function job_command (line 630) | def job_command(req, job_id, command):
  function api_update (line 672) | def api_update(req, env):
  function api_update_post (line 706) | def api_update_post(req, env):

FILE: prusa/link/web/settings.py
  function set_settings_user (line 34) | def set_settings_user(new_username, new_digest):
  function save_settings (line 42) | def save_settings():
  function update_apikey (line 48) | def update_apikey(api_key):
  function api_ports (line 67) | def api_ports(req):
  function api_settings (line 85) | def api_settings(req):
  function api_settings_set (line 105) | def api_settings_set(req):
  function regenerate_api_key (line 172) | def regenerate_api_key(req):
  function delete_api_key (line 191) | def delete_api_key(req):
  function get_api_sn (line 201) | def get_api_sn(req):
  function api_sn (line 209) | def api_sn(req):

FILE: prusa/link/web/wizard.py
  function check_printer (line 27) | def check_printer(fun):
  function check_step (line 43) | def check_step(step):
  class ConfigFile (line 59) | class ConfigFile:
    method __init__ (line 62) | def __init__(self):
    method write (line 65) | def write(self, data):
    method read (line 71) | def read(self):
    method seek (line 75) | def seek(self, size):
  function configfile_factory (line 80) | def configfile_factory(req):
  function process_printer (line 94) | def process_printer(config):
  function process_network (line 109) | def process_network(config):
  function process_connect (line 116) | def process_connect(config):
  function process_local (line 136) | def process_local(config):
  function parse_settings (line 152) | def parse_settings(buffer):
  function wizard_root (line 178) | def wizard_root(req):
  function wizard_restore_ (line 188) | def wizard_restore_(req):
  function wizard_restore_post (line 194) | def wizard_restore_post(req):
  function wizard_credentials (line 213) | def wizard_credentials(req):
  function wizard_credentials_post (line 220) | def wizard_credentials_post(req):
  function wizard_printer (line 247) | def wizard_printer(req):
  function wizard_printer_post (line 254) | def wizard_printer_post(req):
  function wizard_finish (line 265) | def wizard_finish(req):
  function wizard_serial (line 277) | def wizard_serial(req):
  function wizard_serial_set (line 284) | def wizard_serial_set(req):
  function wizard_finish_skip_post (line 309) | def wizard_finish_skip_post(req):
  function wizard_finish_post (line 336) | def wizard_finish_post(req):
  function check_wizard_access (line 375) | def check_wizard_access(req):

FILE: setup.py
  function fill_requires (line 22) | def fill_requires(filename):
  function doc (line 53) | def doc():
  class BuildStatic (line 59) | class BuildStatic(Command):
    method initialize_options (line 68) | def initialize_options(self):
    method finalize_options (line 71) | def finalize_options(self):
    method run (line 76) | def run(self):

FILE: tests/test_carousel.py
  function test_line (line 11) | def test_line():
  function test_screen_lines (line 27) | def test_screen_lines():
  function test_priority (line 64) | def test_priority():
  function test_lines (line 95) | def test_lines():

FILE: tests/test_ipc_queue.py
  function ipc_consumer (line 20) | def ipc_consumer():
  function test_send_and_close (line 28) | def test_send_and_close(ipc_consumer):
  function test_multiple_sends (line 37) | def test_multiple_sends(ipc_consumer):
  function test_args (line 53) | def test_args(ipc_consumer):
  function test_rights (line 66) | def test_rights():
  function test_signal_resistance (line 73) | def test_signal_resistance(ipc_consumer):
  function test_signal_resistance_reverse (line 101) | def test_signal_resistance_reverse():

FILE: tests/test_item_updater.py
  function updater_instance (line 27) | def updater_instance():
  function validator (line 38) | def validator():
  function test_basics (line 47) | def test_basics(updater_instance: ItemUpdater):
  function test_group (line 87) | def test_group(updater_instance: ItemUpdater):
  function test_scheduled_invalidation (line 148) | def test_scheduled_invalidation(updater_instance: ItemUpdater):
  function test_validation (line 285) | def test_validation(updater_instance: ItemUpdater, validator):
  function test_gather_error (line 317) | def test_gather_error(updater_instance: ItemUpdater):
  function test_timeouts (line 348) | def test_timeouts(updater_instance: ItemUpdater, validator):
  function test_empty_group (line 456) | def test_empty_group():
  function test_group_invalidation (line 462) | def test_group_invalidation(updater_instance: ItemUpdater):
  function test_garb (line 485) | def test_garb(updater_instance: ItemUpdater):
  function test_valid_group_init (line 495) | def test_valid_group_init(updater_instance: ItemUpdater):
  function test_valid_item_doesnt_gather (line 528) | def test_valid_item_doesnt_gather(updater_instance: ItemUpdater):
  function test_subclasses_work (line 550) | def test_subclasses_work(updater_instance: ItemUpdater):
  function test_disabling (line 560) | def test_disabling(updater_instance: ItemUpdater):
  function test_group_updating (line 585) | def test_group_updating(updater_instance: ItemUpdater):
  function test_priority_queue (line 605) | def test_priority_queue():

FILE: tests/test_serial_parser.py
  function test_basic (line 10) | def test_basic():
  function test_inverted_basic (line 22) | def test_inverted_basic():
  function test_basic_removal (line 33) | def test_basic_removal():
  function test_priority (line 45) | def test_priority():
  function test_bump_priority (line 71) | def test_bump_priority():

FILE: tests/util.py
  function waiter (line 7) | def waiter(event: Event):
  class WaitingMock (line 16) | class WaitingMock(Mock):
    method __init__ (line 20) | def __init__(self, *args, side_effect=None, **kwargs):
  class EventSetMock (line 32) | class EventSetMock(Mock):
    method __init__ (line 36) | def __init__(self, *args, side_effect=None, **kwargs):
    method reset_mock (line 46) | def reset_mock(self, *args, **kwargs) -> None: