lightning-sdk 0.1.42__py3-none-any.whl → 0.1.43__py3-none-any.whl

lightning_sdk/__init__.py

@@ -27,5 +27,5 @@ __all__ = [
     "AIHub",
 ]
 
-__version__ = "0.1.42"
+__version__ = "0.1.43"
 _check_version_and_prompt_upgrade(__version__)

lightning_sdk/cli/run.py

@@ -2,6 +2,8 @@ from typing import TYPE_CHECKING, Dict, Optional
 
 from lightning_sdk.job import Job
 from lightning_sdk.machine import Machine
+from lightning_sdk.mmt import MMT
+from lightning_sdk.teamspace import Teamspace
 
 if TYPE_CHECKING:
     from lightning_sdk.cli.legacy import _LegacyLightningCLI
@@ -20,7 +22,7 @@ class _Run:
         # Need to set the docstring here for f-strings to work.
         # Sadly this is the only way to really show options as f-strings are not allowed as docstrings directly
         # and fire does not show values for literals, just that it is a literal.
-        docstr = f"""Run async workloads using a docker image or a compute environment from your studio.
+        docstr_job = f"""Run async workloads using a docker image or a compute environment from your studio.
 
         Args:
             name: The name of the job. Needs to be unique within the teamspace.
@@ -54,7 +56,47 @@ class _Run:
         """
         # TODO: the docstrings from artifacts_local and artifacts_remote don't show up completely,
         # might need to switch to explicit cli definition
-        self.job.__func__.__doc__ = docstr
+        self.job.__func__.__doc__ = docstr_job
+
+        # Need to set the docstring here for f-strings to work.
+        # Sadly this is the only way to really show options as f-strings are not allowed as docstrings directly
+        # and fire does not show values for literals, just that it is a literal.
+        docstr_mmt = f"""Run async workloads on multiple machines using a docker image.
+
+        Args:
+            name: The name of the job. Needs to be unique within the teamspace.
+            num_machines: The number of Machines to run on. Defaults to 2 Machines
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}. Defaults to CPU
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            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 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.
+            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.
+        """
+        # TODO: the docstrings from artifacts_local and artifacts_remote don't show up completely,
+        # might need to switch to explicit cli definition
+        self.mmt.__func__.__doc__ = docstr_mmt
 
     # TODO: sadly, fire displays both Optional[type] and Union[type, None] as Optional[Optional]
     # see https://github.com/google/python-fire/pull/513
@@ -62,7 +104,7 @@ class _Run:
     def job(
         self,
         name: str,
-        machine: str,
+        machine: Optional[str] = None,
         command: Optional[str] = None,
         studio: Optional[str] = None,
         image: Optional[str] = None,
@@ -77,6 +119,15 @@ class _Run:
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
     ) -> None:
+        if machine is None:
+            # TODO: infer from studio
+            machine = "CPU"
+        machine_enum = Machine(machine.upper())
+
+        resolved_teamspace = Teamspace(name=teamspace, org=org, user=user)
+
+        if cloud_account is None:
+            cloud_account = resolved_teamspace.default_cloud_account
         machine_enum = Machine(machine.upper())
         Job.run(
             name=name,
@@ -84,7 +135,65 @@ class _Run:
             command=command,
             studio=studio,
             image=image,
-            teamspace=teamspace,
+            teamspace=resolved_teamspace,
+            org=org,
+            user=user,
+            cloud_account=cloud_account,
+            env=env,
+            interruptible=interruptible,
+            image_credentials=image_credentials,
+            cloud_account_auth=cloud_account_auth,
+            artifacts_local=artifacts_local,
+            artifacts_remote=artifacts_remote,
+        )
+
+    # TODO: sadly, fire displays both Optional[type] and Union[type, None] as Optional[Optional]
+    # see https://github.com/google/python-fire/pull/513
+    # might need to move to different cli library
+    def mmt(
+        self,
+        name: Optional[str] = None,
+        num_machines: int = 2,
+        machine: Optional[str] = None,
+        command: Optional[str] = None,
+        image: Optional[str] = None,
+        teamspace: Optional[str] = None,
+        org: Optional[str] = None,
+        user: Optional[str] = None,
+        cloud_account: Optional[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,
+    ) -> None:
+        if name is None:
+            from datetime import datetime
+
+            timestr = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+            name = f"mmt-{timestr}"
+
+        if machine is None:
+            # TODO: infer from studio
+            machine = "CPU"
+        machine_enum = Machine(machine.upper())
+
+        resolved_teamspace = Teamspace(name=teamspace, org=org, user=user)
+        if cloud_account is None:
+            cloud_account = resolved_teamspace.default_cloud_account
+
+        if image is None:
+            raise RuntimeError("Image needs to be specified to run a multi-machine job")
+
+        MMT.run(
+            name=name,
+            num_machines=num_machines,
+            machine=machine_enum,
+            command=command,
+            studio=None,
+            image=image,
+            teamspace=resolved_teamspace,
             org=org,
             user=user,
             cloud_account=cloud_account,

lightning_sdk/cli/serve.py

@@ -2,29 +2,41 @@ import os
 import subprocess
 import warnings
 from pathlib import Path
-from typing import Union
+from typing import Optional, Union
 
 from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.prompt import Confirm
 
 
 class _LitServe:
     """Serve a LitServe model.
 
     Example:
