)
return None
except ValueError as e:
- raise DataValidationError(*e.args)
+ raise DataValidationError(*e.args) from e
except OSError as e:
if not optional_file:
raise e
#
# pylint: disable=no-member
-# We disable pyright checks because it can't find method that don't exist in this Python version
-# so the reported error is correct, but due to the version checking conditions, it never happens.
-# Due to backporting, we are also using private methods and non-existent members of classes
-#
-# pyright: reportUnknownMemberType=false
-# pyright: reportUnknownVariableType=false
-# pyright: reportGeneralTypeIssues=false
-# pyright: reportPrivateUsage=false
-
import asyncio
import functools
import logging
# FIXME the `cwd` argument is used only for configuring control socket path
# it should be removed and relative path used instead as soon as issue
# https://gitlab.nic.cz/knot/knot-resolver/-/issues/720 is fixed
- return MAIN_TEMPLATE.render(cfg=self, cwd=os.getcwd()) # pyright: reportUnknownMemberType=false
+ return MAIN_TEMPLATE.render(cfg=self, cwd=os.getcwd())
def get_rundir_without_validation(data: Dict[str, Any]) -> Dir:
super().__init__(source_value, object_path)
try:
punycode = self._value.encode("idna").decode("utf-8") if self._value != "." else "."
- except ValueError:
+ except ValueError as e:
raise ValueError(
f"conversion of '{self._value}' to IDN punycode representation failed",
object_path,
- )
+ ) from e
if type(self)._re.match(punycode):
self._punycode = punycode
@staticmethod
def from_string(val: str) -> "SupervisordKresID":
- if val == "cache-gc" or val == "cache-gc:cache-gc":
+ if val in ("cache-gc", "cache-gc:cache-gc"):
# the double name is checked because thats how we read it from supervisord
return SupervisordKresID.new(SubprocessType.GC, 0)
else:
template = await read_resource(__package__, "supervisord.conf.j2")
assert template is not None
template = template.decode("utf8")
- config_string = Template(template).render( # pyright: reportUnknownMemberType=false
+ config_string = Template(template).render(
gc=ProcessTypeConfig.create_gc_config(config),
kresd=ProcessTypeConfig.create_kresd_config(config),
manager=ProcessTypeConfig.create_manager_config(config),
try:
rundir = get_rundir_without_validation(config_raw)
except ValueError as e:
- raise DataValidationError(str(e), "/rundir")
+ raise DataValidationError(str(e), "/rundir") from e
logger.debug(f"Changing working directory to '{rundir.to_path().absolute()}'.")
os.chdir(rundir.to_path())
raise KresManagerException(
"Another manager is running in the same working directory."
f" PID file is located at {os.getcwd()}/{PID_FILE_NAME}"
- )
+ ) from e
else:
raise KresManagerException(
"Another manager is running in the same working directory."
f" PID file is located at {os.getcwd()}/{PID_FILE_NAME}"
- )
+ ) from e
# now we know that we are the only manager running in this directory
try:
return func(*nargs, **nkwargs)
except BaseException as e:
- if isinstance(e, exceptions): # pyright: reportUnnecessaryIsInstance=false
+ if isinstance(e, exceptions):
return default
else:
- raise e # pyright: reportGeneralTypeIssues=false
+ raise e
return f
try:
default = self._create_default(getattr(cls, name, None))
except ValueError as e:
- raise DataValidationError(str(e), f"{object_path}/{name}")
+ raise DataValidationError(str(e), f"{object_path}/{name}") from e
value = self.map_object(python_type, default, object_path=f"{object_path}/{name}")
setattr(obj, name, value)
try:
token = int(token)
current = current[token]
- except ValueError:
+ except ValueError as e:
raise ValueError(
f"invalid JSON pointer: list '{current_ptr}' require numbers as keys, instead got '{token}'"
- )
+ ) from e
elif isinstance(current, dict):
current = current.get(token, None)
node.start_mark,
f"found unacceptable key ({exc})",
key_node.start_mark,
- )
+ ) from exc
# check for duplicate keys
if key in mapping:
try:
return parse_yaml(data)
except yaml.YAMLError as ye:
- raise DataParsingError(f"failed to parse data, JSON: {je}, YAML: {ye}")
+ # We do not raise-from here because there are two possible causes
+ # and we may not know which one is the actual one.
+ raise DataParsingError( # pylint: disable=raise-missing-from
+ f"failed to parse data, JSON: {je}, YAML: {ye}"
+ )
"missing-docstring",
"no-else-return",
"no-self-use",
- "raise-missing-from",
"too-few-public-methods",
"unused-import", # checked by flake8,
- "bad-continuation", # conflicts with black
- "consider-using-in", # pyright can't see through in expressions,
"too-many-return-statements", # would prevent us from using recursive tree traversals
"logging-fstring-interpolation", # see https://github.com/PyCQA/pylint/issues/1788
"no-else-raise", # not helpful for readability, when we want explicit branches
"raising-bad-type", # handled by type checker
"too-many-arguments", # sure, but how can we change the signatures to take less arguments? artificially create objects with arguments? That's stupid...
- "no-member", # checked by pyright
- "import-error", # checked by pyright (and pylint does not do it properly)
- "unsupported-delete-operation", # checked by pyright
- "unsubscriptable-object", # checked by pyright
- "unsupported-membership-test", # checked by pyright
"invalid-overridden-method", # hopefully checked by type checkers
+ "no-member", # pylint does not do it properly
+ "import-error", # pylint does not do it properly
]
[tool.pylint.SIMILARITIES]
[tool.pylint.DESIGN]
max-parents = "10"
-[tool.pyright]
-include = [
- "knot_resolver_manager",
- "tests"
-]
-exclude = []
-typeCheckingMode = "strict"
-
[tool.mypy]
python_version = "3.7"
# strict = true
+++ /dev/null
-# Type stubs
-
-See (pyright documentation)[https://github.com/microsoft/pyright/blob/master/docs/type-stubs.md]
-
-Generate stubs using this command (replacing `jinja2` for an appropriate package):
-```
-poetry run yarn pyright --createstub jinja2
-```
\ No newline at end of file
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from _pytest import __version__
-from _pytest.assertion import register_assert_rewrite
-from _pytest.compat import _setup_collect_fakemodule
-from _pytest.config import ExitCode, UsageError, cmdline, hookimpl, hookspec, main
-from _pytest.debugging import pytestPDB as __pytestPDB
-from _pytest.fixtures import fillfixtures as _fillfuncargs
-from _pytest.fixtures import fixture, yield_fixture
-from _pytest.freeze_support import freeze_includes
-from _pytest.main import Session
-from _pytest.mark import MARK_GEN as mark
-from _pytest.mark import param
-from _pytest.nodes import Collector, File, Item
-from _pytest.outcomes import exit, fail, importorskip, skip, xfail
-from _pytest.python import Class, Function, Instance, Module, Package
-from _pytest.python_api import approx, raises
-from _pytest.recwarn import deprecated_call, warns
-from _pytest.warning_types import (
- PytestAssertRewriteWarning,
- PytestCacheWarning,
- PytestCollectionWarning,
- PytestConfigWarning,
- PytestDeprecationWarning,
- PytestExperimentalApiWarning,
- PytestUnhandledCoroutineWarning,
- PytestUnknownMarkWarning,
- PytestWarning,
-)
-
-"""
-pytest: unit and functional testing with Python.
-"""
-set_trace = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-"""
-pytest entry point
-"""
-if __name__ == "__main__":
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def getRPCTransport(env): # -> SupervisorTransport:
- ...
-
-def getRPCInterface(env):
- ...
-
-def get_headers(line): # -> dict[Unknown, Unknown]:
- ...
-
-def eventdata(payload): # -> tuple[dict[Unknown, Unknown], Unknown]:
- ...
-
-def get_asctime(now=...): # -> str:
- ...
-
-class ProcessCommunicationsProtocol:
- def send(self, msg, fp=...): # -> None:
- ...
-
- def stdout(self, msg): # -> None:
- ...
-
- def stderr(self, msg): # -> None:
- ...
-
-
-
-pcomm = ...
-class EventListenerProtocol:
- def wait(self, stdin=..., stdout=...): # -> tuple[dict[Unknown, Unknown], Unknown]:
- ...
-
- def ready(self, stdout=...): # -> None:
- ...
-
- def ok(self, stdout=...): # -> None:
- ...
-
- def fail(self, stdout=...): # -> None:
- ...
-
- def send(self, data, stdout=...): # -> None:
- ...
-
-
-
-listener = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-PY2 = ...
-if PY2:
- long = ...
- raw_input = ...
- unicode = ...
- unichr = ...
- basestring = ...
- def as_bytes(s, encoding=...): # -> str:
- ...
-
- def as_string(s, encoding=...): # -> unicode:
- ...
-
- def is_text_stream(stream): # -> bool:
- ...
-
-else:
- long = ...
- basestring = ...
- raw_input = ...
- unichr = ...
- class unicode(str):
- def __init__(self, string, encoding, errors) -> None:
- ...
-
-
-
- def as_bytes(s, encoding=...): # -> bytes:
- ...
-
- def as_string(s, encoding=...): # -> str:
- ...
-
- def is_text_stream(stream): # -> bool:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def main(out=...): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def process_or_group_name(name): # -> str:
- """Ensures that a process or group name is not created with
- characters that break the eventlistener protocol or web UI URLs"""
- ...
-
-def integer(value): # -> int:
- ...
-
-TRUTHY_STRINGS = ...
-FALSY_STRINGS = ...
-def boolean(s): # -> bool:
- """Convert a string value to a boolean value."""
- ...
-
-def list_of_strings(arg): # -> list[Unknown]:
- ...
-
-def list_of_ints(arg): # -> list[int]:
- ...
-
-def list_of_exitcodes(arg): # -> list[int]:
- ...
-
-def dict_of_key_value_pairs(arg): # -> dict[Unknown, Unknown]:
- """ parse KEY=val,KEY2=val2 into {'KEY':'val', 'KEY2':'val2'}
- Quotes can be used to allow commas in the value
- """
- ...
-
-class Automatic:
- ...
-
-
-class Syslog:
- """TODO deprecated; remove this special 'syslog' filename in the future"""
- ...
-
-
-LOGFILE_NONES = ...
-LOGFILE_AUTOS = ...
-LOGFILE_SYSLOGS = ...
-def logfile_name(val): # -> Type[Automatic] | Type[Syslog] | None:
- ...
-
-class RangeCheckedConversion:
- """Conversion helper that range checks another conversion."""
- def __init__(self, conversion, min=..., max=...) -> None:
- ...
-
- def __call__(self, value):
- ...
-
-
-
-port_number = ...
-def inet_address(s): # -> tuple[Unknown | Literal[''], Unknown]:
- ...
-
-class SocketAddress:
- def __init__(self, s) -> None:
- ...
-
-
-
-class SocketConfig:
- """ Abstract base class which provides a uniform abstraction
- for TCP vs Unix sockets """
- url = ...
- addr = ...
- backlog = ...
- def __repr__(self): # -> str:
- ...
-
- def __str__(self) -> str:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def __ne__(self, other) -> bool:
- ...
-
- def get_backlog(self): # -> None:
- ...
-
- def addr(self):
- ...
-
- def create_and_bind(self):
- ...
-
-
-
-class InetStreamSocketConfig(SocketConfig):
- """ TCP socket config helper """
- host = ...
- port = ...
- def __init__(self, host, port, **kwargs) -> None:
- ...
-
- def addr(self): # -> tuple[Unknown | None, Unknown | None]:
- ...
-
- def create_and_bind(self): # -> socket:
- ...
-
-
-
-class UnixStreamSocketConfig(SocketConfig):
- """ Unix domain socket config helper """
- path = ...
- mode = ...
- owner = ...
- sock = ...
- def __init__(self, path, **kwargs) -> None:
- ...
-
- def addr(self): # -> Unknown | None:
- ...
-
- def create_and_bind(self): # -> socket:
- ...
-
- def get_mode(self): # -> None:
- ...
-
- def get_owner(self): # -> None:
- ...
-
-
-
-def colon_separated_user_group(arg): # -> tuple[int, int]:
- """ Find a user ID and group ID from a string like 'user:group'. Returns
- a tuple (uid, gid). If the string only contains a user like 'user'
- then (uid, -1) will be returned. Raises ValueError if either
- the user or group can't be resolved to valid IDs on the system. """
- ...
-
-def name_to_uid(name): # -> int:
- """ Find a user ID from a string containing a user name or ID.
- Raises ValueError if the string can't be resolved to a valid
- user ID on the system. """
- ...
-
-def name_to_gid(name): # -> int:
- """ Find a group ID from a string containing a group name or ID.
- Raises ValueError if the string can't be resolved to a valid
- group ID on the system. """
- ...
-
-def gid_for_uid(uid): # -> int:
- ...
-
-def octal_type(arg): # -> int:
- ...
-
-def existing_directory(v):
- ...
-
-def existing_dirpath(v):
- ...
-
-def logging_level(value): # -> Any:
- ...
-
-class SuffixMultiplier:
- def __init__(self, d, default=...) -> None:
- ...
-
- def __call__(self, v): # -> int:
- ...
-
-
-
-byte_size = ...
-def url(value):
- ...
-
-SIGNUMS = ...
-def signal_number(value): # -> int | Any:
- ...
-
-class RestartWhenExitUnexpected:
- ...
-
-
-class RestartUnconditionally:
- ...
-
-
-def auto_restart(value): # -> Type[RestartUnconditionally] | Type[RestartWhenExitUnexpected] | str | Literal[False]:
- ...
-
-def profile_options(value): # -> tuple[list[Unknown], bool]:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def find_prefix_at_end(haystack, needle): # -> int:
- ...
-
-class PDispatcher:
- """ Asyncore dispatcher for mainloop, representing a process channel
- (stdin, stdout, or stderr). This class is abstract. """
- closed = ...
- def __init__(self, process, channel, fd) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def readable(self):
- ...
-
- def writable(self):
- ...
-
- def handle_read_event(self):
- ...
-
- def handle_write_event(self):
- ...
-
- def handle_error(self): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def flush(self): # -> None:
- ...
-
-
-
-class POutputDispatcher(PDispatcher):
- """
- Dispatcher for one channel (stdout or stderr) of one process.
- Serves several purposes:
-
- - capture output sent within <!--XSUPERVISOR:BEGIN--> and
- <!--XSUPERVISOR:END--> tags and signal a ProcessCommunicationEvent
- by calling notify(event).
- - route the output to the appropriate log handlers as specified in the
- config.
- """
- childlog = ...
- normallog = ...
- capturelog = ...
- capturemode = ...
- output_buffer = ...
- def __init__(self, process, event_type, fd) -> None:
- """
- Initialize the dispatcher.
-
- `event_type` should be one of ProcessLogStdoutEvent or
- ProcessLogStderrEvent
- """
- ...
-
- def removelogs(self): # -> None:
- ...
-
- def reopenlogs(self): # -> None:
- ...
-
- def record_output(self): # -> None:
- ...
-
- def toggle_capturemode(self): # -> None:
- ...
-
- def writable(self): # -> Literal[False]:
- ...
-
- def readable(self): # -> bool:
- ...
-
- def handle_read_event(self): # -> None:
- ...
-
-
-
-class PEventListenerDispatcher(PDispatcher):
- """ An output dispatcher that monitors and changes a process'
- listener_state """
- childlog = ...
- state_buffer = ...
- READY_FOR_EVENTS_TOKEN = ...
- RESULT_TOKEN_START = ...
- READY_FOR_EVENTS_LEN = ...
- RESULT_TOKEN_START_LEN = ...
- def __init__(self, process, channel, fd) -> None:
- ...
-
- def removelogs(self): # -> None:
- ...
-
- def reopenlogs(self): # -> None:
- ...
-
- def writable(self): # -> Literal[False]:
- ...
-
- def readable(self): # -> bool:
- ...
-
- def handle_read_event(self): # -> None:
- ...
-
- def handle_listener_state_change(self): # -> None:
- ...
-
- def handle_result(self, result): # -> None:
- ...
-
-
-
-class PInputDispatcher(PDispatcher):
- """ Input (stdin) dispatcher """
- def __init__(self, process, channel, fd) -> None:
- ...
-
- def writable(self): # -> bool:
- ...
-
- def readable(self): # -> Literal[False]:
- ...
-
- def flush(self): # -> None:
- ...
-
- def handle_write_event(self): # -> None:
- ...
-
-
-
-ANSI_ESCAPE_BEGIN = ...
-ANSI_TERMINATORS = ...
-def stripEscapes(s): # -> Literal[b'']:
- """
- Remove all ANSI color escapes from the given string.
- """
- ...
-
-class RejectEvent(Exception):
- """ The exception type expected by a dispatcher when a handler wants
- to reject an event """
- ...
-
-
-def default_handler(event, response): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-callbacks = ...
-def subscribe(type, callback): # -> None:
- ...
-
-def unsubscribe(type, callback): # -> None:
- ...
-
-def notify(event): # -> None:
- ...
-
-def clear(): # -> None:
- ...
-
-class Event:
- """ Abstract event type """
- ...
-
-
-class ProcessLogEvent(Event):
- """ Abstract """
- channel = ...
- def __init__(self, process, pid, data) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
-
-
-class ProcessLogStdoutEvent(ProcessLogEvent):
- channel = ...
-
-
-class ProcessLogStderrEvent(ProcessLogEvent):
- channel = ...
-
-
-class ProcessCommunicationEvent(Event):
- """ Abstract """
- BEGIN_TOKEN = ...
- END_TOKEN = ...
- def __init__(self, process, pid, data) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
-
-
-class ProcessCommunicationStdoutEvent(ProcessCommunicationEvent):
- channel = ...
-
-
-class ProcessCommunicationStderrEvent(ProcessCommunicationEvent):
- channel = ...
-
-
-class RemoteCommunicationEvent(Event):
- def __init__(self, type, data) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
-
-
-class SupervisorStateChangeEvent(Event):
- """ Abstract class """
- def payload(self): # -> Literal['']:
- ...
-
-
-
-class SupervisorRunningEvent(SupervisorStateChangeEvent):
- ...
-
-
-class SupervisorStoppingEvent(SupervisorStateChangeEvent):
- ...
-
-
-class EventRejectedEvent:
- def __init__(self, process, event) -> None:
- ...
-
-
-
-class ProcessStateEvent(Event):
- """ Abstract class, never raised directly """
- frm = ...
- to = ...
- def __init__(self, process, from_state, expected=...) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
- def get_extra_values(self): # -> list[Unknown]:
- ...
-
-
-
-class ProcessStateFatalEvent(ProcessStateEvent):
- ...
-
-
-class ProcessStateUnknownEvent(ProcessStateEvent):
- ...
-
-
-class ProcessStateStartingOrBackoffEvent(ProcessStateEvent):
- def get_extra_values(self): # -> list[tuple[Literal['tries'], int]]:
- ...
-
-
-
-class ProcessStateBackoffEvent(ProcessStateStartingOrBackoffEvent):
- ...
-
-
-class ProcessStateStartingEvent(ProcessStateStartingOrBackoffEvent):
- ...
-
-
-class ProcessStateExitedEvent(ProcessStateEvent):
- def get_extra_values(self): # -> list[tuple[Literal['expected'], int] | tuple[Literal['pid'], Unknown]]:
- ...
-
-
-
-class ProcessStateRunningEvent(ProcessStateEvent):
- def get_extra_values(self): # -> list[tuple[Literal['pid'], Unknown]]:
- ...
-
-
-
-class ProcessStateStoppingEvent(ProcessStateEvent):
- def get_extra_values(self): # -> list[tuple[Literal['pid'], Unknown]]:
- ...
-
-
-
-class ProcessStateStoppedEvent(ProcessStateEvent):
- def get_extra_values(self): # -> list[tuple[Literal['pid'], Unknown]]:
- ...
-
-
-
-class ProcessGroupEvent(Event):
- def __init__(self, group) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
-
-
-class ProcessGroupAddedEvent(ProcessGroupEvent):
- ...
-
-
-class ProcessGroupRemovedEvent(ProcessGroupEvent):
- ...
-
-
-class TickEvent(Event):
- """ Abstract """
- def __init__(self, when, supervisord) -> None:
- ...
-
- def payload(self): # -> str:
- ...
-
-
-
-class Tick5Event(TickEvent):
- period = ...
-
-
-class Tick60Event(TickEvent):
- period = ...
-
-
-class Tick3600Event(TickEvent):
- period = ...
-
-
-TICK_EVENTS = ...
-class EventTypes:
- EVENT = Event
- PROCESS_STATE = ProcessStateEvent
- PROCESS_STATE_STOPPED = ProcessStateStoppedEvent
- PROCESS_STATE_EXITED = ProcessStateExitedEvent
- PROCESS_STATE_STARTING = ProcessStateStartingEvent
- PROCESS_STATE_STOPPING = ProcessStateStoppingEvent
- PROCESS_STATE_BACKOFF = ProcessStateBackoffEvent
- PROCESS_STATE_FATAL = ProcessStateFatalEvent
- PROCESS_STATE_RUNNING = ProcessStateRunningEvent
- PROCESS_STATE_UNKNOWN = ProcessStateUnknownEvent
- PROCESS_COMMUNICATION = ProcessCommunicationEvent
- PROCESS_COMMUNICATION_STDOUT = ProcessCommunicationStdoutEvent
- PROCESS_COMMUNICATION_STDERR = ProcessCommunicationStderrEvent
- PROCESS_LOG = ProcessLogEvent
- PROCESS_LOG_STDOUT = ProcessLogStdoutEvent
- PROCESS_LOG_STDERR = ProcessLogStderrEvent
- REMOTE_COMMUNICATION = RemoteCommunicationEvent
- SUPERVISOR_STATE_CHANGE = SupervisorStateChangeEvent
- SUPERVISOR_STATE_CHANGE_RUNNING = SupervisorRunningEvent
- SUPERVISOR_STATE_CHANGE_STOPPING = SupervisorStoppingEvent
- TICK = TickEvent
- TICK_5 = Tick5Event
- TICK_60 = Tick60Event
- TICK_3600 = Tick3600Event
- PROCESS_GROUP = ProcessGroupEvent
- PROCESS_GROUP_ADDED = ProcessGroupAddedEvent
- PROCESS_GROUP_REMOVED = ProcessGroupRemovedEvent
-
-
-def getEventNameByType(requested): # -> str | None:
- ...
-
-def register(name, event): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from supervisor.medusa import http_server
-from supervisor.medusa.auth_handler import auth_handler
-
-class NOT_DONE_YET:
- ...
-
-
-class deferring_chunked_producer:
- """A producer that implements the 'chunked' transfer coding for HTTP/1.1.
- Here is a sample usage:
- request['Transfer-Encoding'] = 'chunked'
- request.push (
- producers.chunked_producer (your_producer)
- )
- request.done()
- """
- def __init__(self, producer, footers=...) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | bytes:
- ...
-
-
-
-class deferring_composite_producer:
- """combine a fifo of producers into one"""
- def __init__(self, producers) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | Literal[b'']:
- ...
-
-
-
-class deferring_globbing_producer:
- """
- 'glob' the output from a producer into a particular buffer size.
- helps reduce the number of calls to send(). [this appears to
- gain about 30% performance on requests to a single channel]
- """
- def __init__(self, producer, buffer_size=...) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | bytes:
- ...
-
-
-
-class deferring_hooked_producer:
- """
- A producer that will call <function> when it empties,.
- with an argument of the number of bytes produced. Useful
- for logging/instrumentation purposes.
- """
- def __init__(self, producer, function) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | Literal[b'']:
- ...
-
-
-
-class deferring_http_request(http_server.http_request):
- """ The medusa http_request class uses the default set of producers in
- medusa.producers. We can't use these because they don't know anything
- about deferred responses, so we override various methods here. This was
- added to support tail -f like behavior on the logtail handler """
- def done(self, *arg, **kw): # -> None:
- """ I didn't want to override this, but there's no way around
- it in order to support deferreds - CM
-
- finalize this transaction - send output to the http channel"""
- ...
-
- def log(self, bytes): # -> None:
- """ We need to override this because UNIX domain sockets return
- an empty string for the addr rather than a (host, port) combination """
- ...
-
- def cgi_environment(self): # -> dict[Unknown, Unknown]:
- ...
-
- def get_server_url(self): # -> str:
- """ Functionality that medusa's http request doesn't have; set an
- attribute named 'server_url' on the request based on the Host: header
- """
- ...
-
-
-
-class deferring_http_channel(http_server.http_channel):
- ac_out_buffer_size = ...
- delay = ...
- last_writable_check = ...
- def writable(self, now=...): # -> bool:
- ...
-
- def refill_buffer(self): # -> None:
- """ Implement deferreds """
- ...
-
- def found_terminator(self): # -> None:
- """ We only override this to use 'deferring_http_request' class
- instead of the normal http_request class; it sucks to need to override
- this """
- ...
-
-
-
-class supervisor_http_server(http_server.http_server):
- channel_class = deferring_http_channel
- ip = ...
- def prebind(self, sock, logger_object): # -> None:
- """ Override __init__ to do logger setup earlier so it can
- go to our logger object instead of stdout """
- ...
-
- def postbind(self): # -> None:
- ...
-
- def log_info(self, message, type=...): # -> None:
- ...
-
-
-
-class supervisor_af_inet_http_server(supervisor_http_server):
- """ AF_INET version of supervisor HTTP server """
- def __init__(self, ip, port, logger_object) -> None:
- ...
-
-
-
-class supervisor_af_unix_http_server(supervisor_http_server):
- """ AF_UNIX version of supervisor HTTP server """
- def __init__(self, socketname, sockchmod, sockchown, logger_object) -> None:
- ...
-
- def checkused(self, socketname): # -> bool:
- ...
-
-
-
-class tail_f_producer:
- def __init__(self, request, filename, head) -> None:
- ...
-
- def __del__(self): # -> None:
- ...
-
- def more(self): # -> bytes | Type[NOT_DONE_YET] | Literal['''==> File truncated <==
-''']:
- ...
-
-
-
-class logtail_handler:
- IDENT = ...
- path = ...
- def __init__(self, supervisord) -> None:
- ...
-
- def match(self, request):
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
-
-
-class mainlogtail_handler:
- IDENT = ...
- path = ...
- def __init__(self, supervisord) -> None:
- ...
-
- def match(self, request):
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
-
-
-def make_http_servers(options, supervisord): # -> list[Unknown]:
- ...
-
-class LogWrapper:
- '''Receives log messages from the Medusa servers and forwards
- them to the Supervisor logger'''
- def __init__(self, logger) -> None:
- ...
-
- def log(self, msg): # -> None:
- '''Medusa servers call this method. There is no log level so
- we have to sniff the message. We want "Server Error" messages
- from medusa.http_server logged as errors at least.'''
- ...
-
-
-
-class encrypted_dictionary_authorizer:
- def __init__(self, dict) -> None:
- ...
-
- def authorize(self, auth_info): # -> Literal[False]:
- ...
-
-
-
-class supervisor_auth_handler(auth_handler):
- def __init__(self, dict, handler, realm=...) -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from supervisor.medusa import asynchat_25 as asynchat
-
-CR = ...
-LF = ...
-CRLF = ...
-class Listener:
- def status(self, url, status): # -> None:
- ...
-
- def error(self, url, error): # -> None:
- ...
-
- def response_header(self, url, name, value): # -> None:
- ...
-
- def done(self, url): # -> None:
- ...
-
- def feed(self, url, data): # -> None:
- ...
-
- def close(self, url): # -> None:
- ...
-
-
-
-class HTTPHandler(asynchat.async_chat):
- def __init__(self, listener, username=..., password=..., conn=..., map=...) -> None:
- ...
-
- def get(self, serverurl, path=...): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def header(self, name, value): # -> None:
- ...
-
- def handle_error(self): # -> None:
- ...
-
- def handle_connect(self): # -> None:
- ...
-
- def feed(self, data): # -> None:
- ...
-
- def collect_incoming_data(self, bytes): # -> None:
- ...
-
- def found_terminator(self): # -> None:
- ...
-
- def ignore(self): # -> None:
- ...
-
- def status_line(self): # -> tuple[bytes | Unknown, int, bytes | Unknown]:
- ...
-
- def headers(self): # -> None:
- ...
-
- def response_header(self, name, value): # -> None:
- ...
-
- def body(self): # -> None:
- ...
-
- def done(self): # -> None:
- ...
-
- def chunked_size(self): # -> None:
- ...
-
- def chunked_body(self): # -> None:
- ...
-
- def trailer(self): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-"""
-Logger implementation loosely modeled on PEP 282. We don't use the
-PEP 282 logger implementation in the stdlib ('logging') because it's
-idiosyncratic and a bit slow for our purposes (we don't use threads).
-"""
-class LevelsByName:
- CRIT = ...
- ERRO = ...
- WARN = ...
- INFO = ...
- DEBG = ...
- TRAC = ...
- BLAT = ...
-
-
-class LevelsByDescription:
- critical = ...
- error = ...
- warn = ...
- info = ...
- debug = ...
- trace = ...
- blather = ...
-
-
-LOG_LEVELS_BY_NUM = ...
-def getLevelNumByDescription(description): # -> Any | None:
- ...
-
-class Handler:
- fmt = ...
- level = ...
- def __init__(self, stream=...) -> None:
- ...
-
- def setFormat(self, fmt): # -> None:
- ...
-
- def setLevel(self, level): # -> None:
- ...
-
- def flush(self): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def emit(self, record): # -> None:
- ...
-
- def handleError(self): # -> None:
- ...
-
-
-
-class StreamHandler(Handler):
- def __init__(self, strm=...) -> None:
- ...
-
- def remove(self): # -> None:
- ...
-
- def reopen(self): # -> None:
- ...
-
-
-
-class BoundIO:
- def __init__(self, maxbytes, buf=...) -> None:
- ...
-
- def flush(self): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def write(self, b): # -> None:
- ...
-
- def getvalue(self): # -> Unknown | bytes:
- ...
-
- def clear(self): # -> None:
- ...
-
-
-
-class FileHandler(Handler):
- """File handler which supports reopening of logs.
- """
- def __init__(self, filename, mode=...) -> None:
- ...
-
- def reopen(self): # -> None:
- ...
-
- def remove(self): # -> None:
- ...
-
-
-
-class RotatingFileHandler(FileHandler):
- def __init__(self, filename, mode=..., maxBytes=..., backupCount=...) -> None:
- """
- Open the specified file and use it as the stream for logging.
-
- By default, the file grows indefinitely. You can specify particular
- values of maxBytes and backupCount to allow the file to rollover at
- a predetermined size.
-
- Rollover occurs whenever the current log file is nearly maxBytes in
- length. If backupCount is >= 1, the system will successively create
- new files with the same pathname as the base file, but with extensions
- ".1", ".2" etc. appended to it. For example, with a backupCount of 5
- and a base file name of "app.log", you would get "app.log",
- "app.log.1", "app.log.2", ... through to "app.log.5". The file being
- written to is always "app.log" - when it gets filled up, it is closed
- and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
- exist, then they are renamed to "app.log.2", "app.log.3" etc.
- respectively.
-
- If maxBytes is zero, rollover never occurs.
- """
- ...
-
- def emit(self, record): # -> None:
- """
- Emit a record.
-
- Output the record to the file, catering for rollover as described
- in doRollover().
- """
- ...
-
- def removeAndRename(self, sfn, dfn): # -> None:
- ...
-
- def doRollover(self): # -> None:
- """
- Do a rollover, as described in __init__().
- """
- ...
-
-
-
-class LogRecord:
- def __init__(self, level, msg, **kw) -> None:
- ...
-
- def asdict(self): # -> dict[str, str | Unknown]:
- ...
-
-
-
-class Logger:
- def __init__(self, level=..., handlers=...) -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def blather(self, msg, **kw): # -> None:
- ...
-
- def trace(self, msg, **kw): # -> None:
- ...
-
- def debug(self, msg, **kw): # -> None:
- ...
-
- def info(self, msg, **kw): # -> None:
- ...
-
- def warn(self, msg, **kw): # -> None:
- ...
-
- def error(self, msg, **kw): # -> None:
- ...
-
- def critical(self, msg, **kw): # -> None:
- ...
-
- def log(self, level, msg, **kw): # -> None:
- ...
-
- def addHandler(self, hdlr): # -> None:
- ...
-
- def getvalue(self):
- ...
-
-
-
-class SyslogHandler(Handler):
- def __init__(self) -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def reopen(self): # -> None:
- ...
-
- def emit(self, record): # -> None:
- ...
-
-
-
-def getLogger(level=...): # -> Logger:
- ...
-
-_2MB = ...
-def handle_boundIO(logger, fmt, maxbytes=...): # -> None:
- """Attach a new BoundIO handler to an existing Logger"""
- ...
-
-def handle_stdout(logger, fmt): # -> None:
- """Attach a new StreamHandler with stdout handler to an existing Logger"""
- ...
-
-def handle_syslog(logger, fmt): # -> None:
- """Attach a new Syslog handler to an existing Logger"""
- ...
-
-def handle_file(logger, filename, fmt, rotating=..., maxbytes=..., backups=...): # -> None:
- """Attach a new file handler to an existing Logger. If the filename
- is the magic name of 'syslog' then make it a syslog handler instead."""
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-"""medusa.__init__
-"""
-__revision__ = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from supervisor.medusa import asyncore_25 as asyncore
-
-r"""A class supporting chat-style (command/response) protocols.
-
-This class adds support for 'chat' style protocols - where one side
-sends a 'command', and the other sends a response (examples would be
-the common internet protocols - smtp, nntp, ftp, etc..).
-
-The handle_read() method looks at the input stream for the current
-'terminator' (usually '\r\n' for single-line responses, '\r\n.\r\n'
-for multi-line output), calling self.found_terminator() on its
-receipt.
-
-for example:
-Say you build an async nntp client using this class. At the start
-of the connection, you'll have self.terminator set to '\r\n', in
-order to process the single-line greeting. Just before issuing a
-'LIST' command you'll set it to '\r\n.\r\n'. The output of the LIST
-command will be accumulated (using your own 'collect_incoming_data'
-method) up to the terminator, and then control will be returned to
-you - by calling your self.found_terminator() method.
-"""
-class async_chat(asyncore.dispatcher):
- """This is an abstract class. You must derive from this class, and add
- the two methods collect_incoming_data() and found_terminator()"""
- ac_in_buffer_size = ...
- ac_out_buffer_size = ...
- def __init__(self, conn=..., map=...) -> None:
- ...
-
- def collect_incoming_data(self, data):
- ...
-
- def found_terminator(self):
- ...
-
- def set_terminator(self, term): # -> None:
- """Set the input delimiter. Can be a fixed string of any length, an integer, or None"""
- ...
-
- def get_terminator(self): # -> int:
- ...
-
- def handle_read(self): # -> None:
- ...
-
- def handle_write(self): # -> None:
- ...
-
- def handle_close(self): # -> None:
- ...
-
- def push(self, data): # -> None:
- ...
-
- def push_with_producer(self, producer): # -> None:
- ...
-
- def readable(self): # -> bool:
- """predicate for inclusion in the readable for select()"""
- ...
-
- def writable(self): # -> bool:
- """predicate for inclusion in the writable for select()"""
- ...
-
- def close_when_done(self): # -> None:
- """automatically close this channel once the outgoing queue is empty"""
- ...
-
- def refill_buffer(self): # -> None:
- ...
-
- def initiate_send(self): # -> None:
- ...
-
- def discard_buffers(self): # -> None:
- ...
-
-
-
-class simple_producer:
- def __init__(self, data, buffer_size=...) -> None:
- ...
-
- def more(self): # -> bytes:
- ...
-
-
-
-class fifo:
- def __init__(self, list=...) -> None:
- ...
-
- def __len__(self): # -> int:
- ...
-
- def is_empty(self): # -> bool:
- ...
-
- def first(self):
- ...
-
- def push(self, data): # -> None:
- ...
-
- def pop(self): # -> tuple[Literal[1], Unknown] | tuple[Literal[0], None]:
- ...
-
-
-
-def find_prefix_at_end(haystack, needle): # -> int:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import os
-
-"""Basic infrastructure for asynchronous socket service clients and servers.
-
-There are only two ways to have a program on a single processor do "more
-than one thing at a time". Multi-threaded programming is the simplest and
-most popular way to do it, but there is another very different technique,
-that lets you have nearly all the advantages of multi-threading, without
-actually using multiple threads. it's really only practical if your program
-is largely I/O bound. If your program is CPU bound, then preemptive
-scheduled threads are probably what you really need. Network servers are
-rarely CPU-bound, however.
-
-If your operating system supports the select() system call in its I/O
-library (and nearly all do), then you can use it to juggle multiple
-communication channels at once; doing other work while your I/O is taking
-place in the "background." Although this strategy can seem strange and
-complex, especially at first, it is in many ways easier to understand and
-control than multi-threaded programming. The module documented here solves
-many of the difficult problems for you, making the task of building
-sophisticated high-performance network servers and clients a snap.
-"""
-class ExitNow(Exception):
- ...
-
-
-def read(obj): # -> None:
- ...
-
-def write(obj): # -> None:
- ...
-
-def readwrite(obj, flags): # -> None:
- ...
-
-def poll(timeout=..., map=...): # -> None:
- ...
-
-def poll2(timeout=..., map=...): # -> None:
- ...
-
-poll3 = ...
-def loop(timeout=..., use_poll=..., map=..., count=...): # -> None:
- ...
-
-class dispatcher:
- debug = ...
- connected = ...
- accepting = ...
- closing = ...
- addr = ...
- def __init__(self, sock=..., map=...) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def add_channel(self, map=...): # -> None:
- ...
-
- def del_channel(self, map=...): # -> None:
- ...
-
- def create_socket(self, family, type): # -> None:
- ...
-
- def set_socket(self, sock, map=...): # -> None:
- ...
-
- def set_reuse_addr(self): # -> None:
- ...
-
- def readable(self): # -> Literal[True]:
- ...
-
- def writable(self): # -> Literal[True]:
- ...
-
- def listen(self, num): # -> None:
- ...
-
- def bind(self, addr): # -> None:
- ...
-
- def connect(self, address): # -> None:
- ...
-
- def accept(self): # -> tuple[socket | Unknown, _RetAddress | Unknown] | None:
- ...
-
- def send(self, data): # -> int:
- ...
-
- def recv(self, buffer_size): # -> bytes:
- ...
-
- def close(self): # -> None:
- ...
-
- def __getattr__(self, attr): # -> Any:
- ...
-
- def log(self, message): # -> None:
- ...
-
- def log_info(self, message, type=...): # -> None:
- ...
-
- def handle_read_event(self): # -> None:
- ...
-
- def handle_write_event(self): # -> None:
- ...
-
- def handle_expt_event(self): # -> None:
- ...
-
- def handle_error(self): # -> None:
- ...
-
- def handle_expt(self): # -> None:
- ...
-
- def handle_read(self): # -> None:
- ...
-
- def handle_write(self): # -> None:
- ...
-
- def handle_connect(self): # -> None:
- ...
-
- def handle_accept(self): # -> None:
- ...
-
- def handle_close(self): # -> None:
- ...
-
-
-
-class dispatcher_with_send(dispatcher):
- def __init__(self, sock=..., map=...) -> None:
- ...
-
- def initiate_send(self): # -> None:
- ...
-
- def handle_write(self): # -> None:
- ...
-
- def writable(self): # -> int | Literal[True]:
- ...
-
- def send(self, data): # -> None:
- ...
-
-
-
-def compact_traceback(): # -> tuple[tuple[Unknown, Unknown, Unknown], Type[BaseException] | None, BaseException | None, str]:
- ...
-
-def close_all(map=...): # -> None:
- ...
-
-if os.name == 'posix':
- class file_wrapper:
- def __init__(self, fd) -> None:
- ...
-
- def recv(self, buffersize): # -> str:
- ...
-
- def send(self, s): # -> int:
- ...
-
- read = ...
- write = ...
- def close(self): # -> None:
- ...
-
- def fileno(self):
- ...
-
-
-
- class file_dispatcher(dispatcher):
- def __init__(self, fd, map=...) -> None:
- ...
-
- def set_file(self, fd): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-RCS_ID = ...
-get_header = ...
-class auth_handler:
- def __init__(self, dict, handler, realm=...) -> None:
- ...
-
- def match(self, request):
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
- def handle_unauthorized(self, request): # -> None:
- ...
-
- def make_nonce(self, request): # -> bytes:
- """A digest-authentication <nonce>, constructed as suggested in RFC 2069"""
- ...
-
- def apply_hash(self, s): # -> bytes:
- """Apply MD5 to a string <s>, then wrap it in base64 encoding."""
- ...
-
- def status(self): # -> composite_producer:
- ...
-
-
-
-class dictionary_authorizer:
- def __init__(self, dict) -> None:
- ...
-
- def authorize(self, auth_info): # -> Literal[1, 0]:
- ...
-
-
-
-AUTHORIZATION = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-class counter:
- """general-purpose counter"""
- def __init__(self, initial_value=...) -> None:
- ...
-
- def increment(self, delta=...): # -> Unknown:
- ...
-
- def decrement(self, delta=...): # -> Unknown:
- ...
-
- def as_long(self): # -> int:
- ...
-
- def __nonzero__(self):
- ...
-
- __bool__ = ...
- def __repr__(self): # -> str:
- ...
-
- def __str__(self) -> str:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import supervisor.medusa.producers as producers
-
-RCS_ID = ...
-unquote = ...
-class default_handler:
- valid_commands = ...
- IDENT = ...
- directory_defaults = ...
- default_file_producer = producers.file_producer
- def __init__(self, filesystem) -> None:
- ...
-
- hit_counter = ...
- def __repr__(self): # -> str:
- ...
-
- def match(self, request): # -> Literal[1]:
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
- def set_content_type(self, path, request): # -> None:
- ...
-
- def status(self): # -> simple_producer:
- ...
-
-
-
-IF_MODIFIED_SINCE = ...
-USER_AGENT = ...
-CONTENT_TYPE = ...
-get_header = ...
-get_header_match = ...
-def get_extension(path): # -> Literal['']:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import os
-
-class abstract_filesystem:
- def __init__(self) -> None:
- ...
-
- def current_directory(self): # -> None:
- """Return a string representing the current directory."""
- ...
-
- def listdir(self, path, long=...): # -> None:
- """Return a listing of the directory at 'path' The empty string
- indicates the current directory. If 'long' is set, instead
- return a list of (name, stat_info) tuples
- """
- ...
-
- def open(self, path, mode): # -> None:
- """Return an open file object"""
- ...
-
- def stat(self, path): # -> None:
- """Return the equivalent of os.stat() on the given path."""
- ...
-
- def isdir(self, path): # -> None:
- """Does the path represent a directory?"""
- ...
-
- def isfile(self, path): # -> None:
- """Does the path represent a plain file?"""
- ...
-
- def cwd(self, path): # -> None:
- """Change the working directory."""
- ...
-
- def cdup(self): # -> None:
- """Change to the parent of the current directory."""
- ...
-
- def longify(self, path): # -> None:
- """Return a 'long' representation of the filename
- [for the output of the LIST command]"""
- ...
-
-
-
-def safe_stat(path): # -> tuple[Unknown, stat_result] | None:
- ...
-
-class os_filesystem:
- path_module = os.path
- do_globbing = ...
- def __init__(self, root, wd=...) -> None:
- ...
-
- def current_directory(self): # -> Unknown | str:
- ...
-
- def isfile(self, path): # -> bool:
- ...
-
- def isdir(self, path): # -> bool:
- ...
-
- def cwd(self, path): # -> Literal[0, 1]:
- ...
-
- def cdup(self): # -> Literal[0, 1]:
- ...
-
- def listdir(self, path, long=...): # -> list_producer:
- ...
-
- def stat(self, path): # -> stat_result:
- ...
-
- def open(self, path, mode): # -> TextIOWrapper:
- ...
-
- def unlink(self, path): # -> None:
- ...
-
- def mkdir(self, path): # -> None:
- ...
-
- def rmdir(self, path): # -> None:
- ...
-
- def rename(self, src, dst): # -> None:
- ...
-
- def normalize(self, path): # -> str:
- ...
-
- def translate(self, path): # -> str:
- ...
-
- def longify(self, path_stat_info_tuple): # -> str:
- ...
-
- def __repr__(self): # -> str:
- ...
-
-
-
-if os.name == 'posix':
- class unix_filesystem(os_filesystem):
- ...
-
-
- class schizophrenic_unix_filesystem(os_filesystem):
- PROCESS_UID = ...
- PROCESS_EUID = ...
- PROCESS_GID = ...
- PROCESS_EGID = ...
- def __init__(self, root, wd=..., persona=...) -> None:
- ...
-
- def become_persona(self): # -> None:
- ...
-
- def become_nobody(self): # -> None:
- ...
-
- def cwd(self, path): # -> Literal[0, 1]:
- ...
-
- def cdup(self): # -> Literal[0, 1]:
- ...
-
- def open(self, filename, mode): # -> TextIOWrapper:
- ...
-
- def listdir(self, path, long=...): # -> list_producer:
- ...
-
-
-
-class msdos_filesystem(os_filesystem):
- def longify(self, path_stat_info_tuple): # -> str:
- ...
-
-
-
-class merged_filesystem:
- def __init__(self, *fsys) -> None:
- ...
-
-
-
-def msdos_longify(file, stat_info): # -> str:
- ...
-
-def msdos_date(t): # -> str:
- ...
-
-months = ...
-mode_table = ...
-def unix_longify(file, stat_info): # -> str:
- ...
-
-def ls_date(now, t): # -> str:
- ...
-
-class list_producer:
- def __init__(self, list, func=...) -> None:
- ...
-
- def more(self): # -> str:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def concat(*args): # -> str:
- ...
-
-def join(seq, field=...):
- ...
-
-def group(s):
- ...
-
-short_days = ...
-long_days = ...
-short_day_reg = ...
-long_day_reg = ...
-daymap = ...
-hms_reg = ...
-months = ...
-monmap = ...
-months_reg = ...
-rfc822_date = ...
-rfc822_reg = ...
-def unpack_rfc822(m): # -> tuple[int, Unknown, int, int, int, int, Literal[0], Literal[0], Literal[0]]:
- ...
-
-rfc850_date = ...
-rfc850_reg = ...
-def unpack_rfc850(m): # -> tuple[int, Unknown, int, int, int, int, Literal[0], Literal[0], Literal[0]]:
- ...
-
-def build_http_date(when): # -> str:
- ...
-
-def parse_http_date(d): # -> int:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import supervisor.medusa.asynchat_25 as asynchat
-import supervisor.medusa.asyncore_25 as asyncore
-
-RCS_ID = ...
-VERSION_STRING = ...
-class http_request:
- reply_code = ...
- request_counter = ...
- use_chunked = ...
- collector = ...
- def __init__(self, *args) -> None:
- ...
-
- def __setitem__(self, key, value): # -> None:
- ...
-
- def __getitem__(self, key): # -> str:
- ...
-
- def __contains__(self, key): # -> bool:
- ...
-
- def has_key(self, key): # -> bool:
- ...
-
- def build_reply_header(self): # -> bytes:
- ...
-
- def add_header(self, name, value): # -> None:
- """ Adds a header to the reply headers """
- ...
-
- def clear_headers(self): # -> None:
- """ Clears the reply header list """
- ...
-
- def remove_header(self, name, value=...): # -> None:
- """ Removes the specified header.
- If a value is provided, the name and
- value must match to remove the header.
- If the value is None, removes all headers
- with that name."""
- ...
-
- def get_reply_headers(self): # -> List[Unknown]:
- """ Get the tuple of headers that will be used
- for generating reply headers"""
- ...
-
- def get_reply_header_text(self): # -> str:
- """ Gets the reply header (including status and
- additional crlf)"""
- ...
-
- path_regex = ...
- def split_uri(self): # -> Tuple[str | Any, ...]:
- ...
-
- def get_header_with_regex(self, head_reg, group): # -> Literal['']:
- ...
-
- def get_header(self, header): # -> None:
- ...
-
- def collect_incoming_data(self, data): # -> None:
- ...
-
- def found_terminator(self): # -> None:
- ...
-
- def push(self, thing): # -> None:
- ...
-
- def response(self, code=...): # -> str:
- ...
-
- def error(self, code): # -> None:
- ...
-
- reply_now = ...
- def done(self): # -> None:
- """finalize this transaction - send output to the http channel"""
- ...
-
- def log_date_string(self, when): # -> str:
- ...
-
- def log(self, bytes): # -> None:
- ...
-
- responses = ...
- DEFAULT_ERROR_MESSAGE = ...
- def log_info(self, msg, level): # -> None:
- ...
-
-
-
-class http_channel(asynchat.async_chat):
- ac_out_buffer_size = ...
- current_request = ...
- channel_counter = ...
- def __init__(self, server, conn, addr) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- maintenance_interval = ...
- def check_maintenance(self): # -> None:
- ...
-
- def maintenance(self): # -> None:
- ...
-
- zombie_timeout = ...
- def kill_zombies(self): # -> None:
- ...
-
- def send(self, data): # -> int:
- ...
-
- def recv(self, buffer_size): # -> bytes:
- ...
-
- def handle_error(self): # -> None:
- ...
-
- def log(self, *args): # -> None:
- ...
-
- def collect_incoming_data(self, data): # -> None:
- ...
-
- def found_terminator(self): # -> None:
- ...
-
- def writable_for_proxy(self): # -> bool | Literal[1] | None:
- ...
-
-
-
-class http_server(asyncore.dispatcher):
- SERVER_IDENT = ...
- channel_class = http_channel
- def __init__(self, ip, port, resolver=..., logger_object=...) -> None:
- ...
-
- def writable(self): # -> Literal[0]:
- ...
-
- def handle_read(self): # -> None:
- ...
-
- def readable(self): # -> bool:
- ...
-
- def handle_connect(self): # -> None:
- ...
-
- def handle_accept(self): # -> None:
- ...
-
- def install_handler(self, handler, back=...): # -> None:
- ...
-
- def remove_handler(self, handler): # -> None:
- ...
-
- def status(self): # -> composite_producer:
- ...
-
-
-
-def maybe_status(thing): # -> None:
- ...
-
-CONNECTION = ...
-def join_headers(headers): # -> list[Unknown]:
- ...
-
-def get_header(head_reg, lines, group=...): # -> Literal['']:
- ...
-
-def get_header_match(head_reg, lines): # -> Literal['']:
- ...
-
-REQUEST = ...
-def crack_request(r): # -> tuple[str | Any, str | Any, str | Any | None] | tuple[None, None, None]:
- ...
-
-if __name__ == '__main__':
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import supervisor.medusa.asynchat_25 as asynchat
-
-class file_logger:
- def __init__(self, file, flush=..., mode=...) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def write(self, data): # -> None:
- ...
-
- def writeline(self, line): # -> None:
- ...
-
- def writelines(self, lines): # -> None:
- ...
-
- def maybe_flush(self): # -> None:
- ...
-
- def flush(self): # -> None:
- ...
-
- def softspace(self, *args): # -> None:
- ...
-
- def log(self, message): # -> None:
- ...
-
-
-
-class rotating_file_logger(file_logger):
- def __init__(self, file, freq=..., maxsize=..., flush=..., mode=...) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def next_backup(self, freq): # -> float | None:
- ...
-
- def maybe_flush(self): # -> None:
- ...
-
- def maybe_rotate(self): # -> None:
- ...
-
- def rotate(self): # -> None:
- ...
-
-
-
-class socket_logger(asynchat.async_chat):
- def __init__(self, address) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def log(self, message): # -> None:
- ...
-
-
-
-class multi_logger:
- def __init__(self, loggers) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def log(self, message): # -> None:
- ...
-
-
-
-class resolving_logger:
- """Feed (ip, message) combinations into this logger to get a
- resolved hostname in front of the message. The message will not
- be logged until the PTR request finishes (or fails)."""
- def __init__(self, resolver, logger) -> None:
- ...
-
- class logger_thunk:
- def __init__(self, message, logger) -> None:
- ...
-
- def __call__(self, host, ttl, answer): # -> None:
- ...
-
-
-
- def log(self, ip, message): # -> None:
- ...
-
-
-
-class unresolving_logger:
- """Just in case you don't want to resolve"""
- def __init__(self, logger) -> None:
- ...
-
- def log(self, ip, message): # -> None:
- ...
-
-
-
-def strip_eol(line):
- ...
-
-class tail_logger:
- """Keep track of the last <size> log messages"""
- def __init__(self, logger, size=...) -> None:
- ...
-
- def log(self, message): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-RCS_ID = ...
-class simple_producer:
- """producer for a string"""
- def __init__(self, data, buffer_size=...) -> None:
- ...
-
- def more(self): # -> bytes | Unknown:
- ...
-
-
-
-class scanning_producer:
- """like simple_producer, but more efficient for large strings"""
- def __init__(self, data, buffer_size=...) -> None:
- ...
-
- def more(self): # -> Literal[b'']:
- ...
-
-
-
-class lines_producer:
- """producer for a list of lines"""
- def __init__(self, lines) -> None:
- ...
-
- def more(self): # -> str:
- ...
-
-
-
-class buffer_list_producer:
- """producer for a list of strings"""
- def __init__(self, buffers) -> None:
- ...
-
- def more(self): # -> Literal[b'']:
- ...
-
-
-
-class file_producer:
- """producer wrapper for file[-like] objects"""
- out_buffer_size = ...
- def __init__(self, file) -> None:
- ...
-
- def more(self): # -> Literal[b'']:
- ...
-
-
-
-class output_producer:
- """Acts like an output file; suitable for capturing sys.stdout"""
- def __init__(self) -> None:
- ...
-
- def write(self, data): # -> None:
- ...
-
- def writeline(self, line): # -> None:
- ...
-
- def writelines(self, lines): # -> None:
- ...
-
- def flush(self): # -> None:
- ...
-
- def softspace(self, *args): # -> None:
- ...
-
- def more(self): # -> bytes | Literal['']:
- ...
-
-
-
-class composite_producer:
- """combine a fifo of producers into one"""
- def __init__(self, producers) -> None:
- ...
-
- def more(self): # -> Literal[b'']:
- ...
-
-
-
-class globbing_producer:
- """
- 'glob' the output from a producer into a particular buffer size.
- helps reduce the number of calls to send(). [this appears to
- gain about 30% performance on requests to a single channel]
- """
- def __init__(self, producer, buffer_size=...) -> None:
- ...
-
- def more(self): # -> bytes:
- ...
-
-
-
-class hooked_producer:
- """
- A producer that will call <function> when it empties,.
- with an argument of the number of bytes produced. Useful
- for logging/instrumentation purposes.
- """
- def __init__(self, producer, function) -> None:
- ...
-
- def more(self): # -> Literal['']:
- ...
-
-
-
-class chunked_producer:
- """A producer that implements the 'chunked' transfer coding for HTTP/1.1.
- Here is a sample usage:
- request['Transfer-Encoding'] = 'chunked'
- request.push (
- producers.chunked_producer (your_producer)
- )
- request.done()
- """
- def __init__(self, producer, footers=...) -> None:
- ...
-
- def more(self): # -> bytes:
- ...
-
-
-
-class compressed_producer:
- """
- Compress another producer on-the-fly, using ZLIB
- """
- def __init__(self, producer, level=...) -> None:
- ...
-
- def more(self): # -> bytes:
- ...
-
-
-
-class escaping_producer:
- """A producer that escapes a sequence of characters"""
- def __init__(self, producer, esc_from=..., esc_to=...) -> None:
- ...
-
- def more(self):
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-def html_repr(object): # -> str:
- ...
-
-def progressive_divide(n, parts): # -> list[Unknown]:
- ...
-
-def split_by_units(n, units, dividers, format_string): # -> list[Unknown]:
- ...
-
-def english_bytes(n): # -> list[str]:
- ...
-
-def english_time(n): # -> list[str]:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-VERSION = ...
-class xmlrpc_handler:
- def match(self, request): # -> Literal[1, 0]:
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
- def continue_request(self, data, request): # -> None:
- ...
-
- def call(self, method, params): # -> NoReturn:
- ...
-
-
-
-class collector:
- """gathers input for POST and PUT requests"""
- def __init__(self, handler, request) -> None:
- ...
-
- def collect_incoming_data(self, data): # -> None:
- ...
-
- def found_terminator(self): # -> None:
- ...
-
-
-
-if __name__ == '__main__':
- class rpc_demo(xmlrpc_handler):
- def call(self, method, params): # -> Literal['Sure, that works']:
- ...
-
-
-
- hs = ...
- rpc = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import warnings
-
-from supervisor.compat import ConfigParser
-
-VERSION = ...
-def normalize_path(v):
- ...
-
-class Dummy:
- ...
-
-
-class Options:
- stderr = ...
- stdout = ...
- exit = ...
- warnings = warnings
- uid = ...
- progname = ...
- configfile = ...
- schemadir = ...
- configroot = ...
- here = ...
- positional_args_allowed = ...
- def __init__(self, require_configfile=...) -> None:
- """Constructor.
-
- Params:
- require_configfile -- whether we should fail on no config file.
- """
- ...
-
- def default_configfile(self): # -> str | None:
- """Return the name of the found config file or print usage/exit."""
- ...
-
- def help(self, dummy): # -> None:
- """Print a long help message to stdout and exit(0).
-
- Occurrences of "%s" in are replaced by self.progname.
- """
- ...
-
- def usage(self, msg): # -> None:
- """Print a brief error message to stderr and exit(2)."""
- ...
-
- def add(self, name=..., confname=..., short=..., long=..., handler=..., default=..., required=..., flag=..., env=...): # -> None:
- """Add information about a configuration option.
-
- This can take several forms:
-
- add(name, confname)
- Configuration option 'confname' maps to attribute 'name'
- add(name, None, short, long)
- Command line option '-short' or '--long' maps to 'name'
- add(None, None, short, long, handler)
- Command line option calls handler
- add(name, None, short, long, handler)
- Assign handler return value to attribute 'name'
-
- In addition, one of the following keyword arguments may be given:
-
- default=... -- if not None, the default value
- required=... -- if nonempty, an error message if no value provided
- flag=... -- if not None, flag value for command line option
- env=... -- if not None, name of environment variable that
- overrides the configuration file or default
- """
- ...
-
- def realize(self, args=..., doc=..., progname=...): # -> None:
- """Realize a configuration.
-
- Optional arguments:
-
- args -- the command line arguments, less the program name
- (default is sys.argv[1:])
-
- doc -- usage message (default is __main__.__doc__)
- """
- ...
-
- def process_config(self, do_usage=...): # -> None:
- """Process configuration data structure.
-
- This includes reading config file if necessary, setting defaults etc.
- """
- ...
-
- def process_config_file(self, do_usage): # -> None:
- ...
-
- def exists(self, path): # -> bool:
- ...
-
- def open(self, fn, mode=...): # -> TextIOWrapper:
- ...
-
- def get_plugins(self, parser, factory_key, section_prefix): # -> list[Unknown]:
- ...
-
- def import_spec(self, spec): # -> Any:
- ...
-
-
-
-class ServerOptions(Options):
- user = ...
- sockchown = ...
- sockchmod = ...
- logfile = ...
- loglevel = ...
- pidfile = ...
- passwdfile = ...
- nodaemon = ...
- silent = ...
- httpservers = ...
- unlink_pidfile = ...
- unlink_socketfiles = ...
- mood = ...
- def __init__(self) -> None:
- ...
-
- def version(self, dummy): # -> None:
- """Print version to stdout and exit(0).
- """
- ...
-
- def getLogger(self, *args, **kwargs): # -> Logger:
- ...
-
- def default_configfile(self): # -> str | None:
- ...
-
- def realize(self, *arg, **kw): # -> None:
- ...
-
- def process_config(self, do_usage=...): # -> None:
- ...
-
- def read_config(self, fp):
- ...
-
- def process_groups_from_parser(self, parser): # -> list[Unknown]:
- ...
-
- def parse_fcgi_socket(self, sock, proc_uid, socket_owner, socket_mode, socket_backlog): # -> UnixStreamSocketConfig | InetStreamSocketConfig:
- ...
-
- def processes_from_section(self, parser, section, group_name, klass=...): # -> list[Unknown]:
- ...
-
- def server_configs_from_parser(self, parser): # -> list[Unknown]:
- ...
-
- def daemonize(self): # -> None:
- ...
-
- def write_pidfile(self): # -> None:
- ...
-
- def cleanup(self): # -> None:
- ...
-
- def close_httpservers(self): # -> None:
- ...
-
- def close_logger(self): # -> None:
- ...
-
- def setsignals(self): # -> None:
- ...
-
- def get_signal(self): # -> None:
- ...
-
- def openhttpservers(self, supervisord): # -> None:
- ...
-
- def get_autochildlog_name(self, name, identifier, channel):
- ...
-
- def clear_autochildlogdir(self): # -> None:
- ...
-
- def get_socket_map(self): # -> dict[Unknown, Unknown]:
- ...
-
- def cleanup_fds(self): # -> None:
- ...
-
- def kill(self, pid, signal): # -> None:
- ...
-
- def waitpid(self): # -> tuple[int | None, int | None]:
- ...
-
- def drop_privileges(self, user): # -> str | None:
- """Drop privileges to become the specified user, which may be a
- username or uid. Called for supervisord startup and when spawning
- subprocesses. Returns None on success or a string error message if
- privileges could not be dropped."""
- ...
-
- def set_uid_or_exit(self): # -> None:
- """Set the uid of the supervisord process. Called during supervisord
- startup only. No return value. Exits the process via usage() if
- privileges could not be dropped."""
- ...
-
- def set_rlimits_or_exit(self): # -> None:
- """Set the rlimits of the supervisord process. Called during
- supervisord startup only. No return value. Exits the process via
- usage() if any rlimits could not be set."""
- ...
-
- def make_logger(self): # -> None:
- ...
-
- def make_http_servers(self, supervisord): # -> list[Unknown]:
- ...
-
- def close_fd(self, fd): # -> None:
- ...
-
- def fork(self): # -> int:
- ...
-
- def dup2(self, frm, to): # -> None:
- ...
-
- def setpgrp(self): # -> None:
- ...
-
- def stat(self, filename): # -> stat_result:
- ...
-
- def write(self, fd, data): # -> int:
- ...
-
- def execve(self, filename, argv, env): # -> NoReturn:
- ...
-
- def mktempfile(self, suffix, prefix, dir):
- ...
-
- def remove(self, path): # -> None:
- ...
-
- def setumask(self, mask): # -> None:
- ...
-
- def get_path(self): # -> List[str]:
- """Return a list corresponding to $PATH, or a default."""
- ...
-
- def get_pid(self): # -> int:
- ...
-
- def check_execv_args(self, filename, argv, st): # -> None:
- ...
-
- def reopenlogs(self): # -> None:
- ...
-
- def readfd(self, fd): # -> bytes:
- ...
-
- def chdir(self, dir): # -> None:
- ...
-
- def make_pipes(self, stderr=...): # -> dict[str, None]:
- """ Create pipes for parent to child stdin/stdout/stderr
- communications. Open fd in non-blocking mode so we can read them
- in the mainloop without blocking. If stderr is False, don't
- create a pipe for stderr. """
- ...
-
- def close_parent_pipes(self, pipes): # -> None:
- ...
-
- def close_child_pipes(self, pipes): # -> None:
- ...
-
-
-
-class ClientOptions(Options):
- positional_args_allowed = ...
- interactive = ...
- prompt = ...
- serverurl = ...
- username = ...
- password = ...
- history_file = ...
- def __init__(self) -> None:
- ...
-
- def realize(self, *arg, **kw): # -> None:
- ...
-
- def read_config(self, fp):
- ...
-
- def getServerProxy(self):
- ...
-
-
-
-_marker = ...
-class UnhosedConfigParser(ConfigParser.RawConfigParser):
- mysection = ...
- def __init__(self, *args, **kwargs) -> None:
- ...
-
- def read_string(self, string, source=...): # -> None:
- '''Parse configuration data from a string. This is intended
- to be used in tests only. We add this method for Py 2/3 compat.'''
- ...
-
- def read(self, filenames, **kwargs): # -> list[Unknown]:
- '''Attempt to read and parse a list of filenames, returning a list
- of filenames which were successfully parsed. This is a method of
- RawConfigParser that is overridden to build self.section_to_file,
- which is a mapping of section names to the files they came from.
- '''
- ...
-
- def saneget(self, section, option, default=..., do_expand=..., expansions=...): # -> str:
- ...
-
- def getdefault(self, option, default=..., expansions=..., **kwargs): # -> str:
- ...
-
- def expand_here(self, here): # -> None:
- ...
-
-
-
-class Config:
- def __ne__(self, other) -> bool:
- ...
-
- def __lt__(self, other) -> bool:
- ...
-
- def __le__(self, other) -> bool:
- ...
-
- def __gt__(self, other) -> bool:
- ...
-
- def __ge__(self, other) -> bool:
- ...
-
- def __repr__(self): # -> str:
- ...
-
-
-
-class ProcessConfig(Config):
- req_param_names = ...
- optional_param_names = ...
- def __init__(self, options, **params) -> None:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def get_path(self):
- '''Return a list corresponding to $PATH that is configured to be set
- in the process environment, or the system default.'''
- ...
-
- def create_autochildlogs(self): # -> None:
- ...
-
- def make_process(self, group=...): # -> Subprocess:
- ...
-
- def make_dispatchers(self, proc): # -> tuple[dict[Unknown, Unknown], Unknown]:
- ...
-
-
-
-class EventListenerConfig(ProcessConfig):
- def make_dispatchers(self, proc): # -> tuple[dict[Unknown, Unknown], Unknown]:
- ...
-
-
-
-class FastCGIProcessConfig(ProcessConfig):
- def make_process(self, group=...): # -> FastCGISubprocess:
- ...
-
- def make_dispatchers(self, proc): # -> tuple[dict[Unknown, Unknown], Unknown]:
- ...
-
-
-
-class ProcessGroupConfig(Config):
- def __init__(self, options, name, priority, process_configs) -> None:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def after_setuid(self): # -> None:
- ...
-
- def make_group(self): # -> ProcessGroup:
- ...
-
-
-
-class EventListenerPoolConfig(Config):
- def __init__(self, options, name, priority, process_configs, buffer_size, pool_events, result_handler) -> None:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def after_setuid(self): # -> None:
- ...
-
- def make_group(self): # -> EventListenerPool:
- ...
-
-
-
-class FastCGIGroupConfig(ProcessGroupConfig):
- def __init__(self, options, name, priority, process_configs, socket_config) -> None:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def make_group(self): # -> FastCGIProcessGroup:
- ...
-
-
-
-def readFile(filename, offset, length): # -> bytes:
- """ Read length bytes from the file named by filename starting at
- offset """
- ...
-
-def tailFile(filename, offset, length): # -> list[str | int | bool] | list[str | Unknown | bool]:
- """
- Read length bytes from the file named by filename starting at
- offset, automatically increasing offset and setting overflow
- flag if log size has grown beyond (offset + length). If length
- bytes are not available, as many bytes as are available are returned.
- """
- ...
-
-def decode_wait_status(sts): # -> tuple[int, str] | tuple[Literal[-1], Unknown | str] | tuple[Literal[-1], Unknown]:
- """Decode the status returned by wait() or waitpid().
-
- Return a tuple (exitstatus, message) where exitstatus is the exit
- status, or -1 if the process was killed by a signal; and message
- is a message telling what happened. It is the caller's
- responsibility to display the message.
- """
- ...
-
-_signames = ...
-def signame(sig):
- """Return a symbolic name for a signal.
-
- Return "signal NNN" if there is no corresponding SIG name in the
- signal module.
- """
- ...
-
-class SignalReceiver:
- def __init__(self) -> None:
- ...
-
- def receive(self, sig, frame): # -> None:
- ...
-
- def get_signal(self): # -> None:
- ...
-
-
-
-def expand(s, expansions, name):
- ...
-
-def make_namespec(group_name, process_name): # -> str:
- ...
-
-def split_namespec(namespec): # -> tuple[Unknown, Unknown | None]:
- ...
-
-class ProcessException(Exception):
- """ Specialized exceptions used when attempting to start a process """
- ...
-
-
-class BadCommand(ProcessException):
- """ Indicates the command could not be parsed properly. """
- ...
-
-
-class NotExecutable(ProcessException):
- """ Indicates that the filespec cannot be executed because its path
- resolves to a file which is not executable, or which is a directory. """
- ...
-
-
-class NotFound(ProcessException):
- """ Indicates that the filespec cannot be executed because it could not
- be found """
- ...
-
-
-class NoPermission(ProcessException):
- """ Indicates that the file cannot be executed because the supervisor
- process does not possess the appropriate UNIX filesystem permission
- to execute the file. """
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-""" An executable which proxies for a subprocess; upon a signal, it sends that
-signal to the process identified by a pidfile. """
-class PidProxy:
- pid = ...
- def __init__(self, args) -> None:
- ...
-
- def go(self): # -> None:
- ...
-
- def usage(self): # -> None:
- ...
-
- def setsignals(self): # -> None:
- ...
-
- def reap(self, sig, frame): # -> None:
- ...
-
- def passtochild(self, sig, frame): # -> None:
- ...
-
-
-
-def main(): # -> None:
- ...
-
-if __name__ == '__main__':
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-class BasePoller:
- def __init__(self, options) -> None:
- ...
-
- def initialize(self): # -> None:
- ...
-
- def register_readable(self, fd):
- ...
-
- def register_writable(self, fd):
- ...
-
- def unregister_readable(self, fd):
- ...
-
- def unregister_writable(self, fd):
- ...
-
- def poll(self, timeout):
- ...
-
- def before_daemonize(self): # -> None:
- ...
-
- def after_daemonize(self): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
-
-
-class SelectPoller(BasePoller):
- def initialize(self): # -> None:
- ...
-
- def register_readable(self, fd): # -> None:
- ...
-
- def register_writable(self, fd): # -> None:
- ...
-
- def unregister_readable(self, fd): # -> None:
- ...
-
- def unregister_writable(self, fd): # -> None:
- ...
-
- def unregister_all(self): # -> None:
- ...
-
- def poll(self, timeout): # -> tuple[list[Unknown], list[Unknown]] | tuple[List[Any], List[Any]]:
- ...
-
-
-
-class PollPoller(BasePoller):
- def initialize(self): # -> None:
- ...
-
- def register_readable(self, fd): # -> None:
- ...
-
- def register_writable(self, fd): # -> None:
- ...
-
- def unregister_readable(self, fd): # -> None:
- ...
-
- def unregister_writable(self, fd): # -> None:
- ...
-
- def poll(self, timeout): # -> tuple[list[Unknown], list[Unknown]]:
- ...
-
-
-
-class KQueuePoller(BasePoller):
- '''
- Wrapper for select.kqueue()/kevent()
- '''
- max_events = ...
- def initialize(self): # -> None:
- ...
-
- def register_readable(self, fd): # -> None:
- ...
-
- def register_writable(self, fd): # -> None:
- ...
-
- def unregister_readable(self, fd): # -> None:
- ...
-
- def unregister_writable(self, fd): # -> None:
- ...
-
- def poll(self, timeout): # -> tuple[list[Unknown], list[Unknown]]:
- ...
-
- def before_daemonize(self): # -> None:
- ...
-
- def after_daemonize(self): # -> None:
- ...
-
- def close(self): # -> None:
- ...
-
-
-
-def implements_poll(): # -> bool:
- ...
-
-def implements_kqueue(): # -> bool:
- ...
-
-if implements_kqueue():
- Poller = ...
-else:
- Poller = ...
- Poller = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import functools
-
-@functools.total_ordering
-class Subprocess:
- """A class to manage a subprocess."""
- pid = ...
- config = ...
- state = ...
- listener_state = ...
- event = ...
- laststart = ...
- laststop = ...
- laststopreport = ...
- delay = ...
- administrative_stop = ...
- system_stop = ...
- killing = ...
- backoff = ...
- dispatchers = ...
- pipes = ...
- exitstatus = ...
- spawnerr = ...
- group = ...
- def __init__(self, config) -> None:
- """Constructor.
-
- Argument is a ProcessConfig instance.
- """
- ...
-
- def removelogs(self): # -> None:
- ...
-
- def reopenlogs(self): # -> None:
- ...
-
- def drain(self): # -> None:
- ...
-
- def write(self, chars): # -> None:
- ...
-
- def get_execv_args(self): # -> tuple[str | None, List[str]]:
- """Internal: turn a program name into a file name, using $PATH,
- make sure it exists / is executable, raising a ProcessException
- if not """
- ...
-
- event_map = ...
- def change_state(self, new_state, expected=...): # -> Literal[False] | None:
- ...
-
- def record_spawnerr(self, msg): # -> None:
- ...
-
- def spawn(self): # -> None:
- """Start the subprocess. It must not be running already.
-
- Return the process id. If the fork() call fails, return None.
- """
- ...
-
- def stop(self): # -> str | None:
- """ Administrative stop """
- ...
-
- def stop_report(self): # -> None:
- """ Log a 'waiting for x to stop' message with throttling. """
- ...
-
- def give_up(self): # -> None:
- ...
-
- def kill(self, sig): # -> str | None:
- """Send a signal to the subprocess with the intention to kill
- it (to make it exit). This may or may not actually kill it.
-
- Return None if the signal was sent, or an error message string
- if an error occurred or if the subprocess is not running.
- """
- ...
-
- def signal(self, sig): # -> str | None:
- """Send a signal to the subprocess, without intending to kill it.
-
- Return None if the signal was sent, or an error message string
- if an error occurred or if the subprocess is not running.
- """
- ...
-
- def finish(self, pid, sts): # -> None:
- """ The process was reaped and we need to report and manage its state
- """
- ...
-
- def set_uid(self): # -> None:
- ...
-
- def __lt__(self, other) -> bool:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def get_state(self): # -> int | None:
- ...
-
- def transition(self): # -> None:
- ...
-
-
-
-class FastCGISubprocess(Subprocess):
- """Extends Subprocess class to handle FastCGI subprocesses"""
- def __init__(self, config) -> None:
- ...
-
- def before_spawn(self): # -> None:
- """
- The FastCGI socket needs to be created by the parent before we fork
- """
- ...
-
- def spawn(self): # -> None:
- """
- Overrides Subprocess.spawn() so we can hook in before it happens
- """
- ...
-
- def after_finish(self): # -> None:
- """
- Releases reference to FastCGI socket when process is reaped
- """
- ...
-
- def finish(self, pid, sts): # -> None:
- """
- Overrides Subprocess.finish() so we can hook in after it happens
- """
- ...
-
-
-
-@functools.total_ordering
-class ProcessGroupBase:
- def __init__(self, config) -> None:
- ...
-
- def __lt__(self, other) -> bool:
- ...
-
- def __eq__(self, other) -> bool:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def removelogs(self): # -> None:
- ...
-
- def reopenlogs(self): # -> None:
- ...
-
- def stop_all(self): # -> None:
- ...
-
- def get_unstopped_processes(self): # -> list[Unknown]:
- """ Processes which aren't in a state that is considered 'stopped' """
- ...
-
- def get_dispatchers(self): # -> dict[Unknown, Unknown]:
- ...
-
- def before_remove(self): # -> None:
- ...
-
-
-
-class ProcessGroup(ProcessGroupBase):
- def transition(self): # -> None:
- ...
-
-
-
-class FastCGIProcessGroup(ProcessGroup):
- def __init__(self, config, **kwargs) -> None:
- ...
-
-
-
-class EventListenerPool(ProcessGroupBase):
- def __init__(self, config) -> None:
- ...
-
- def handle_rejected(self, event): # -> None:
- ...
-
- def transition(self): # -> None:
- ...
-
- def before_remove(self): # -> None:
- ...
-
- def dispatch(self): # -> None:
- ...
-
-
-
-class GlobalSerial:
- def __init__(self) -> None:
- ...
-
-
-
-GlobalSerial = ...
-def new_serial(inst):
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-API_VERSION = ...
-class SupervisorNamespaceRPCInterface:
- def __init__(self, supervisord) -> None:
- ...
-
- def getAPIVersion(self): # -> Literal['3.0']:
- """ Return the version of the RPC API used by supervisord
-
- @return string version version id
- """
- ...
-
- getVersion = ...
- def getSupervisorVersion(self): # -> str:
- """ Return the version of the supervisor package in use by supervisord
-
- @return string version version id
- """
- ...
-
- def getIdentification(self):
- """ Return identifying string of supervisord
-
- @return string identifier identifying string
- """
- ...
-
- def getState(self): # -> dict[str, Unknown | None]:
- """ Return current state of supervisord as a struct
-
- @return struct A struct with keys int statecode, string statename
- """
- ...
-
- def getPID(self):
- """ Return the PID of supervisord
-
- @return int PID
- """
- ...
-
- def readLog(self, offset, length): # -> str:
- """ Read length bytes from the main log starting at offset
-
- @param int offset offset to start reading from.
- @param int length number of bytes to read from the log.
- @return string result Bytes of log
- """
- ...
-
- readMainLog = ...
- def clearLog(self): # -> Literal[True]:
- """ Clear the main log.
-
- @return boolean result always returns True unless error
- """
- ...
-
- def shutdown(self): # -> Literal[True]:
- """ Shut down the supervisor process
-
- @return boolean result always returns True unless error
- """
- ...
-
- def restart(self): # -> Literal[True]:
- """ Restart the supervisor process
-
- @return boolean result always return True unless error
- """
- ...
-
- def reloadConfig(self): # -> list[list[list[Unknown]]]:
- """
- Reload the configuration.
-
- The result contains three arrays containing names of process
- groups:
-
- * `added` gives the process groups that have been added
- * `changed` gives the process groups whose contents have
- changed
- * `removed` gives the process groups that are no longer
- in the configuration
-
- @return array result [[added, changed, removed]]
-
- """
- ...
-
- def addProcessGroup(self, name): # -> Literal[True]:
- """ Update the config for a running process from config file.
-
- @param string name name of process group to add
- @return boolean result true if successful
- """
- ...
-
- def removeProcessGroup(self, name): # -> Literal[True]:
- """ Remove a stopped process from the active configuration.
-
- @param string name name of process group to remove
- @return boolean result Indicates whether the removal was successful
- """
- ...
-
- def startProcess(self, name, wait=...): # -> () -> (Type[NOT_DONE_YET] | Literal[True]) | Literal[True]:
- """ Start a process
-
- @param string name Process name (or ``group:name``, or ``group:*``)
- @param boolean wait Wait for process to be fully started
- @return boolean result Always true unless error
-
- """
- ...
-
- def startProcessGroup(self, name, wait=...): # -> (processes: Unknown = processes, predicate: Unknown = predicate, func: Unknown = func, extra_kwargs: Unknown = extra_kwargs, callbacks: Unknown = callbacks, results: Unknown = results) -> (Unknown | Type[NOT_DONE_YET]):
- """ Start all processes in the group named 'name'
-
- @param string name The group name
- @param boolean wait Wait for each process to be fully started
- @return array result An array of process status info structs
- """
- ...
-
- def startAllProcesses(self, wait=...): # -> (processes: Unknown = processes, predicate: Unknown = predicate, func: Unknown = func, extra_kwargs: Unknown = extra_kwargs, callbacks: Unknown = callbacks, results: Unknown = results) -> (Unknown | Type[NOT_DONE_YET]):
- """ Start all processes listed in the configuration file
-
- @param boolean wait Wait for each process to be fully started
- @return array result An array of process status info structs
- """
- ...
-
- def stopProcess(self, name, wait=...): # -> () -> (Type[NOT_DONE_YET] | Literal[True]) | Literal[True]:
- """ Stop a process named by name
-
- @param string name The name of the process to stop (or 'group:name')
- @param boolean wait Wait for the process to be fully stopped
- @return boolean result Always return True unless error
- """
- ...
-
- def stopProcessGroup(self, name, wait=...): # -> (processes: Unknown = processes, predicate: Unknown = predicate, func: Unknown = func, extra_kwargs: Unknown = extra_kwargs, callbacks: Unknown = callbacks, results: Unknown = results) -> (Unknown | Type[NOT_DONE_YET]):
- """ Stop all processes in the process group named 'name'
-
- @param string name The group name
- @param boolean wait Wait for each process to be fully stopped
- @return array result An array of process status info structs
- """
- ...
-
- def stopAllProcesses(self, wait=...): # -> (processes: Unknown = processes, predicate: Unknown = predicate, func: Unknown = func, extra_kwargs: Unknown = extra_kwargs, callbacks: Unknown = callbacks, results: Unknown = results) -> (Unknown | Type[NOT_DONE_YET]):
- """ Stop all processes in the process list
-
- @param boolean wait Wait for each process to be fully stopped
- @return array result An array of process status info structs
- """
- ...
-
- def signalProcess(self, name, signal): # -> Literal[True]:
- """ Send an arbitrary UNIX signal to the process named by name
-
- @param string name Name of the process to signal (or 'group:name')
- @param string signal Signal to send, as name ('HUP') or number ('1')
- @return boolean
- """
- ...
-
- def signalProcessGroup(self, name, signal): # -> Type[NOT_DONE_YET] | list[Unknown]:
- """ Send a signal to all processes in the group named 'name'
-
- @param string name The group name
- @param string signal Signal to send, as name ('HUP') or number ('1')
- @return array
- """
- ...
-
- def signalAllProcesses(self, signal): # -> Type[NOT_DONE_YET] | list[Unknown]:
- """ Send a signal to all processes in the process list
-
- @param string signal Signal to send, as name ('HUP') or number ('1')
- @return array An array of process status info structs
- """
- ...
-
- def getAllConfigInfo(self): # -> list[Unknown]:
- """ Get info about all available process configurations. Each struct
- represents a single process (i.e. groups get flattened).
-
- @return array result An array of process config info structs
- """
- ...
-
- def getProcessInfo(self, name): # -> dict[str, Unknown | int | str | None]:
- """ Get info about a process named name
-
- @param string name The name of the process (or 'group:name')
- @return struct result A structure containing data about the process
- """
- ...
-
- def getAllProcessInfo(self): # -> list[Unknown]:
- """ Get info about all processes
-
- @return array result An array of process status results
- """
- ...
-
- def readProcessStdoutLog(self, name, offset, length): # -> str:
- """ Read length bytes from name's stdout log starting at offset
-
- @param string name the name of the process (or 'group:name')
- @param int offset offset to start reading from.
- @param int length number of bytes to read from the log.
- @return string result Bytes of log
- """
- ...
-
- readProcessLog = ...
- def readProcessStderrLog(self, name, offset, length): # -> str:
- """ Read length bytes from name's stderr log starting at offset
-
- @param string name the name of the process (or 'group:name')
- @param int offset offset to start reading from.
- @param int length number of bytes to read from the log.
- @return string result Bytes of log
- """
- ...
-
- def tailProcessStdoutLog(self, name, offset, length): # -> list[str | int | bool]:
- """
- Provides a more efficient way to tail the (stdout) log than
- readProcessStdoutLog(). Use readProcessStdoutLog() to read
- chunks and tailProcessStdoutLog() to tail.
-
- Requests (length) bytes from the (name)'s log, starting at
- (offset). If the total log size is greater than (offset +
- length), the overflow flag is set and the (offset) is
- automatically increased to position the buffer at the end of
- the log. If less than (length) bytes are available, the
- maximum number of available bytes will be returned. (offset)
- returned is always the last offset in the log +1.
-
- @param string name the name of the process (or 'group:name')
- @param int offset offset to start reading from
- @param int length maximum number of bytes to return
- @return array result [string bytes, int offset, bool overflow]
- """
- ...
-
- tailProcessLog = ...
- def tailProcessStderrLog(self, name, offset, length): # -> list[str | int | bool]:
- """
- Provides a more efficient way to tail the (stderr) log than
- readProcessStderrLog(). Use readProcessStderrLog() to read
- chunks and tailProcessStderrLog() to tail.
-
- Requests (length) bytes from the (name)'s log, starting at
- (offset). If the total log size is greater than (offset +
- length), the overflow flag is set and the (offset) is
- automatically increased to position the buffer at the end of
- the log. If less than (length) bytes are available, the
- maximum number of available bytes will be returned. (offset)
- returned is always the last offset in the log +1.
-
- @param string name the name of the process (or 'group:name')
- @param int offset offset to start reading from
- @param int length maximum number of bytes to return
- @return array result [string bytes, int offset, bool overflow]
- """
- ...
-
- def clearProcessLogs(self, name): # -> Literal[True]:
- """ Clear the stdout and stderr logs for the named process and
- reopen them.
-
- @param string name The name of the process (or 'group:name')
- @return boolean result Always True unless error
- """
- ...
-
- clearProcessLog = ...
- def clearAllProcessLogs(self): # -> () -> (Type[NOT_DONE_YET] | list[Unknown]):
- """ Clear all process log files
-
- @return array result An array of process status info structs
- """
- ...
-
- def sendProcessStdin(self, name, chars): # -> Literal[True]:
- """ Send a string of chars to the stdin of the process name.
- If non-7-bit data is sent (unicode), it is encoded to utf-8
- before being sent to the process' stdin. If chars is not a
- string or is not unicode, raise INCORRECT_PARAMETERS. If the
- process is not running, raise NOT_RUNNING. If the process'
- stdin cannot accept input (e.g. it was closed by the child
- process), raise NO_FILE.
-
- @param string name The process name to send to (or 'group:name')
- @param string chars The character data to send to the process
- @return boolean result Always return True unless error
- """
- ...
-
- def sendRemoteCommEvent(self, type, data): # -> Literal[True]:
- """ Send an event that will be received by event listener
- subprocesses subscribing to the RemoteCommunicationEvent.
-
- @param string type String for the "type" key in the event header
- @param string data Data for the event body
- @return boolean Always return True unless error
- """
- ...
-
-
-
-def make_allfunc(processes, predicate, func, **extra_kwargs): # -> (processes: Unknown = processes, predicate: Unknown = predicate, func: Unknown = func, extra_kwargs: Unknown = extra_kwargs, callbacks: Unknown = callbacks, results: Unknown = results) -> (Unknown | Type[NOT_DONE_YET]):
- """ Return a closure representing a function that calls a
- function for every process, and returns a result """
- ...
-
-def isRunning(process): # -> bool:
- ...
-
-def isNotRunning(process): # -> bool:
- ...
-
-def isSignallable(process): # -> Literal[True] | None:
- ...
-
-def make_main_rpcinterface(supervisord): # -> SupervisorNamespaceRPCInterface:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-class Proxy:
- """ Class for wrapping a shared resource object and getting
- notified when it's deleted
- """
- def __init__(self, object, **kwargs) -> None:
- ...
-
- def __del__(self): # -> None:
- ...
-
- def __getattr__(self, name): # -> Any:
- ...
-
-
-
-class ReferenceCounter:
- """ Class for tracking references to a shared resource
- """
- def __init__(self, **kwargs) -> None:
- ...
-
- def get_count(self): # -> int:
- ...
-
- def increment(self): # -> None:
- ...
-
- def decrement(self): # -> None:
- ...
-
-
-
-class SocketManager:
- """ Class for managing sockets in servers that create/bind/listen
- before forking multiple child processes to accept()
- Sockets are managed at the process group level and referenced counted
- at the process level b/c that's really the only place to hook in
- """
- def __init__(self, socket_config, **kwargs) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def config(self): # -> Unknown:
- ...
-
- def is_prepared(self): # -> bool:
- ...
-
- def get_socket(self): # -> Proxy:
- ...
-
- def get_socket_ref_count(self): # -> int:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-class ProcessStates:
- STOPPED = ...
- STARTING = ...
- RUNNING = ...
- BACKOFF = ...
- STOPPING = ...
- EXITED = ...
- FATAL = ...
- UNKNOWN = ...
-
-
-STOPPED_STATES = ...
-RUNNING_STATES = ...
-SIGNALLABLE_STATES = ...
-def getProcessStateDescription(code): # -> None:
- ...
-
-class SupervisorStates:
- FATAL = ...
- RUNNING = ...
- RESTARTING = ...
- SHUTDOWN = ...
-
-
-def getSupervisorStateDescription(code): # -> None:
- ...
-
-class EventListenerStates:
- READY = ...
- BUSY = ...
- ACKNOWLEDGED = ...
- UNKNOWN = ...
-
-
-def getEventListenerStateDescription(code): # -> None:
- ...
-
-_process_states_by_code = ...
-_supervisor_states_by_code = ...
-_eventlistener_states_by_code = ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-import cmd
-import threading
-
-"""supervisorctl -- control applications run by supervisord from the cmd line.
-
-Usage: %s [options] [action [arguments]]
-
-Options:
--c/--configuration FILENAME -- configuration file path (searches if not given)
--h/--help -- print usage message and exit
--i/--interactive -- start an interactive shell after executing commands
--s/--serverurl URL -- URL on which supervisord server is listening
- (default "http://localhost:9001").
--u/--username USERNAME -- username to use for authentication with server
--p/--password PASSWORD -- password to use for authentication with server
--r/--history-file -- keep a readline history (if readline is available)
-
-action [arguments] -- see below
-
-Actions are commands like "tail" or "stop". If -i is specified or no action is
-specified on the command line, a "shell" interpreting actions typed
-interactively is started. Use the action "help" to find out about available
-actions.
-"""
-class LSBInitExitStatuses:
- SUCCESS = ...
- GENERIC = ...
- INVALID_ARGS = ...
- UNIMPLEMENTED_FEATURE = ...
- INSUFFICIENT_PRIVILEGES = ...
- NOT_INSTALLED = ...
- NOT_RUNNING = ...
-
-
-class LSBStatusExitStatuses:
- NOT_RUNNING = ...
- UNKNOWN = ...
-
-
-DEAD_PROGRAM_FAULTS = ...
-class fgthread(threading.Thread):
- """ A subclass of threading.Thread, with a kill() method.
- To be used for foreground output/error streaming.
- http://mail.python.org/pipermail/python-list/2004-May/260937.html
- """
- def __init__(self, program, ctl) -> None:
- ...
-
- def start(self): # -> None:
- ...
-
- def run(self): # -> None:
- ...
-
- def globaltrace(self, frame, why, arg): # -> (frame: Unknown, why: Unknown, arg: Unknown) -> (frame: Unknown, why: Unknown, arg: Unknown) -> Unknown | None:
- ...
-
- def localtrace(self, frame, why, arg): # -> (frame: Unknown, why: Unknown, arg: Unknown) -> Unknown:
- ...
-
- def kill(self): # -> None:
- ...
-
-
-
-class Controller(cmd.Cmd):
- def __init__(self, options, completekey=..., stdin=..., stdout=...) -> None:
- ...
-
- def emptyline(self): # -> None:
- ...
-
- def default(self, line): # -> None:
- ...
-
- def exec_cmdloop(self, args, options): # -> None:
- ...
-
- def set_exitstatus_from_xmlrpc_fault(self, faultcode, ignored_faultcode=...): # -> None:
- ...
-
- def onecmd(self, line): # -> Any | None:
- """ Override the onecmd method to:
- - catch and print all exceptions
- - call 'do_foo' on plugins rather than ourself
- """
- ...
-
- def output(self, message): # -> None:
- ...
-
- def get_supervisor(self): # -> Any:
- ...
-
- def get_server_proxy(self, namespace=...): # -> Any:
- ...
-
- def upcheck(self): # -> bool:
- ...
-
- def complete(self, text, state, line=...): # -> str | None:
- """Completer function that Cmd will register with readline using
- readline.set_completer(). This function will be called by readline
- as complete(text, state) where text is a fragment to complete and
- state is an integer (0..n). Each call returns a string with a new
- completion. When no more are available, None is returned."""
- ...
-
- def do_help(self, arg): # -> None:
- ...
-
- def help_help(self): # -> None:
- ...
-
- def do_EOF(self, arg): # -> Literal[1]:
- ...
-
- def help_EOF(self): # -> None:
- ...
-
-
-
-def get_names(inst): # -> List[Unknown]:
- ...
-
-class ControllerPluginBase:
- name = ...
- def __init__(self, controller) -> None:
- ...
-
- doc_header = ...
- def do_help(self, arg): # -> None:
- ...
-
-
-
-def not_all_langs(): # -> str | None:
- ...
-
-def check_encoding(ctl): # -> None:
- ...
-
-class DefaultControllerPlugin(ControllerPluginBase):
- name = ...
- listener = ...
- def do_tail(self, arg): # -> None:
- ...
-
- def help_tail(self): # -> None:
- ...
-
- def do_maintail(self, arg): # -> None:
- ...
-
- def help_maintail(self): # -> None:
- ...
-
- def do_quit(self, arg):
- ...
-
- def help_quit(self): # -> None:
- ...
-
- do_exit = ...
- def help_exit(self): # -> None:
- ...
-
- def do_status(self, arg): # -> None:
- ...
-
- def help_status(self): # -> None:
- ...
-
- def do_pid(self, arg): # -> None:
- ...
-
- def help_pid(self): # -> None:
- ...
-
- def do_start(self, arg): # -> None:
- ...
-
- def help_start(self): # -> None:
- ...
-
- def do_stop(self, arg): # -> None:
- ...
-
- def help_stop(self): # -> None:
- ...
-
- def do_signal(self, arg): # -> None:
- ...
-
- def help_signal(self): # -> None:
- ...
-
- def do_restart(self, arg): # -> None:
- ...
-
- def help_restart(self): # -> None:
- ...
-
- def do_shutdown(self, arg): # -> None:
- ...
-
- def help_shutdown(self): # -> None:
- ...
-
- def do_reload(self, arg): # -> None:
- ...
-
- def help_reload(self): # -> None:
- ...
-
- def do_avail(self, arg): # -> None:
- ...
-
- def help_avail(self): # -> None:
- ...
-
- def do_reread(self, arg): # -> None:
- ...
-
- def help_reread(self): # -> None:
- ...
-
- def do_add(self, arg): # -> None:
- ...
-
- def help_add(self): # -> None:
- ...
-
- def do_remove(self, arg): # -> None:
- ...
-
- def help_remove(self): # -> None:
- ...
-
- def do_update(self, arg): # -> None:
- ...
-
- def help_update(self): # -> None:
- ...
-
- def do_clear(self, arg): # -> None:
- ...
-
- def help_clear(self): # -> None:
- ...
-
- def do_open(self, arg): # -> None:
- ...
-
- def help_open(self): # -> None:
- ...
-
- def do_version(self, arg): # -> None:
- ...
-
- def help_version(self): # -> None:
- ...
-
- def do_fg(self, arg): # -> None:
- ...
-
- def help_fg(self, args=...): # -> None:
- ...
-
-
-
-def main(args=..., options=...): # -> None:
- ...
-
-if __name__ == "__main__":
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-"""supervisord -- run a set of applications as daemons.
-
-Usage: %s [options]
-
-Options:
--c/--configuration FILENAME -- configuration file path (searches if not given)
--n/--nodaemon -- run in the foreground (same as 'nodaemon=true' in config file)
--s/--silent -- no logs to stdout (maps to 'silent=true' in config file)
--h/--help -- print this usage message and exit
--v/--version -- print supervisord version number and exit
--u/--user USER -- run supervisord as this user (or numeric uid)
--m/--umask UMASK -- use this umask for daemon subprocess (default is 022)
--d/--directory DIRECTORY -- directory to chdir to when daemonized
--l/--logfile FILENAME -- use FILENAME as logfile path
--y/--logfile_maxbytes BYTES -- use BYTES to limit the max size of logfile
--z/--logfile_backups NUM -- number of backups to keep when max bytes reached
--e/--loglevel LEVEL -- use LEVEL as log level (debug,info,warn,error,critical)
--j/--pidfile FILENAME -- write a pid file for the daemon process to FILENAME
--i/--identifier STR -- identifier used for this instance of supervisord
--q/--childlogdir DIRECTORY -- the log directory for child process logs
--k/--nocleanup -- prevent the process from performing cleanup (removal of
- old automatic child log files) at startup.
--a/--minfds NUM -- the minimum number of file descriptors for start success
--t/--strip_ansi -- strip ansi escape codes from process output
---minprocs NUM -- the minimum number of processes available for start success
---profile_options OPTIONS -- run supervisord under profiler and output
- results based on OPTIONS, which is a comma-sep'd
- list of 'cumulative', 'calls', and/or 'callers',
- e.g. 'cumulative,callers')
-"""
-class Supervisor:
- stopping = ...
- lastshutdownreport = ...
- process_groups = ...
- stop_groups = ...
- def __init__(self, options) -> None:
- ...
-
- def main(self): # -> None:
- ...
-
- def run(self): # -> None:
- ...
-
- def diff_to_active(self): # -> tuple[list[Unknown], list[Unknown], list[Unknown]]:
- ...
-
- def add_process_group(self, config): # -> bool:
- ...
-
- def remove_process_group(self, name): # -> bool:
- ...
-
- def get_process_map(self): # -> dict[Unknown, Unknown]:
- ...
-
- def shutdown_report(self): # -> list[Unknown]:
- ...
-
- def ordered_stop_groups_phase_1(self): # -> None:
- ...
-
- def ordered_stop_groups_phase_2(self): # -> None:
- ...
-
- def runforever(self): # -> None:
- ...
-
- def tick(self, now=...): # -> None:
- """ Send one or more 'tick' events when the timeslice related to
- the period for the event type rolls over """
- ...
-
- def reap(self, once=..., recursionguard=...): # -> None:
- ...
-
- def handle_signal(self): # -> None:
- ...
-
- def get_state(self):
- ...
-
-
-
-def timeslice(period, when): # -> int:
- ...
-
-def profile(cmd, globals, locals, sort_order, callers): # -> None:
- ...
-
-def main(args=..., test=...): # -> None:
- ...
-
-def go(options): # -> None:
- ...
-
-if __name__ == "__main__":
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from xml.etree.ElementTree import TreeBuilder
-
-from supervisor.compat import PY2, HTMLParser
-
-AUTOCLOSE = ...
-IGNOREEND = ...
-_BLANK = ...
-_SPACE = ...
-_EQUAL = ...
-_QUOTE = ...
-_OPEN_TAG_START = ...
-_CLOSE_TAG_START = ...
-_OPEN_TAG_END = ...
-_SELF_CLOSE = ...
-_OMITTED_TEXT = ...
-_COMMENT_START = ...
-_COMMENT_END = ...
-_PI_START = ...
-_PI_END = ...
-_AMPER_ESCAPED = ...
-_LT = ...
-_LT_ESCAPED = ...
-_QUOTE_ESCAPED = ...
-_XML_PROLOG_BEGIN = ...
-_ENCODING = ...
-_XML_PROLOG_END = ...
-_DOCTYPE_BEGIN = ...
-_PUBLIC = ...
-_DOCTYPE_END = ...
-if PY2:
- def encode(text, encoding):
- ...
-
-else:
- def encode(text, encoding): # -> bytes:
- ...
-
-def Replace(text, structure=...): # -> _MeldElementInterface:
- ...
-
-class PyHelper:
- def findmeld(self, node, name, default=...):
- ...
-
- def clone(self, node, parent=...): # -> _MeldElementInterface:
- ...
-
- def bfclone(self, node, parent=...): # -> _MeldElementInterface:
- ...
-
- def getiterator(self, node, tag=...): # -> list[Unknown]:
- ...
-
- def content(self, node, text, structure=...): # -> None:
- ...
-
-
-
-helper = ...
-_MELD_NS_URL = ...
-_MELD_PREFIX = ...
-_MELD_LOCAL = ...
-_MELD_ID = ...
-_MELD_SHORT_ID = ...
-_XHTML_NS_URL = ...
-_XHTML_PREFIX = ...
-_XHTML_PREFIX_LEN = ...
-_marker = ...
-class doctype:
- html_strict = ...
- html = ...
- xhtml_strict = ...
- xhtml = ...
-
-
-class _MeldElementInterface:
- parent = ...
- attrib = ...
- text = ...
- tail = ...
- structure = ...
- def __init__(self, tag, attrib) -> None:
- ...
-
- def __repr__(self): # -> str:
- ...
-
- def __len__(self): # -> int:
- ...
-
- def __getitem__(self, index):
- ...
-
- def __getslice__(self, start, stop): # -> List[Unknown]:
- ...
-
- def getchildren(self): # -> list[Unknown]:
- ...
-
- def find(self, path):
- ...
-
- def findtext(self, path, default=...):
- ...
-
- def findall(self, path):
- ...
-
- def clear(self): # -> None:
- ...
-
- def get(self, key, default=...):
- ...
-
- def set(self, key, value): # -> None:
- ...
-
- def keys(self): # -> list[Unknown]:
- ...
-
- def items(self): # -> list[Unknown]:
- ...
-
- def getiterator(self, *ignored_args, **ignored_kw): # -> list[Unknown]:
- ...
-
- def __setitem__(self, index, element): # -> None:
- ...
-
- def __setslice__(self, start, stop, elements): # -> None:
- ...
-
- def append(self, element): # -> None:
- ...
-
- def insert(self, index, element): # -> None:
- ...
-
- def __delitem__(self, index): # -> None:
- ...
-
- def __delslice__(self, start, stop): # -> None:
- ...
-
- def remove(self, element): # -> None:
- ...
-
- def makeelement(self, tag, attrib): # -> _MeldElementInterface:
- ...
-
- def __mod__(self, other): # -> list[Unknown]:
- """ Fill in the text values of meld nodes in tree; only
- support dictionarylike operand (sequence operand doesn't seem
- to make sense here)"""
- ...
-
- def fillmelds(self, **kw): # -> list[Unknown]:
- """ Fill in the text values of meld nodes in tree using the
- keyword arguments passed in; use the keyword keys as meld ids
- and the keyword values as text that should fill in the node
- text on which that meld id is found. Return a list of keys
- from **kw that were not able to be found anywhere in the tree.
- Never raises an exception. """
- ...
-
- def fillmeldhtmlform(self, **kw): # -> list[Unknown]:
- """ Perform magic to 'fill in' HTML form element values from a
- dictionary. Unlike 'fillmelds', the type of element being
- 'filled' is taken into consideration.
-
- Perform a 'findmeld' on each key in the dictionary and use the
- value that corresponds to the key to perform mutation of the
- tree, changing data in what is presumed to be one or more HTML
- form elements according to the following rules::
-
- If the found element is an 'input group' (its meld id ends
- with the string ':inputgroup'), set the 'checked' attribute
- on the appropriate subelement which has a 'value' attribute
- which matches the dictionary value. Also remove the
- 'checked' attribute from every other 'input' subelement of
- the input group. If no input subelement's value matches the
- dictionary value, this key is treated as 'unfilled'.
-
- If the found element is an 'input type=text', 'input
- type=hidden', 'input type=submit', 'input type=password',
- 'input type=reset' or 'input type=file' element, replace its
- 'value' attribute with the value.
-
- If the found element is an 'input type=checkbox' or 'input
- type='radio' element, set its 'checked' attribute to true if
- the dict value is true, or remove its 'checked' attribute if
- the dict value is false.
-
- If the found element is a 'select' element and the value
- exists in the 'value=' attribute of one of its 'option'
- subelements, change that option's 'selected' attribute to
- true and mark all other option elements as unselected. If
- the select element does not contain an option with a value
- that matches the dictionary value, do nothing and return
- this key as unfilled.
-
- If the found element is a 'textarea' or any other kind of
- element, replace its text with the value.
-
- If the element corresponding to the key is not found,
- do nothing and treat the key as 'unfilled'.
-
- Return a list of 'unfilled' keys, representing meld ids
- present in the dictionary but not present in the element tree
- or meld ids which could not be filled due to the lack of any
- matching subelements for 'select' nodes or 'inputgroup' nodes.
- """
- ...
-
- def findmeld(self, name, default=...):
- """ Find a node in the tree that has a 'meld id' corresponding
- to 'name'. Iterate over all subnodes recursively looking for a
- node which matches. If we can't find the node, return None."""
- ...
-
- def findmelds(self): # -> list[Unknown]:
- """ Find all nodes that have a meld id attribute and return
- the found nodes in a list"""
- ...
-
- def findwithattrib(self, attrib, value=...): # -> list[Unknown]:
- """ Find all nodes that have an attribute named 'attrib'. If
- 'value' is not None, omit nodes on which the attribute value
- does not compare equally to 'value'. Return the found nodes in
- a list."""
- ...
-
- def repeat(self, iterable, childname=...): # -> list[Unknown]:
- """repeats an element with values from an iterable. If
- 'childname' is not None, repeat the element on which the
- repeat is called, otherwise find the child element with a
- 'meld:id' matching 'childname' and repeat that. The element
- is repeated within its parent element (nodes that are created
- as a result of a repeat share the same parent). This method
- returns an iterable; the value of each iteration is a
- two-sequence in the form (newelement, data). 'newelement' is
- a clone of the template element (including clones of its
- children) which has already been seated in its parent element
- in the template. 'data' is a value from the passed in
- iterable. Changing 'newelement' (typically based on values
- from 'data') mutates the element 'in place'."""
- ...
-
- def replace(self, text, structure=...): # -> None:
- """ Replace this element with a Replace node in our parent with
- the text 'text' and return the index of our position in
- our parent. If we have no parent, do nothing, and return None.
- Pass the 'structure' flag to the replace node so it can do the right
- thing at render time. """
- ...
-
- def content(self, text, structure=...): # -> None:
- """ Delete this node's children and append a Replace node that
- contains text. Always return None. Pass the 'structure' flag
- to the replace node so it can do the right thing at render
- time."""
- ...
-
- def attributes(self, **kw): # -> None:
- """ Set attributes on this node. """
- ...
-
- def write_xmlstring(self, encoding=..., doctype=..., fragment=..., declaration=..., pipeline=...): # -> bytes:
- ...
-
- def write_xml(self, file, encoding=..., doctype=..., fragment=..., declaration=..., pipeline=...): # -> None:
- """ Write XML to 'file' (which can be a filename or filelike object)
-
- encoding - encoding string (if None, 'utf-8' encoding is assumed)
- Must be a recognizable Python encoding type.
- doctype - 3-tuple indicating name, pubid, system of doctype.
- The default is to prevent a doctype from being emitted.
- fragment - True if a 'fragment' should be emitted for this node (no
- declaration, no doctype). This causes both the
- 'declaration' and 'doctype' parameters to become ignored
- if provided.
- declaration - emit an xml declaration header (including an encoding
- if it's not None). The default is to emit the
- doctype.
- pipeline - preserve 'meld' namespace identifiers in output
- for use in pipelining
- """
- ...
-
- def write_htmlstring(self, encoding=..., doctype=..., fragment=...): # -> bytes:
- ...
-
- def write_html(self, file, encoding=..., doctype=..., fragment=...): # -> None:
- """ Write HTML to 'file' (which can be a filename or filelike object)
-
- encoding - encoding string (if None, 'utf-8' encoding is assumed).
- Unlike XML output, this is not used in a declaration,
- but it is used to do actual character encoding during
- output. Must be a recognizable Python encoding type.
- doctype - 3-tuple indicating name, pubid, system of doctype.
- The default is the value of doctype.html (HTML 4.0
- 'loose')
- fragment - True if a "fragment" should be omitted (no doctype).
- This overrides any provided "doctype" parameter if
- provided.
-
- Namespace'd elements and attributes have their namespaces removed
- during output when writing HTML, so pipelining cannot be performed.
-
- HTML is not valid XML, so an XML declaration header is never emitted.
- """
- ...
-
- def write_xhtmlstring(self, encoding=..., doctype=..., fragment=..., declaration=..., pipeline=...): # -> bytes:
- ...
-
- def write_xhtml(self, file, encoding=..., doctype=..., fragment=..., declaration=..., pipeline=...): # -> None:
- """ Write XHTML to 'file' (which can be a filename or filelike object)
-
- encoding - encoding string (if None, 'utf-8' encoding is assumed)
- Must be a recognizable Python encoding type.
- doctype - 3-tuple indicating name, pubid, system of doctype.
- The default is the value of doctype.xhtml (XHTML
- 'loose').
- fragment - True if a 'fragment' should be emitted for this node (no
- declaration, no doctype). This causes both the
- 'declaration' and 'doctype' parameters to be ignored.
- declaration - emit an xml declaration header (including an encoding
- string if 'encoding' is not None)
- pipeline - preserve 'meld' namespace identifiers in output
- for use in pipelining
- """
- ...
-
- def clone(self, parent=...): # -> _MeldElementInterface:
- """ Create a clone of an element. If parent is not None,
- append the element to the parent. Recurse as necessary to create
- a deep clone of the element. """
- ...
-
- def deparent(self): # -> None:
- """ Remove ourselves from our parent node (de-parent) and return
- the index of the parent which was deleted. """
- ...
-
- def parentindex(self): # -> None:
- """ Return the parent node index in which we live """
- ...
-
- def shortrepr(self, encoding=...): # -> bytes:
- ...
-
- def diffmeld(self, other): # -> dict[str, dict[str, list[Unknown]]]:
- """ Compute the meld element differences from this node (the
- source) to 'other' (the target). Return a dictionary of
- sequences in the form {'unreduced:
- {'added':[], 'removed':[], 'moved':[]},
- 'reduced':
- {'added':[], 'removed':[], 'moved':[]},}
- """
- ...
-
- def meldid(self):
- ...
-
- def lineage(self): # -> list[Unknown]:
- ...
-
-
-
-class MeldTreeBuilder(TreeBuilder):
- def __init__(self) -> None:
- ...
-
- def start(self, tag, attrs): # -> Element:
- ...
-
- def comment(self, data): # -> None:
- ...
-
- def doctype(self, name, pubid, system): # -> None:
- ...
-
-
-
-class HTMLXMLParser(HTMLParser):
- """ A mostly-cut-and-paste of ElementTree's HTMLTreeBuilder that
- does special meld3 things (like preserve comments and munge meld
- ids). Subclassing is not possible due to private attributes. :-("""
- def __init__(self, builder=..., encoding=...) -> None:
- ...
-
- def close(self): # -> Element:
- ...
-
- def handle_starttag(self, tag, attrs): # -> None:
- ...
-
- def handle_endtag(self, tag): # -> None:
- ...
-
- def handle_charref(self, char): # -> None:
- ...
-
- def handle_entityref(self, name): # -> None:
- ...
-
- def handle_data(self, data): # -> None:
- ...
-
- def unknown_entityref(self, name): # -> None:
- ...
-
- def handle_comment(self, data): # -> None:
- ...
-
-
-
-def do_parse(source, parser): # -> Element:
- ...
-
-def parse_xml(source): # -> Element:
- """ Parse source (a filelike object) into an element tree. If
- html is true, use a parser that can resolve somewhat ambiguous
- HTML into XHTML. Otherwise use a 'normal' parser only."""
- ...
-
-def parse_html(source, encoding=...): # -> Element:
- ...
-
-def parse_xmlstring(text): # -> Element:
- ...
-
-def parse_htmlstring(text, encoding=...): # -> Element:
- ...
-
-attrib_needs_escaping = ...
-cdata_needs_escaping = ...
-_HTMLTAGS_UNBALANCED = ...
-_HTMLTAGS_NOESCAPE = ...
-_HTMLATTRS_BOOLEAN = ...
-_NONENTITY_RE = ...
-_XML_DECL_RE = ...
-_BEGIN_TAG_RE = ...
-def insert_doctype(data, doctype=...):
- ...
-
-def insert_meld_ns_decl(data):
- ...
-
-def prefeed(data, doctype=...):
- ...
-
-def sharedlineage(srcelement, tgtelement): # -> bool:
- ...
-
-def diffreduce(elements): # -> list[Unknown]:
- ...
-
-def intersection(S1, S2): # -> list[Unknown]:
- ...
-
-def melditerator(element, meldid=..., _MELD_ID=...): # -> Generator[Unknown, None, None]:
- ...
-
-_NON_ASCII_MIN = ...
-_NON_ASCII_MAX = ...
-_escape_map = ...
-_namespace_map = ...
-_pattern = ...
-def fixtag(tag, namespaces): # -> tuple[str, tuple[str, str | Unknown] | None]:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-class DeferredWebProducer:
- """ A medusa producer that implements a deferred callback; requires
- a subclass of asynchat.async_chat that handles NOT_DONE_YET sentinel """
- CONNECTION = ...
- def __init__(self, request, callback) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | Literal[''] | None:
- ...
-
- def sendresponse(self, response): # -> None:
- ...
-
-
-
-class ViewContext:
- def __init__(self, **kw) -> None:
- ...
-
-
-
-class MeldView:
- content_type = ...
- delay = ...
- def __init__(self, context) -> None:
- ...
-
- def __call__(self): # -> Type[NOT_DONE_YET]:
- ...
-
- def render(self): # -> None:
- ...
-
- def clone(self):
- ...
-
-
-
-class TailView(MeldView):
- def render(self): # -> str:
- ...
-
-
-
-class StatusView(MeldView):
- def actions_for_process(self, process): # -> list[dict[str, str | Unknown | None] | dict[str, str | Unknown]] | list[dict[str, str | Unknown | None] | dict[str, str | Unknown] | None]:
- ...
-
- def css_class_for_state(self, state): # -> Literal['statusrunning', 'statuserror', 'statusnominal']:
- ...
-
- def make_callback(self, namespec, action): # -> () -> str | () -> (Type[NOT_DONE_YET] | str) | () -> Unknown | () -> (str | Type[NOT_DONE_YET] | Unknown) | () -> (Type[NOT_DONE_YET] | Unknown):
- ...
-
- def render(self): # -> Type[NOT_DONE_YET] | str:
- ...
-
-
-
-class OKView:
- delay = ...
- def __init__(self, context) -> None:
- ...
-
- def __call__(self): # -> dict[str, str]:
- ...
-
-
-
-VIEWS = ...
-class supervisor_ui_handler:
- IDENT = ...
- def __init__(self, supervisord) -> None:
- ...
-
- def match(self, request): # -> bool | None:
- ...
-
- def handle_request(self, request): # -> None:
- ...
-
- def continue_request(self, data, request): # -> None:
- ...
+++ /dev/null
-"""
-This type stub file was generated by pyright.
-"""
-
-from supervisor.compat import httplib, xmlrpclib
-from supervisor.medusa.xmlrpc_handler import xmlrpc_handler
-
-class Faults:
- UNKNOWN_METHOD = ...
- INCORRECT_PARAMETERS = ...
- BAD_ARGUMENTS = ...
- SIGNATURE_UNSUPPORTED = ...
- SHUTDOWN_STATE = ...
- BAD_NAME = ...
- BAD_SIGNAL = ...
- NO_FILE = ...
- NOT_EXECUTABLE = ...
- FAILED = ...
- ABNORMAL_TERMINATION = ...
- SPAWN_ERROR = ...
- ALREADY_STARTED = ...
- NOT_RUNNING = ...
- SUCCESS = ...
- ALREADY_ADDED = ...
- STILL_RUNNING = ...
- CANT_REREAD = ...
-
-
-def getFaultDescription(code): # -> str:
- ...
-
-class RPCError(Exception):
- def __init__(self, code, extra=...) -> None:
- ...
-
- def __str__(self) -> str:
- ...
-
-
-
-class DeferredXMLRPCResponse:
- """ A medusa producer that implements a deferred callback; requires
- a subclass of asynchat.async_chat that handles NOT_DONE_YET sentinel """
- CONNECTION = ...
- def __init__(self, request, callback) -> None:
- ...
-
- def more(self): # -> Type[NOT_DONE_YET] | Literal[''] | None:
- ...
-
- def getresponse(self, body): # -> None:
- ...
-
-
-
-def xmlrpc_marshal(value):
- ...
-
-class SystemNamespaceRPCInterface:
- def __init__(self, namespaces) -> None:
- ...
-
- def listMethods(self): # -> list[Unknown]:
- """ Return an array listing the available method names
-
- @return array result An array of method names available (strings).
- """
- ...
-
- def methodHelp(self, name):
- """ Return a string showing the method's documentation
-
- @param string name The name of the method.
- @return string result The documentation for the method name.
- """
- ...
-
- def methodSignature(self, name): # -> List[Unknown]:
- """ Return an array describing the method signature in the
- form [rtype, ptype, ptype...] where rtype is the return data type
- of the method, and ptypes are the parameter data types that the
- method accepts in method argument order.
-
- @param string name The name of the method.
- @return array result The result.
- """
- ...
-
- def multicall(self, calls): # -> (remaining_calls: Unknown = remaining_calls, callbacks: Unknown = callbacks, results: Unknown = results) -> (Type[NOT_DONE_YET] | Unknown) | Type[NOT_DONE_YET] | list[Unknown]:
- """Process an array of calls, and return an array of
- results. Calls should be structs of the form {'methodName':
- string, 'params': array}. Each result will either be a
- single-item array containing the result value, or a struct of
- the form {'faultCode': int, 'faultString': string}. This is
- useful when you need to make lots of small calls without lots
- of round trips.
-
- @param array calls An array of call requests
- @return array result An array of results
- """
- ...
-
-
-
-class AttrDict(dict):
- def __getattr__(self, name): # -> None:
- ...
-
-
-
-class RootRPCInterface:
- def __init__(self, subinterfaces) -> None:
- ...
-
-
-
-def capped_int(value): # -> int:
- ...
-
-def make_datetime(text): # -> datetime:
- ...
-
-class supervisor_xmlrpc_handler(xmlrpc_handler):
- path = ...
- IDENT = ...
- unmarshallers = ...
- def __init__(self, supervisord, subinterfaces) -> None:
- ...
-
- def loads(self, data): # -> tuple[tuple[Any, ...] | None, Any | None]:
- ...
-
- def match(self, request):
- ...
-
- def continue_request(self, data, request): # -> None:
- ...
-
- def call(self, method, params): # -> Any:
- ...
-
-
-
-def traverse(ob, method, params): # -> Any:
- ...
-
-class SupervisorTransport(xmlrpclib.Transport):
- """
- Provides a Transport for xmlrpclib that uses
- httplib.HTTPConnection in order to support persistent
- connections. Also support basic auth and UNIX domain socket
- servers.
- """
- connection = ...
- def __init__(self, username=..., password=..., serverurl=...) -> None:
- ...
-
- def close(self): # -> None:
- ...
-
- def request(self, host, handler, request_body, verbose=...):
- ...
-
-
-
-class UnixStreamHTTPConnection(httplib.HTTPConnection):
- def connect(self): # -> None:
- ...
-
-
-
-def gettags(comment): # -> list[Unknown]:
- """ Parse documentation strings into JavaDoc-like tokens """
- ...
projects / thirdparty / knot-resolver.git / commitdiff
