docker-systemctl-replacement 1.7.1063__py3-none-any.whl

systemctl3/systemctl.pyi

@@ -0,0 +1,1534 @@
+import logging, socket, threading
+from types import TracebackType
+from typing import Callable, Dict, Iterable, Iterator, List, Match, NamedTuple, NoReturn, Optional, TextIO, Tuple, Type, Union
+
+class ExecMode(NamedTuple):
+    mode: str
+    check: bool
+    nouser: bool
+    noexpand: bool
+    argv0: bool
+
+class LoadMode(NamedTuple):
+    mode: str
+    check: bool
+
+class SystemctlWaitPID(NamedTuple):
+    pid: Optional[int]
+    returncode: Optional[int]
+    signal: int
+
+class SystemctlUnitName(NamedTuple):
+    fullname: str
+    name: str
+    prefix: str
+    instance: str
+    suffix: str
+    component: str
+__copyright__: str
+__version__: str
+logg: logging.Logger
+DEBUG_AFTER: bool
+DEBUG_STATUS: bool
+DEBUG_BOOTTIME: bool
+DEBUG_INITLOOP: bool
+DEBUG_KILLALL: bool
+
+def logg_debug_flock(msg: str, *args: Union[str, int]) -> None:
+    pass
+
+def logg_debug_after(msg: str, *args: Union[str, int]) -> None:
+    pass
+NOT_A_PROBLEM: int
+NOT_OK: int
+NOT_ACTIVE: int
+NOT_FOUND: int
+_extra_vars: List[str]
+_force: bool
+_full: bool
+_now: int
+_no_legend: bool
+_no_ask_password: bool
+_preset_mode: str
+_quiet: bool
+_root: str
+_show_all: int
+_user_mode: bool
+_only_what: List[str]
+_only_type: List[str]
+_only_state: List[str]
+_only_property: List[str]
+_system_folders: List[str]
+_user_folders: List[str]
+_preset_folders: List[str]
+SystemCompatibilityVersion: int
+SysInitTarget: str
+SysInitWait: int
+MinimumYield: float
+MinimumTimeoutStartSec: int
+MinimumTimeoutStopSec: int
+DefaultTimeoutStartSec: int
+DefaultTimeoutStopSec: int
+DefaultTimeoutAbortSec: int
+DefaultMaximumTimeout: int
+DefaultRestartSec: float
+DefaultStartLimitIntervalSec: int
+DefaultStartLimitBurst: int
+InitLoopSleep: int
+MaxLockWait: int
+DefaultPath: str
+ResetLocale: List[str]
+DefaultUnit: str
+DefaultTarget: str
+REMOVE_LOCK_FILE: bool
+BOOT_PID_MIN: int
+BOOT_PID_MAX: int
+PROC_MAX_DEPTH: int
+EXPAND_VARS_MAXDEPTH: int
+EXPAND_KEEP_VARS: bool
+RESTART_FAILED_UNITS: bool
+_journal_log_folder: str
+SYSTEMCTL_DEBUG_LOG: str
+SYSTEMCTL_EXTRA_LOG: str
+_default_targets: List[str]
+_feature_targets: List[str]
+_all_common_targets: List[str]
+_all_common_enabled: List[str]
+_all_common_disabled: List[str]
+_runlevel_mappings: Dict[str, str]
+_sysv_mappings: Dict[str, str]
+
+def strINET(value: int) -> str:
+    pass
+
+def strYes(value: Union[str, bool, None]) -> str:
+    pass
+
+def strE(part: Union[str, int, float, None]) -> str:
+    pass
+
+def strQ(part: Union[str, int, None]) -> str:
+    pass
+
+def shell_cmd(cmd: List[str]) -> str:
+    pass
+
+def to_intN(value: Optional[str], default: Optional[int]=None) -> Optional[int]:
+    pass
+
+def to_int(value: str, default: int=0) -> int:
+    pass
+
+def to_list(value: Union[str, List[str], Tuple[str], Tuple[str, ...], None]) -> List[str]:
+    pass
+
+def commalist(value: Iterable[str]) -> List[str]:
+    pass
+
+def _commalist(value: Iterable[str]) -> Iterator[str]:
+    pass
+
+def int_mode(value: str) -> Optional[int]:
+    pass
+
+def unit_of(module: str) -> str:
+    pass
+
+def o22(part: str) -> str:
+    pass
+
+def o44(part: str) -> str:
+    pass
+
+def o77(part: str) -> str:
+    pass
+
+def delayed(attempt: int, suffix: str='.') -> str:
+    pass
+
+def fnmatched(text: str, *patterns: str) -> bool:
+    pass
+
+def unit_name_escape(text: str) -> str:
+    pass
+
+def unit_name_unescape(text: str) -> str:
+    pass
+
+def is_good_root(root: Optional[str]) -> bool:
+    pass
+
+def os_path(root: Optional[str], path: str) -> str:
+    pass
+
+def path_replace_extension(path: str, old: str, new: str) -> str:
+    pass
+
+def get_exist_path(paths: List[str]) -> Optional[str]:
+    pass
+
+def get_PAGER() -> List[str]:
+    pass
+
+def os_getlogin() -> str:
+    pass
+
+def get_runtime_dir() -> str:
+    pass
+
+def get_RUN(root: bool=False) -> str:
+    pass
+
+def get_PID_DIR(root: bool=False) -> str:
+    pass
+
+def get_home() -> str:
+    pass
+
+def get_HOME(root: bool=False) -> str:
+    pass
+
+def get_USER_ID(root: bool=False) -> int:
+    pass
+
+def get_USER(root: bool=False) -> str:
+    pass
+
+def get_GROUP_ID(root: bool=False) -> int:
+    pass
+
+def get_GROUP(root: bool=False) -> str:
+    pass
+
+def get_TMP(root: bool=False) -> str:
+    pass
+
+def get_VARTMP(root: bool=False) -> str:
+    pass
+
+def get_SHELL(root: bool=False) -> str:
+    pass
+
+def get_RUNTIME_DIR(root: bool=False) -> str:
+    pass
+
+def get_CONFIG_HOME(root: bool=False) -> str:
+    pass
+
+def get_CACHE_HOME(root: bool=False) -> str:
+    pass
+
+def get_DATA_HOME(root: bool=False) -> str:
+    pass
+
+def get_LOG_DIR(root: bool=False) -> str:
+    pass
+
+def get_VARLIB_HOME(root: bool=False) -> str:
+    pass
+
+def expand_path(path: str, root: bool=False) -> str:
+    pass
+
+def shutil_fchown(fileno: int, user: Optional[str], group: Optional[str]) -> None:
+    pass
+
+def shutil_setuid(user: Optional[str]=None, group: Optional[str]=None, xgroups: Optional[List[str]]=None) -> Dict[str, str]:
+    pass
+
+def shutil_truncate(filename: str) -> None:
+    pass
+
+def pid_exists(pid: int) -> bool:
+    pass
+
+def _pid_exists(pid: int) -> bool:
+    pass
+
+def pid_zombie(pid: int) -> bool:
+    pass
+
+def _pid_zombie(pid: int) -> bool:
+    pass
+
+def checkprefix(cmd: str) -> Tuple[str, str]:
+    pass
+
+def exec_path(cmd: str) -> Tuple[ExecMode, str]:
+    pass
+
+def load_path(ref: str) -> Tuple[LoadMode, str]:
+    pass
+
+def ignore_signals_and_raise_keyboard_interrupt(signame: str) -> None:
+    pass
+_default_dict_type: Type[Dict[str, List[str]]]
+_default_conf_type: Type[Dict[str, Dict[str, List[str]]]]
+
+class SystemctlConfData:
+    _defaults: Dict[str, str]
+    _conf_type: Type[Dict[str, Dict[str, List[str]]]]
+    _dict_type: Type[Dict[str, List[str]]]
+    _allow_no_value: bool
+    _conf: Dict[str, Dict[str, List[str]]]
+    _files: List[str]
+
+    def __init__(self, defaults: Optional[Dict[str, str]]=None, dict_type: Optional[Type[Dict[str, List[str]]]]=None, conf_type: Optional[Type[Dict[str, Dict[str, List[str]]]]]=None, allow_no_value: bool=False) -> None:
+        pass
+
+    def defaults(self) -> Dict[str, str]:
+        pass
+
+    def sections(self) -> List[str]:
+        pass
+
+    def add_section(self, section: str) -> None:
+        pass
+
+    def has_section(self, section: str) -> bool:
+        pass
+
+    def has_option(self, section: str, option: str) -> bool:
+        pass
+
+    def set(self, section: str, option: str, value: Optional[str]) -> None:
+        pass
+
+    def getstr(self, section: str, option: str, default: Optional[str]=None, allow_no_value: bool=False) -> str:
+        pass
+
+    def get(self, section: str, option: str, default: Optional[str]=None, allow_no_value: bool=False) -> Optional[str]:
+        pass
+
+    def getlist(self, section: str, option: str, default: Optional[List[str]]=None, allow_no_value: bool=False) -> List[str]:
+        pass
+
+    def filenames(self) -> List[str]:
+        pass
+
+class SystemctlConfigParser(SystemctlConfData):
+
+    def read(self, filename: str) -> 'SystemctlConfigParser':
+        pass
+
+    def read_sysd(self, filename: str) -> 'SystemctlConfigParser':
+        pass
+
+    def read_sysv(self, filename: str) -> 'SystemctlConfigParser':
+        pass
+
+    def systemd_sysv_generator(self, filename: str) -> None:
+        pass
+
+class SystemctlConf:
+    data: SystemctlConfData
+    env: Dict[str, str]
+    status: Optional[Dict[str, str]]
+    masked: Optional[str]
+    module: Optional[str]
+    nonloaded_path: str
+    drop_in_files: Dict[str, str]
+    _root: str
+    _user_mode: bool
+
+    def __init__(self, data: SystemctlConfData, module: Optional[str]=None) -> None:
+        pass
+
+    def root_mode(self) -> bool:
+        pass
+
+    def is_loaded(self) -> str:
+        pass
+
+    def filename(self) -> Optional[str]:
+        pass
+
+    def overrides(self) -> List[str]:
+        pass
+
+    def name(self) -> str:
+        pass
+
+    def set(self, section: str, name: str, value: Optional[str]) -> None:
+        pass
+
+    def get(self, section: str, name: str, default: Optional[str], allow_no_value: bool=False) -> str:
+        pass
+
+    def getlist(self, section: str, name: str, default: Optional[List[str]]=None, allow_no_value: bool=False) -> List[str]:
+        pass
+
+    def getbool(self, section: str, name: str, default: Optional[str]=None) -> bool:
+        pass
+
+class SystemctlSocket:
+
+    def __init__(self, conf: SystemctlConf, sock: socket.socket, skip: bool=False) -> None:
+        pass
+
+    def fileno(self) -> int:
+        pass
+
+    def listen(self, backlog: Optional[int]=None) -> None:
+        pass
+
+    def name(self) -> str:
+        pass
+
+    def addr(self) -> str:
+        pass
+
+    def close(self) -> None:
+        pass
+
+class PresetFile:
+    _files: List[str]
+    _lines: List[str]
+
+    def __init__(self) -> None:
+        pass
+
+    def filename(self) -> Optional[str]:
+        pass
+
+    def read(self, filename: str) -> 'PresetFile':
+        pass
+
+    def get_preset(self, unit: str) -> Optional[str]:
+        pass
+
+class waitlock:
+    conf: SystemctlConf
+    opened: int
+    lockfolder: str
+
+    def __init__(self, conf: SystemctlConf) -> None:
+        pass
+
+    def lockfile(self) -> str:
+        pass
+
+    def __enter__(self) -> bool:
+        pass
+
+    def __exit__(self, exc: Optional[Type[BaseException]], value: Optional[BaseException], traceback: Optional[TracebackType]) -> None:
+        pass
+
+def must_have_failed(waitpid: SystemctlWaitPID, cmd: List[str]) -> SystemctlWaitPID:
+    pass
+
+def subprocess_waitpid(pid: int) -> SystemctlWaitPID:
+    pass
+
+def subprocess_testpid(pid: int) -> SystemctlWaitPID:
+    pass
+
+def parse_unit(fullname: str) -> SystemctlUnitName:
+    pass
+
+def time_to_seconds(text: str, maximum: float) -> float:
+    pass
+
+def seconds_to_time(seconds: float) -> str:
+    pass
+
+def getBefore(conf: SystemctlConf) -> List[str]:
+    pass
+
+def getAfter(conf: SystemctlConf) -> List[str]:
+    pass
+
+def compareAfter(confA: SystemctlConf, confB: SystemctlConf) -> int:
+    pass
+
+def conf_sortedAfter(conflist: Iterable[SystemctlConf], cmp: Callable[[SystemctlConf, SystemctlConf], int]=compareAfter) -> List[SystemctlConf]:
+    pass
+
+def read_env_file(filename: str, root: Optional[str]=NIX) -> Iterator[Tuple[str, str]]:
+    pass
+
+class SystemctlUnitFiles:
+    _root: str
+    _user_mode: bool
+    _user_getlogin: str
+    _extra_vars: List[str]
+    _SYSTEMD_UNIT_PATH: Optional[str]
+    _SYSTEMD_SYSVINIT_PATH: Optional[str]
+    _SYSTEMD_PRESET_PATH: Optional[str]
+    _loaded_file_sysv: Dict[str, SystemctlConf]
+    _loaded_file_sysd: Dict[str, SystemctlConf]
+    _file_for_unit_sysv: Optional[Dict[str, str]]
+    _file_for_unit_sysd: Optional[Dict[str, str]]
+    _preset_file_list: Optional[Dict[str, PresetFile]]
+
+    def __init__(self, root: str=NIX) -> None:
+        pass
+
+    def user(self) -> str:
+        pass
+
+    def user_mode(self) -> bool:
+        pass
+
+    def user_folder(self) -> str:
+        pass
+
+    def system_folder(self) -> str:
+        pass
+
+    def preset_folders(self) -> Iterable[str]:
+        pass
+
+    def init_folders(self) -> Iterable[str]:
+        pass
+
+    def user_folders(self) -> Iterable[str]:
+        pass
+
+    def system_folders(self) -> Iterable[str]:
+        pass
+
+    def get_SYSTEMD_UNIT_PATH(self) -> str:
+        pass
+
+    def get_SYSTEMD_SYSVINIT_PATH(self) -> str:
+        pass
+
+    def get_SYSTEMD_PRESET_PATH(self) -> str:
+        pass
+
+    def sysd_folders(self) -> Iterable[str]:
+        pass
+
+    def scan_unit_sysd_files(self) -> List[str]:
+        pass
+
+    def scan_unit_sysv_files(self) -> List[str]:
+        pass
+
+    def unit_sysd_file(self, module: Optional[str]=None) -> Optional[str]:
+        pass
+
+    def unit_sysv_file(self, module: Optional[str]=None) -> Optional[str]:
+        pass
+
+    def unit_file(self, module: Optional[str]=None) -> Optional[str]:
+        pass
+
+    def is_sysv_file(self, filename: Optional[str]) -> Optional[bool]:
+        pass
+
+    def is_user_conf(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def not_user_conf(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def find_drop_in_files(self, unit: str) -> Dict[str, str]:
+        pass
+
+    def load_sysd_template_conf(self, module: Optional[str]) -> Optional[SystemctlConf]:
+        pass
+
+    def load_sysd_unit_conf(self, module: Optional[str]) -> Optional[SystemctlConf]:
+        pass
+
+    def load_sysv_unit_conf(self, module: Optional[str]) -> Optional[SystemctlConf]:
+        pass
+
+    def load_conf(self, module: Optional[str]) -> Optional[SystemctlConf]:
+        pass
+
+    def default_conf(self, module: str, description: Optional[str]=None) -> SystemctlConf:
+        pass
+
+    def get_conf(self, module: str) -> SystemctlConf:
+        pass
+
+    def match_sysd_templates(self, modules: Optional[List[str]]=None) -> Iterable[str]:
+        pass
+
+    def match_sysd_units(self, modules: Optional[List[str]]=None) -> Iterable[str]:
+        pass
+
+    def match_sysv_units(self, modules: Optional[List[str]]=None) -> Iterable[str]:
+        pass
+
+    def match_units(self, modules: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def list_all(self) -> List[Tuple[str, str, str]]:
+        pass
+
+    def each_target_file(self) -> Iterable[Tuple[str, str]]:
+        pass
+
+    def get_target_conf(self, module: str) -> SystemctlConf:
+        pass
+
+    def get_target_list(self, module: str) -> List[str]:
+        pass
+
+    def get_InstallTarget(self, conf: SystemctlConf, default: Optional[str]=None) -> Optional[str]:
+        pass
+
+    def get_TimeoutStartSec(self, conf: SystemctlConf, section: str=Service) -> float:
+        pass
+
+    def get_SocketTimeoutSec(self, conf: SystemctlConf, section: str=Socket) -> float:
+        pass
+
+    def get_RemainAfterExit(self, conf: SystemctlConf, section: str=Service) -> bool:
+        pass
+
+    def get_StatusFile(self, conf: SystemctlConf, section: str=Service) -> Optional[str]:
+        pass
+
+    def get_RuntimeDirectoryPreserve(self, conf: SystemctlConf, section: str=Service) -> bool:
+        pass
+
+    def get_RuntimeDirectory(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_StateDirectory(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_CacheDirectory(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_LogsDirectory(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_ConfigurationDirectory(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_RuntimeDirectoryMode(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_StateDirectoryMode(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_CacheDirectoryMode(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_LogsDirectoryMode(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_ConfigurationDirectoryMode(self, conf: SystemctlConf, section: str=Service) -> str:
+        pass
+
+    def get_WorkingDirectory(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_TimeoutStopSec(self, conf: SystemctlConf) -> float:
+        pass
+
+    def get_SendSIGKILL(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def get_SendSIGHUP(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def get_KillMode(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_KillSignal(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_StartLimitBurst(self, conf: SystemctlConf) -> int:
+        pass
+
+    def get_StartLimitIntervalSec(self, conf: SystemctlConf, maximum: Optional[int]=None) -> float:
+        pass
+
+    def get_RestartSec(self, conf: SystemctlConf, maximum: Optional[int]=None) -> float:
+        pass
+
+    def get_description(self, unit: str, default: str=NIX) -> str:
+        pass
+
+    def get_Description(self, conf: Optional[SystemctlConf], default: str=NIX) -> str:
+        pass
+
+    def get_User(self, conf: SystemctlConf) -> Optional[str]:
+        pass
+
+    def get_Group(self, conf: SystemctlConf) -> Optional[str]:
+        pass
+
+    def get_SupplementaryGroups(self, conf: SystemctlConf) -> List[str]:
+        pass
+
+    def expand_list(self, group_lines: List[str], conf: SystemctlConf) -> List[str]:
+        pass
+
+    def expand_special(self, cmd: str, conf: SystemctlConf) -> str:
+        pass
+
+    def extra_vars(self) -> List[str]:
+        pass
+
+    def get_env(self, conf: SystemctlConf) -> Dict[str, str]:
+        pass
+
+    def expand_env(self, cmd: str, env: Dict[str, str]) -> str:
+        pass
+
+    def read_env_file(self, env_file: str) -> Iterable[Tuple[str, str]]:
+        pass
+
+    def read_env_part(self, env_part: str) -> Iterable[Tuple[str, str]]:
+        pass
+
+    def get_dependencies_unit(self, unit: str, styles: Optional[List[str]]=None) -> Dict[str, str]:
+        pass
+
+    def get_required_dependencies(self, unit: str, styles: Optional[List[str]]=None) -> Dict[str, str]:
+        pass
+
+    def get_start_dependencies(self, unit: str, styles: Optional[List[str]]=None) -> Dict[str, List[str]]:
+        pass
+
+    def sorted_after(self, unitlist: List[str]) -> List[str]:
+        pass
+
+    def list_dependencies(self, unit: str, indent: Optional[str]=None) -> Iterable[str]:
+        pass
+
+    def list_all_dependencies(self, unit: str, indent: Optional[str]=None) -> Iterable[str]:
+        pass
+
+    def _list_dependencies(self, unit: str, show: str=NIX, indent: Optional[str]=None, mark: Optional[str]=None, loop: Optional[List[str]]=None) -> Iterable[str]:
+        pass
+
+    def list_start_dependencies_units(self, units: List[str]) -> List[Tuple[str, str]]:
+        pass
+
+    def load_preset_files(self, *modules: str) -> List[str]:
+        pass
+
+    def get_preset_of_unit(self, unit: str) -> Optional[str]:
+        pass
+
+    def check_env_conditions(self, conf: SystemctlConf, section: str=Unit, warning: int=logging.WARNING) -> List[str]:
+        pass
+
+    def check_system_conditions(self, conf: SystemctlConf, section: str=Unit, warning: int=logging.WARNING) -> List[str]:
+        pass
+
+    def check_file_conditions(self, conf: SystemctlConf, section: str=Unit, warning: int=logging.WARNING) -> List[str]:
+        pass
+
+    def syntax_check(self, conf: SystemctlConf, *, conditions: bool=True) -> int:
+        pass
+
+    def syntax_check_enable(self, conf: SystemctlConf, section: str=Install) -> int:
+        pass
+
+    def syntax_check_service(self, conf: SystemctlConf, section: str=Service) -> int:
+        pass
+
+    def exec_check(self, conf: SystemctlConf, env: Dict[str, str], section: str=Service, exectype: str=NIX) -> bool:
+        pass
+
+    def expand_cmd(self, cmd: str, env: Dict[str, str], conf: SystemctlConf) -> Tuple[ExecMode, List[str]]:
+        pass
+
+    def split_cmd(self, cmd: str) -> List[str]:
+        pass
+
+    def split_cmd_and_expand(self, cmd: str, env: Dict[str, str], conf: SystemctlConf) -> List[str]:
+        pass
+
+class SystemctlListenThread(threading.Thread):
+
+    def __init__(self, systemctl: 'Systemctl') -> None:
+        pass
+
+    def stop(self) -> None:
+        pass
+
+    def run(self) -> None:
+        pass
+
+class Systemctl:
+    error: int
+    _extra_vars: List[str]
+    _force: bool
+    _full: bool
+    _no_ask_password: bool
+    _no_legend: bool
+    _now: int
+    _preset_mode: str
+    _quiet: bool
+    _root: str
+    _show_all: int
+    _unit_property: Optional[str]
+    _unit_state: Optional[str]
+    _unit_type: Optional[str]
+    _systemd_version: int
+    _pid_file_folder: str
+    _journal_log_folder: str
+    _default_target: str
+    _sysinit_target: Optional[SystemctlConf]
+    exit_mode: int
+    init_mode: int
+    _log_file: Dict[str, int]
+    _log_hold: Dict[str, bytes]
+    _boottime: Optional[float]
+    _restarted_unit: Dict[str, List[float]]
+    _restart_failed_units: Dict[str, float]
+    _sockets: Dict[str, SystemctlSocket]
+    loop_sleep: int
+    loop_lock: threading.Lock
+    unitfiles: SystemctlUnitFiles
+
+    def __init__(self) -> None:
+        pass
+
+    def get_unit_type(self, module: str) -> Optional[str]:
+        pass
+
+    def get_unit_section(self, module: str, default: str=Service) -> str:
+        pass
+
+    def get_unit_section_from(self, conf: SystemctlConf, default: str=Service) -> str:
+        pass
+
+    def list_service_units(self, *modules: str) -> List[Tuple[str, str, str]]:
+        pass
+
+    def list_units_modules(self, *modules: str) -> List[Tuple[str, str, str]]:
+        pass
+
+    def list_service_unit_files(self, *modules: str) -> List[Tuple[str, str]]:
+        pass
+
+    def list_target_unit_files(self, *modules: str) -> List[Tuple[str, str]]:
+        pass
+
+    def list_service_unit_basics(self) -> List[Tuple[str, str, str]]:
+        pass
+
+    def list_unit_files_modules(self, *modules: str) -> List[Tuple[str, str]]:
+        pass
+
+    def read_pid_file(self, pid_file: str, default: Optional[int]=None) -> Optional[int]:
+        pass
+
+    def wait_pid_file(self, pid_file: str, timeout: Optional[int]=None) -> Optional[int]:
+        pass
+
+    def get_status_pid_file(self, unit: str) -> str:
+        pass
+
+    def pid_file_from(self, conf: SystemctlConf, default: str='') -> str:
+        pass
+
+    def get_pid_file(self, conf: SystemctlConf, default: Optional[str]=None) -> str:
+        pass
+
+    def read_mainpid_from(self, conf: SystemctlConf, default: Optional[int]=None) -> Optional[int]:
+        pass
+
+    def clean_pid_file_from(self, conf: SystemctlConf) -> None:
+        pass
+
+    def get_status_file(self, unit: str) -> str:
+        pass
+
+    def get_status_file_from(self, conf: SystemctlConf, default: Optional[str]=None) -> str:
+        pass
+
+    def get_StatusFile(self, conf: SystemctlConf, default: Optional[str]=None) -> str:
+        pass
+
+    def clean_status_from(self, conf: SystemctlConf) -> None:
+        pass
+
+    def write_status_from(self, conf: SystemctlConf, **status: Union[str, int, None]) -> bool:
+        pass
+
+    def read_status_from(self, conf: SystemctlConf) -> Dict[str, str]:
+        pass
+
+    def get_status_from(self, conf: SystemctlConf, name: str, default: Optional[str]=None) -> Optional[str]:
+        pass
+
+    def set_status_from(self, conf: SystemctlConf, name: str, value: Optional[str]) -> None:
+        pass
+
+    def get_boottime(self) -> float:
+        pass
+
+    def get_boottime_from_proc(self) -> float:
+        pass
+
+    def get_boottime_from_old_proc(self) -> float:
+        pass
+
+    def path_proc_started(self, proc: str) -> float:
+        pass
+
+    def get_filetime(self, filename: str) -> float:
+        pass
+
+    def truncate_old(self, filename: str) -> bool:
+        pass
+
+    def getsize(self, filename: str) -> int:
+        pass
+
+    def command_of_unit(self, unit: str) -> Union[None, List[str]]:
+        pass
+
+    def environment_of_unit(self, unit: str) -> Union[None, Dict[str, str]]:
+        pass
+
+    def system_exec_env(self) -> List[str]:
+        pass
+
+    def each_system_exec_env(self, env: Dict[str, str]) -> Iterator[str]:
+        pass
+
+    def remove_service_directories(self, conf: SystemctlConf, section: str=Service) -> bool:
+        pass
+
+    def do_rm_tree(self, path: str) -> bool:
+        pass
+
+    def clean_service_directories(self, conf: SystemctlConf, which: str=NIX) -> bool:
+        pass
+
+    def env_service_directories(self, conf: SystemctlConf) -> Dict[str, str]:
+        pass
+
+    def create_service_directories(self, conf: SystemctlConf) -> Dict[str, str]:
+        pass
+
+    def make_service_directory(self, path: str, mode: str) -> bool:
+        pass
+
+    def chown_service_directory(self, path: str, user: Optional[str], group: Optional[str]) -> bool:
+        pass
+
+    def do_chown_tree(self, path: str, user: Optional[str], group: Optional[str]) -> bool:
+        pass
+
+    def clean_modules(self, *modules: str) -> bool:
+        pass
+
+    def clean_units(self, units: List[str], what: str=NIX) -> bool:
+        pass
+
+    def clean_unit(self, unit: str, what: str=NIX) -> bool:
+        pass
+
+    def clean_unit_from(self, conf: SystemctlConf, what: str) -> bool:
+        pass
+
+    def log_modules(self, *modules: str) -> bool:
+        pass
+
+    def log_units(self, units: List[str], lines: Optional[int]=None, follow: bool=False) -> int:
+        pass
+
+    def log_unit(self, unit: str, lines: Optional[int]=None, follow: bool=False) -> int:
+        pass
+
+    def log_unit_from(self, conf: SystemctlConf, lines: Optional[int]=None, follow: bool=False) -> int:
+        pass
+
+    def get_journal_log_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_journal_log(self, conf: SystemctlConf) -> str:
+        pass
+
+    def open_journal_log(self, conf: SystemctlConf) -> TextIO:
+        pass
+
+    def chdir_workingdir(self, conf: SystemctlConf) -> Union[str, bool, None]:
+        pass
+
+    def get_notify_socket_from(self, conf: SystemctlConf, socketfile: Optional[str]=None, debug: bool=False) -> str:
+        pass
+
+    def notify_socket_from(self, conf: SystemctlConf, socketfile: Optional[str]=None) -> NotifySocket:
+        pass
+
+    def read_notify_socket(self, notify: NotifySocket, timeout: float) -> str:
+        pass
+
+    def wait_notify_socket(self, notify: NotifySocket, timeout: float, pid: Optional[int]=None, pid_file: Optional[str]=None) -> Dict[str, str]:
+        pass
+
+    def start_modules(self, *modules: str) -> bool:
+        pass
+
+    def start_units(self, units: List[str], init: Optional[int]=None) -> bool:
+        pass
+
+    def start_unit(self, unit: str) -> bool:
+        pass
+
+    def start_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_start_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_start_service_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def listen_modules(self, *modules: str) -> bool:
+        pass
+
+    def listen_units(self, units: List[str]) -> bool:
+        pass
+
+    def listen_unit(self, unit: str) -> bool:
+        pass
+
+    def listen_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_listen_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_accept_socket_from(self, conf: SystemctlConf, sock: socket.socket) -> bool:
+        pass
+
+    def get_socket_service_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def do_start_socket_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def socketlist(self) -> List[SystemctlSocket]:
+        pass
+
+    def create_socket(self, conf: SystemctlConf) -> Optional[socket.socket]:
+        pass
+
+    def create_unix_socket(self, conf: SystemctlConf, path: str, dgram: bool) -> Optional[socket.socket]:
+        pass
+
+    def create_port_socket(self, conf: SystemctlConf, port: str, dgram: bool) -> Optional[socket.socket]:
+        pass
+
+    def create_port_ipv4_socket(self, conf: SystemctlConf, addr: str, port: str, dgram: bool) -> Optional[socket.socket]:
+        pass
+
+    def create_port_ipv6_socket(self, conf: SystemctlConf, addr: str, port: str, dgram: bool) -> Optional[socket.socket]:
+        pass
+
+    def extend_exec_env(self, env: Dict[str, str]) -> Dict[str, str]:
+        pass
+
+    def skip_journal_log(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def dup2_journal_log(self, conf: SystemctlConf) -> None:
+        pass
+
+    def execve_from(self, conf: SystemctlConf, cmd: List[str], env: Dict[str, str]) -> NoReturn:
+        pass
+
+    def test_start_unit(self, unit: str) -> None:
+        pass
+
+    def stop_modules(self, *modules: str) -> bool:
+        pass
+
+    def stop_units(self, units: List[str]) -> bool:
+        pass
+
+    def stop_unit(self, unit: str) -> bool:
+        pass
+
+    def stop_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_stop_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_stop_service_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_stop_socket_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def wait_vanished_pid(self, pid: int, timeout: float) -> bool:
+        pass
+
+    def reload_modules(self, *modules: str) -> bool:
+        pass
+
+    def reload_units(self, units: List[str]) -> bool:
+        pass
+
+    def reload_unit(self, unit: str) -> bool:
+        pass
+
+    def reload_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_reload_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_reload_service_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def restart_modules(self, *modules: str) -> bool:
+        pass
+
+    def restart_units(self, units: List[str]) -> bool:
+        pass
+
+    def restart_unit(self, unit: str) -> bool:
+        pass
+
+    def restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def try_restart_modules(self, *modules: str) -> bool:
+        pass
+
+    def try_restart_units(self, units: List[str]) -> bool:
+        pass
+
+    def try_restart_unit(self, unit: str) -> bool:
+        pass
+
+    def reload_or_restart_modules(self, *modules: str) -> bool:
+        pass
+
+    def reload_or_restart_units(self, units: List[str]) -> bool:
+        pass
+
+    def reload_or_restart_unit(self, unit: str) -> bool:
+        pass
+
+    def reload_or_restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_reload_or_restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def reload_or_try_restart_modules(self, *modules: str) -> bool:
+        pass
+
+    def reload_or_try_restart_units(self, units: List[str]) -> bool:
+        pass
+
+    def reload_or_try_restart_unit(self, unit: str) -> bool:
+        pass
+
+    def reload_or_try_restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_reload_or_try_restart_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def kill_modules(self, *modules: str) -> bool:
+        pass
+
+    def kill_units(self, units: List[str]) -> bool:
+        pass
+
+    def kill_unit(self, unit: str) -> bool:
+        pass
+
+    def kill_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_kill_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def _kill_pid(self, pid: int, kill_signal: Optional[int]=None) -> bool:
+        pass
+
+    def is_active_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def is_active_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def active_pid_from(self, conf: SystemctlConf) -> Optional[int]:
+        pass
+
+    def is_active_pid(self, pid: Optional[int]) -> Optional[int]:
+        pass
+
+    def get_active_unit(self, unit: str) -> str:
+        pass
+
+    def get_active_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_active_service_from(self, conf: Optional[SystemctlConf]) -> str:
+        pass
+
+    def get_active_target_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_active_target(self, target: str) -> str:
+        pass
+
+    def get_active_target_list(self) -> List[str]:
+        pass
+
+    def get_substate_from(self, conf: SystemctlConf) -> Optional[str]:
+        pass
+
+    def is_failed_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def is_failed_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def reset_failed_modules(self, *modules: str) -> bool:
+        pass
+
+    def reset_failed_unit(self, unit: str) -> bool:
+        pass
+
+    def reset_failed_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def status_modules(self, *modules: str) -> str:
+        pass
+
+    def status_units(self, units: List[str]) -> str:
+        pass
+
+    def status_unit(self, unit: str) -> Tuple[int, str]:
+        pass
+
+    def cat_modules(self, *modules: str) -> str:
+        pass
+
+    def cat_units(self, units: List[str]) -> str:
+        pass
+
+    def cat_unit(self, unit: str) -> Optional[str]:
+        pass
+
+    def preset_modules(self, *modules: str) -> bool:
+        pass
+
+    def preset_units(self, units: List[str]) -> bool:
+        pass
+
+    def preset_all_modules(self, *modules: str) -> bool:
+        pass
+
+    def enablefolders(self, wanted: str) -> Iterable[str]:
+        pass
+
+    def enablefolder(self, wanted: str) -> str:
+        pass
+
+    def default_enablefolder(self, wanted: str, basefolder: Optional[str]=None) -> str:
+        pass
+
+    def enable_modules(self, *modules: str) -> bool:
+        pass
+
+    def enable_units(self, units: List[str]) -> bool:
+        pass
+
+    def enable_unit(self, unit: str) -> bool:
+        pass
+
+    def enable_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def rc3_root_folder(self) -> str:
+        pass
+
+    def rc5_root_folder(self) -> str:
+        pass
+
+    def enable_unit_sysv(self, unit_file: str) -> bool:
+        pass
+
+    def _enable_unit_sysv(self, unit_file: str, rc_folder: str) -> bool:
+        pass
+
+    def disable_modules(self, *modules: str) -> bool:
+        pass
+
+    def disable_units(self, units: List[str]) -> bool:
+        pass
+
+    def disable_unit(self, unit: str) -> bool:
+        pass
+
+    def disable_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def disable_unit_sysv(self, unit_file: str) -> bool:
+        pass
+
+    def _disable_unit_sysv(self, unit_file: str, rc_folder: str) -> bool:
+        pass
+
+    def is_enabled_sysv(self, unit_file: str) -> bool:
+        pass
+
+    def is_enabled_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def is_enabled_units(self, units: List[str]) -> List[str]:
+        pass
+
+    def is_enabled(self, unit: str) -> bool:
+        pass
+
+    def enabled_unit(self, unit: str) -> str:
+        pass
+
+    def enabled_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def get_enabled_from(self, conf: SystemctlConf) -> str:
+        pass
+
+    def mask_modules(self, *modules: str) -> bool:
+        pass
+
+    def mask_units(self, units: List[str]) -> bool:
+        pass
+
+    def mask_unit(self, unit: str) -> bool:
+        pass
+
+    def mask_folder(self) -> str:
+        pass
+
+    def mask_folders(self) -> Iterable[str]:
+        pass
+
+    def unmask_modules(self, *modules: str) -> bool:
+        pass
+
+    def unmask_units(self, units: List[str]) -> bool:
+        pass
+
+    def unmask_unit(self, unit: str) -> bool:
+        pass
+
+    def list_dependencies_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def list_dependencies_units(self, units: List[str]) -> List[str]:
+        pass
+
+    def list_dependencies_unit(self, unit: str) -> List[str]:
+        pass
+
+    def list_start_dependencies_modules(self, *modules: str) -> List[Tuple[str, str]]:
+        pass
+
+    def daemon_reload_target(self) -> bool:
+        pass
+
+    def show_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def show_units(self, units: List[str]) -> List[str]:
+        pass
+
+    def show_unit_items(self, unit: str) -> Iterable[Tuple[str, str]]:
+        pass
+
+    def each_unit_items(self, unit: str, conf: SystemctlConf) -> Iterable[Tuple[str, str]]:
+        pass
+
+    def _ignored_unit(self, unit: str, ignore_list: List[str]) -> bool:
+        pass
+
+    def default_services_modules(self, *modules: str) -> List[str]:
+        pass
+
+    def target_default_services(self, target: Optional[str]=None, sysv: str='S') -> List[str]:
+        pass
+
+    def enabled_target_services(self, target: str, sysv: str='S', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def enabled_target_user_local_units(self, target: str, unit_kind: str='.service', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def enabled_target_user_system_units(self, target: str, unit_kind: str='.service', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def enabled_target_installed_system_units(self, target: str, unit_type: str='.service', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def enabled_target_configured_system_units(self, target: str, unit_type: str='.service', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def enabled_target_sysv_units(self, target: str, sysv: str='S', igno: Optional[List[str]]=None) -> List[str]:
+        pass
+
+    def required_target_units(self, target: str, unit_type: str, igno: List[str]) -> List[str]:
+        pass
+
+    def default_system(self, arg: bool=True) -> bool:
+        pass
+
+    def start_system_default(self, init: int=0) -> bool:
+        pass
+
+    def start_target_system(self, target: str, init: int=False) -> List[str]:
+        pass
+
+    def do_start_target_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def stop_system_default(self) -> bool:
+        pass
+
+    def stop_target_system(self, target: str) -> List[str]:
+        pass
+
+    def do_stop_target_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def do_reload_target_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def reload_target_system(self, target: str) -> bool:
+        pass
+
+    def halt_target(self, arg: bool=True) -> bool:
+        pass
+
+    def system_get_default(self) -> str:
+        pass
+
+    def get_targets_folder(self) -> str:
+        pass
+
+    def get_default_target_file(self) -> str:
+        pass
+
+    def get_default_target(self, default_target: Optional[str]=None) -> str:
+        pass
+
+    def set_default_modules(self, *modules: str) -> str:
+        pass
+
+    def init_modules(self, *modules: str) -> bool:
+        pass
+
+    def start_log_files(self, units: List[str]) -> None:
+        pass
+
+    def read_log_files(self, units: List[str]) -> None:
+        pass
+
+    def print_log_files(self, units: List[str], stdout: int=1) -> int:
+        pass
+
+    def stop_log_files(self, units: List[str]) -> None:
+        pass
+
+    def restart_failed_units(self, units: List[str], maximum: Optional[int]=None) -> List[str]:
+        pass
+
+    def init_loop_until_stop(self, units: List[str]) -> Optional[str]:
+        pass
+
+    def reap_zombies_target(self) -> str:
+        pass
+
+    def reap_zombies(self) -> int:
+        pass
+
+    def sysinit_status(self, **status: Optional[str]) -> None:
+        pass
+
+    def sysinit_target(self) -> SystemctlConf:
+        pass
+
+    def is_system_running(self) -> str:
+        pass
+
+    def is_system_running_info(self) -> Optional[str]:
+        pass
+
+    def wait_system(self, target: Optional[str]=None) -> None:
+        pass
+
+    def is_running_unit_from(self, conf: SystemctlConf) -> bool:
+        pass
+
+    def is_running_unit(self, unit: str) -> bool:
+        pass
+
+    def pidlist_of(self, pid: Optional[int]) -> List[int]:
+        pass
+
+    def echo(self, *targets: str) -> str:
+        pass
+
+    def killall(self, *targets: str) -> bool:
+        pass
+
+    def force_ipv4(self) -> None:
+        pass
+
+    def force_ipv6(self) -> None:
+        pass
+
+    def help_list(self, show_all: Optional[int]=None) -> Dict[str, str]:
+        pass
+
+    def help_modules(self, *args: str) -> List[str]:
+        pass
+
+    def systemd_version(self) -> str:
+        pass
+
+    def systemd_features(self) -> str:
+        pass
+
+    def version_info(self) -> List[str]:
+        pass
+
+    def test_float(self) -> float:
+        pass
+
+def print_begin(argv: List[str], args: List[str]) -> None:
+    pass
+
+def print_begin2(args: List[str]) -> None:
+    pass
+
+def is_not_ok(result: bool) -> int:
+    pass
+
+def print_str(result: Optional[str]) -> None:
+    pass
+
+def print_str_list(result: Union[None, List[str]]) -> None:
+    pass
+
+def print_str_list_list(result: Union[List[Tuple[str]], List[Tuple[str, str]], List[Tuple[str, str, str]]]) -> None:
+    pass
+
+def print_str_dict(result: Union[None, Dict[str, str]]) -> None:
+    pass
+
+def runcommand(command: str, *modules: str) -> int:
+    pass
+
+def main() -> int:
+    pass