-        lightning serve api server.py
+        lightning serve api server.py  # serve locally
+        lightning serve api server.py --cloud  # deploy to the cloud
+
+    You can deploy the API to the cloud by running `lightning serve api server.py --cloud`.
+    This will generate a Dockerfile, build the image, and push it to the image registry.
+    Deploying to the cloud requires pre-login to the docker registry.
     """
 
     def api(
         self,
         script_path: Union[str, Path],
         easy: bool = False,
+        cloud: bool = False,
+        repository: Optional[str] = None,
+        non_interactive: bool = False,
     ) -> None:
         """Deploy a LitServe model script.
 
         Args:
             script_path: Path to the script to serve
             easy: If True, generates a client for the model
-
+            cloud: If True, deploy the model to the Lightning Studio
+            repository: Optional Docker repository name (e.g., 'username/model-name')
+            non_interactive: If True, do not prompt for confirmation
         Raises:
             FileNotFoundError: If script_path doesn't exist
             ImportError: If litserve is not installed
@@ -56,6 +68,10 @@ class _LitServe:
                 except OSError as e:
                     raise OSError(f"Failed to generate client.py: {e!s}") from None
 
+        if cloud:
+            tag = repository if repository else "litserve-model"
+            return self._handle_cloud(script_path, console, tag=tag, non_interactive=non_interactive)
+
         try:
             subprocess.run(
                 ["python", str(script_path)],
@@ -66,20 +82,91 @@ class _LitServe:
             error_msg = f"Script execution failed with exit code {e.returncode}\nstdout: {e.stdout}\nstderr: {e.stderr}"
             raise RuntimeError(error_msg) from None
 
+    def _handle_cloud(
+        self,
+        script_path: Union[str, Path],
+        console: Console,
+        tag: str = "litserve-model",
+        non_interactive: bool = False,
+    ) -> None:
+        try:
+            import docker
+        except ImportError:
+            raise ImportError("docker-py is not installed. Please install it with `pip install docker`") from None
+
+        try:
+            client = docker.from_env()
+            client.ping()
+        except docker.errors.DockerException as e:
+            raise RuntimeError(f"Failed to connect to Docker daemon: {e!s}. Is Docker running?") from None
+
+        dockerizer = _Docker()
+        path = dockerizer.api(script_path, port=8000, gpu=False, tag=tag)
+
+        console.clear()
+        if non_interactive:
+            console.print("[italic]non-interactive[/italic] mode enabled, skipping confirmation prompts", style="blue")
+
+        console.print(f"\nPlease review the Dockerfile at [u]{path}[/u] and make sure it is correct.", style="bold")
+        correct_dockerfile = True if non_interactive else Confirm.ask("Is the Dockerfile correct?", default=True)
+        if not correct_dockerfile:
+            console.print("Please fix the Dockerfile and try again.", style="red")
+            return
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            TimeElapsedColumn(),
+            console=console,
+            transient=False,
+        ) as progress:
+            build_task = progress.add_task("Building Docker image", total=None)
+            build_status = client.api.build(
+                path=os.path.dirname(path), dockerfile=path, tag=tag, decode=True, quiet=False
+            )
+            for line in build_status:
+                if "error" in line:
+                    progress.stop()
+                    console.print(f"\n[red]{line}[/red]")
+                    return
+                if "stream" in line and line["stream"].strip():
+                    console.print(line["stream"].strip(), style="bright_black")
+                    progress.update(build_task, description="Building Docker image")
+
+            progress.update(build_task, description="[green]Build completed![/green]")
+
+            push_task = progress.add_task("Pushing to registry", total=None)
+            console.print("\nPushing image...", style="bold blue")
+            push_status = client.api.push(tag, stream=True, decode=True)
+            for line in push_status:
+                if "error" in line:
+                    progress.stop()
+                    console.print(f"\n[red]{line}[/red]")
+                    return
+                if "status" in line:
+                    console.print(line["status"], style="bright_black")
+                    progress.update(push_task, description="Pushing to registry")
+
+            progress.update(push_task, description="[green]Push completed![/green]")
+
+        console.print(f"\n✅ Image pushed to {tag}", style="bold green")
+        console.print(
+            "Soon you will be able to deploy this model to the Lightning Studio!",
+        )
+        # TODO: Deploy to the cloud
+
 
 class _Docker:
     """Generate a Dockerfile for a LitServe model."""
 
-    def api(self, server_filename: str, port: int = 8000, gpu: bool = False) -> None:
+    def api(self, server_filename: str, port: int = 8000, gpu: bool = False, tag: str = "litserve-model") -> str:
         """Generate a Dockerfile for the given server code.
 
-        Example:
-            lightning litserve dockerize server.py --port 8000 --gpu
-
         Args:
-            server_filename (str): The path to the server file. Example sever.py or app.py.
-            port (int, optional): The port to expose in the Docker container.
-            gpu (bool, optional): Whether to use a GPU-enabled Docker image.
+            server_filename: The path to the server file. Example sever.py or app.py.
+            port: The port to expose in the Docker container.
+            gpu: Whether to use a GPU-enabled Docker image.
+            tag: Docker image tag to use in examples.
         """
         import litserve as ls
         from litserve import docker_builder
@@ -101,10 +188,10 @@ class _Docker:
 
         version = ls.__version__
         if gpu:
-            run_cmd = f"docker run --gpus all -p {port}:{port} litserve-model:latest"
+            run_cmd = f"docker run --gpus all -p {port}:{port} {tag}:latest"
             docker_template = docker_builder.CUDA_DOCKER_TEMPLATE
         else:
