wandb 0.18.5__py3-none-macosx_11_0_arm64.whl → 0.18.7__py3-none-macosx_11_0_arm64.whl

wandb/sdk/internal/system/assets/gpu_apple.py

@@ -1,177 +0,0 @@
-import json
-import logging
-import pathlib
-import platform
-import subprocess
-import sys
-import threading
-from collections import deque
-from typing import TYPE_CHECKING, List
-
-if sys.version_info >= (3, 8):
-    from typing import TypedDict
-else:
-    from typing_extensions import TypedDict
-
-from wandb.sdk.lib import telemetry
-
-from .aggregators import aggregate_mean
-from .asset_registry import asset_registry
-from .interfaces import Interface, Metric, MetricsMonitor
-
-if TYPE_CHECKING:
-    from typing import Deque
-
-    from wandb.sdk.internal.settings_static import SettingsStatic
-
-
-logger = logging.getLogger(__name__)
-
-
-class _Stats(TypedDict):
-    gpu: float
-    memoryAllocated: float  # noqa: N815
-    temp: float
-    powerWatts: float  # noqa: N815
-    powerPercent: float  # noqa: N815
-    # cpuWaitMs: float
-
-
-def get_apple_gpu_path() -> pathlib.Path:
-    return (
-        pathlib.Path(sys.modules["wandb"].__path__[0]) / "bin" / "apple_gpu_stats"
-    ).resolve()
-
-
-class GPUAppleStats:
-    """Apple GPU stats available on Arm Macs."""
-
-    name = "gpu.0.{}"
-    samples: "Deque[_Stats]"
-
-    # TODO: hard coded max watts as 16.5, found this number in the SMC list.
-    #  Eventually we can have the apple_gpu_stats binary query for this.
-    MAX_POWER_WATTS = 16.5
-
-    def __init__(self) -> None:
-        self.samples = deque()
-        self.binary_path = get_apple_gpu_path()
-
-    def sample(self) -> None:
-        try:
-            command = [str(self.binary_path), "--json"]
-            output = (
-                subprocess.check_output(command, universal_newlines=True)
-                .strip()
-                .split("\n")
-            )[0]
-            raw_stats = json.loads(output)
-
-            temp_keys = [
-                "m1Gpu1",
-                "m1Gpu2",
-                "m1Gpu3",
-                "m1Gpu4",
-                "m2Gpu1",
-                "m2Gpu2",
-                "m3Gpu1",
-                "m3Gpu2",
-                "m3Gpu3",
-                "m3Gpu4",
-                "m3Gpu5",
-                "m3Gpu6",
-                "m3Gpu7",
-                "m3Gpu8",
-            ]
-            temp, count = 0, 0
-            for k in temp_keys:
-                if raw_stats.get(k, 0) > 0:
-                    temp += raw_stats[k]
-                    count += 1
-
-            stats: _Stats = {
-                "gpu": raw_stats["utilization"],
-                "memoryAllocated": (
-                    raw_stats["inUseSystemMemory"]
-                    / raw_stats["allocatedSystemMemory"]
-                    * 100
-                ),
-                "powerWatts": raw_stats["systemPower"],
-                "powerPercent": (raw_stats["systemPower"] / self.MAX_POWER_WATTS) * 100,
-                "temp": temp / count if count > 0 else 0,
-                # TODO: this stat could be useful eventually, it was consistently
-                #  0 in my experimentation and requires a frontend change
-                #  so leaving it out for now.
-                # "cpuWaitMs": raw_stats["cpu_wait_ms"],
-            }
-            self.samples.append(stats)
-
-        except (OSError, ValueError, TypeError, subprocess.CalledProcessError) as e:
-            logger.exception("GPU stats error: %s", e)
-
-    def clear(self) -> None:
-        self.samples.clear()
-
-    def aggregate(self) -> dict:
-        if not self.samples:
-            return {}
-        stats = {}
-        for key in self.samples[0].keys():
-            samples = [s[key] for s in self.samples]  # type: ignore
-            aggregate = aggregate_mean(samples)
-            stats[self.name.format(key)] = aggregate
-        return stats
-
-
-@asset_registry.register
-class GPUApple:
-    def __init__(
-        self,
-        interface: "Interface",
-        settings: "SettingsStatic",
-        shutdown_event: threading.Event,
-    ) -> None:
-        self.name = self.__class__.__name__.lower()
-        self.metrics: List[Metric] = [
-            GPUAppleStats(),
-        ]
-        self.metrics_monitor = MetricsMonitor(
-            self.name,
-            self.metrics,
-            interface,
-            settings,
-            shutdown_event,
-        )
-        telemetry_record = telemetry.TelemetryRecord()
-        telemetry_record.env.m1_gpu = True
-        interface._publish_telemetry(telemetry_record)
-        self.binary_path = get_apple_gpu_path()
-
-    @classmethod
-    def is_available(cls) -> bool:
-        return platform.system() == "Darwin" and platform.processor() == "arm"
-
-    def start(self) -> None:
-        self.metrics_monitor.start()
-
-    def finish(self) -> None:
-        self.metrics_monitor.finish()
-
-    def probe(self) -> dict:
-        try:
-            command = [str(self.binary_path), "--json"]
-            output = (
-                subprocess.check_output(command, universal_newlines=True)
-                .strip()
-                .split("\n")
-            )[0]
-            raw_stats = json.loads(output)
-            return {
-                self.name: {
-                    "type": raw_stats["name"],
-                    "vendor": raw_stats["vendor"],
-                }
-            }
-        except (OSError, ValueError, TypeError, subprocess.CalledProcessError) as e:
-            logger.exception("GPU stats error: %s", e)
-            return {self.name: {"type": "arm", "vendor": "Apple"}}

