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

lightning_sdk/api/utils.py

@@ -1,3 +1,4 @@
+import concurrent.futures
 import errno
 import math
 import os
@@ -8,7 +9,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 import backoff
 import requests
-from tqdm import tqdm
+from tqdm.auto import tqdm
 
 from lightning_sdk.constants import __GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__, _LIGHTNING_DEBUG
 from lightning_sdk.lightning_cloud.openapi import (
@@ -66,14 +67,14 @@ class _FileUploader:
         self,
         client: LightningClient,
         teamspace_id: str,
-        cluster_id: str,
+        cloud_account: str,
         file_path: str,
         remote_path: str,
         progress_bar: bool,
     ) -> None:
         self.client = client
         self.teamspace_id = teamspace_id
-        self.cluster_id = cluster_id
+        self.cloud_account = cloud_account
 
         self.local_path = file_path
 
@@ -107,7 +108,7 @@ class _FileUploader:
 
     def _multipart_upload(self, count: int) -> None:
         """Does a parallel multipart upload."""
-        body = ProjectIdStorageBody(cluster_id=self.cluster_id, filename=self.remote_path)
+        body = ProjectIdStorageBody(cluster_id=self.cloud_account, filename=self.remote_path)
         resp: V1UploadProjectArtifactResponse = self.client.storage_service_upload_project_artifact(
             body=body, project_id=self.teamspace_id
         )
@@ -123,7 +124,7 @@ class _FileUploader:
                 completed.extend(self._process_upload_batch(executor=p, batch=batch, upload_id=resp.upload_id))
 
         completed_body = StorageCompleteBody(
-            cluster_id=self.cluster_id, filename=self.remote_path, parts=completed, upload_id=resp.upload_id
+            cluster_id=self.cloud_account, filename=self.remote_path, parts=completed, upload_id=resp.upload_id
         )
         self.client.storage_service_complete_upload_project_artifact(body=completed_body, project_id=self.teamspace_id)
 
@@ -135,7 +136,7 @@ class _FileUploader:
 
     def _request_urls(self, parts: List[int], upload_id: str) -> List[V1PresignedUrl]:
         """Requests urls for a batch of parts."""
-        body = UploadsUploadIdBody(cluster_id=self.cluster_id, filename=self.remote_path, parts=parts)
+        body = UploadsUploadIdBody(cluster_id=self.cloud_account, filename=self.remote_path, parts=parts)
         resp: V1UploadProjectArtifactPartsResponse = self.client.storage_service_upload_project_artifact_parts(
             body, self.teamspace_id, upload_id
         )
@@ -192,7 +193,7 @@ class _ModelFileUploader:
         model_id: str,
         version: str,
         teamspace_id: str,
-        cluster_id: str,
+        cloud_account: str,
         file_path: str,
         remote_path: str,
         progress_bar: bool,
@@ -201,7 +202,6 @@ class _ModelFileUploader:
         self.model_id = model_id
         self.version = version
         self.teamspace_id = teamspace_id
-        self.cluster_id = cluster_id
         self.local_path = file_path
         self.remote_path = remote_path
 
@@ -215,6 +215,8 @@ class _ModelFileUploader:
                 unit="B",
                 unit_scale=True,
                 unit_divisor=1000,
+                position=1,
+                leave=False,
             )
         else:
             self.progress_bar = None
@@ -376,6 +378,7 @@ class _FileDownloader:
         teamspace_id: str,
         remote_path: str,
         file_path: str,
+        executor: ThreadPoolExecutor,
         num_workers: int = 20,
         progress_bar: Optional[tqdm] = None,
     ) -> None:
@@ -389,7 +392,7 @@ class _FileDownloader:
         self.num_workers = num_workers
         self._url = ""
         self._size = 0
-        self.refresh()
+        self.executor = executor
 
     @backoff.on_exception(backoff.expo, ApiException, max_tries=10)
     def refresh(self) -> None:
@@ -445,26 +448,26 @@ class _FileDownloader:
                 if remaining_size > 0:
                     f.write(b"\x00" * remaining_size)
 
-    def _multipart_download(self, filename: str, max_workers: int) -> None:
-        num_chunks = max_workers
+    def _multipart_download(self, filename: str, num_workers: int) -> None:
+        num_chunks = num_workers
         chunk_size = math.ceil(self.size / num_chunks)
 
         if chunk_size < _DOWNLOAD_MIN_CHUNK_SIZE:
             num_chunks = math.ceil(self.size / _DOWNLOAD_MIN_CHUNK_SIZE)
             chunk_size = _DOWNLOAD_MIN_CHUNK_SIZE
 
