wandb 0.17.0rc2__py3-none-win_amd64.whl → 0.17.1__py3-none-win_amd64.whl

wandb/sdk/internal/sender.py

@@ -39,7 +39,6 @@ from wandb.sdk.internal import (
     datastore,
     file_stream,
     internal_api,
-    job_builder,
     sender_config,
     update,
 )
@@ -217,6 +216,7 @@ class SendManager:
     _record_exit: Optional["Record"]
     _exit_result: Optional["RunExitResult"]
     _resume_state: ResumeState
+    _rewind_response: Optional[Dict[str, Any]]
     _cached_server_info: Dict[str, Any]
     _cached_viewer: Dict[str, Any]
     _server_messages: List[Dict[str, Any]]
@@ -276,6 +276,7 @@ class SendManager:
 
         # State updated by resuming
         self._resume_state = ResumeState()
+        self._rewind_response = None
 
         # State added when run_exit is initiated and complete
         self._record_exit = None
@@ -327,7 +328,6 @@ class SendManager:
             # ignore_globs=(),
             _sync=True,
             disable_job_creation=False,
-            _async_upload_concurrency_limit=None,
             _file_stream_timeout_seconds=0,
         )
         record_q: Queue[Record] = queue.Queue()
@@ -808,7 +808,9 @@ class SendManager:
             if self._settings.resume == "must":
                 error = wandb_internal_pb2.ErrorInfo()
                 error.code = wandb_internal_pb2.ErrorInfo.ErrorCode.USAGE
-                error.message = "resume='must' but could not resume (%s) " % run.run_id
+                error.message = "resume='must' but could not resume ({}) ".format(
+                    run.run_id
+                )
                 return error
 
         # TODO: Do we need to restore config / summary?
@@ -824,7 +826,7 @@ class SendManager:
         self._resume_state.summary = summary
         self._resume_state.tags = tags
         self._resume_state.resumed = True
-        logger.info("configured resuming with: %s" % self._resume_state)
+        logger.info("configured resuming with: {}".format(self._resume_state))
         return None
 
     def _telemetry_get_framework(self) -> str:
@@ -890,6 +892,36 @@ class SendManager:
         self._run.forked = True
         self._run.starting_step = first_step
 