wandb/sdk/lib/_wburls_generate.py

@@ -1,25 +0,0 @@
-from wburls import wburls  # type: ignore
-
-template = """
-import sys
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
-
-URLS = Literal[
-    $literal_list
-]
-"""
-
-
-def generate() -> None:
-    urls = wburls._get_urls()
-    literal_list = ", ".join([f"{key!r}" for key in urls])
-    print(template.replace("$literal_list", literal_list))
-
-
-if __name__ == "__main__":
-    generate()

wandb/sdk/lib/_wburls_generated.py

@@ -1,22 +0,0 @@
-# DO NOT EDIT -- GENERATED BY: `generate-tool.py --generate`
-import sys
-
-if sys.version_info >= (3, 8):
-    from typing import Literal
-else:
-    from typing_extensions import Literal
-
-
-URLS = Literal[
-    "cli_launch",
-    "doc_run",
-    "doc_require",
-    "doc_start_err",
-    "doc_artifacts_guide",
-    "upgrade_server",
-    "multiprocess",
-    "wandb_init",
-    "wandb_server",
-    "wandb_define_metric",
-    "wandb_core",
-]

wandb/sdk/lib/tracelog.py

@@ -1,255 +0,0 @@
-"""tracelog.
-
-Functions:
-    log_message_queue   - message put() to queue
-    log_message_dequeue - message get() from queue
-    log_message_send    - message sent to socket
-    log_message_recv    - message received from socket
-    log_message_process - message processed by thread
-    log_message_link    - message linked to another message
-    log_message_assert  - message encountered problem
-
-"""
-
-import datetime
-import logging
-import secrets
-import sys
-import threading
-from typing import TYPE_CHECKING, Optional, cast
-
-if TYPE_CHECKING:
-    import multiprocessing
-    import queue
-    import socket
-    from typing import Union
-
-    from wandb.proto import wandb_internal_pb2 as pb
-    from wandb.proto import wandb_server_pb2 as spb
-
-    MessageQueueType = Union[pb.Record, pb.Result]
-    MessageType = Union[pb.Record, pb.Result, spb.ServerRequest, spb.ServerResponse]
-    QueueType = Union[multiprocessing.Queue, queue.Queue]
-    TransportType = Union[socket.socket, str]
-
-
-# Supported modes:
-#   logger - tracelog output goes to python logging (default)
-#   stdout - tracelog output goes to stdout
-#   stderr - tracelog output goes to stderr
-tracelog_mode: Optional[str] = "logger"
-
-logger = logging.getLogger(__name__)
-
-
-ANNOTATE_QUEUE_NAME = "_DEBUGLOG_QUEUE_NAME"
-
-# capture stdout and stderr before anyone messes with them
-stdout_write = sys.__stdout__.write  # type: ignore
-stderr_write = sys.__stderr__.write  # type: ignore
-
-
-def _log(
-    msg_type: str,
-    log_type: str,
-    is_response: bool = False,
-    record: Optional["pb.Record"] = None,
-    result: Optional["pb.Result"] = None,
-    resource: Optional[str] = None,
-) -> None:
-    prefix = "TRACELOG(1)"
-    tname = threading.current_thread().name
-    now = datetime.datetime.now()
-    ts = now.strftime("%H%M%S.%f")
-    arrow = "<-" if is_response else "->"
-    resource = resource or "unknown"
-    uuid = ""
-    data = record or result
-    record_id = ""
-    if data:
-        uuid = data.uuid or uuid
-        record_id = data._info._tracelog_id
-    uuid = uuid or "-"
-    record_id = record_id or "-"
-    relay = ""
-    if data and data.control and data.control.relay_id:
-        relay = data.control.relay_id
-    relay = relay or "-"
-    line = f"{prefix} {arrow} {ts} {record_id:16} {log_type:7} {resource:8} {tname:16} {msg_type:32} {uuid:32} {relay:32}"
-    if tracelog_mode == "stdout":
-        stdout_write(f"{line}\n")
-    elif tracelog_mode == "stderr":
-        stderr_write(f"{line}\n")
-    elif tracelog_mode == "logger":
-        logger.info(line)
-
-
-def _record_msg_type(record: "pb.Record") -> str:
-    msg_type = str(record.WhichOneof("record_type"))
-    if msg_type == "request":
-        request = record.request
-        msg_type = str(request.WhichOneof("request_type"))
-    return msg_type
-
-
-def _result_msg_type(result: "pb.Result") -> str:
-    msg_type = str(result.WhichOneof("result_type"))
-    if msg_type == "response":
-        response = result.response
-        msg_type = str(response.WhichOneof("response_type"))
-    return msg_type
-
-
-def _log_message(
-    msg: "MessageType", log_type: str, resource: Optional[str] = None
-) -> None:
-    record: Optional[pb.Record] = None
-    result: Optional[pb.Result] = None
-    is_response = False
-    msg_type: str
-    # Note: using strings to avoid an import
-    message_type_str = type(msg).__name__
-    if message_type_str == "Record":
-        record = cast("pb.Record", msg)
-        msg_type = _record_msg_type(record)
-    elif message_type_str == "Result":
-        is_response = True
-        result = cast("pb.Result", msg)
-        msg_type = _result_msg_type(result)
-    elif message_type_str == "ServerRequest":
-        server_request = cast("spb.ServerRequest", msg)
-        msg_type = str(server_request.WhichOneof("server_request_type"))
-        if msg_type == "record_publish":
-            record = server_request.record_publish
-            sub_msg_type = _record_msg_type(record)
-            msg_type = f"pub-{sub_msg_type}"
-        elif msg_type == "record_communicate":
-            record = server_request.record_communicate
-            sub_msg_type = _record_msg_type(record)
-            msg_type = f"comm-{sub_msg_type}"
-        # print("SRV", server_request)
-    elif message_type_str == "ServerResponse":
-        is_response = True
-        server_response = cast("spb.ServerResponse", msg)
-        msg_type = str(server_response.WhichOneof("server_response_type"))
-        if msg_type == "result_communicate":
-            result = server_response.result_communicate
-            sub_msg_type = _result_msg_type(result)
-            msg_type = f"comm-{sub_msg_type}"
-    else:
-        raise AssertionError(f"Unknown message type {message_type_str}")
-    _log(
-        msg_type,
-        is_response=is_response,
-        record=record,
-        result=result,
-        log_type=log_type,
-        resource=resource,
-    )
-
-
-def _log_message_queue(msg: "MessageQueueType", q: "QueueType") -> None:
-    _annotate_message(msg)
-    resource = getattr(q, ANNOTATE_QUEUE_NAME, None)
-    _log_message(msg, "queue", resource=resource)
-
-
-def _log_message_dequeue(msg: "MessageQueueType", q: "QueueType") -> None:
-    resource = getattr(q, ANNOTATE_QUEUE_NAME, None)
-    _log_message(msg, "dequeue", resource=resource)
-
-
-def _log_message_send(msg: "MessageType", t: "TransportType") -> None:
-    _log_message(msg, "send")
-
-
-def _log_message_recv(msg: "MessageType", t: "TransportType") -> None:
-    _log_message(msg, "recv")
-
-
-def _log_message_process(msg: "MessageType") -> None:
-    _log_message(msg, "process")
-
-
-def _log_message_link(src: "MessageType", dest: "MessageType") -> None:
-    _log_message(src, "source")
-    _log_message(dest, "dest")
-
-
-def _log_message_assert(msg: "MessageType") -> None:
-    _log_message(msg, "assert")
-
-
-def _annotate_queue(q: "QueueType", name: str) -> None:
-    setattr(q, ANNOTATE_QUEUE_NAME, name)
-
-
-def _annotate_message(msg: "MessageQueueType") -> None:
-    record_id = secrets.token_hex(8)
-    msg._info._tracelog_id = record_id
-
-
-#
-# Default functions when logging is disabled
-#
-
-
-def log_message_queue(msg: "MessageQueueType", q: "QueueType") -> None:
-    return None
-
-
-def log_message_dequeue(msg: "MessageQueueType", q: "QueueType") -> None:
-    return None
-
-
-def log_message_send(msg: "MessageType", t: "TransportType") -> None:
-    return None
-
-
-def log_message_recv(msg: "MessageType", t: "TransportType") -> None:
-    return None
-
-
-def log_message_process(msg: "MessageType") -> None:
-    return None
-
-
-def log_message_link(src: "MessageType", dest: "MessageType") -> None:
-    return None
-
-
-def log_message_assert(msg: "MessageType") -> None:
-    return None
-
-
-def annotate_queue(q: "QueueType", name: str) -> None:
-    return None
-
-
-def annotate_message(msg: "MessageQueueType") -> None:
-    return None
-
-
-def enable(log_mode: Optional[str] = None) -> None:
-    global tracelog_mode
-    if log_mode:
-        tracelog_mode = log_mode
-
-    global log_message_queue
-    global log_message_dequeue
-    global log_message_send
-    global log_message_recv
-    global log_message_process
-    global log_message_link
-    global log_message_assert
-    global annotate_queue
-    global annotate_message
-    log_message_queue = _log_message_queue
-    log_message_dequeue = _log_message_dequeue
-    log_message_send = _log_message_send
-    log_message_recv = _log_message_recv
-    log_message_process = _log_message_process
-    log_message_link = _log_message_link
-    log_message_assert = _log_message_assert
-    annotate_queue = _annotate_queue
-    annotate_message = _annotate_message

