wandb 0.18.7__py3-none-any.whl → 0.19.0__py3-none-any.whl

wandb/sdk/lib/_settings_toposort_generate.py

@@ -1,159 +0,0 @@
-import inspect
-import sys
-from typing import 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_type_hints
-else:
-    from typing_extensions import get_type_hints
-
-
-template = """
-__all__ = ("SETTINGS_TOPOLOGICALLY_SORTED", "_Setting")
-
-import sys
-from typing import Tuple
-
-if sys.version_info >= (3, 8):
-    from typing import Final, Literal
-else:
-    from typing_extensions import Final, Literal
-
-
-_Setting = Literal[
-    $settings_literal_list
-]
-
-SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
-    $settings_topologically_sorted
-)
-"""
-
-
-class Graph:
-    # A simple class representing an unweighted directed graph
-    # that uses an adjacency list representation.
-    # We use to ensure that we don't have cyclic dependencies in the settings
-    # and that modifications to the settings are applied in the correct order.
-    def __init__(self) -> None:
-        self.adj_list: Dict[str, Set[str]] = {}
-
-    def add_node(self, node: str) -> None:
-        if node not in self.adj_list:
-            self.adj_list[node] = set()
-
-    def add_edge(self, node1: str, node2: str) -> None:
-        self.adj_list[node1].add(node2)
-
-    def get_neighbors(self, node: str) -> Set[str]:
-        return self.adj_list[node]
-
-    # return a list of nodes sorted in topological order
-    def topological_sort_dfs(self) -> List[str]:
-        sorted_copy = {k: sorted(v) for k, v in self.adj_list.items()}
-
-        sorted_nodes: List[str] = []
-        visited_nodes: Set[str] = set()
-        current_nodes: Set[str] = set()
-
-        def visit(n: str) -> None:
-            if n in visited_nodes:
-                return None
-            if n in current_nodes:
-                raise UsageError("Cyclic dependency detected in wandb.Settings")
-
-            current_nodes.add(n)
-            for neighbor in sorted_copy[n]:
-                visit(neighbor)
-
-            current_nodes.remove(n)
-            visited_nodes.add(n)
-            sorted_nodes.append(n)
-
-            return None
-
-        for node in self.adj_list:
-            if node not in visited_nodes:
-                visit(node)
-
-        return sorted_nodes
-
-
-def _get_modification_order(
-    settings: Settings,
-) -> Tuple[Tuple[str, ...], Tuple[str, ...]]:
-    """Return the order in which settings should be modified, based on dependencies."""
-    dependency_graph = Graph()
-
-    props = tuple(get_type_hints(Settings).keys())
-
-    # discover prop dependencies from validator methods and runtime hooks
-
-    prefix = "_validate_"
-    symbols = set(dir(settings))
-    validator_methods = tuple(sorted(m for m in symbols if m.startswith(prefix)))
-
-    # extract dependencies from validator methods
-    for m in validator_methods:
-        setting = m.split(prefix)[1]
-        dependency_graph.add_node(setting)
-        # if the method is not static, inspect its code to find the attributes it depends on
-        if (
-            not isinstance(Settings.__dict__[m], staticmethod)
-            and not isinstance(Settings.__dict__[m], classmethod)
-            and Settings.__dict__[m].__code__.co_argcount > 0
-        ):
-            unbound_closure_vars = inspect.getclosurevars(Settings.__dict__[m]).unbound
-            dependencies = (v for v in unbound_closure_vars if v in props)
-            for d in dependencies:
-                dependency_graph.add_node(d)
-                dependency_graph.add_edge(setting, d)
-
-    # extract dependencies from props' runtime hooks
-    default_props = settings._default_props()
-    for prop, spec in default_props.items():
-        if "hook" not in spec:
-            continue
-
-        dependency_graph.add_node(prop)
-
-        hook = spec["hook"]
-        if callable(hook):
-            hook = [hook]
-
-        for h in hook:
-            unbound_closure_vars = inspect.getclosurevars(h).unbound
-            dependencies = (v for v in unbound_closure_vars if v in props)
-            for d in dependencies:
-                dependency_graph.add_node(d)
-                dependency_graph.add_edge(prop, d)
-
-    modification_order = dependency_graph.topological_sort_dfs()
-    return props, tuple(modification_order)
-
-
-def generate(settings: Settings) -> None:
-    _settings_literal_list, _settings_topologically_sorted = _get_modification_order(
-        settings
-    )
-    settings_literal_list = ", ".join(f'"{s}"' for s in _settings_literal_list)
-    settings_topologically_sorted = ", ".join(
-        f'"{s}"' for s in _settings_topologically_sorted
-    )
-
-    print(
-        template.replace(
-            "$settings_literal_list",
-            settings_literal_list,
-        ).replace(
-            "$settings_topologically_sorted",
-            settings_topologically_sorted,
-        )
-    )
-
-
-if __name__ == "__main__":
-    generate(Settings())

