lightning-sdk 0.1.49__py3-none-any.whl → 2025.11.5__py3-none-any.whl

lightning_sdk/job/base.py

@@ -1,11 +1,14 @@
+import warnings
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Any, Dict, Optional, TypedDict, Union
 
+from lightning_sdk.api.cloud_account_api import CloudAccountApi
 from lightning_sdk.api.utils import _get_cloud_url
-from lightning_sdk.utils.resolve import _resolve_deprecated_cluster, _resolve_teamspace
+from lightning_sdk.utils.logging import TrackCallsABCMeta
+from lightning_sdk.utils.resolve import _resolve_deprecated_cluster, _resolve_teamspace, in_studio, skip_studio_setup
 
 if TYPE_CHECKING:
-    from lightning_sdk.machine import Machine
+    from lightning_sdk.machine import CloudProvider, Machine
     from lightning_sdk.organization import Organization
     from lightning_sdk.status import Status
     from lightning_sdk.studio import Studio
@@ -16,7 +19,7 @@ if TYPE_CHECKING:
 class MachineDict(TypedDict):
     name: str
     status: "Status"
-    machine: "Machine"
+    machine: Union["Machine", str]
 
 
 class JobDict(MachineDict):
@@ -27,7 +30,7 @@ class JobDict(MachineDict):
     total_cost: float
 
 
