wandb 0.16.6__py3-none-any.whl → 0.17.0__py3-none-any.whl

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

@@ -37,6 +37,12 @@ class _Stats(TypedDict):
     # 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."""
 
@@ -49,9 +55,7 @@ class GPUAppleStats:
 
     def __init__(self) -> None:
         self.samples = deque()
-        self.binary_path = (
-            pathlib.Path(sys.modules["wandb"].__path__[0]) / "bin" / "apple_gpu_stats"
-        ).resolve()
+        self.binary_path = get_apple_gpu_path()
 
     def sample(self) -> None:
         try:
@@ -63,22 +67,47 @@ class GPUAppleStats:
             )[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["mem_used"],
-                "temp": raw_stats["temperature"],
-                "powerWatts": raw_stats["power"],
-                "powerPercent": (raw_stats["power"] / self.MAX_POWER_WATTS) * 100,
+                "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(f"GPU stats error: {e}")
+            logger.exception("GPU stats error: %s", e)
 
     def clear(self) -> None:
         self.samples.clear()
@@ -116,6 +145,7 @@ class GPUApple:
         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:
@@ -128,5 +158,20 @@ class GPUApple:
         self.metrics_monitor.finish()
 
     def probe(self) -> dict:
-        # todo: make this actually meaningful
-        return {self.name: {"type": "arm", "vendor": "Apple"}}
+        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/internal/system/assets/interfaces.py

@@ -68,8 +68,7 @@ class Asset(Protocol):
     metrics: List[Metric]
     metrics_monitor: "MetricsMonitor"
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
-        ...  # pragma: no cover
+    def __init__(self, *args: Any, **kwargs: Any) -> None: ...  # pragma: no cover
 
     @classmethod
     def is_available(cls) -> bool:
@@ -90,14 +89,13 @@ class Asset(Protocol):
 
 
 class Interface(Protocol):
-    def publish_stats(self, stats: dict) -> None:
-        ...  # pragma: no cover
+    def publish_stats(self, stats: dict) -> None: ...  # pragma: no cover
 
-    def _publish_telemetry(self, telemetry: "TelemetryRecord") -> None:
-        ...  # pragma: no cover
+    def _publish_telemetry(
+        self, telemetry: "TelemetryRecord"
+    ) -> None: ...  # pragma: no cover
 
-    def publish_files(self, files_dict: "FilesDict") -> None:
-        ...  # pragma: no cover
+    def publish_files(self, files_dict: "FilesDict") -> None: ...  # pragma: no cover
 
 
 class MetricsMonitor:

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

@@ -65,13 +65,13 @@ def _setup_requests_session() -> requests.Session:
 
 
 def _nested_dict_to_tuple(
-    nested_dict: Mapping[str, Mapping[str, str]]
+    nested_dict: Mapping[str, Mapping[str, str]],
 ) -> Tuple[Tuple[str, Tuple[str, str]], ...]:
     return tuple((k, *v.items()) for k, v in nested_dict.items())  # type: ignore
 
 
 def _tuple_to_nested_dict(
-    nested_tuple: Tuple[Tuple[str, Tuple[str, str]], ...]
+    nested_tuple: Tuple[Tuple[str, Tuple[str, str]], ...],
 ) -> Dict[str, Dict[str, str]]:
     return {k: dict(v) for k, *v in nested_tuple}
 

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

@@ -197,9 +197,7 @@ class NeuronCoreStats:
                 entry["report"]
                 for entry in raw_stats["neuron_runtime_data"]
                 if self._is_matching_entry(entry)
-            ][
-                0
-            ]  # there should be only one entry with the pid
+            ][0]  # there should be only one entry with the pid
 
             neuroncores_in_use = neuron_runtime_data["neuroncore_counters"][
                 "neuroncores_in_use"

wandb/sdk/launch/__init__.py

@@ -1,6 +1,14 @@
 from ._launch import launch
 from ._launch_add import launch_add
 from .agent.agent import LaunchAgent
+from .inputs.manage import manage_config_file, manage_wandb_config
 from .utils import load_wandb_config
 
-__all__ = ["LaunchAgent", "launch", "launch_add", "load_wandb_config"]
+__all__ = [
+    "LaunchAgent",
+    "launch",
+    "launch_add",
+    "load_wandb_config",
+    "manage_config_file",
+    "manage_wandb_config",
+]

wandb/sdk/launch/_launch.py

@@ -12,13 +12,12 @@ from wandb.apis.internal import Api
 from . import loader
 from ._project_spec import LaunchProject
 from .agent import LaunchAgent
-from .builder.build import construct_agent_configs
+from .agent.agent import construct_agent_configs
 from .environment.local_environment import LocalEnvironment
 from .errors import ExecutionError, LaunchError
 from .runner.abstract import AbstractRun
 from .utils import (
     LAUNCH_CONFIG_FILE,
-    LAUNCH_DEFAULT_PROJECT,
     PROJECT_SYNCHRONOUS,
     construct_launch_spec,
     validate_launch_spec_source,
@@ -58,7 +57,6 @@ def set_launch_logfile(logfile: str) -> None:
 
 def resolve_agent_config(  # noqa: C901
     entity: Optional[str],
-    project: Optional[str],
     max_jobs: Optional[int],
     queues: Optional[Tuple[str]],
     config: Optional[str],
@@ -69,7 +67,6 @@ def resolve_agent_config(  # noqa: C901
     Arguments:
         api (Api): The api.
         entity (str): The entity.
-        project (str): The project.
         max_jobs (int): The max number of jobs.
         queues (Tuple[str]): The queues.
         config (str): The config.
@@ -79,7 +76,6 @@ def resolve_agent_config(  # noqa: C901
         Tuple[Dict[str, Any], Api]: The resolved config and api.
     """
     defaults = {
-        "project": LAUNCH_DEFAULT_PROJECT,
         "max_jobs": 1,
         "max_schedulers": 1,
         "queues": [],
@@ -87,7 +83,6 @@ def resolve_agent_config(  # noqa: C901
         "builder": {},
         "verbosity": 0,
     }
-    user_set_project = False
     resolved_config: Dict[str, Any] = defaults
     config_path = config or os.path.expanduser(LAUNCH_CONFIG_FILE)
     if os.path.isfile(config_path):
@@ -100,16 +95,11 @@ def resolve_agent_config(  # noqa: C901
                     launch_config = {}  # type: ignore
             except yaml.YAMLError as e:
                 raise LaunchError(f"Invalid launch agent config: {e}")
-        if launch_config.get("project") is not None:
-            user_set_project = True
         resolved_config.update(launch_config.items())
     elif config is not None:
         raise LaunchError(
             f"Could not find use specified launch config file: {config_path}"
         )
-    if os.environ.get("WANDB_PROJECT") is not None:
-        resolved_config.update({"project": os.environ.get("WANDB_PROJECT")})
-        user_set_project = True
     if os.environ.get("WANDB_ENTITY") is not None:
         resolved_config.update({"entity": os.environ.get("WANDB_ENTITY")})
     if os.environ.get("WANDB_LAUNCH_MAX_JOBS") is not None:
@@ -117,9 +107,6 @@ def resolve_agent_config(  # noqa: C901
             {"max_jobs": int(os.environ.get("WANDB_LAUNCH_MAX_JOBS", 1))}
         )
 
-    if project is not None:
-        resolved_config.update({"project": project})
-        user_set_project = True
     if entity is not None:
         resolved_config.update({"entity": entity})
     if max_jobs is not None:
@@ -138,7 +125,7 @@ def resolve_agent_config(  # noqa: C901
                 + " (expected str). Specify multiple queues with the 'queues' key"
             )
 
-    keys = ["project", "entity"]
+    keys = ["entity"]
     settings = {
         k: resolved_config.get(k) for k in keys if resolved_config.get(k) is not None
     }
@@ -147,10 +134,6 @@ def resolve_agent_config(  # noqa: C901
 
     if resolved_config.get("entity") is None:
         resolved_config.update({"entity": api.default_entity})
-    if user_set_project:
-        wandb.termwarn(
-            "Specifying a project for the launch agent is deprecated. Please use queues found in the Launch application at https://wandb.ai/launch."
-        )
 
     return resolved_config, api
 
@@ -188,7 +171,6 @@ def create_and_run_agent(
 
 async def _launch(
     api: Api,
-    uri: Optional[str] = None,
     job: Optional[str] = None,
     name: Optional[str] = None,
     project: Optional[str] = None,
@@ -209,7 +191,7 @@ async def _launch(
     if resource is None:
         resource = "local-container"
     launch_spec = construct_launch_spec(
-        uri,
+        None,
         job,
         api,
         name,
@@ -228,7 +210,7 @@ async def _launch(
     validate_launch_spec_source(launch_spec)
     launch_project = LaunchProject.from_spec(launch_spec, api)
     launch_project.fetch_and_validate_project()
-    entrypoint = launch_project.get_single_entry_point()
+    entrypoint = launch_project.get_job_entry_point()
     image_uri = launch_project.docker_image  # Either set by user or None.
 
     # construct runner config.
@@ -326,8 +308,6 @@ def launch(
     """
     submitted_run_obj = asyncio.run(
         _launch(
-            # TODO: fully deprecate URI path
-            uri=None,
             job=job,
             name=name,
             project=project,

wandb/sdk/launch/_launch_add.py

@@ -109,7 +109,6 @@ def launch_add(
 
     return _launch_add(
         api,
-        uri,
         job,
         config,
         template_variables,
@@ -134,7 +133,6 @@ def launch_add(
 
 def _launch_add(
     api: Api,
-    uri: Optional[str],
     job: Optional[str],
     config: Optional[Dict[str, Any]],
     template_variables: Optional[dict],
@@ -156,7 +154,7 @@ def _launch_add(
     priority: Optional[int] = None,
 ) -> "public.QueuedRun":
     launch_spec = construct_launch_spec(
-        uri,
+        None,
         job,
         api,
         name,