wandb/sdk/lib/_settings_toposort_generated.py

@@ -1,251 +0,0 @@
-# DO NOT EDIT -- GENERATED BY: `generate-tool.py --generate`
-__all__ = ("SETTINGS_TOPOLOGICALLY_SORTED", "_Setting")
-
-import sys
-from typing import Tuple
-
-if sys.version_info >= (3, 8):
-    from typing import Final, Literal
-else:
-    from typing_extensions import Final, Literal
-
-
-_Setting = Literal[
-    "_args",
-    "_aws_lambda",
-    "_cli_only_mode",
-    "_code_path_local",
-    "_colab",
-    "_cuda",
-    "_disable_meta",
-    "_disable_service",
-    "_disable_setproctitle",
-    "_disable_stats",
-    "_disable_update_check",
-    "_disable_viewer",
-    "_disable_machine_info",
-    "_executable",
-    "_extra_http_headers",
-    "_file_stream_max_bytes",
-    "_file_stream_transmit_interval",
-    "_file_stream_retry_max",
-    "_file_stream_retry_wait_min_seconds",
-    "_file_stream_retry_wait_max_seconds",
-    "_file_stream_timeout_seconds",
-    "_file_transfer_retry_max",
-    "_file_transfer_retry_wait_min_seconds",
-    "_file_transfer_retry_wait_max_seconds",
-    "_file_transfer_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",
-    "_jupyter",
-    "_jupyter_name",
-    "_jupyter_path",
-    "_jupyter_root",
-    "_kaggle",
-    "_live_policy_rate_limit",
-    "_live_policy_wait_time",
-    "_log_level",
-    "_network_buffer",
-    "_noop",
-    "_notebook",
-    "_offline",
-    "_sync",
-    "_os",
-    "_platform",
-    "_proxies",
-    "_python",
-    "_runqueue_item_id",
-    "_require_legacy_service",
-    "_save_requirements",
-    "_service_transport",
-    "_service_wait",
-    "_shared",
-    "_start_datetime",
-    "_start_time",
-    "_stats_pid",
-    "_stats_sampling_interval",
-    "_stats_sample_rate_seconds",
-    "_stats_samples_to_average",
-    "_stats_join_assets",
-    "_stats_neuron_monitor_config_path",
-    "_stats_open_metrics_endpoints",
-    "_stats_open_metrics_filters",
-    "_stats_disk_paths",
-    "_stats_buffer_size",
-    "_tmp_code_dir",
-    "_tracelog",
-    "_unsaved_keys",
-    "_windows",
-    "allow_offline_artifacts",
-    "allow_val_change",
-    "anonymous",
-    "api_key",
-    "azure_account_url_to_access_key",
-    "base_url",
-    "code_dir",
-    "colab_url",
-    "config_paths",
-    "console",
-    "console_multipart",
-    "credentials_file",
-    "deployment",
-    "disable_code",
-    "disable_git",
-    "disable_hints",
-    "disable_job_creation",
-    "disabled",
-    "docker",
-    "email",
-    "entity",
-    "files_dir",
-    "force",
-    "fork_from",
-    "resume_from",
-    "git_commit",
-    "git_remote",
-    "git_remote_url",
-    "git_root",
-    "heartbeat_seconds",
-    "host",
-    "http_proxy",
-    "https_proxy",
-    "identity_token_file",
-    "ignore_globs",
-    "init_timeout",
-    "is_local",
-    "job_name",
-    "job_source",
-    "label_disable",
-    "launch",
-    "launch_config_path",
-    "log_dir",
-    "log_internal",
-    "log_symlink_internal",
-    "log_symlink_user",
-    "log_user",
-    "login_timeout",
-    "mode",
-    "notebook_name",
-    "program",
-    "program_abspath",
-    "program_relpath",
-    "project",
-    "project_url",
-    "quiet",
-    "reinit",
-    "relogin",
-    "resume",
-    "resume_fname",
-    "resumed",
-    "root_dir",
-    "run_group",
-    "run_id",
-    "run_job_type",
-    "run_mode",
-    "run_name",
-    "run_notes",
-    "run_tags",
-    "run_url",
-    "sagemaker_disable",
-    "save_code",
-    "settings_system",
-    "settings_workspace",
-    "show_colors",
-    "show_emoji",
-    "show_errors",
-    "show_info",
-    "show_warnings",
-    "silent",
-    "start_method",
-    "strict",
-    "summary_errors",
-    "summary_timeout",
-    "summary_warnings",
-    "sweep_id",
-    "sweep_param_path",
-    "sweep_url",
-    "symlink",
-    "sync_dir",
-    "sync_file",
-    "sync_symlink_latest",
-    "table_raise_on_max_row_limit_exceeded",
-    "timespec",
-    "tmp_dir",
-    "username",
-    "wandb_dir",
-]
-
-SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
-    "_service_wait",
-    "_stats_sample_rate_seconds",
-    "_stats_samples_to_average",
-    "_stats_sampling_interval",
-    "anonymous",
-    "api_key",
-    "base_url",
-    "console",
-    "job_source",
-    "mode",
-    "project",
-    "run_id",
-    "start_method",
-    "_aws_lambda",
-    "program",
-    "_code_path_local",
-    "_colab",
-    "_disable_machine_info",
-    "_disable_meta",
-    "_disable_stats",
-    "_network_buffer",
-    "_flow_control_disabled",
-    "_flow_control_custom",
-    "_ipython",
-    "_jupyter",
-    "_kaggle",
-    "_noop",
-    "_notebook",
-    "disabled",
-    "_offline",
-    "_shared",
-    "_stats_neuron_monitor_config_path",
-    "run_mode",
-    "_start_datetime",
-    "timespec",
-    "root_dir",
-    "wandb_dir",
-    "tmp_dir",
-    "_tmp_code_dir",
-    "_windows",
-    "colab_url",
-    "is_local",
-    "deployment",
-    "disable_code",
-    "disable_git",
-    "disable_job_creation",
-    "files_dir",
-    "_proxies",
-    "http_proxy",
-    "https_proxy",
-    "log_dir",
-    "log_internal",
-    "log_symlink_internal",
-    "log_symlink_user",
-    "log_user",
-    "project_url",
-    "resume_fname",
-    "run_url",
-    "settings_system",
-    "settings_workspace",
-    "sweep_url",
-    "sync_dir",
-    "sync_file",
-    "sync_symlink_latest",
-)