-class _BaseJob(ABC):
+class _BaseJob(ABC, metaclass=TrackCallsABCMeta):
     """Base interface to all job types."""
 
     def __init__(
@@ -63,12 +66,13 @@ class _BaseJob(ABC):
             self._update_internal_job()
 
         self._prevent_refetch_latest = False
+        self._cloud_account_api = CloudAccountApi()
 
     @classmethod
     def run(
         cls,
         name: str,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: Optional[str] = None,
         studio: Union["Studio", str, None] = None,
         image: Optional[str] = None,
@@ -76,6 +80,7 @@ class _BaseJob(ABC):
         org: Union[str, "Organization", None] = None,
         user: Union[str, "User", None] = None,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[Union["CloudProvider", str]] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         image_credentials: Optional[str] = None,
@@ -83,7 +88,10 @@ class _BaseJob(ABC):
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
         entrypoint: str = "sh -c",
+        path_mappings: Optional[Dict[str, str]] = None,
+        max_runtime: Optional[int] = None,
         cluster: Optional[str] = None,  # deprecated in favor of cloud_account
+        reuse_snapshot: bool = True,
     ) -> "_BaseJob":
         """Run async workloads using a docker image or a compute environment from your studio.
 
@@ -99,7 +107,11 @@ class _BaseJob(ABC):
             user: The user owning the teamspace (if any). Defaults to the current user.
             cloud_account: The cloud account to run the job on.
                 Defaults to the studio cloud account if running with studio compute env.
-                If not provided will fall back to the teamspaces default cloud account.
+                If not provided and `cloud_account_provider` is set, will resolve cluster from this, else
+                will fall back to the teamspaces default cloud account.
+            cloud_account_provider: The provider to select the cloud-account from.
+                If set, must be in agreement with the provider from the cloud_account (if specified).
+                If not specified, falls backto the teamspace default cloud account.
             env: Environment variables to set inside the job.
             interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
             image_credentials: The credentials used to pull the image. Required if the image is private.
@@ -120,7 +132,14 @@ class _BaseJob(ABC):
                 just runs the provided command in a standard shell.
                 To use the pre-defined entrypoint of the provided image, set this to an empty string.
                 Only applicable when submitting docker jobs.
+            max_runtime: the duration (in seconds) for which to allocate the machine.
+                Irrelevant for most machines, required for some of the top-end machines on GCP.
+                If in doubt, set it. Won't have an effect on machines not requiring it.
+                Defaults to 3h
+            reuse_snapshot: Whether the job should reuse a Studio snapshot when multiple jobs for the same Studio are
+                submitted. Turning this off may result in longer job startup times. Defaults to True.
         """
+        from lightning_sdk.lightning_cloud.openapi.rest import ApiException
         from lightning_sdk.studio import Studio
 
         cloud_account = _resolve_deprecated_cluster(cloud_account, cluster)
@@ -130,9 +149,15 @@ class _BaseJob(ABC):
 
         if image is None:
             if not isinstance(studio, Studio):
-                studio = Studio(
-                    name=studio, teamspace=teamspace, org=org, user=user, cloud_account=cloud_account, create_ok=False
-                )
+                with skip_studio_setup():
+                    studio = Studio(
+                        name=studio,
+                        teamspace=teamspace,
+                        org=org,
+                        user=user,
+                        cloud_account=cloud_account,
+                        create_ok=False,
+                    )
 
             # studio is a Studio instance at this point
             if teamspace is None:
@@ -175,6 +200,13 @@ class _BaseJob(ABC):
                 raise RuntimeError(
                     "image and studio are mutually exclusive as both define the environment to run the job in"
                 )
+            if cloud_account is None and in_studio():
+                try:
+                    with skip_studio_setup():
+                        resolve_studio = Studio(teamspace=teamspace, user=user, org=org)
+                    cloud_account = resolve_studio.cloud_account
+                except (ValueError, ApiException):
+                    warnings.warn("Could not infer cloud account from studio. Using teamspace default.")
 
             # they either need to specified both or none of them
             if bool(artifacts_local) != bool(artifacts_remote):
@@ -190,6 +222,7 @@ class _BaseJob(ABC):
         return inst._submit(
             machine=machine,
             cloud_account=cloud_account,
+            cloud_provider=cloud_provider,
             command=command,
             studio=studio,
             image=image,
@@ -200,23 +233,30 @@ class _BaseJob(ABC):
             artifacts_local=artifacts_local,
             artifacts_remote=artifacts_remote,
             entrypoint=entrypoint,
+            path_mappings=path_mappings,
+            max_runtime=max_runtime,
+            reuse_snapshot=reuse_snapshot,
         )
 
     @abstractmethod
     def _submit(
         self,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: Optional[str] = None,
         studio: Optional["Studio"] = None,
         image: Optional[str] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[Union["CloudProvider", str]] = None,
         image_credentials: Optional[str] = None,
         cloud_account_auth: bool = False,
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
         entrypoint: str = "sh -c",
+        path_mappings: Optional[Dict[str, str]] = None,
+        max_runtime: Optional[int] = None,
+        reuse_snapshot: bool = True,
     ) -> "_BaseJob":
         """Submit a new job to the Lightning AI platform.
 
@@ -230,7 +270,11 @@ class _BaseJob(ABC):
             interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
             cloud_account: The cloud account to run the job on.
                 Defaults to the studio cloud account if running with studio compute env.
-                If not provided will fall back to the teamspaces default cloud account.
+                If not provided and `cloud_account_provider` is set, will resolve cluster from this, else
+                will fall back to the teamspaces default cloud account.
+            cloud_account_provider: The provider to select the cloud-account from.
+                If set, must be in agreement with the provider from the cloud_account (if specified).
+                If not specified, falls backto the teamspace default cloud account.
             image_credentials: The credentials used to pull the image. Required if the image is private.
                 This should be the name of the respective credentials secret created on the Lightning AI platform.
             cloud_account_auth: Whether to authenticate with the cloud account to pull the image.
@@ -248,6 +292,12 @@ class _BaseJob(ABC):
             entrypoint: The entrypoint of your docker container. Defaults to sh -c.
                 To use the pre-defined entrypoint of the provided image, set this to an empty string.
                 Only applicable when submitting docker jobs.
+            max_runtime: the duration (in seconds) for which to allocate the machine.
+                Irrelevant for most machines, required for some of the top-end machines on GCP.
+                If in doubt, set it. Won't have an effect on machines not requiring it.
+                Defaults to 3h
+            reuse_snapshot: Whether the job should reuse a Studio snapshot when multiple jobs for the same Studio are
+                submitted. Turning this off may result in longer job startup times. Defaults to True.
         """
 
     @abstractmethod
@@ -264,6 +314,56 @@ class _BaseJob(ABC):
         Caution: This also deletes all artifacts and snapshots associated with the job.
         """
 
+    def wait(self, interval: float = 5.0, timeout: Optional[float] = None, stop_on_timeout: bool = False) -> None:
+        """Waits for the job to be either completed, manually stopped or failed.
+
+        Args:
+            interval: The number of seconds to spend in-between status checks.
+            timeout: The maximum number of seconds to wait before raising an error. If None, waits forever.
+            stop_on_timeout: Whether to stop the job if it didn't finish within the timeout.
+        """
+        import time
+
+        from lightning_sdk.status import Status
+
+        start = time.time()
+        while True:
+            if self.status in (Status.Completed, Status.Stopped, Status.Failed):
+                break
+
+            if timeout is not None and time.time() - start > timeout:
+                if stop_on_timeout:
+                    self.stop()  # ensure the job is stopped if it didn't finish
+                raise TimeoutError("Job didn't finish within the provided timeout.")
+
+            time.sleep(interval)
+
+    async def async_wait(
+        self, interval: float = 5.0, timeout: Optional[float] = None, stop_on_timeout: bool = False
+    ) -> None:
+        """Waits for the job to be either completed, manually stopped or failed.
+
+        Args:
+            interval: The number of seconds to spend in-between status checks.
+            timeout: The maximum number of seconds to wait before raising an error. If None, waits forever.
+            stop_on_timeout: Whether to stop the job if it didn't finish within the timeout.
+        """
+        import asyncio
+
+        from lightning_sdk.status import Status
+
+        start = asyncio.get_event_loop().time()
+        while True:
+            if self.status in (Status.Completed, Status.Stopped, Status.Failed):
+                break
+
+            if timeout is not None and asyncio.get_event_loop().time() - start > timeout:
+                if stop_on_timeout:
+                    self.stop()  # ensure the job is stopped if it didn't finish
+                raise TimeoutError("Job didn't finish within the provided timeout.")
+
+            await asyncio.sleep(interval)
+
     @property
     @abstractmethod
     def status(self) -> "Status":
@@ -271,7 +371,7 @@ class _BaseJob(ABC):
 
     @property
     @abstractmethod
-    def machine(self) -> "Machine":
+    def machine(self) -> Union["Machine", str]:
         """The machine type the job is running on."""
 
     @property

lightning_sdk/job/job.py

@@ -1,7 +1,5 @@
-from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Dict, Optional, Union
 
-from lightning_sdk.api.user_api import UserApi
 from lightning_sdk.job.base import _BaseJob
 from lightning_sdk.job.v1 import _JobV1
 from lightning_sdk.job.v2 import _JobV2
@@ -10,7 +8,7 @@ from lightning_sdk.utils.resolve import _setup_logger
 _logger = _setup_logger(__name__)
 
 if TYPE_CHECKING:
-    from lightning_sdk.machine import Machine
+    from lightning_sdk.machine import CloudProvider, Machine
     from lightning_sdk.organization import Organization
     from lightning_sdk.status import Status
     from lightning_sdk.studio import Studio
@@ -18,15 +16,6 @@ if TYPE_CHECKING:
     from lightning_sdk.user import User
 
 
-@lru_cache(maxsize=None)
-def _has_jobs_v2() -> bool:
-    api = UserApi()
-    try:
-        return api._get_feature_flags().jobs_v2
-    except Exception:
-        return False
-
-
 class Job(_BaseJob):
     """Class to submit and manage single-machine jobs on the Lightning AI Platform."""
 
@@ -52,7 +41,7 @@ class Job(_BaseJob):
         """
         from lightning_sdk.lightning_cloud.openapi.rest import ApiException
 
-        if _has_jobs_v2() and not self._force_v1:
+        if not self._force_v1:
             # try with v2 and fall back to v1
             try:
                 job = _JobV2(
@@ -89,7 +78,7 @@ class Job(_BaseJob):
     def run(
         cls,
         name: str,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: Optional[str] = None,
         studio: Union["Studio", str, None] = None,
         image: Union[str, None] = None,
@@ -97,14 +86,18 @@ class Job(_BaseJob):
         org: Union[str, "Organization", None] = None,
         user: Union[str, "User", None] = None,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[Union["CloudProvider", str]] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         image_credentials: Optional[str] = None,
         cloud_account_auth: bool = False,
-        artifacts_local: Optional[str] = None,
-        artifacts_remote: Optional[str] = None,
         entrypoint: str = "sh -c",
+        path_mappings: Optional[Dict[str, str]] = None,
+        max_runtime: Optional[int] = None,
+        artifacts_local: Optional[str] = None,  # deprecated in terms of path_mappings
+        artifacts_remote: Optional[str] = None,  # deprecated in terms of path_mappings
         cluster: Optional[str] = None,  # deprecated in favor of cloud_account
+        reuse_snapshot: bool = True,
     ) -> "Job":
         """Run async workloads using a docker image or a compute environment from your studio.
 
@@ -118,29 +111,38 @@ class Job(_BaseJob):
         teamspace: The teamspace the job should be associated with. Defaults to the current teamspace.
         org: The organization owning the teamspace (if any). Defaults to the current organization.
         user: The user owning the teamspace (if any). Defaults to the current user.
-        cloud_account: The cloud acocunt to run the job on.
+        cloud_account: The cloud account to run the job on.
             Defaults to the studio cloud account if running with studio compute env.
-        If not provided will fall back to the teamspaces default cloud account.
+            If not provided and `cloud_account_provider` is set, will resolve cluster from this, else
+            will fall back to the teamspaces default cloud account.
+        cloud_account_provider: The provider to select the cloud-account from.
+            If set, must be in agreement with the provider from the cloud_account (if specified).
+            If not specified, falls backto the teamspace default cloud account.
         env: Environment variables to set inside the job.
         interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
         image_credentials: The credentials used to pull the image. Required if the image is private.
             This should be the name of the respective credentials secret created on the Lightning AI platform.
         cloud_account_auth: Whether to authenticate with the cloud account to pull the image.
             Required if the registry is part of a cloud provider (e.g. ECR).
-        artifacts_local: The path of inside the docker container, you want to persist images from.
-            CAUTION: When setting this to "/", it will effectively erase your container.
-            Only supported for jobs with a docker image compute environment.
-        artifacts_remote: The remote storage to persist your artifacts to.
-            Should be of format <CONNECTION_TYPE>:<CONNECTION_NAME>:<PATH_WITHIN_CONNECTION>.
-            PATH_WITHIN_CONNECTION hereby is a path relative to the connection's root.
-            E.g. efs:data:some-path would result in an EFS connection named `data` and to the path `some-path`
-            within it.
-            Note that the connection needs to be added to the teamspace already in order for it to be found.
-            Only supported for jobs with a docker image compute environment.
         entrypoint: The entrypoint of your docker container. Defaults to `sh -c` which
             just runs the provided command in a standard shell.
             To use the pre-defined entrypoint of the provided image, set this to an empty string.
             Only applicable when submitting docker jobs.
+        path_mappings: Dictionary of path mappings. The keys are the path inside the container whereas the value
+            represents the data-connection name and the path inside that connection.
+            Should be of form
+                {
+                    "<CONTAINER_PATH_1>": "<CONNECTION_NAME_1>:<PATH_WITHIN_CONNECTION_1>",
+                    "<CONTAINER_PATH_2>": "<CONNECTION_NAME_2>"
+                }
+            If the path inside the connection is omitted it's assumed to be the root path of that connection.
+            Only applicable when submitting docker jobs.
+        max_runtime: the duration (in seconds) for which to allocate the machine.
+                Irrelevant for most machines, required for some of the top-end machines on GCP.
+                If in doubt, set it. Won't have an effect on machines not requiring it.
+                Defaults to 3h
+        reuse_snapshot: Whether the job should reuse a Studio snapshot when multiple jobs for the same Studio are
+                submitted. Turning this off may result in longer job startup times. Defaults to True.
         """
         ret_val = super().run(
             name=name,
@@ -152,6 +154,7 @@ class Job(_BaseJob):
             org=org,
             user=user,
             cloud_account=cloud_account,
+            cloud_provider=cloud_provider,
             env=env,
             interruptible=interruptible,
             image_credentials=image_credentials,
@@ -159,7 +162,10 @@ class Job(_BaseJob):
             artifacts_local=artifacts_local,
             artifacts_remote=artifacts_remote,
             entrypoint=entrypoint,
+            path_mappings=path_mappings,
+            max_runtime=max_runtime,
             cluster=cluster,
+            reuse_snapshot=reuse_snapshot,
         )
         # required for typing with "Job"
         assert isinstance(ret_val, cls)
@@ -169,18 +175,22 @@ class Job(_BaseJob):
 
     def _submit(
         self,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: Optional[str] = None,
         studio: Optional["Studio"] = None,
         image: Optional[str] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[Union["CloudProvider", str]] = None,
         image_credentials: Optional[str] = None,
         cloud_account_auth: bool = False,
-        artifacts_local: Optional[str] = None,
-        artifacts_remote: Optional[str] = None,
         entrypoint: str = "sh -c",
+        path_mappings: Optional[Dict[str, str]] = None,
+        artifacts_local: Optional[str] = None,  # deprecated in terms of path_mappings
+        artifacts_remote: Optional[str] = None,  # deprecated in terms of path_mappings
+        max_runtime: Optional[int] = None,
+        reuse_snapshot: bool = True,
     ) -> "Job":
         """Submit a new job to the Lightning AI platform.
 
@@ -194,28 +204,38 @@ class Job(_BaseJob):
             interruptible: Whether the job should run on interruptible instances. They are cheaper but can be preempted.
             cloud_account: The cloud account to run the job on.
                 Defaults to the studio cloud account if running with studio compute env.
-                If not provided will fall back to the teamspaces default cloud account.
+                If not provided and `cloud_account_provider` is set, will resolve cluster from this, else
+                will fall back to the teamspaces default cloud account.
+            cloud_account_provider: The provider to select the cloud-account from.
+                If set, must be in agreement with the provider from the cloud_account (if specified).
+                If not specified, falls backto the teamspace default cloud account.
             image_credentials: The credentials used to pull the image. Required if the image is private.
                 This should be the name of the respective credentials secret created on the Lightning AI platform.
             cloud_account_auth: Whether to authenticate with the cloud account to pull the image.
                 Required if the registry is part of a cloud provider (e.g. ECR).
-            artifacts_local: The path of inside the docker container, you want to persist images from.
-                CAUTION: When setting this to "/", it will effectively erase your container.
-                Only supported for jobs with a docker image compute environment.
-            artifacts_remote: The remote storage to persist your artifacts to.
-                Should be of format <CONNECTION_TYPE>:<CONNECTION_NAME>:<PATH_WITHIN_CONNECTION>.
-                PATH_WITHIN_CONNECTION hereby is a path relative to the connection's root.
-                E.g. efs:data:some-path would result in an EFS connection named `data` and to the path `some-path`
-                within it.
-                Note that the connection needs to be added to the teamspace already in order for it to be found.
-                Only supported for jobs with a docker image compute environment.
             entrypoint: The entrypoint of your docker container. Defaults to sh -c.
                 To use the pre-defined entrypoint of the provided image, set this to an empty string.
                 Only applicable when submitting docker jobs.
+            path_mappings: Dictionary of path mappings. The keys are the path inside the container whereas the value
+                represents the data-connection name and the path inside that connection.
+                Should be of form
+                    {
+                        "<CONTAINER_PATH_1>": "<CONNECTION_NAME_1>:<PATH_WITHIN_CONNECTION_1>",
+                        "<CONTAINER_PATH_2>": "<CONNECTION_NAME_2>"
+                    }
+                If the path inside the connection is omitted it's assumed to be the root path of that connection.
+                Only applicable when submitting docker jobs.
+            max_runtime: the duration (in seconds) for which to allocate the machine.
+                Irrelevant for most machines, required for some of the top-end machines on GCP.
+                If in doubt, set it. Won't have an effect on machines not requiring it.
+                Defaults to 3h
+            reuse_snapshot: Whether the job should reuse a Studio snapshot when multiple jobs for the same Studio are
+                submitted. Turning this off may result in longer job startup times. Defaults to True.
         """
         self._job = self._internal_job._submit(
             machine=machine,
             cloud_account=cloud_account,
+            cloud_provider=cloud_provider,
             command=command,
             studio=studio,
             image=image,
@@ -223,8 +243,12 @@ class Job(_BaseJob):
             interruptible=interruptible,
             image_credentials=image_credentials,
             cloud_account_auth=cloud_account_auth,
+            entrypoint=entrypoint,
+            path_mappings=path_mappings,
             artifacts_local=artifacts_local,
             artifacts_remote=artifacts_remote,
+            max_runtime=max_runtime,
+            reuse_snapshot=reuse_snapshot,
         )
         return self
 
@@ -243,15 +267,20 @@ class Job(_BaseJob):
         return self._internal_job.delete()
 
     @property
-    def status(self) -> "Status":
+    def status(self) -> Optional["Status"]:
         """The current status of the job."""
         return self._internal_job.status
 
     @property
-    def machine(self) -> "Machine":
+    def machine(self) -> Union["Machine", str]:
         """The machine type the job is running on."""
         return self._internal_job.machine
 
+    @property
+    def public_ip(self) -> Optional[str]:
+        """The public IP address of the machine the job is running on."""
+        return self._internal_job.public_ip
+
     @property
     def artifact_path(self) -> Optional[str]:
         """Path to the artifacts created by the job within the distributed teamspace filesystem."""

lightning_sdk/job/v1.py

@@ -5,7 +5,7 @@ from lightning_sdk.job.base import _BaseJob
 from lightning_sdk.status import Status
 
 if TYPE_CHECKING:
-    from lightning_sdk.machine import Machine
+    from lightning_sdk.machine import CloudProvider, Machine
     from lightning_sdk.organization import Organization
     from lightning_sdk.studio import Studio
     from lightning_sdk.teamspace import Teamspace
@@ -44,15 +44,17 @@ class _JobV1(_BaseJob):
     def run(
         cls,
         name: str,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: str,
         studio: "Studio",
         teamspace: Union[str, "Teamspace", None] = None,
         org: Union[str, "Organization", None] = None,
         user: Union[str, "User", None] = None,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[str] = None,
         interruptible: bool = False,
         cluster: Optional[str] = None,  # deprecated in favor of cloud_account
+        reuse_snapshot: bool = True,
     ) -> "_BaseJob":
         """Start a new async workload from your studio.
 
@@ -80,27 +82,35 @@ class _JobV1(_BaseJob):
             org=org,
             user=user,
             cloud_account=cloud_account,
+            cloud_provider=cloud_provider,
             env=None,
             interruptible=interruptible,
             image_credentials=None,
             cloud_account_auth=False,
             cluster=cluster,
+            path_mappings=None,
+            max_runtime=None,
+            reuse_snapshot=reuse_snapshot,
         )
 
     def _submit(
         self,
-        machine: "Machine",
+        machine: Union["Machine", str],
         command: Optional[str] = None,
         studio: Optional["Studio"] = None,
         image: Optional[str] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         cloud_account: Optional[str] = None,
+        cloud_provider: Optional[Union["CloudProvider", str]] = None,
         image_credentials: Optional[str] = None,
         cloud_account_auth: bool = False,
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
         entrypoint: str = "sh -c",
+        path_mappings: Optional[Dict[str, str]] = None,
+        max_runtime: Optional[int] = None,
+        reuse_snapshot: bool = True,
     ) -> "_JobV1":
         """Submit a job to run on a machine.
 
@@ -114,46 +124,21 @@ class _JobV1(_BaseJob):
             cloud_account: The cloud account to run the job on.
             image_credentials: The image credentials for the job (not supported).
             cloud_account_auth: Whether to use cloud account authentication for the job (not supported).
-            artifacts_local: The local path for persisting artifacts (not supported).
-            artifacts_remote: The remote path for persisting artifacts (not supported).
             entrypoint: The entrypoint of your docker container (not supported).
                 Defaults to `sh -c` which just runs the provided command in a standard shell.
                 To use the pre-defined entrypoint of the provided image, set this to an empty string.
                 Only applicable when submitting docker jobs.
+            path_mappings: The mappings from data connection inside your container (not supported)
+            max_runtime: the duration (in seconds) for which to allocate the machine.
+                Irrelevant for most machines, required for some of the top-end machines on GCP.
+                If in doubt, set it. Won't have an effect on machines not requiring it.
+                Defaults to 3h
 
         Returns:
             The submitted job.
 
         """
-        if studio is None:
-            raise ValueError("Studio is required for submitting jobs")
-        if image is not None or image_credentials is not None or cloud_account_auth:
-            raise ValueError("Image is not supported for submitting jobs")
-
-        if artifacts_local is not None or artifacts_remote is not None:
-            raise ValueError("Specifying how to persist artifacts is not yet supported with jobs")
-
-        if env is not None:
-            raise ValueError("Environment variables are not supported for submitting jobs")
-        if command is None:
-            raise ValueError("Command is required for submitting jobs")
-
-        if entrypoint != "sh -c":
-            raise ValueError("Specifying the entrypoint is not yet supported with jobs")
-
-        # TODO: add support for empty names (will give an empty string)
-        _submitted = self._job_api.submit_job(
-            name=self._name,
-            command=command,
-            studio_id=studio._studio.id,
-            teamspace_id=self._teamspace.id,
-            cloud_account=cloud_account or "",
-            machine=machine,
-            interruptible=interruptible,
-        )
-        self._name = _submitted.name
-        self._job = _submitted
-        return self
+        raise NotImplementedError("Cannot submit new jobs with JobsV1!")
 
     def _update_internal_job(self) -> None:
         try:
@@ -195,10 +180,18 @@ class _JobV1(_BaseJob):
         return Work(_work[0].id, self, self.teamspace)
 
     @property
-    def machine(self) -> "Machine":
+    def machine(self) -> Union["Machine", str]:
         """Get the machine the job is running on."""
         return self.work.machine
 
+    @property
+    def public_ip(self) -> Optional[str]:
+        """Get the public IP of the machine the job is running on."""
+        try:
+            return self._job.status.ip_address
+        except AttributeError:
+            return None
+
     @property
     def name(self) -> str:
         """The name of the job."""