lightning 2.3.0.dev20240623__tar.gz → 2.3.2__tar.gz

{lightning-2.3.0.dev20240623/src/lightning.egg-info → lightning-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lightning
-Version: 2.3.0.dev20240623
+Version: 2.3.2
 Summary: The Deep Learning framework to train, deploy, and ship AI products Lightning fast.
 Home-page: https://github.com/Lightning-AI/lightning
 Author: Lightning AI et al.
@@ -78,7 +78,7 @@ ______________________________________________________________________
   <a href="#examples">Examples</a> •
   <a href="#pytorch-lightning-train-and-deploy-pytorch-at-scale">PyTorch Lightning</a> •
   <a href="#lightning-fabric-expert-control">Fabric</a> •
-  <a href="https://pytorch-lightning.readthedocs.io/en/2.3.0.dev20240623">Docs</a> •
+  <a href="https://pytorch-lightning.readthedocs.io/en/2.3.2">Docs</a> •
   <a href="#community">Community</a> •
   <a href="https://lightning.ai/docs/pytorch/stable/generated/CONTRIBUTING.html">Contribute</a> •
 </p>
@@ -594,7 +594,7 @@ Lightning is rigorously tested across multiple CPUs, GPUs and TPUs and against m
 
 |       System / PyTorch ver.        | 1.13                                                                                                                                                                                                                            | 2.0                                                                                                                                                                                                                             |                                                                                                               2.1                                                                                                               |
 | :--------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |:-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
-|        Linux py3.9 \[GPUs\]        |  |  | [![Build Status](https://dev.azure.com/Lightning-AI/lightning/_apis/build/status%2Fpytorch-lightning%20%28GPUs%29?branchName=refs%2Ftags%2F2.3.0.dev20240623)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) |
+|        Linux py3.9 \[GPUs\]        |  |  | [![Build Status](https://dev.azure.com/Lightning-AI/lightning/_apis/build/status%2Fpytorch-lightning%20%28GPUs%29?branchName=refs%2Ftags%2F2.3.2)](https://dev.azure.com/Lightning-AI/lightning/_build/latest?definitionId=24&branchName=master) |
 |        Linux py3.9 \[TPUs\]        |                                                                                                                                                                                                                                 |  [![Test PyTorch - TPU](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/tpu-tests.yml)     |      |
 |  Linux (multiple Python versions)  | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 |
 |   OSX (multiple Python versions)   | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 | [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                                 |                 [![Test PyTorch](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml/badge.svg)](https://github.com/Lightning-AI/lightning/actions/workflows/ci-tests-pytorch.yml)                 |

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/pyproject.toml

@@ -140,6 +140,7 @@ exclude = [
     "src/lightning/app/cli/component-template",
     "src/lightning/app/cli/pl-app-template",
     "src/lightning/app/cli/react-ui-template",
+    "src/lightning/app/launcher/utils.py",
 ]
 install_types = "True"
 non_interactive = "True"

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/requirements/app/app.txt

@@ -1,4 +1,4 @@
-lightning-cloud == 0.5.69  # Must be pinned to ensure compatibility
+lightning-cloud == 0.5.70  # Must be pinned to ensure compatibility
 packaging
 typing-extensions >=4.4.0, <4.10.0
 deepdiff >=5.7.0, <6.6.0
@@ -6,7 +6,7 @@ fsspec[http] >=2022.5.0, <2023.11.0
 croniter >=1.3.0, <1.5.0  # strict; TODO: for now until we find something more robust.
 traitlets >=5.3.0, <5.12.0
 arrow >=1.2.0, <1.3.0
-lightning-utilities >=0.8.0, <0.12.0
+lightning-utilities >=0.10.0, <0.12.0
 beautifulsoup4 >=4.8.0, <4.13.0
 inquirer >=2.10.0, <3.2.0
 psutil <5.9.6
@@ -27,3 +27,5 @@ urllib3 <2.0.0
 uvicorn <0.24.0
 websocket-client <1.7.0
 websockets <11.1.0
+numpy >=1.17.2, <2.0
+msgpack

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/requirements/pytorch/extra.txt

@@ -3,8 +3,8 @@
 
 # extended list of package dependencies to reach full functionality
 matplotlib>3.1, <3.9.0
-omegaconf >=2.0.5, <2.4.0
-hydra-core >=1.0.5, <1.4.0
+omegaconf >=2.2.3, <2.4.0
+hydra-core >=1.2.0, <1.4.0
 jsonargparse[signatures] >=4.27.7, <4.28.0
 rich >=12.3.0, <13.6.0
 tensorboardX >=2.2, <2.7.0  # min version is set by torch.onnx missing attribute

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/__setup__.py

@@ -114,7 +114,6 @@ def _setup_args() -> Dict[str, Any]:
             "console_scripts": [
                 "fabric = lightning.fabric.cli:_main",
                 "lightning = lightning.fabric.cli:_legacy_main",
-                "lightning_app = lightning:_cli_entry_point",
             ],
         },
         "setup_requires": [],

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/cli/lightning_cli.py

@@ -40,7 +40,19 @@ from lightning.app.cli.connect.data import connect_data
 from lightning.app.cli.lightning_cli_delete import delete
 from lightning.app.cli.lightning_cli_launch import launch
 from lightning.app.cli.lightning_cli_list import get_list
-from lightning.app.core.constants import ENABLE_APP_COMMENT_COMMAND_EXECUTION, get_lightning_cloud_url
+from lightning.app.core.constants import (
+    APP_SERVER_HOST,
+    APP_SERVER_PORT,
+    ENABLE_APP_COMMENT_COMMAND_EXECUTION,
+    get_lightning_cloud_url,
+)
+from lightning.app.launcher.launcher import (
+    run_lightning_flow,
+    run_lightning_work,
+    serve_frontend,
+    start_application_server,
+    start_flow_and_servers,
+)
 from lightning.app.runners.cloud import CloudRuntime
 from lightning.app.runners.runtime import dispatch
 from lightning.app.runners.runtime_type import RuntimeType
@@ -393,3 +405,99 @@ def _prepare_file(file: str) -> str:
         return file
 
     raise FileNotFoundError(f"The provided file {file} hasn't been found.")
+
+
+@run.command("server")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--queue-id", help="ID for identifying queue", default="", type=str)
+@click.option("--host", help="Application running host", default=APP_SERVER_HOST, type=str)
+@click.option("--port", help="Application running port", default=APP_SERVER_PORT, type=int)
+def run_server(file: str, queue_id: str, host: str, port: int) -> None:
+    """It takes the application file as input, build the application object and then use that to run the application
+    server.
+
+    This is used by the cloud runners to start the status server for the application
+
+    """
+    logger.debug(f"Run Server: {file} {queue_id} {host} {port}")
+    start_application_server(file, host, port, queue_id=queue_id)
+
+
+@run.command("flow")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--queue-id", help="ID for identifying queue", default="", type=str)
+@click.option("--base-url", help="Base url at which the app server is hosted", default="")
+def run_flow(file: str, queue_id: str, base_url: str) -> None:
+    """It takes the application file as input, build the application object, proxy all the work components and then run
+    the application flow defined in the root component.
+
+    It does exactly what a singleprocess dispatcher would do but with proxied work components.
+
+    """
+    logger.debug(f"Run Flow: {file} {queue_id} {base_url}")
+    run_lightning_flow(file, queue_id=queue_id, base_url=base_url)
+
+
+@run.command("work")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--work-name", type=str)
+@click.option("--queue-id", help="ID for identifying queue", default="", type=str)
+def run_work(file: str, work_name: str, queue_id: str) -> None:
+    """Unlike other entrypoints, this command will take the file path or module details for a work component and run
+    that by fetching the states from the queues."""
+    logger.debug(f"Run Work: {file} {work_name} {queue_id}")
+    run_lightning_work(
+        file=file,
+        work_name=work_name,
+        queue_id=queue_id,
+    )
+
+
+@run.command("frontend")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--flow-name")
+@click.option("--host")
+@click.option("--port", type=int)
+def run_frontend(file: str, flow_name: str, host: str, port: int) -> None:
+    """Serve the frontend specified by the given flow."""
+    logger.debug(f"Run Frontend: {file} {flow_name} {host}")
+    serve_frontend(file=file, flow_name=flow_name, host=host, port=port)
+
+
+@run.command("flow-and-servers")
+@click.argument("file", type=click.Path(exists=True))
+@click.option("--queue-id", help="ID for identifying queue", default="", type=str)
+@click.option("--base-url", help="Base url at which the app server is hosted", default="")
+@click.option("--host", help="Application running host", default=APP_SERVER_HOST, type=str)
+@click.option("--port", help="Application running port", default=APP_SERVER_PORT, type=int)
+@click.option(
+    "--flow-port",
+    help="Pair of flow name and frontend port",
+    type=(str, int),
+    multiple=True,
+)
+def run_flow_and_servers(
+    file: str,
+    base_url: str,
+    queue_id: str,
+    host: str,
+    port: int,
+    flow_port: Tuple[Tuple[str, int]],
+) -> None:
+    """It takes the application file as input, build the application object and then use that to run the application
+    flow defined in the root component, the application server and all the flow frontends.
+
+    This is used by the cloud runners to start the flow, the status server and all frontends for the application
+
+    """
+    logger.debug(f"Run Flow: {file} {queue_id} {base_url}")
+    logger.debug(f"Run Server: {file} {queue_id} {host} {port}.")
+    logger.debug(f"Run Frontend's: {flow_port}")
+    start_flow_and_servers(
+        entrypoint_file=file,
+        base_url=base_url,
+        queue_id=queue_id,
+        host=host,
+        port=port,
+        flow_names_and_ports=flow_port,
+    )

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/core/app.py

@@ -35,6 +35,7 @@ from lightning.app.core.constants import (
     FLOW_DURATION_SAMPLES,
     FLOW_DURATION_THRESHOLD,
     FRONTEND_DIR,
+    SHOULD_START_WORKS_WITH_FLOW,
     STATE_ACCUMULATE_WAIT,
 )
 from lightning.app.core.queues import BaseQueue
@@ -144,6 +145,7 @@ class LightningApp:
         self.threads: List[threading.Thread] = []
         self.exception = None
         self.collect_changes: bool = True
+        self._should_start_works_with_flow: bool = SHOULD_START_WORKS_WITH_FLOW
 
         self.status: Optional[AppStatus] = None
         # TODO: Enable ready locally for opening the UI.
@@ -733,6 +735,9 @@ class LightningApp:
                 self.flow_to_work_delta_queues[w.name].put(deep_diff)
 
     def _start_with_flow_works(self) -> None:
+        if not self._should_start_works_with_flow:
+            return
+
         for w in self.works:
             if w._start_with_flow:
                 parallel = w.parallel

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/core/constants.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import json
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 import lightning_cloud.env
 
@@ -101,6 +102,37 @@ SYS_CUSTOMIZATIONS_SYNC_PATH = ".sys-customizations-sync"
 
 BATCH_DELTA_COUNT = int(os.getenv("BATCH_DELTA_COUNT", "128"))
 CHECK_ERROR_QUEUE_INTERVAL = float(os.getenv("CHECK_ERROR_QUEUE_INTERVAL", "30"))
+SHOULD_START_WORKS_WITH_FLOW = bool(int(os.getenv("SHOULD_START_WORKS_WITH_FLOW", "1")))
+IS_RUNNING_IN_FLOW = os.getenv("LIGHTNING_CLOUD_WORK_NAME", None) is None
+
+
+class DistributedPluginChecker:
+    def __init__(self) -> None:
+        self.distributed_arguments = os.getenv("DISTRIBUTED_ARGUMENTS", None)
+        if self.distributed_arguments:
+            self.distributed_arguments = json.loads(self.distributed_arguments)
+
+        self.running_distributed_plugin = False
+
+        if self.distributed_arguments and os.getenv("LIGHTNING_CLOUD_WORK_NAME"):
+            self.running_distributed_plugin = True
+
+    def __bool__(self) -> bool:
+        return self.running_distributed_plugin
+
+    def should_create_work(self, work: Any) -> bool:
+        if not self.distributed_arguments:
+            return True
+
+        num_nodes = self.distributed_arguments.get("num_instances", 0)
+        node_rank = int(work.name.split(".")[-1])
+
+        # Only the start with flow works are skipped for performance purposes
+        return node_rank >= num_nodes
+
+
+# TODO (tchaton): Add LitData and JobPlugin optimizations
+PLUGIN_CHECKER = IS_DISTRIBUTED_PLUGIN = DistributedPluginChecker()
 
 
 def enable_multiple_works_in_default_container() -> bool:

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/core/flow.py

@@ -836,6 +836,11 @@ class LightningFlow:
             elif strict:
                 raise ValueError(f"The component {child_name} wasn't instantiated for the component {self.name}")
 
+    def stop_works(self, works: List[Any]) -> None:
+        if self._backend is None:
+            raise RuntimeError("Your flow should have a backend attached. Found None.")
+        self._backend.stop_works(works)
+
 
 class _RootFlow(LightningFlow):
     def __init__(self, work: LightningWork) -> None:

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/core/queues.py

@@ -17,7 +17,6 @@ import multiprocessing
 import pickle
 import queue  # needed as import instead from/import for mocking in tests
 import time
-import warnings
 from abc import ABC, abstractmethod
 from enum import Enum
 from pathlib import Path
@@ -25,6 +24,7 @@ from typing import Any, List, Optional, Tuple
 from urllib.parse import urljoin
 
 import backoff
+import msgpack
 import requests
 from requests.exceptions import ConnectionError, ConnectTimeout, ReadTimeout
 
@@ -34,6 +34,7 @@ from lightning.app.core.constants import (
     HTTP_QUEUE_REQUESTS_PER_SECOND,
     HTTP_QUEUE_TOKEN,
     HTTP_QUEUE_URL,
+    IS_RUNNING_IN_FLOW,
     LIGHTNING_DIR,
     QUEUE_DEBUG_ENABLED,
     REDIS_HOST,
@@ -41,7 +42,6 @@ from lightning.app.core.constants import (
     REDIS_PORT,
     REDIS_QUEUES_READ_DEFAULT_TIMEOUT,
     STATE_UPDATE_TIMEOUT,
-    WARNING_QUEUE_SIZE,
 )
 from lightning.app.utilities.app_helpers import Logger
 from lightning.app.utilities.imports import _is_redis_available, requires
@@ -80,9 +80,14 @@ class QueuingSystem(Enum):
             return MultiProcessQueue(queue_name, default_timeout=STATE_UPDATE_TIMEOUT)
         if self == QueuingSystem.REDIS:
             return RedisQueue(queue_name, default_timeout=REDIS_QUEUES_READ_DEFAULT_TIMEOUT)
-        return RateLimitedQueue(
-            HTTPQueue(queue_name, default_timeout=STATE_UPDATE_TIMEOUT), HTTP_QUEUE_REQUESTS_PER_SECOND
-        )
+
+        queue = HTTPQueue(queue_name, default_timeout=STATE_UPDATE_TIMEOUT)
+
+        # In the flow, don't rate limit the caller queue. Otherwise, startup time would be slow with lot of works.
+        if CALLER_QUEUE_CONSTANT in queue_name and IS_RUNNING_IN_FLOW:
+            return queue
+
+        return RateLimitedQueue(queue, HTTP_QUEUE_REQUESTS_PER_SECOND)
 
     def get_api_response_queue(self, queue_id: Optional[str] = None) -> "BaseQueue":
         queue_name = f"{queue_id}_{API_RESPONSE_QUEUE_CONSTANT}" if queue_id else API_RESPONSE_QUEUE_CONSTANT
@@ -284,14 +289,6 @@ class RedisQueue(BaseQueue):
             item._backend = None
 
         value = pickle.dumps(item)
-        queue_len = self.length()
-        if queue_len >= WARNING_QUEUE_SIZE:
-            warnings.warn(
-                f"The Redis Queue {self.name} length is larger than the "
-                f"recommended length of {WARNING_QUEUE_SIZE}. "
-                f"Found {queue_len}. This might cause your application to crash, "
-                "please investigate this."
-            )
         try:
             self.redis.rpush(self.name, value)
         except redis.exceptions.ConnectionError:
@@ -451,7 +448,11 @@ class HTTPQueue(BaseQueue):
             return False
         return False
 
+    @backoff.on_exception(
+        backoff.expo, (RuntimeError, requests.exceptions.HTTPError, requests.exceptions.ChunkedEncodingError)
+    )
     def get(self, timeout: Optional[float] = None) -> Any:
+        logger.debug(f"get {self.name}")
         if not self.app_id:
             raise ValueError(f"App ID couldn't be extracted from the queue name: {self.name}")
 
@@ -498,13 +499,17 @@ class HTTPQueue(BaseQueue):
             resp = self.client.post(f"v1/{self.app_id}/{self._name_suffix}", query_params={"action": "pop"})
             if resp.status_code == 204:
                 raise queue.Empty
-            return pickle.loads(resp.content)
+
+            if self._use_pickle():
+                return pickle.loads(resp.content)
+            return msgpack.unpackb(resp.content)
         except ConnectionError:
             # Note: If the Http Queue service isn't available,
             # we consider the queue is empty to avoid failing the app.
             raise queue.Empty
 
     def batch_get(self, timeout: Optional[float] = None, count: Optional[int] = None) -> List[Any]:
+        logger.debug(f"batch_get {self.name}")
         try:
             resp = self.client.post(
                 f"v1/{self.app_id}/{self._name_suffix}",
@@ -512,24 +517,24 @@ class HTTPQueue(BaseQueue):
             )
             if resp.status_code == 204:
                 raise queue.Empty
-            return [pickle.loads(base64.b64decode(data)) for data in resp.json()]
+
+            if self._use_pickle():
+                return [pickle.loads(base64.b64decode(data)) for data in resp.json()]
+            return [msgpack.unpackb(base64.b64decode(data)) for data in resp.json()]
         except ConnectionError:
             # Note: If the Http Queue service isn't available,
             # we consider the queue is empty to avoid failing the app.
             raise queue.Empty
 
-    @backoff.on_exception(backoff.expo, (RuntimeError, requests.exceptions.HTTPError))
+    @backoff.on_exception(
+        backoff.expo, (RuntimeError, requests.exceptions.HTTPError, requests.exceptions.ChunkedEncodingError)
+    )
     def put(self, item: Any) -> None:
+        logger.debug(f"put {self.name}")
         if not self.app_id:
             raise ValueError(f"The Lightning App ID couldn't be extracted from the queue name: {self.name}")
 
-        value = pickle.dumps(item)
-        queue_len = self.length()
-        if queue_len >= WARNING_QUEUE_SIZE:
-            warnings.warn(
-                f"The Queue {self._name_suffix} length is larger than the recommended length of {WARNING_QUEUE_SIZE}. "
-                f"Found {queue_len}. This might cause your application to crash, please investigate this."
-            )
+        value = pickle.dumps(item, protocol=pickle.HIGHEST_PROTOCOL) if self._use_pickle() else msgpack.packb(item)
         resp = self.client.post(f"v1/{self.app_id}/{self._name_suffix}", data=value, query_params={"action": "push"})
         if resp.status_code != 201:
             raise RuntimeError(f"Failed to push to queue: {self._name_suffix}")
@@ -568,6 +573,12 @@ class HTTPQueue(BaseQueue):
     def from_dict(cls, state: dict) -> "HTTPQueue":
         return cls(**state)
 
+    def _use_pickle(self) -> bool:
+        # Note: msgpack is faster than pickle to serialize and deserialize simple JSON
+        return (
+            WORK_QUEUE_CONSTANT in self.name or DELTA_QUEUE_CONSTANT in self.name or ERROR_QUEUE_CONSTANT in self.name
+        )
+
 
 def debug_log_callback(message: str, *args: Any, **kwargs: Any) -> None:
     if QUEUE_DEBUG_ENABLED or (Path(LIGHTNING_DIR) / "QUEUE_DEBUG_ENABLED").exists():

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/core/work.py

@@ -630,6 +630,9 @@ class LightningWork:
         # This enables to start the run method with a phony input and exit.
         self.run(Action(method="start"))
 
+    def on_start(self) -> None:
+        """Define actions to perform when the work has started."""
+
     def run(self, *args: Any, **kwargs: Any) -> None:
         """Override to add your own logic.
 

{lightning-2.3.0.dev20240623 → lightning-2.3.2}/src/lightning/app/launcher/launcher.py

@@ -9,31 +9,33 @@ from functools import partial
 from multiprocessing import Process
 from typing import Callable, Dict, List, Optional, Tuple, TypedDict
 
-ENABLE_MULTIPLE_WORKS_IN_DEFAULT_CONTAINER = bool(int(os.getenv("ENABLE_MULTIPLE_WORKS_IN_DEFAULT_CONTAINER", "0")))
-
-if True:  # ToDo: Avoid Module level import not at top of file
-    from lightning.app.core import constants
-    from lightning.app.core.api import start_server
-    from lightning.app.core.flow import LightningFlow
-    from lightning.app.core.queues import MultiProcessQueue, QueuingSystem
-    from lightning.app.storage.orchestrator import StorageOrchestrator
+from lightning.app import LightningFlow
+from lightning.app.core import constants
+from lightning.app.core.api import start_server
+from lightning.app.core.constants import (
+    CHECK_ERROR_QUEUE_INTERVAL,
+    ENABLE_ORCHESTRATOR,
+    IS_DISTRIBUTED_PLUGIN,
+)
+from lightning.app.core.queues import MultiProcessQueue, QueuingSystem
+from lightning.app.storage.orchestrator import StorageOrchestrator
+from lightning.app.utilities.cloud import _sigterm_flow_handler
+from lightning.app.utilities.component import _set_flow_context, _set_frontend_context
+from lightning.app.utilities.enum import AppStage
+from lightning.app.utilities.exceptions import ExitAppException
+from lightning.app.utilities.load_app import extract_metadata_from_app, load_app_from_file
+from lightning.app.utilities.proxies import WorkRunner
+from lightning.app.utilities.redis import check_if_redis_running
+
+try:
     from lightning.app.utilities.app_commands import run_app_commands
-    from lightning.app.utilities.cloud import _sigterm_flow_handler
-    from lightning.app.utilities.component import _set_flow_context, _set_frontend_context
-    from lightning.app.utilities.enum import AppStage
-    from lightning.app.utilities.exceptions import ExitAppException
-    from lightning.app.utilities.load_app import extract_metadata_from_app, load_app_from_file
-    from lightning.app.utilities.proxies import WorkRunner
-    from lightning.app.utilities.redis import check_if_redis_running
-
-if ENABLE_MULTIPLE_WORKS_IN_DEFAULT_CONTAINER:
-    from lightning.app.launcher.lightning_hybrid_backend import CloudHybridBackend as CloudBackend
-else:
-    from lightning.app.launcher.lightning_backend import CloudBackend
 
-if True:  # Avoid Module level import not at top of file
-    from lightning.app.utilities.app_helpers import convert_print_to_logger_info
-    from lightning.app.utilities.packaging.lightning_utils import enable_debugging
+    ABLE_TO_RUN_APP_COMMANDS = True
+except (ImportError, ModuleNotFoundError):
+    ABLE_TO_RUN_APP_COMMANDS = False
+
+from lightning.app.launcher.lightning_backend import CloudBackend
+from lightning.app.launcher.utils import LIGHTNING_VERSION, convert_print_to_logger_info, enable_debugging, exit_app
 
 if hasattr(constants, "get_cloud_queue_type"):
     CLOUD_QUEUE_TYPE = constants.get_cloud_queue_type() or "redis"
@@ -48,6 +50,22 @@ class FlowRestAPIQueues(TypedDict):
     api_response_queue: MultiProcessQueue
 
 
+def check_error_queue(self) -> None:
+    if not getattr(self, "_last_check_error_queue", None):
+        self._last_check_error_queue = 0.0
+
+    if (time.time() - self._last_check_error_queue) > CHECK_ERROR_QUEUE_INTERVAL:
+        exception: Exception = self.get_state_changed_from_queue(self.error_queue)  # type: ignore[assignment,arg-type]
+        if isinstance(exception, Exception):
+            self.exception = exception
+            self.stage = AppStage.FAILED
+        self._last_check_error_queue = time.time()
+
+
+def patch_app(app):
+    app.check_error_queue = partial(check_error_queue, self=app)
+
+
 @convert_print_to_logger_info
 @enable_debugging
 def start_application_server(
@@ -72,6 +90,7 @@ def start_application_server(
         })
 
     app = load_app_from_file(entrypoint_file)
+    patch_app(app)
 
     from lightning.app.api.http_methods import _add_tags_to_api, _validate_api
     from lightning.app.utilities.app_helpers import is_overridden
@@ -124,12 +143,34 @@ def run_lightning_work(
     copy_request_queues = queues.get_orchestrator_copy_request_queue(work_name=work_name, queue_id=queue_id)
     copy_response_queues = queues.get_orchestrator_copy_response_queue(work_name=work_name, queue_id=queue_id)
 
-    run_app_commands(file)
+    if ABLE_TO_RUN_APP_COMMANDS:
+        run_app_commands(file)
 
     load_app_from_file(file)
 
-    queue = queues.get_work_queue(work_name=work_name, queue_id=queue_id)
-    work = queue.get()
+    if IS_DISTRIBUTED_PLUGIN:
+        import json
+
+        from multi_node.launcher import ScriptLauncher
+
+        from lightning.app import CloudCompute
+
+        script_command = os.environ["COMMAND"]
+        distributed_arguments = os.environ["DISTRIBUTED_ARGUMENTS"]
+        distributed_arguments = json.loads(distributed_arguments)
+        cloud_compute = distributed_arguments["cloud_compute"]
+        disk_size = int(distributed_arguments.get("disk_size", 400))
+
+        work = ScriptLauncher(
+            cloud_compute=CloudCompute(cloud_compute, disk_size=disk_size),
+            parallel=True,
+            command=script_command,
+        )
+        work_name = os.getenv("LIGHTNING_CLOUD_WORK_NAME", "")
+        work._name = work_name
+    else:
+        queue = queues.get_work_queue(work_name=work_name, queue_id=queue_id)
+        work = queue.get()
 
     extras = {}
 
@@ -179,15 +220,17 @@ def run_lightning_flow(entrypoint_file: str, queue_id: str, base_url: str, queue
 
     app.should_publish_changes_to_api = True
 
-    storage_orchestrator = StorageOrchestrator(
-        app,
-        app.request_queues,
-        app.response_queues,
-        app.copy_request_queues,
-        app.copy_response_queues,
-    )
-    storage_orchestrator.setDaemon(True)
-    storage_orchestrator.start()
+    # reduces the number of requests to the CP
+    if ENABLE_ORCHESTRATOR:
+        storage_orchestrator = StorageOrchestrator(
+            app,
+            app.request_queues,
+            app.response_queues,
+            app.copy_request_queues,
+            app.copy_response_queues,
+        )
+        storage_orchestrator.setDaemon(True)
+        storage_orchestrator.start()
 
     # refresh the layout with the populated urls.
     app._update_layout()
@@ -211,14 +254,16 @@ def run_lightning_flow(entrypoint_file: str, queue_id: str, base_url: str, queue
         app.stage = AppStage.FAILED
         print(traceback.format_exc())
 
-    storage_orchestrator.join(0)
+    if ENABLE_ORCHESTRATOR:
+        storage_orchestrator.join(0)
+
     app.backend.stop_all_works(app.works)
 
     exit_code = 1 if app.stage == AppStage.FAILED else 0
     print(f"Finishing the App with exit_code: {str(exit_code)}...")
 
     if not exit_code:
-        app.backend.stop_app(app)
+        exit_app(app)
 
     sys.exit(exit_code)
 
@@ -385,12 +430,13 @@ def start_flow_and_servers(
         "api_response_queue": queue_system.get_api_response_queue(queue_id=queue_id),
     }
 
-    # In order to avoid running this function 3 seperate times while executing the
-    # `run_lightning_flow`, `start_application_server`, & `serve_frontend` functions
-    # in a subprocess we extract this to the top level. If we intend to make changes
-    # to be able to start these components in seperate containers, the implementation
-    # will have to move a call to this function within the initialization process.
-    run_app_commands(entrypoint_file)
+    if ABLE_TO_RUN_APP_COMMANDS:
+        # In order to avoid running this function 3 seperate times while executing the
+        # `run_lightning_flow`, `start_application_server`, & `serve_frontend` functions
+        # in a subprocess we extract this to the top level. If we intend to make changes
+        # to be able to start these components in seperate containers, the implementation
+        # will have to move a call to this function within the initialization process.
+        run_app_commands(entrypoint_file)
 
     flow_process = start_server_in_process(
         run_lightning_flow,
@@ -434,6 +480,12 @@ def wait_for_queues(queue_system: QueuingSystem) -> None:
                 logger.warning("Waiting for http queues to start...")
             time.sleep(1)
     else:
+        if CLOUD_QUEUE_TYPE != "redis":
+            raise ValueError(
+                f"Queue system {queue_system} is not correctly configured. You seem to have requested HTTP queues,"
+                f"but using an old version of lightning framework ({LIGHTNING_VERSION}) that doesn't support "
+                f"HTTP queues. Try upgrading lightning framework to the latest version."
+            )
         while not check_if_redis_running():
             if (int(time.time()) - queue_check_start_time) % 10 == 0:
                 logger.warning("Waiting for redis queues to start...")