-            run_cmd = f"docker run -p {port}:{port} litserve-model:latest"
+            run_cmd = f"docker run -p {port}:{port} {tag}:latest"
             docker_template = docker_builder.DOCKERFILE_TEMPLATE
         dockerfile_content = docker_template.format(
             server_filename=server_filename,
@@ -119,12 +206,13 @@ class _Docker:
 Update [underline]{os.path.abspath("Dockerfile")}[/underline] to add any additional dependencies or commands.
 
 [bold]Build the container with:[/bold]
-> [underline]docker build -t litserve-model .[/underline]
+> [underline]docker build -t {tag} .[/underline]
 
 [bold]To run the Docker container on the machine:[/bold]
 > [underline]{run_cmd}[/underline]
 
 [bold]To push the container to a registry:[/bold]
-> [underline]docker push litserve-model[/underline]
+> [underline]docker push {tag}[/underline]
 """
         console.print(success_msg)
+        return os.path.abspath("Dockerfile")

lightning_sdk/job/job.py

@@ -25,6 +25,8 @@ def _has_jobs_v2() -> bool:
 
 
 class Job(_BaseJob):
+    """Class to submit and manage single-machine jobs on the Lightning AI Platform."""
+
     def __init__(
         self,
         name: str,
@@ -34,6 +36,15 @@ class Job(_BaseJob):
         *,
         _fetch_job: bool = True,
     ) -> None:
+        """Fetch already existing jobs.
+
+        Args:
+            name: the name of the job
+            teamspace: the teamspace the job is part of
+            org: the name of the organization owning the :param`teamspace` in case it is owned by an org
+            user: the name of the user owning the :param`teamspace`
+                in case it is owned directly by a user instead of an org.
+        """
         internal_job_cls = _JobV2 if _has_jobs_v2() else _JobV1
 
         self._internal_job = internal_job_cls(

lightning_sdk/mmt/__init__.py

@@ -1,3 +1,4 @@
+from lightning_sdk.mmt.base import MMTMachine
 from lightning_sdk.mmt.mmt import MMT
 
-__all__ = ["MMT"]
+__all__ = ["MMT", "MMTMachine"]

lightning_sdk/mmt/base.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Dict, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Dict, Optional, Protocol, Tuple, Union
 
 if TYPE_CHECKING:
     from lightning_sdk.machine import Machine
@@ -10,11 +10,36 @@ if TYPE_CHECKING:
     from lightning_sdk.user import User
 
 from lightning_sdk.job.base import _BaseJob
-from lightning_sdk.job.job import Job
 from lightning_sdk.utils.resolve import _resolve_deprecated_cluster
 
 
+class MMTMachine(Protocol):
+    """A single machine in multi-machine training."""
+
+    @property
+    def name(self) -> str:
+        """The Name of the individual machine. Usually corresponds to the rank."""
+        ...
+
+    @property
+    def machine(self) -> "Machine":
+        """The actual machine type this node is running on."""
+        ...
+
+    @property
+    def artifact_path(self) -> Optional[str]:
+        """The path to the artifacts of this job."""
+        ...
+
+    @property
+    def status(self) -> "Status":
+        """The status of this job."""
+        ...
+
+
 class _BaseMMT(_BaseJob):
+    """Base interface to all job types."""
+
     @classmethod
     def run(
         cls,
@@ -36,6 +61,39 @@ class _BaseMMT(_BaseJob):
         artifacts_remote: Optional[str] = None,
         cluster: Optional[str] = None,  # deprecated in favor of cloud_account
     ) -> "_BaseMMT":
+        """Run async workloads using a docker image across multiple machines.
+
+        Args:
+            name: The name of the job. Needs to be unique within the teamspace.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            num_machine: The number of machines to run on.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            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 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.
+            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.
+        """
         from lightning_sdk.studio import Studio
 
         cloud_account = _resolve_deprecated_cluster(cloud_account, cluster)
@@ -134,53 +192,87 @@ class _BaseMMT(_BaseJob):
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
     ) -> None:
-        """Submits a job and updates the internal _job attribute as well as the _name attribute."""
+        """Submit a new multi-machine job to the Lightning AI platform.
+
+        Args:
+            num_machines: The number of machines to run on.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            env: Environment variables to set inside the job.
+            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.
+            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.
+        """
 
     @property
     @abstractmethod
-    def machines(self) -> Tuple["Job", ...]:
-        pass
+    def machines(self) -> Tuple[MMTMachine, ...]:
+        """Returns the sub-jobs for each individual instance."""
 
     @property
     @abstractmethod
     def machine(self) -> "Machine":
-        pass
+        """Returns the machine type this job is running on."""
 
     @abstractmethod
     def stop(self) -> None:
-        pass
+        """Stops the job."""
 
     @abstractmethod
     def delete(self) -> None:
-        pass
+        """Deletes the job.
+
+        Caution: This also deletes all artifacts and snapshots associated with the job.
+        """
 
     @property
     @abstractmethod
     def status(self) -> "Status":
-        pass
+        """The current status of the job."""
 
     @property
     @abstractmethod
     def artifact_path(self) -> Optional[str]:
-        pass
+        """Path to the artifacts created by the job within the distributed teamspace filesystem."""
 
     @property
     @abstractmethod
     def snapshot_path(self) -> Optional[str]:
-        pass
+        """Path to the studio snapshot used to create the job within the distributed teamspace filesystem."""
 
     @property
     def share_path(self) -> Optional[str]:
+        """Path to the jobs share path."""
         return None
 
-    @abstractmethod
-    def _update_internal_job(self) -> None:
-        pass
-
     @property
     def name(self) -> str:
+        """The job's name."""
         return self._name
 
     @property
     def teamspace(self) -> "Teamspace":
+        """The teamspace the job is part of."""
         return self._teamspace
+
+    @abstractmethod
+    def _update_internal_job(self) -> None:
+        pass

lightning_sdk/mmt/mmt.py

@@ -1,7 +1,9 @@
-from typing import TYPE_CHECKING, Any, Dict, Optional, Protocol, Tuple, Union
+from functools import lru_cache
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
 
+from lightning_sdk.api.user_api import UserApi
 from lightning_sdk.job.job import _has_jobs_v2
-from lightning_sdk.mmt.base import _BaseMMT
+from lightning_sdk.mmt.base import MMTMachine, _BaseMMT
 from lightning_sdk.mmt.v1 import _MMTV1
 from lightning_sdk.mmt.v2 import _MMTV2
 
@@ -14,27 +16,22 @@ if TYPE_CHECKING:
     from lightning_sdk.user import User
 
 
-class MMTMachine(Protocol):
-    """A single machine in multi-machine training."""
+@lru_cache(maxsize=None)
+def _has_mmt_v2() -> bool:
+    # users need both mmtv2 and jobsv2 flags in order for mmtv2 to work correctly
+    if not _has_jobs_v2():
+        return False
 
-    @property
-    def name(self) -> str:
-        ...
-
-    @property
-    def machine(self) -> "Machine":
-        ...
-
-    @property
-    def artifact_path(self) -> Optional[str]:
-        ...
-
-    @property
-    def status(self) -> "Status":
-        ...
+    api = UserApi()
+    try:
+        return api._get_feature_flags().mmt_v2
+    except Exception:
+        return False
 
 
 class MMT(_BaseMMT):
+    """Class to submit and manage multi-machine jobs on the Lightning AI Platform."""
+
     _force_v1: (
         bool
     ) = False  # required for studio plugin still working correctly as v2 currently does not support the studio env
@@ -48,7 +45,16 @@ class MMT(_BaseMMT):
         *,
         _fetch_job: bool = True,
     ) -> None:
-        internal_mmt_cls = _MMTV2 if _has_jobs_v2() and not self._force_v1 else _MMTV1
+        """Fetch already existing jobs.
+
+        Args:
+            name: the name of the job
+            teamspace: the teamspace the job is part of
+            org: the name of the organization owning the :param`teamspace` in case it is owned by an org
+            user: the name of the user owning the :param`teamspace`
+                in case it is owned directly by a user instead of an org.
+        """
+        internal_mmt_cls = _MMTV2 if _has_mmt_v2() and not self._force_v1 else _MMTV1
 
         self._internal_mmt = internal_mmt_cls(
             name=name,
@@ -79,6 +85,39 @@ class MMT(_BaseMMT):
         artifacts_remote: Optional[str] = None,
         cluster: Optional[str] = None,  # deprecated in favor of cloud_account
     ) -> "MMT":
+        """Run async workloads using a docker image across multiple machines.
+
+        Args:
+            name: The name of the job. Needs to be unique within the teamspace.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            num_machine: The number of machines to run on.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            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 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.
+            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.
+        """
         ret_val = super().run(
             name=name,
             num_machines=num_machines,
@@ -117,6 +156,35 @@ class MMT(_BaseMMT):
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
     ) -> "MMT":
+        """Submit a new multi-machine job to the Lightning AI platform.
+
+        Args:
+            num_machines: The number of machines to run on.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            env: Environment variables to set inside the job.
+            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.
+            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.
+        """
         self._job = self._internal_mmt._submit(
             num_machines=num_machines,
             machine=machine,
@@ -134,33 +202,44 @@ class MMT(_BaseMMT):
         return self
 
     def stop(self) -> None:
+        """Stops the job."""
         return self._internal_mmt.stop()
 
     def delete(self) -> None:
+        """Deletes the job.
+
+        Caution: This also deletes all artifacts and snapshots associated with the job.
+        """
         return self._internal_mmt.delete()
 
     @property
     def status(self) -> "Status":
+        """The current status of the job (accumulated over all machines)."""
         return self._internal_mmt.status
 
     @property
     def machines(self) -> Tuple[MMTMachine, ...]:
+        """Returns the sub-jobs for each individual instance."""
         return self._internal_mmt.machines
 
     @property
     def machine(self) -> "Machine":
+        """Returns the machine type this job is running on."""
         return self._internal_mmt.machine
 
     @property
     def artifact_path(self) -> Optional[str]:
+        """Path to the artifacts created by the job within the distributed teamspace filesystem."""
         return self._internal_mmt.artifact_path
 
     @property
     def snapshot_path(self) -> Optional[str]:
+        """Path to the studio snapshot used to create the job within the distributed teamspace filesystem."""
         return self._internal_mmt.snapshot_path
 
     @property
     def share_path(self) -> Optional[str]:
+        """Path to the jobs share path."""
         return None
 
     def _update_internal_job(self) -> None:
@@ -168,16 +247,14 @@ class MMT(_BaseMMT):
 
     @property
     def name(self) -> str:
+        """The job's name."""
         return self._internal_mmt.name
 
     @property
     def teamspace(self) -> "Teamspace":
+        """The teamspace the job is part of."""
         return self._internal_mmt._teamspace
 
-    @property
-    def cloud_account(self) -> Optional[str]:
-        return self._internal_mmt.cloud_account
-
     def __getattr__(self, key: str) -> Any:
         """Forward the attribute lookup to the internal job implementation."""
         try:

lightning_sdk/mmt/v1.py

@@ -16,6 +16,8 @@ from lightning_sdk.mmt.base import _BaseMMT
 
 
 class _MMTV1(_BaseMMT):
+    """V1 Implementation of Multi-Machine Training."""
+
     def __init__(
         self,
         name: str,
@@ -25,6 +27,15 @@ class _MMTV1(_BaseMMT):
         *,
         _fetch_job: bool = True,
     ) -> None:
+        """Fetch already existing jobs.
+
+        Args:
+            name: the name of the job
+            teamspace: the teamspace the job is part of
+            org: the name of the organization owning the :param`teamspace` in case it is owned by an org
+            user: the name of the user owning the :param`teamspace`
+                in case it is owned directly by a user instead of an org.
+        """
         self._job_api = MMTApiV1()
         super().__init__(name=name, teamspace=teamspace, org=org, user=user, _fetch_job=_fetch_job)
 
@@ -43,6 +54,35 @@ class _MMTV1(_BaseMMT):
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
     ) -> "_MMTV1":