+    def _load_rewind_state(self, run: "RunRecord"):
+        assert self._settings.resume_from
+        self._rewind_response = self._api.rewind_run(
+            run_name=run.run_id,
+            entity=run.entity or None,
+            project=run.project or None,
+            metric_name=self._settings.resume_from.metric,
+            metric_value=self._settings.resume_from.value,
+            program_path=self._settings.program or None,
+        )
+        self._resume_state.history = self._rewind_response.get("historyLineCount", 0)
+        self._resume_state.config = json.loads(
+            self._rewind_response.get("config", "{}")
+        )
+
+    def _install_rewind_state(self):
+        assert self._settings.resume_from
+        assert self._settings.resume_from.metric == "_step"
+        assert self._run
+        assert self._rewind_response
+
+        first_step = int(self._settings.resume_from.value) + 1
+        self._resume_state.step = first_step
+
+        # We set the fork flag here because rewind uses the forking
+        # infrastructure under the hood. Setting `forked` here
+        # ensures that run._step is properly set in the user process.
+        self._run.forked = True
+        self._run.starting_step = first_step
+
     def _handle_error(
         self,
         record: "Record",
@@ -926,13 +958,16 @@ class SendManager:
             self._config_save(config_value_dict)
 
         do_fork = self._settings.fork_from is not None and is_wandb_init
+        do_rewind = self._settings.resume_from is not None and is_wandb_init
         do_resume = bool(self._settings.resume)
 
-        if do_fork and do_resume:
+        num_resume_options_set = sum([do_fork, do_rewind, do_resume])
+        if num_resume_options_set > 1:
             error = wandb_internal_pb2.ErrorInfo()
             error.code = wandb_internal_pb2.ErrorInfo.ErrorCode.USAGE
             error.message = (
-                "You cannot use `resume` and `fork_from` together. Please choose one."
+                "Multiple resume options specified. "
+                "Please specify only one of `fork_from`, `resume`, or `resume_from`."
             )
             self._handle_error(record, error, run)
 
@@ -945,6 +980,9 @@ class SendManager:
             if do_resume:
                 error = self._setup_resume(run)
 
+            elif do_rewind:
+                error = self._load_rewind_state(run)
+
         if error is not None:
             self._handle_error(record, error, run)
             return
@@ -996,6 +1034,26 @@ class SendManager:
         else:
             logger.info("updated run: %s", self._run.run_id)
 
+    def _update_resume_state(self, is_rewinding: bool, inserted: bool):
+        assert self._run
+        if self._resume_state.resumed:
+            self._run.resumed = True
+            if self._resume_state.wandb_runtime is not None:
+                self._run.runtime = self._resume_state.wandb_runtime
+        elif is_rewinding:
+            # because is_rewinding is mutually exclusive with self._resume_state.resumed,
+            # this block will always execute if is_rewinding is set
+            self._install_rewind_state()
+        else:
+            # If the user is not resuming, and we didn't insert on upsert_run then
+            # it is likely that we are overwriting the run which we might want to
+            # prevent in the future.  This could be a false signal since an upsert_run
+            # message which gets retried in the network could also show up as not
+            # inserted.
+            if not inserted:
+                # no need to flush this, it will get updated eventually
+                self._telemetry_obj.feature.maybe_run_overwrite = True
+
     def _init_run(
         self,
         run: "RunRecord",
@@ -1011,22 +1069,30 @@ class SendManager:
         if self._resume_state and self._resume_state.tags and not run.tags:
             run.tags.extend(self._resume_state.tags)
 
-        server_run, inserted, server_messages = self._api.upsert_run(
-            name=run.run_id,
-            entity=run.entity or None,
-            project=run.project or None,
-            group=run.run_group or None,
-            job_type=run.job_type or None,
-            display_name=run.display_name or None,
-            notes=run.notes or None,
-            tags=run.tags[:] or None,
-            config=config_dict or None,
-            sweep_name=run.sweep_id or None,
-            host=run.host or None,
-            program_path=self._settings.program or None,
-            repo=run.git.remote_url or None,
-            commit=run.git.commit or None,
-        )
+        is_rewinding = bool(self._settings.resume_from)
+        if is_rewinding:
+            assert self._rewind_response
+            server_run = self._rewind_response
+            server_messages = None
+            inserted = True
+        else:
+            server_run, inserted, server_messages = self._api.upsert_run(
+                name=run.run_id,
+                entity=run.entity or None,
+                project=run.project or None,
+                group=run.run_group or None,
+                job_type=run.job_type or None,
+                display_name=run.display_name or None,
+                notes=run.notes or None,
+                tags=run.tags[:] or None,
+                config=config_dict or None,
+                sweep_name=run.sweep_id or None,
+                host=run.host or None,
+                program_path=self._settings.program or None,
+                repo=run.git.remote_url or None,
+                commit=run.git.commit or None,
+            )
+
         # TODO: we don't want to create jobs in sweeps, since the
         #  executable doesn't appear to be consistent
         if run.sweep_id:
@@ -1034,19 +1100,17 @@ class SendManager:
 
         self._server_messages = server_messages or []
         self._run = run
-        if self._resume_state.resumed:
-            self._run.resumed = True
-            if self._resume_state.wandb_runtime is not None:
-                self._run.runtime = self._resume_state.wandb_runtime
-        else:
-            # If the user is not resuming, and we didn't insert on upsert_run then
-            # it is likely that we are overwriting the run which we might want to
-            # prevent in the future.  This could be a false signal since an upsert_run
-            # message which gets retried in the network could also show up as not
-            # inserted.
-            if not inserted:
-                # no need to flush this, it will get updated eventually
-                self._telemetry_obj.feature.maybe_run_overwrite = True
+
+        if self._resume_state.resumed and is_rewinding:
+            # this should not ever be possible to hit, since we check for
+            # resumption above and raise an error if resumption is specified
+            # twice.
+            raise ValueError(
+                "Cannot attempt to rewind and resume a run - only one of "
+                "`resume` or `resume_from` can be specified."
+            )
+
+        self._update_resume_state(is_rewinding, inserted)
         self._run.starting_step = self._resume_state.step
         self._run.start_time.FromMicroseconds(int(start_time * 1e6))
         self._run.config.CopyFrom(self._interface._make_config(config_dict))
@@ -1439,9 +1503,7 @@ class SendManager:
             self._job_builder.disable = True
         elif use.partial.job_name:
             # job is partial, let job builder rebuild job, set job source dict
-            self._job_builder._partial_source = (
-                job_builder.convert_use_artifact_to_job_source(record.use_artifact)
-            )
+            self._job_builder.set_partial_source_id(use.id)
 
     def send_request_log_artifact(self, record: "Record") -> None:
         assert record.control.req_resp
@@ -1617,7 +1679,8 @@ class SendManager:
         summary_dict = self._cached_summary.copy()
         summary_dict.pop("_wandb", None)
         self._job_builder.set_summary(summary_dict)
-        artifact = self._job_builder.build()
+
+        artifact = self._job_builder.build(api=self._api)
         if artifact is not None and self._run is not None:
             proto_artifact = self._interface._make_artifact(artifact)
             proto_artifact.run_id = self._run.run_id

wandb/sdk/internal/settings_static.py

@@ -18,6 +18,7 @@ class SettingsStatic(SettingsData):
         object.__setattr__(self, "_proto", proto)
 
     def _from_proto(self, proto: wandb_settings_pb2.Settings) -> None:
+        forks_specified: list[str] = []
         for field in fields(SettingsData):
             key = field.name
             value: Any = None
@@ -39,12 +40,13 @@ class SettingsStatic(SettingsData):
                             unpacked_inner[inner_key] = inner_value
                         unpacked_mapping[outer_key] = unpacked_inner
                     value = unpacked_mapping
-            elif key == "fork_from":
+            elif key == "fork_from" or key == "resume_from":
                 value = getattr(proto, key)
                 if value.run:
                     value = RunMoment(
                         run=value.run, value=value.value, metric=value.metric
                     )
+                    forks_specified.append(key)
                 else:
                     value = None
             else:
@@ -58,6 +60,11 @@ class SettingsStatic(SettingsData):
                     value = None
             object.__setattr__(self, key, value)
 
+        if len(forks_specified) > 1:
+            raise ValueError(
+                "Only one of fork_from or resume_from can be specified, not both"
+            )
+
     def __setattr__(self, name: str, value: object) -> None:
         raise AttributeError("Error: SettingsStatic is a readonly object")
 

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

@@ -133,7 +133,7 @@ class NeuronCoreStats:
                 process.kill()
                 process.wait()
         except Exception as e:
-            logger.error("neuron-monitor failed: %s" % e)
+            logger.error("neuron-monitor failed: {}".format(e))
 
     def __init__(
         self,
@@ -175,7 +175,7 @@ class NeuronCoreStats:
             assert self.neuron_monitor_thread is not None
             self.neuron_monitor_thread.join()
         except Exception as e:
-            logger.error("neuron-monitor thread failed to stop: %s" % e)
+            logger.error("neuron-monitor thread failed to stop: {}".format(e))
         finally:
             self.neuron_monitor_thread = None
 
@@ -394,5 +394,5 @@ class Trainium:
 
             return {self.name: neuron_hardware_info}
         except Exception as e:
-            logger.error("neuron-monitor failed: %s" % e)
+            logger.error("neuron-monitor failed: {}".format(e))
             return {}

wandb/sdk/internal/system/system_info.py

@@ -55,7 +55,9 @@ class SystemInfo:
         )
         program_absolute = os.path.join(root, program_relative)
         if not os.path.exists(program_absolute):
-            logger.warning("unable to save code -- can't find %s" % program_absolute)
+            logger.warning(
+                "unable to save code -- can't find {}".format(program_absolute)
+            )
             return None
         saved_program = os.path.join(self.settings.files_dir, "code", program_relative)
         self.saved_program = program_relative  # type: ignore
@@ -120,7 +122,7 @@ class SystemInfo:
             subprocess.CalledProcessError,
             subprocess.TimeoutExpired,
         ) as e:
-            logger.error("Error generating diff: %s" % e)
+            logger.error("Error generating diff: {}".format(e))
         logger.debug("Saving git patches done")
 
     def _probe_git(self, data: Dict[str, Any]) -> Dict[str, Any]:

wandb/sdk/internal/update.py

@@ -98,7 +98,7 @@ def check_available(current_version: str) -> Optional[Dict[str, Optional[str]]]:
         )
     yank_message = None
     if yanked:
-        reason_message = "(%s)  " % yanked_reason if yanked_reason else ""
+        reason_message = "({})  ".format(yanked_reason) if yanked_reason else ""
         yank_message = "{} version {} has been recalled!  {}Please upgrade.".format(
             wandb_module_name,
             current_version,

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,