wandb/sdk/lib/wburls.py

@@ -1,46 +0,0 @@
-"""Container for urls used in the wandb package.
-
-Use this anytime a URL is displayed to the user.
-
-Usage:
-    ```python
-    from wandb.sdk.lib.wburls import wburls
-
-    print(f"This is a url {wburls.get('cli_launch')}")
-    ```
-"""
-
-from typing import TYPE_CHECKING, Dict, Optional
-
-if TYPE_CHECKING:
-    from ._wburls_generated import URLS
-
-
-class WBURLs:
-    _urls_dict: Optional[Dict["URLS", str]]
-
-    def __init__(self) -> None:
-        self._urls_dict = None
-
-    def _get_urls(self) -> Dict["URLS", str]:
-        return dict(
-            cli_launch="https://wandb.me/launch",
-            doc_run="https://wandb.me/run",
-            doc_require="https://wandb.me/library-require",
-            doc_start_err="https://docs.wandb.ai/guides/track/tracking-faq#initstarterror-error-communicating-with-wandb-process-",
-            doc_artifacts_guide="https://docs.wandb.ai/guides/artifacts",
-            upgrade_server="https://wandb.me/server-upgrade",
-            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",
-            wandb_core="https://wandb.me/wandb-core",
-        )
-
-    def get(self, s: "URLS") -> str:
-        if self._urls_dict is None:
-            self._urls_dict = self._get_urls()
-        return self._urls_dict[s]
-
-
-wburls = WBURLs()