wandb/sdk/lib/reporting.py

@@ -1,99 +0,0 @@
-"""reporting."""
-
-import logging
-
-logger = logging.getLogger("wandb")
-
-
-class _Reporter:
-    def __init__(self, settings):
-        self._settings = settings
-        self._errors = []
-        self._warnings = []
-        self._num_errors = 0
-        self._num_warnings = 0
-        self._context = dict()
-
-    def error(self, __s, *args):
-        pass
-
-    def warning(self, __s, *args):
-        show = self._settings.show_warnings
-        summary = self._settings.summary_warnings
-        if show is not None or summary is not None:
-            s = __s % args
-        self._num_warnings += 1
-        if show is not None:
-            if self._num_warnings <= show or show == 0:
-                print("[WARNING]", s)
-                if self._num_warnings == show:
-                    print("not showing any more warnings")
-        if summary is not None:
-            if self._num_warnings <= summary or summary == 0:
-                self._warnings.append(s)
-
-    def info(self, __s, *args):
-        if self._settings.show_info:
-            print(("[INFO]" + __s) % args)
-
-    def internal(self, __s, *args):
-        pass
-
-    def problem(self, bool, __s=None, *args):
-        pass
-
-    def set_context(self, __d=None, **kwargs):
-        if __d:
-            self._context.update(__d)
-        self._context.update(**kwargs)
-
-    def clear_context(self, keys=None):
-        if keys is None:
-            self._context = dict()
-            return
-        for k in keys:
-            self._context.pop(k, None)
-
-    @property
-    def warning_count(self):
-        return self._num_warnings
-
-    @property
-    def error_count(self):
-        return self._num_errors
-
-    @property
-    def warning_lines(self):
-        return self._warnings
-
-    @property
-    def error_lines(self):
-        return self._errors
-
-
-class Reporter:
-    _instance = None
-
-    def __init__(self, settings=None):
-        if Reporter._instance is not None:
-            return
-        if settings is None:
-            logging.error("internal issue: reporter not setup")
-
-        Reporter._instance = _Reporter(settings)
-
-    def __getattr__(self, name):
-        return getattr(self._instance, name)
-
-
-def setup_reporter(settings):
-    # fixme: why?
-    # if not settings.is_frozen():
-    #     logging.error("internal issue: settings not frozen")
-    r = Reporter(settings=settings)
-    return r
-
-
-def get_reporter():
-    r = Reporter()
-    return r