wandb 0.15.9__py3-none-any.whl → 0.15.11__py3-none-any.whl

wandb/sdk/lib/_settings_toposort_generate.py

@@ -1,22 +1,16 @@
 import inspect
 import sys
-from typing import Any, Dict, List, Optional, Set, Tuple
+from typing import Any, Dict, List, Set, Tuple
 
 from wandb.errors import UsageError
 from wandb.sdk.wandb_settings import Settings
 
 if sys.version_info >= (3, 8):
-    from typing import get_args, get_origin, get_type_hints
+    from typing import get_type_hints
 elif sys.version_info >= (3, 7):
-    from typing_extensions import get_args, get_origin, get_type_hints
+    from typing_extensions import get_type_hints
 else:
 
-    def get_args(obj: Any) -> Optional[Any]:
-        return obj.__args__ if hasattr(obj, "__args__") else None
-
-    def get_origin(obj: Any) -> Optional[Any]:
-        return obj.__origin__ if hasattr(obj, "__origin__") else None
-
     def get_type_hints(obj: Any) -> Dict[str, Any]:
         return dict(obj.__annotations__) if hasattr(obj, "__annotations__") else dict()
 

wandb/sdk/lib/_settings_toposort_generated.py

@@ -22,12 +22,24 @@ _Setting = Literal[
     "_disable_setproctitle",
     "_disable_stats",
     "_disable_viewer",
+    "_disable_machine_info",
     "_except_exit",
     "_executable",
     "_extra_http_headers",
+    "_file_stream_retry_max",
+    "_file_stream_retry_wait_min_seconds",
+    "_file_stream_retry_wait_max_seconds",
     "_file_stream_timeout_seconds",
+    "_file_uploader_retry_max",
+    "_file_uploader_retry_wait_min_seconds",
+    "_file_uploader_retry_wait_max_seconds",
+    "_file_uploader_timeout_seconds",
     "_flow_control_custom",
     "_flow_control_disabled",
+    "_graphql_retry_max",
+    "_graphql_retry_wait_min_seconds",
+    "_graphql_retry_wait_max_seconds",
+    "_graphql_timeout_seconds",
     "_internal_check_process",
     "_internal_queue_timeout",
     "_ipython",
@@ -46,6 +58,7 @@ _Setting = Literal[
     "_sync",
     "_os",
     "_platform",
+    "_proxies",
     "_python",
     "_runqueue_item_id",
     "_require_nexus",
@@ -61,6 +74,7 @@ _Setting = Literal[
     "_stats_neuron_monitor_config_path",
     "_stats_open_metrics_endpoints",
     "_stats_open_metrics_filters",
+    "_stats_disk_paths",
     "_tmp_code_dir",
     "_tracelog",
     "_unsaved_keys",
@@ -71,6 +85,7 @@ _Setting = Literal[
     "azure_account_url_to_access_key",
     "base_url",
     "code_dir",
+    "colab_url",
     "config_paths",
     "console",
     "deployment",
@@ -108,6 +123,7 @@ _Setting = Literal[
     "notebook_name",
     "problem",
     "program",
+    "program_abspath",
     "program_relpath",
     "project",
     "project_url",
@@ -174,6 +190,12 @@ SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
     "start_method",
     "_aws_lambda",
     "_colab",
+    "_disable_machine_info",
+    "_disable_meta",
+    "_disable_stats",
+    "_network_buffer",
+    "_flow_control_disabled",
+    "_flow_control_custom",
     "_ipython",
     "_jupyter",
     "_kaggle",
@@ -181,9 +203,6 @@ SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
     "_notebook",
     "disabled",
     "_offline",
-    "_network_buffer",
-    "_flow_control_disabled",
-    "_flow_control_custom",
     "_stats_neuron_monitor_config_path",
     "run_mode",
     "_start_datetime",
@@ -193,14 +212,19 @@ SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
     "tmp_dir",
     "_tmp_code_dir",
     "_windows",
+    "colab_url",
     "is_local",
     "deployment",
+    "disable_code",
+    "disable_git",
+    "disable_job_creation",
     "files_dir",
     "log_dir",
     "log_internal",
     "log_symlink_internal",
     "log_symlink_user",
     "log_user",
+    "program",
     "project_url",
     "resume_fname",
     "run_url",

wandb/sdk/lib/_wburls_generated.py

@@ -17,4 +17,5 @@ URLS = Literal[
     "multiprocess",
     "wandb_init",
     "wandb_server",
+    "wandb_define_metric",
 ]

wandb/sdk/lib/filenames.py

@@ -1,6 +1,5 @@
-#
 import os
-from typing import Callable, Generator
+from typing import Callable, Generator, Union
 
 WANDB_DIRS = ("wandb", ".wandb")
 
@@ -29,15 +28,37 @@ def is_wandb_file(name: str) -> bool:
 
 
 def filtered_dir(
-    root: str, include_fn: Callable[[str], bool], exclude_fn: Callable[[str], bool]
+    root: str,
+    include_fn: Union[Callable[[str, str], bool], Callable[[str], bool]],
+    exclude_fn: Union[Callable[[str, str], bool], Callable[[str], bool]],
 ) -> Generator[str, None, None]:
     """Simple generator to walk a directory."""
+    import inspect
+
+    # compatibility with old API, which didn't pass root
+    def _include_fn(path: str, root: str) -> bool:
+        return (
+            include_fn(path, root)  # type: ignore
+            if len(inspect.signature(include_fn).parameters) == 2
+            else include_fn(path)  # type: ignore
+        )
+
+    def _exclude_fn(path: str, root: str) -> bool:
+        return (
+            exclude_fn(path, root)  # type: ignore
+            if len(inspect.signature(exclude_fn).parameters) == 2
+            else exclude_fn(path)  # type: ignore
+        )
+
     for dirpath, _, files in os.walk(root):
         for fname in files:
             file_path = os.path.join(dirpath, fname)
-            if include_fn(file_path) and not exclude_fn(file_path):
+            if _include_fn(file_path, root) and not _exclude_fn(file_path, root):
                 yield file_path
 
 
-def exclude_wandb_fn(path: str) -> bool:
-    return any(os.sep + wandb_dir + os.sep in path for wandb_dir in WANDB_DIRS)
+def exclude_wandb_fn(path: str, root: str) -> bool:
+    return any(
+        os.path.relpath(path, root).startswith(wandb_dir + os.sep)
+        for wandb_dir in WANDB_DIRS
+    )

wandb/sdk/lib/filesystem.py

@@ -1,4 +1,6 @@
 import contextlib
+import ctypes
+import errno
 import logging
 import os
 import platform
@@ -8,7 +10,7 @@ import stat
 import tempfile
 import threading
 from pathlib import Path
-from typing import IO, Any, BinaryIO, Generator
+from typing import IO, Any, BinaryIO, Generator, Optional
 
 from wandb.sdk.lib.paths import StrPath
 
@@ -17,6 +19,10 @@ logger = logging.getLogger(__name__)
 WRITE_PERMISSIONS = stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH | stat.S_IWRITE
 
 
+# https://en.wikipedia.org/wiki/Filename#Comparison_of_filename_limitations
+PROBLEMATIC_PATH_CHARS = "".join(chr(i) for i in range(0, 32)) + ':"*<>?|'
+
+
 def mkdir_exists_ok(dir_name: StrPath) -> None:
     """Create `dir_name` and any parent directories if they don't exist.
 
@@ -32,6 +38,53 @@ def mkdir_exists_ok(dir_name: StrPath) -> None:
         raise PermissionError(f"{dir_name!s} is not writable") from e
 
 
+def path_fallbacks(path: StrPath) -> Generator[str, None, None]:
+    """Yield variations of `path` that may exist on the filesystem.
+
+    Return a sequence of paths that should be checked in order for existence or
+    create-ability. Essentially, keep replacing "suspect" characters until we run out.
+    """
+    path = str(path)
+    root, tail = os.path.splitdrive(path)
+    yield os.path.join(root, tail)
+    for char in PROBLEMATIC_PATH_CHARS:
+        if char in tail:
+            tail = tail.replace(char, "-")
+            yield os.path.join(root, tail)
+
+
+def mkdir_allow_fallback(dir_name: StrPath) -> StrPath:
+    """Create `dir_name`, removing invalid path characters if necessary.
+
+    Returns:
+        The path to the created directory, which may not be the original path.
+    """
+    for new_name in path_fallbacks(dir_name):
+        try:
+            os.makedirs(new_name, exist_ok=True)
+            if Path(new_name) != Path(dir_name):
+                logger.warning(f"Creating '{new_name}' instead of '{dir_name}'")
+            return Path(new_name) if isinstance(dir_name, Path) else new_name
+        except (ValueError, NotADirectoryError):
+            pass
+        except OSError as e:
+            if e.errno != 22:
+                raise
+
+    raise OSError(f"Unable to create directory '{dir_name}'")
+
+
+def files_in(path: StrPath) -> Generator[os.DirEntry, None, None]:
+    """Yield a directory entry for each file under a given path (recursive)."""
+    if not os.path.isdir(path):
+        return
+    for entry in os.scandir(path):
+        if entry.is_dir():
+            yield from files_in(entry.path)
+        else:
+            yield entry
+
+
 class WriteSerializingFile:
     """Wrapper for a file object that serializes writes."""
 
@@ -99,11 +152,7 @@ def copy_or_overwrite_changed(source_path: StrPath, target_path: StrPath) -> Str
     """
     return_type = type(target_path)
 
-    if platform.system() == "Windows":
-        head, tail = os.path.splitdrive(str(target_path))
-        if ":" in tail:
-            logger.warning("Replacing ':' in %s with '-'", tail)
-            target_path = os.path.join(head, tail.replace(":", "-"))
+    target_path = system_preferred_path(target_path, warn=True)
 
     need_copy = (
         not os.path.isfile(target_path)
@@ -112,7 +161,8 @@ def copy_or_overwrite_changed(source_path: StrPath, target_path: StrPath) -> Str
 
     permissions_plus_write = os.stat(source_path).st_mode | WRITE_PERMISSIONS
     if need_copy:
-        mkdir_exists_ok(os.path.dirname(target_path))
+        dir_name, file_name = os.path.split(target_path)
+        target_path = os.path.join(mkdir_allow_fallback(dir_name), file_name)
         try:
             # Use copy2 to preserve file metadata (including modified time).
             shutil.copy2(source_path, target_path)
@@ -190,3 +240,127 @@ def safe_copy(source_path: StrPath, target_path: StrPath) -> StrPath:
         shutil.copy2(source_path, tmp_path)
         tmp_path.replace(output_path)
     return target_path
+
+
+def _reflink_linux(existing_path: Path, new_path: Path) -> None:
+    """Create a reflink to `existing_path` at `new_path` on Linux."""
+    import fcntl
+
+    FICLONE = 0x40049409  # magic number from <linux/fs.h>  # noqa: N806
+    with open(existing_path, "rb") as t_f, open(new_path, "wb+") as l_f:
+        fcntl.ioctl(l_f.fileno(), FICLONE, t_f.fileno())
+
+
+def _reflink_macos(existing_path: Path, new_path: Path) -> None:
+    try:
+        clib = ctypes.CDLL("libc.dylib", use_errno=True)
+    except (FileNotFoundError, OSError) as e:
+        if ctypes.get_errno() != errno.ENOENT and not isinstance(e, FileNotFoundError):
+            raise
+        # Before macOS 11 (<Nov 2020) clib was in libSystem.dylib, so we can try there.
+        clib = ctypes.CDLL("/usr/lib/libSystem.dylib", use_errno=True)
+
+    try:
+        clonefile = clib.clonefile
+    except AttributeError:
+        raise OSError(errno.ENOTSUP, "'clonefile' is not available on this system")
+
+    clonefile.argtypes = (ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int)
+    clonefile.restype = ctypes.c_int
+
+    if clonefile(os.fsencode(existing_path), os.fsencode(new_path), ctypes.c_int(0)):
+        # Anything other than 0 is an error.
+        err = ctypes.get_errno()
+        raise OSError(err, os.strerror(err), existing_path)
+
+
+def reflink(existing_path: StrPath, new_path: StrPath, overwrite: bool = False) -> None:
+    """Create a reflink to `existing_path` at `new_path`.
+
+    A reflink (reflective link) is a copy-on-write reference to a file. Once linked, the
+    file and link are both "real" files (not symbolic or hard links) and each can be
+    modified independently without affecting the other; however, they share the same
+    underlying data blocks on disk so until one is modified they are "zero-cost" copies.
+
+    Reflinks have all the functionality of copies, so we should use them wherever they
+    are supported if we would otherwise copy a file. (This is not particularly radical--
+    GNU `cp` defaults to `reflink=auto`, using it whenever available) However, support
+    for them is limited to a small number of filesystems. They should work on:
+    - Linux with a Btrfs or XFS filesystem (NOT ext4)
+    - macOS 10.13 or later with an APFS filesystem (called clone files)
+
+    Reflinks are also supported on Solaris and Windows with ReFSv2, but we haven't
+    implemented support for them.
+
+    Like hard links, a reflink can only be created on the same filesystem as the target.
+    """
+    if platform.system() == "Linux":
+        link_fn = _reflink_linux
+    elif platform.system() == "Darwin":
+        link_fn = _reflink_macos
+    else:
+        raise OSError(
+            errno.ENOTSUP, f"reflinks are not supported on {platform.system()}"
+        )
+
+    new_path = Path(new_path).resolve()
+    existing_path = Path(existing_path).resolve()
+    if new_path.exists():
+        if not overwrite:
+            raise FileExistsError(f"{new_path} already exists")
+        logger.warning(f"Overwriting existing file {new_path}.")
+        new_path.unlink()
+
+    # Create any missing parent directories.
+    new_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        link_fn(existing_path, new_path)
+    except OSError as e:
+        base_msg = f"failed to create reflink from {existing_path} to {new_path}."
+        if e.errno in (errno.EPERM, errno.EACCES):
+            raise PermissionError(f"Insufficient permissions; {base_msg}") from e
+        if e.errno == errno.ENOENT:
+            raise FileNotFoundError(f"File not found; {base_msg}") from e
+        if e.errno == errno.EXDEV:
+            raise ValueError(f"Cannot link across filesystems; {base_msg}") from e
+        if e.errno == errno.EISDIR:
+            raise IsADirectoryError(f"Cannot reflink a directory; {base_msg}") from e
+        if e.errno in (errno.EOPNOTSUPP, errno.ENOTSUP):
+            raise OSError(
+                errno.ENOTSUP,
+                f"Filesystem does not support reflinks; {base_msg}",
+            ) from e
+        if e.errno == errno.EINVAL:
+            raise ValueError(f"Cannot link file ranges; {base_msg}") from e
+        raise
+
+
+def check_exists(path: StrPath) -> Optional[StrPath]:
+    """Look for variations of `path` and return the first found.
+
+    This exists to support former behavior around system-dependent paths; we used to use
+    ':' in Artifact paths unless we were on Windows, but this has issues when e.g. a
+    Linux machine is accessing an NTFS filesystem; we might need to look for the
+    alternate path. This checks all the possible directories we would consider creating.
+    """
+    for dest in path_fallbacks(path):
+        if os.path.exists(dest):
+            return Path(dest) if isinstance(path, Path) else dest
+    return None
+
+
+def system_preferred_path(path: StrPath, warn: bool = False) -> StrPath:
+    """Replace ':' with '-' in paths on Windows.
+
+    Args:
+        path: The path to convert.
+        warn: Whether to warn if ':' is replaced.
+    """
+    if platform.system() != "Windows":
+        return path
+    head, tail = os.path.splitdrive(path)
+    if warn and ":" in tail:
+        logger.warning(f"Replacing ':' in {tail} with '-'")
+    new_path = head + tail.replace(":", "-")
+    return Path(new_path) if isinstance(path, Path) else new_path

wandb/sdk/lib/fsm.py

@@ -9,19 +9,21 @@ Usage:
         def on_output(self, inputs) -> None:
             pass
 
+
     class B:
         def on_output(self, inputs) -> None:
             pass
 
+
     def to_b(inputs) -> bool:
         return True
 
+
     def to_a(inputs) -> bool:
         return True
 
-    f = Fsm(states=[A(), B()],
-            table={A: [(to_b, B)],
-                   B: [(to_a, A)]})
+
+    f = Fsm(states=[A(), B()], table={A: [(to_b, B)], B: [(to_a, A)]})
     f.run({"input1": 1, "input2": 2})
     ```
 """

wandb/sdk/lib/gql_request.py

@@ -20,6 +20,7 @@ class GraphQLSession(HTTPTransport):
         auth: Optional[Union[Tuple[str, str], Callable]] = None,
         use_json: bool = False,
         timeout: Optional[Union[int, float]] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any,
     ) -> None:
         """Setup a session for sending GraphQL queries and mutations.
@@ -32,6 +33,8 @@ class GraphQLSession(HTTPTransport):
         """
         super().__init__(url, **kwargs)
         self.session = requests.Session()
+        if proxies:
+            self.session.proxies.update(proxies)
         self.session.auth = auth
         self.default_timeout = timeout
         self.use_json = use_json

wandb/sdk/lib/ipython.py

@@ -28,6 +28,9 @@ def toggle_button(what="run"):
 
 
 def _get_python_type() -> PythonType:
+    if "IPython" not in sys.modules:
+        return "python"
+
     try:
         from IPython import get_ipython  # type: ignore
 
@@ -42,6 +45,10 @@ def _get_python_type() -> PythonType:
         (get_ipython().config.get("IPKernelApp", {}) or {})
         .get("connection_file", "")
         .lower()
+    ) or (
+        (get_ipython().config.get("ColabKernelApp", {}) or {})
+        .get("connection_file", "")
+        .lower()
     )
 
     if (

wandb/sdk/lib/wburls.py

@@ -33,6 +33,7 @@ class WBURLs:
             multiprocess="http://wandb.me/init-multiprocess",
             wandb_init="https://wandb.me/wandb-init",
             wandb_server="https://wandb.me/wandb-server",
+            wandb_define_metric="https://wandb.me/define-metric",
         )
 
     def get(self, s: "URLS") -> str:

wandb/sdk/service/port_file.py

@@ -6,18 +6,13 @@ from typing import Optional
 
 
 class PortFile:
-    _grpc_port: Optional[int]
     _sock_port: Optional[int]
     _valid: bool
 
-    GRPC_TOKEN = "grpc="
     SOCK_TOKEN = "sock="
     EOF_TOKEN = "EOF"
 
-    def __init__(
-        self, grpc_port: Optional[int] = None, sock_port: Optional[int] = None
-    ) -> None:
-        self._grpc_port = grpc_port
+    def __init__(self, sock_port: Optional[int] = None) -> None:
         self._sock_port = sock_port
         self._valid = False
 
@@ -28,8 +23,6 @@ class PortFile:
             tmp_filename = f.name
             with f:
                 data = []
-                if self._grpc_port:
-                    data.append(f"{self.GRPC_TOKEN}{self._grpc_port}")
                 if self._sock_port:
                     data.append(f"{self.SOCK_TOKEN}{self._sock_port}")
                 data.append(self.EOF_TOKEN)
@@ -47,16 +40,10 @@ class PortFile:
             if lines[-1] != self.EOF_TOKEN:
                 return
             for ln in lines:
-                if ln.startswith(self.GRPC_TOKEN):
-                    self._grpc_port = int(ln[len(self.GRPC_TOKEN) :])
-                elif ln.startswith(self.SOCK_TOKEN):
+                if ln.startswith(self.SOCK_TOKEN):
                     self._sock_port = int(ln[len(self.SOCK_TOKEN) :])
             self._valid = True
 
-    @property
-    def grpc_port(self) -> Optional[int]:
-        return self._grpc_port
-
     @property
     def sock_port(self) -> Optional[int]:
         return self._sock_port

wandb/sdk/service/server.py

@@ -1,12 +1,11 @@
 """wandb server.
 
-Start up grpc or socket transport servers.
+Start up socket transport servers.
 """
 
 import logging
 import os
 import sys
-from concurrent import futures
 from typing import Optional
 
 import wandb
@@ -19,83 +18,39 @@ from .streams import StreamMux
 
 class WandbServer:
     _pid: Optional[int]
-    _grpc_port: Optional[int]
     _sock_port: Optional[int]
     _debug: bool
-    _serve_grpc: bool
     _serve_sock: bool
     _sock_server: Optional[SocketServer]
     _startup_debug_enabled: bool
 
     def __init__(
         self,
-        grpc_port: Optional[int] = None,
         sock_port: Optional[int] = None,
         port_fname: Optional[str] = None,
         address: Optional[str] = None,
         pid: Optional[int] = None,
         debug: bool = True,
-        serve_grpc: bool = False,
         serve_sock: bool = False,
     ) -> None:
-        self._grpc_port = grpc_port
         self._sock_port = sock_port
         self._port_fname = port_fname
         self._address = address
         self._pid = pid
         self._debug = debug
-        self._serve_grpc = serve_grpc
         self._serve_sock = serve_sock
         self._sock_server = None
         self._startup_debug_enabled = _startup_debug.is_enabled()
 
-        if grpc_port:
-            _ = wandb.util.get_module(
-                "grpc",
-                required="grpc port requires the grpcio library, run pip install wandb[grpc]",
-            )
-
         if debug:
             logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
 
-    def _inform_used_ports(
-        self, grpc_port: Optional[int], sock_port: Optional[int]
-    ) -> None:
+    def _inform_used_ports(self, sock_port: Optional[int]) -> None:
         if not self._port_fname:
             return
-        pf = port_file.PortFile(grpc_port=grpc_port, sock_port=sock_port)
+        pf = port_file.PortFile(sock_port=sock_port)
         pf.write(self._port_fname)
 
-    def _start_grpc(self, mux: StreamMux) -> int:
-        import grpc
-
-        from wandb.proto import wandb_server_pb2_grpc as spb_grpc
-
-        from .server_grpc import WandbServicer
-
-        address: str = self._address or "127.0.0.1"
-        port: int = self._grpc_port or 0
-        pid: int = self._pid or 0
-        server = grpc.server(
-            futures.ThreadPoolExecutor(max_workers=10, thread_name_prefix="GrpcPoolThr")
-        )
-        servicer = WandbServicer(server=server, mux=mux)
-        try:
-            spb_grpc.add_InternalServiceServicer_to_server(servicer, server)
-            port = server.add_insecure_port(f"{address}:{port}")
-            mux.set_port(port)
-            mux.set_pid(pid)
-            server.start()
-        except KeyboardInterrupt:
-            mux.cleanup()
-            server.stop(0)
-            raise
-        except Exception:
-            mux.cleanup()
-            server.stop(0)
-            raise
-        return port
-
     def _start_sock(self, mux: StreamMux) -> int:
         address: str = self._address or "127.0.0.1"
         port: int = self._sock_port or 0
@@ -129,9 +84,7 @@ class WandbServer:
             return
         _startup_debug.print_message(message)
 
-    def _setup_proctitle(
-        self, grpc_port: Optional[int], sock_port: Optional[int]
-    ) -> None:
+    def _setup_proctitle(self, sock_port: Optional[int]) -> None:
         # TODO: similar to _setup_tracelog, the internal_process should have
         # a better way to have access to settings.
         disable_setproctitle = os.environ.get("WANDB__DISABLE_SETPROCTITLE")
@@ -143,7 +96,7 @@ class WandbServer:
             service_ver = 2
             pid = str(self._pid or 0)
             transport = "s" if sock_port else "g"
-            port = grpc_port or sock_port or 0
+            port = sock_port or 0
             # this format is similar to wandb_manager token, but it's purely informative now
             # (consider unifying this in the future)
             service_id = f"{service_ver}-{pid}-{transport}-{port}"
@@ -156,12 +109,11 @@ class WandbServer:
         self._setup_tracelog()
         mux = StreamMux()
         self._startup_debug_print("before_network")
-        grpc_port = self._start_grpc(mux=mux) if self._serve_grpc else None
         sock_port = self._start_sock(mux=mux) if self._serve_sock else None
         self._startup_debug_print("after_network")
-        self._inform_used_ports(grpc_port=grpc_port, sock_port=sock_port)
+        self._inform_used_ports(sock_port=sock_port)
         self._startup_debug_print("after_inform")
-        self._setup_proctitle(grpc_port=grpc_port, sock_port=sock_port)
+        self._setup_proctitle(sock_port=sock_port)
         self._startup_debug_print("before_loop")
         mux.loop()
         self._stop_servers()