-        num_workers = min(max_workers, num_chunks)
-
         ranges = []
         for part_number in range(num_chunks):
             start = part_number * chunk_size
             end = min(start + chunk_size - 1, self.size - 1)
             ranges.append((start, end))
 
-        with ThreadPoolExecutor(max_workers=num_workers) as executor:
-            executor.map(partial(self._download_chunk, filename), ranges)
+        futures = [self.executor.submit(self._download_chunk, filename, r) for r in ranges]
+        concurrent.futures.wait(futures)
 
     def download(self) -> None:
+        self.refresh()
+
         tmp_filename = f"{self.local_path}.download"
 
         try:
@@ -536,31 +539,40 @@ def _download_model_files(
             unit_divisor=1000,
         )
 
-    for filepath in response.filepaths:
-        local_file = download_dir / filepath
-        local_file.parent.mkdir(parents=True, exist_ok=True)
-
-        file_downloader = _FileDownloader(
-            client=client,
-            model_id=response.model_id,
-            version=response.version,
-            teamspace_id=response.project_id,
-            remote_path=filepath,
-            file_path=str(local_file),
-            num_workers=num_workers,
-            progress_bar=pbar,
-        )
+    with ThreadPoolExecutor(max_workers=min(num_workers, len(response.filepaths))) as file_executor, ThreadPoolExecutor(
+        max_workers=num_workers
+    ) as part_executor:
+        futures = []
+
+        for filepath in response.filepaths:
+            local_file = download_dir / filepath
+            local_file.parent.mkdir(parents=True, exist_ok=True)
+
+            file_downloader = _FileDownloader(
+                client=client,
+                model_id=response.model_id,
+                version=response.version,
+                teamspace_id=response.project_id,
+                remote_path=filepath,
+                file_path=str(local_file),
+                num_workers=num_workers,
+                progress_bar=pbar,
+                executor=part_executor,
+            )
+
+            futures.append(file_executor.submit(file_downloader.download))
 
-        file_downloader.download()
+        # wait for all threads
+        concurrent.futures.wait(futures)
 
-    return response.filepaths
+        return response.filepaths
 
 
 def _create_app(
     client: CloudSpaceServiceApi,
     studio_id: str,
     teamspace_id: str,
-    cluster_id: str,
+    cloud_account: str,
     plugin_type: str,
     **other_arguments: Any,
 ) -> Externalv1LightningappInstance:
@@ -573,7 +585,7 @@ def _create_app(
         del other_arguments["interruptible"]
 
     body = AppsIdBody(
-        cluster_id=cluster_id,
+        cluster_id=cloud_account,
         plugin_arguments=other_arguments,
         service_id=os.getenv(_LIGHTNING_SERVICE_EXECUTION_ID_KEY),
         unique_id=__GLOBAL_LIGHTNING_UNIQUE_IDS_STORE__[studio_id],
@@ -584,6 +596,6 @@ def _create_app(
     ).lightningappinstance
 
     if _LIGHTNING_DEBUG:
-        print(f"Create App: {resp.id=} {teamspace_id=} {studio_id=} {cluster_id=}")
+        print(f"Create App: {resp.id=} {teamspace_id=} {studio_id=} {cloud_account=}")
 
     return resp

lightning_sdk/cli/ai_hub.py

@@ -32,7 +32,7 @@ class _AIHub(_StudiosMenu):
     def deploy(
         self,
         api_id: str,
-        cluster: Optional[str] = None,
+        cloud_account: Optional[str] = None,
         name: Optional[str] = None,
         teamspace: Optional[str] = None,
         org: Optional[str] = None,
@@ -41,9 +41,9 @@ class _AIHub(_StudiosMenu):
 
         Args:
           api_id: API template ID.
-          cluster: Cluster to deploy the API to. Defaults to user's default cluster.
+          cloud_account: Cloud Account to deploy the API to. Defaults to user's default cloud account.
           name: Name of the deployed API. Defaults to the name of the API template.
           teamspace: Teamspace to deploy the API to. Defaults to user's default teamspace.
           org: Organization to deploy the API to. Defaults to user's default organization.
         """
-        return self._hub.run(api_id, cluster=cluster, name=name, teamspace=teamspace, org=org)
+        return self._hub.run(api_id, cloud_account=cloud_account, name=name, teamspace=teamspace, org=org)

lightning_sdk/cli/entrypoint.py

@@ -6,6 +6,7 @@ from lightning_sdk.cli.ai_hub import _AIHub
 from lightning_sdk.cli.download import _Downloads
 from lightning_sdk.cli.legacy import _LegacyLightningCLI
 from lightning_sdk.cli.run import _Run
+from lightning_sdk.cli.serve import _Docker, _LitServe
 from lightning_sdk.cli.upload import _Uploads
 from lightning_sdk.lightning_cloud.login import Auth
 
@@ -19,8 +20,9 @@ class StudioCLI:
         self.download = _Downloads()
         self.upload = _Uploads()
         self.aihub = _AIHub()
-
         self.run = _Run(legacy_run=_LegacyLightningCLI() if _LIGHTNING_AVAILABLE else None)
+        self.serve = _LitServe()
+        self.dockerize = _Docker()
 
     def login(self) -> None:
         """Login to Lightning AI Studios."""

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.
@@ -32,14 +34,15 @@ class _Run:
             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.
-            cluster: The cluster to run the job on. Defaults to the studio cluster if running with studio compute env.
-                If not provided will fall back to the teamspaces default cluster.
+            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.
-            cluster_auth: Whether to authenticate with the cluster to pull the image.
-                Required if the registry is part of a cluster provider (e.g. ECR).
+            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.
@@ -53,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
@@ -61,21 +104,30 @@ 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,
         teamspace: Optional[str] = None,
         org: Optional[str] = None,
         user: Optional[str] = None,
-        cluster: Optional[str] = None,
+        cloud_account: Optional[str] = None,
         env: Optional[Dict[str, str]] = None,
         interruptible: bool = False,
         image_credentials: Optional[str] = None,
-        cluster_auth: bool = False,
+        cloud_account_auth: bool = False,
         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,
@@ -83,14 +135,72 @@ 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,
-            cluster=cluster,
+            cloud_account=cloud_account,
             env=env,
             interruptible=interruptible,
             image_credentials=image_credentials,
-            cluster_auth=cluster_auth,
+            cloud_account_auth=cloud_account_auth,
             artifacts_local=artifacts_local,
             artifacts_remote=artifacts_remote,
         )

lightning_sdk/cli/serve.py

@@ -0,0 +1,218 @@
+import os
+import subprocess
+import warnings
+from pathlib import Path
+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  # 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
+            subprocess.CalledProcessError: If the script fails to run
+            IOError: If client.py generation fails
+        """
+        console = Console()
+        script_path = Path(script_path)
+        if not script_path.exists():
+            raise FileNotFoundError(f"Script not found: {script_path}")
+        if not script_path.is_file():
+            raise ValueError(f"Path is not a file: {script_path}")
+
+        try:
+            from litserve.python_client import client_template
+        except ImportError:
+            raise ImportError(
+                "litserve is not installed. Please install it with `pip install lightning_sdk[serve]`"
+            ) from None
+
+        if easy:
+            client_path = Path("client.py")
+            if client_path.exists():
+                console.print("Skipping client generation: client.py already exists", style="blue")
+            else:
+                try:
+                    client_path.write_text(client_template)
+                    console.print("✅ Client generated at client.py", style="bold green")
+                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)],
+                check=True,
+                text=True,
+            )
+        except subprocess.CalledProcessError as e:
+            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, tag: str = "litserve-model") -> str:
+        """Generate a Dockerfile for the given server code.
+
+        Args:
+            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
+
+        console = Console()
+        requirements = ""
+        if os.path.exists("requirements.txt"):
+            requirements = "-r requirements.txt"
+        else:
+            warnings.warn(
+                f"requirements.txt not found at {os.getcwd()}. "
+                f"Make sure to install the required packages in the Dockerfile.",
+                UserWarning,
+            )
+
+        current_dir = Path.cwd()
+        if not (current_dir / server_filename).is_file():
+            raise FileNotFoundError(f"Server file `{server_filename}` must be in the current directory: {os.getcwd()}")
+
+        version = ls.__version__
+        if gpu:
+            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} {tag}:latest"
+            docker_template = docker_builder.DOCKERFILE_TEMPLATE
+        dockerfile_content = docker_template.format(
+            server_filename=server_filename,
+            port=port,
+            version=version,
+            requirements=requirements,
+        )
+        with open("Dockerfile", "w") as f:
+            f.write(dockerfile_content)
+
+        success_msg = f"""[bold]Dockerfile created successfully[/bold]
+Update [underline]{os.path.abspath("Dockerfile")}[/underline] to add any additional dependencies or commands.
+
+[bold]Build the container with:[/bold]
+> [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 {tag}[/underline]
+"""
+        console.print(success_msg)
+        return os.path.abspath("Dockerfile")