+        """Submit a new multi-machine job to the Lightning AI platform.
+
+        Args:
+            num_machines: The number of machines to run on.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            env: Environment variables to set inside the job.
+            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.
+            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.
+        """
         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:
@@ -80,18 +120,25 @@ class _MMTV1(_BaseMMT):
 
     @property
     def machines(self) -> Tuple["Work", ...]:
+        """Returns the sub-jobs for each individual instance."""
         works = self._job_api.list_works(self._guaranteed_job.id, self.teamspace.id)
 
         return tuple(Work(w.id, self, self.teamspace) for w in works)
 
     def stop(self) -> None:
+        """Stops the job."""
         self._job_api.stop_job(self._guaranteed_job.id, self.teamspace.id)
 
     def delete(self) -> None:
+        """Deletes the job.
+
+        Caution: This also deletes all artifacts and snapshots associated with the job.
+        """
         self._job_api.delete_job(self._guaranteed_job.id, self.teamspace.id)
 
     @property
     def status(self) -> "Status":
+        """The current status of the job."""
         try:
             status = self._job_api.get_job_status(self._job.id, self.teamspace.id)
             return _internal_status_to_external_status(status)
@@ -102,22 +149,27 @@ class _MMTV1(_BaseMMT):
 
     @property
     def artifact_path(self) -> Optional[str]:
+        """Path to the artifacts created by the job within the distributed teamspace filesystem."""
         return f"/teamspace/jobs/{self.name}"
 
     @property
     def snapshot_path(self) -> Optional[str]:
+        """Path to the studio snapshot used to create the job within the distributed teamspace filesystem."""
         return f"/teamspace/jobs/{self.name}/snapshot"
 
     @property
     def machine(self) -> "Machine":
+        """Returns the machine type this job is running on."""
         return self.machines[0].machine
 
     @property
     def name(self) -> str:
+        """The job's name."""
         return self._name
 
     @property
     def teamspace(self) -> "Teamspace":
+        """The teamspace the job is part of."""
         return self._teamspace
 
     # the following and functions are solely to make the Work class function

lightning_sdk/mmt/v2.py

@@ -15,6 +15,8 @@ from lightning_sdk.mmt.base import _BaseMMT
 
 
 class _MMTV2(_BaseMMT):
+    """New implementation of Multi-Machine Training."""
+
     def __init__(
         self,
         name: str,
@@ -24,6 +26,15 @@ class _MMTV2(_BaseMMT):
         *,
         _fetch_job: bool = True,
     ) -> None:
+        """Fetch already existing jobs.
+
+        Args:
+            name: the name of the job
+            teamspace: the teamspace the job is part of
+            org: the name of the organization owning the :param`teamspace` in case it is owned by an org
+            user: the name of the user owning the :param`teamspace`
+                in case it is owned directly by a user instead of an org.
+        """
         self._job_api = MMTApiV2()
         super().__init__(name=name, teamspace=teamspace, org=org, user=user, _fetch_job=_fetch_job)
 
@@ -42,6 +53,35 @@ class _MMTV2(_BaseMMT):
         artifacts_local: Optional[str] = None,
         artifacts_remote: Optional[str] = None,
     ) -> "_MMTV2":
+        """Submit a new multi-machine job to the Lightning AI platform.
+
+        Args:
+            num_machines: The number of machines to run on.
+            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}.
+            command: The command to run inside your job. Required if using a studio. Optional if using an image.
+                If not provided for images, will run the container entrypoint and default command.
+            studio: The studio env to run the job with. Mutually exclusive with image.
+            image: The docker image to run the job with. Mutually exclusive with studio.
+            env: Environment variables to set inside the job.
+            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.
+            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.
+        """
         # Command is required if Studio is provided to know what to run
         # Image is mutually exclusive with Studio
         # Command is optional for Image
@@ -80,6 +120,7 @@ class _MMTV2(_BaseMMT):
 
     @property
     def machines(self) -> Tuple["Job", ...]:
+        """Returns the sub-jobs for each individual instance."""
         from lightning_sdk.job import Job
 
         return tuple(
@@ -88,9 +129,14 @@ class _MMTV2(_BaseMMT):
         )
 
     def stop(self) -> None:
+        """Stops the job."""
         self._job_api.stop_job(job_id=self._guaranteed_job.id, teamspace_id=self._teamspace.id)
 
     def delete(self) -> None:
+        """Deletes the job.
+
+        Caution: This also deletes all artifacts and snapshots associated with the job.
+        """
         self._job_api.delete_job(
             job_id=self._guaranteed_job.id,
             teamspace_id=self._teamspace.id,
@@ -104,20 +150,24 @@ class _MMTV2(_BaseMMT):
 
     @property
     def status(self) -> "Status":
+        """The current status of the job."""
         return self._job_api._job_state_to_external(self._latest_job.state)
 
     @property
     def artifact_path(self) -> Optional[str]:
+        """Path to the artifacts created by the job within the distributed teamspace filesystem."""
         # TODO: Since grouping for those is not done yet on the BE, we cannot yet have a unified link here
         raise NotImplementedError
 
     @property
     def snapshot_path(self) -> Optional[str]:
+        """Path to the studio snapshot used to create the job within the distributed teamspace filesystem."""
         # TODO: Since grouping for those is not done yet on the BE, we cannot yet have a unified link here
         raise NotImplementedError
 
     @property
     def machine(self) -> "Machine":
+        """Returns the machine type this job is running on."""
         return self._job_api._get_job_machine_from_spec(self._guaranteed_job.spec)
 
     def _update_internal_job(self) -> None:
@@ -129,8 +179,10 @@ class _MMTV2(_BaseMMT):
 
     @property
     def name(self) -> str:
+        """The job's name."""
         return self._name
 
     @property
     def teamspace(self) -> "Teamspace":
+        """The teamspace the job is part of."""
         return self._teamspace

{lightning_sdk-0.1.42.dist-info → lightning_sdk-0.1.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightning_sdk
-Version: 0.1.42
+Version: 0.1.43
 Summary: SDK to develop using Lightning AI Studios
 Author-email: Lightning-AI <justus@lightning.ai>
 License: MIT License
@@ -47,6 +47,7 @@ Requires-Dist: simple-term-menu
 Requires-Dist: lightning-utilities
 Provides-Extra: serve
 Requires-Dist: litserve>=0.2.5; extra == "serve"
+Requires-Dist: docker; extra == "serve"
 
 # Lightning SDK
 

{lightning_sdk-0.1.42.dist-info → lightning_sdk-0.1.43.dist-info}/RECORD

@@ -1,5 +1,5 @@
 docs/source/conf.py,sha256=r8yX20eC-4mHhMTd0SbQb5TlSWHhO6wnJ0VJ_FBFpag,13249
-lightning_sdk/__init__.py,sha256=Tndl6PUCxWaYJY0gViZXePoopC4k4r3QXpC0MR7r9ZY,925
+lightning_sdk/__init__.py,sha256=je3-DFVBfoAqqPLrFLZmVZGWPNda7886O9-BrY6dvlQ,925
 lightning_sdk/agents.py,sha256=ly6Ma1j0ZgGPFyvPvMN28JWiB9dATIstFa5XM8pMi6I,1577
 lightning_sdk/ai_hub.py,sha256=kBjtmrzVHPCgqtV_TrSNkuf4oT2DLm8SYRTz4iTQmmY,6624
 lightning_sdk/constants.py,sha256=ztl1PTUBULnqTf3DyKUSJaV_O20hNtUYT6XvAYIrmIk,749
@@ -30,16 +30,15 @@ lightning_sdk/cli/download.py,sha256=nyQN3q1vZ0fg4_cfit8cKaokQ9VUd46l_TNcAQWkLwU
 lightning_sdk/cli/entrypoint.py,sha256=Hl2Lm7-OS0kx_pyJyGe7Nii0Soc6HYe4r4xXKeJuC_o,1507
 lightning_sdk/cli/exceptions.py,sha256=QUF3OMAMZwBikvlusimSHSBjb6ywvHpfAumJBEaodSw,169
 lightning_sdk/cli/legacy.py,sha256=ocTVNwlsLRS5aMjbMkwFPjT3uEYvS8C40CJ0PeRRv8g,4707
-lightning_sdk/cli/mmt.py,sha256=sRCr9q3XOggaScOeM0O30mZvO6sNQ2hvL3_kuXB5eLY,6327
-lightning_sdk/cli/run.py,sha256=K467Do3AekbjHFR9KLIOEfuMrUdyx-JW1Rd4Pvd-KRs,5112
-lightning_sdk/cli/serve.py,sha256=dfhbxNscaDJijJSXxpqRKZoI-eGvaIVWKoqTsg_xZWk,4619
+lightning_sdk/cli/run.py,sha256=B6ttd9SKg373ngug-lj74CEcuEoxwz-P6nUBVnQeijI,10836
+lightning_sdk/cli/serve.py,sha256=UaXhGHU6nbAzrnVigSKOTrMjLwSs-sjyhuJCdVUBwzc,8722
 lightning_sdk/cli/studios_menu.py,sha256=0kQGqGel8gAbpdJtjOM1a6NEat_TnIqRNprNn8QiK58,3236
 lightning_sdk/cli/upload.py,sha256=H9OyipYTYAQ9Mzy2e8jtoaa-B34-uXHbTQTzY2Vmhv4,9078
 lightning_sdk/deployment/__init__.py,sha256=BLu7_cVLp97TYxe6qe-J1zKUSZXAVcvCjgcA7plV2k4,497
 lightning_sdk/deployment/deployment.py,sha256=Dp15pn8rFAfMfaDhKn0v3bphFuvLgkPFs3KSNxW6eyc,15472
 lightning_sdk/job/__init__.py,sha256=1MxjQ6rHkyUHCypSW9RuXuVMVH11WiqhIXcU2LCFMwE,64
 lightning_sdk/job/base.py,sha256=I4-iWyiKp1KUkxDy97zJYbwbdQ_7cu6FqCayKwXDloQ,13000
-lightning_sdk/job/job.py,sha256=Qh7BHoyNYVn4QotT8suceCsyBtJolYhbUZdTj-zpmns,10574
+lightning_sdk/job/job.py,sha256=pT9rkSsK5BHu6dSyHpAlYfGXvaF0s_XtrjjhOSAVFWU,11070
 lightning_sdk/job/v1.py,sha256=zIcngaM2_c-2thcKiCOPoWGUuIKc4tasJEwEFJv6bAA,8953
 lightning_sdk/job/v2.py,sha256=oq54VFInuVV_L-nUO_dnBbn4TxPWiBuIqmdFpNN1LmU,8057
 lightning_sdk/job/work.py,sha256=PYopS_6c556I2o8ouSXmzb4FGQflzCe06GpqJiCdedw,1604
@@ -834,11 +833,11 @@ lightning_sdk/lightning_cloud/utils/data_connection.py,sha256=VN-Gs0a4g3tA9TQCwP
 lightning_sdk/lightning_cloud/utils/dataset.py,sha256=4nUspe8iAaRPgSYpXA2uAQCgydm78kJzhOIx3C9qKls,2011
 lightning_sdk/lightning_cloud/utils/name_generator.py,sha256=MkciuA10332V0mcE2PxLIiwWomWE0Fm_gNGK01vwRr4,58046
 lightning_sdk/lightning_cloud/utils/network.py,sha256=axPgl8rhyPcPjxiztDxyksfxax3VNg2OXL5F5Uc81b4,406
-lightning_sdk/mmt/__init__.py,sha256=-qAR2-NihgWNY2tfi0z7atwDLOLwY86tvmgyHA2tfr8,57
-lightning_sdk/mmt/base.py,sha256=9_Lk2aX7HEflDN9ntosDSO5JHRSVVx7w_0EQAjLqKSQ,6411
-lightning_sdk/mmt/mmt.py,sha256=xZUuwgxh_6LSrnNQs5K9Rd5htQ9ZSaKnXbJYO979UM8,5720
-lightning_sdk/mmt/v1.py,sha256=E0zCwUq628xfiygdQEU10dGT4z1Kp1b39Sg212mJKdM,4489
-lightning_sdk/mmt/v2.py,sha256=Mga_LaTr8BM1_6YwnErAE3iq3hJh8r-88hSjN_l9UjE,4772
+lightning_sdk/mmt/__init__.py,sha256=ExMu90-96bGBnyp5h0CErQszUGB1-PcjC4-R8_NYbeY,117
+lightning_sdk/mmt/base.py,sha256=lUB8pAKXTjn_WD6vcJIUMxtZQwrzwxYnaPJbaiPPtMw,12548
+lightning_sdk/mmt/mmt.py,sha256=vMAoR3qjb0VRwCXpKpAMxeTEMALmQB9_RK064fTHM8M,11922
+lightning_sdk/mmt/v1.py,sha256=8LjZnMSGgsGLeajuPto3gknJwVRvsGfkYVoo5A_UlO8,7917
+lightning_sdk/mmt/v2.py,sha256=TsJ8PNluyU0WnNdHvEKWkpJxMwjmyFFJZIaJKCgugIM,8201
 lightning_sdk/services/__init__.py,sha256=gSWUjccEhMI9CIWL_nbrFHUK2S6TM2725mEzrLMfK1Y,225
 lightning_sdk/services/file_endpoint.py,sha256=we5HC_o74J4Y6fSP_31jIizi_I_1FO_Rb2qblspD9eE,7855
 lightning_sdk/services/utilities.py,sha256=IeOx8hc3F8ZevHeKBysh08BXhJliTNzvKp1gwpEfdik,4087
@@ -847,9 +846,9 @@ lightning_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSu
 lightning_sdk/utils/dynamic.py,sha256=glUTO1JC9APtQ6Gr9SO02a3zr56-sPAXM5C3NrTpgyQ,1959
 lightning_sdk/utils/enum.py,sha256=h2JRzqoBcSlUdanFHmkj_j5DleBHAu1esQYUsdNI-hU,4106
 lightning_sdk/utils/resolve.py,sha256=RWvlOWLHjaHhR0W0zT3mN719cbzhFfYCKBss38zfv3k,5783
-lightning_sdk-0.1.42.dist-info/LICENSE,sha256=uFIuZwj5z-4TeF2UuacPZ1o17HkvKObT8fY50qN84sg,1064
-lightning_sdk-0.1.42.dist-info/METADATA,sha256=Jj7QwfnaNqn5u_4muQcqPYx-h2LCwhG4w2aRTHGVeQY,3991
-lightning_sdk-0.1.42.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-lightning_sdk-0.1.42.dist-info/entry_points.txt,sha256=ye4ni8VbtyMXt6e0f5xIL6Liucg4Wrl02DEfLjiMte0,106
-lightning_sdk-0.1.42.dist-info/top_level.txt,sha256=ps8doKILFXmN7F1mHncShmnQoTxKBRPIcchC8TpoBw4,19
-lightning_sdk-0.1.42.dist-info/RECORD,,
+lightning_sdk-0.1.43.dist-info/LICENSE,sha256=uFIuZwj5z-4TeF2UuacPZ1o17HkvKObT8fY50qN84sg,1064
+lightning_sdk-0.1.43.dist-info/METADATA,sha256=qsepNbeCeaApc3hDy1vhjhXs-sIoKUwYfMVK_MaKVUA,4031
+lightning_sdk-0.1.43.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+lightning_sdk-0.1.43.dist-info/entry_points.txt,sha256=msB9PJWIJ784dX-OP8by51d4IbKYH3Fj1vCuA9oXjHY,68
+lightning_sdk-0.1.43.dist-info/top_level.txt,sha256=ps8doKILFXmN7F1mHncShmnQoTxKBRPIcchC8TpoBw4,19
+lightning_sdk-0.1.43.dist-info/RECORD,,

{lightning_sdk-0.1.42.dist-info → lightning_sdk-0.1.43.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
-_mmt = lightning_sdk.cli.mmt:main_cli
 lightning = lightning_sdk.cli.entrypoint:main_cli

lightning_sdk/cli/mmt.py

@@ -1,138 +0,0 @@
-from typing import Dict, Optional
-
-from fire import Fire
-
-from lightning_sdk._mmt import MMT
-from lightning_sdk.api.studio_api import _cloud_url
-from lightning_sdk.lightning_cloud.login import Auth
-from lightning_sdk.machine import Machine
-from lightning_sdk.teamspace import Teamspace
-
-_MACHINE_VALUES = tuple([machine.value for machine in Machine])
-
-
-class MMTCLI:
-    """Command line interface (CLI) to interact with/manage Lightning AI MMT."""
-
-    def __init__(self) -> None:
-        # Need to set the docstring here for f-strings to work.
-        # Sadly this is the only way to really show options as f-strings are not allowed as docstrings directly
-        # and fire does not show values for literals, just that it is a literal.
-        docstr = f"""Run async workloads on multiple machines using a docker image.
-
-        Args:
-            name: The name of the job. Needs to be unique within the teamspace.
-            num_machines: The number of Machines to run on. Defaults to 2 Machines
-            machine: The machine type to run the job on. One of {", ".join(_MACHINE_VALUES)}. Defaults to CPU
-            command: The command to run inside your job. Required if using a studio. Optional if using an image.
-                If not provided for images, will run the container entrypoint and default command.
-            studio: The studio env to run the job with. Mutually exclusive with image.
-            image: The docker image to run the job with. Mutually exclusive with studio.
-            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 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.
-            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.
-        """
-        # TODO: the docstrings from artifacts_local and artifacts_remote don't show up completely,
-        # might need to switch to explicit cli definition
-        self.run.__func__.__doc__ = docstr
-
-    def login(self) -> None:
-        """Login to Lightning AI Studios."""
-        auth = Auth()
-        auth.clear()
-
-        try:
-            auth.authenticate()
-        except ConnectionError:
-            raise RuntimeError(f"Unable to connect to {_cloud_url()}. Please check your internet connection.") from None
-
-    def logout(self) -> None:
-        """Logout from Lightning AI Studios."""
-        auth = Auth()
-        auth.clear()
-
-    # TODO: sadly, fire displays both Optional[type] and Union[type, None] as Optional[Optional]
-    # see https://github.com/google/python-fire/pull/513
-    # might need to move to different cli library
-    def run(
-        self,
-        name: Optional[str] = None,
-        num_machines: int = 2,
-        machine: Optional[str] = None,
-        command: Optional[str] = None,
-        studio: Optional[str] = None,
-        image: Optional[str] = None,
-        teamspace: Optional[str] = None,
-        org: Optional[str] = None,
-        user: Optional[str] = None,
-        cloud_account: Optional[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,
-    ) -> None:
-        if name is None:
-            from datetime import datetime
-
-            timestr = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
-            name = f"mmt-{timestr}"
-
-        if machine is None:
-            # TODO: infer from studio
-            machine = "CPU"
-        machine_enum = Machine(machine.upper())
-
-        teamspace = Teamspace(name=teamspace, org=org, user=user)
-        if cloud_account is None:
-            cloud_account = teamspace.default_cloud_account
-
-        if image is None:
-            raise RuntimeError("Currently only docker images are specified")
-        MMT.run(
-            name=name,
-            num_machines=num_machines,
-            machine=machine_enum,
-            command=command,
-            studio=studio,
-            image=image,
-            teamspace=teamspace,
-            org=org,
-            user=user,
-            cloud_account=cloud_account,
-            env=env,
-            interruptible=interruptible,
-            image_credentials=image_credentials,
-            cloud_account_auth=cloud_account_auth,
-            artifacts_local=artifacts_local,
-            artifacts_remote=artifacts_remote,
-        )
-
-
-def main_cli() -> None:
-    """CLI entrypoint."""
-    Fire(MMTCLI(), name="_mmt")
-
-
-if __name__ == "__main__":
-    main_cli()