autogluon.cloud 0.4.2__tar.gz → 0.6.0__tar.gz

autogluon_cloud-0.6.0/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: autogluon.cloud
+Version: 0.6.0
+Summary: Train and deploy ML models in the cloud
+Author: AutoGluon Community
+License-Expression: Apache-2.0
+Project-URL: Documentation, https://auto.gluon.ai/cloud
+Project-URL: Bug Reports, https://github.com/autogluon/autogluon-cloud/issues
+Project-URL: Source, https://github.com/autogluon/autogluon-cloud/
+Project-URL: Contribute!, https://github.com/autogluon/autogluon-cloud/blob/master/CONTRIBUTING.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Customer Service
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Healthcare Industry
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: autogluon.common<1.7,>=0.7
+Requires-Dist: boto3<2,>=1.37.23
+Requires-Dist: packaging<27,>=23.0
+Requires-Dist: sagemaker<3,>=2.240.0
+Requires-Dist: pyarrow<25,>=19.0.1
+Requires-Dist: PyYAML~=6.0
+Requires-Dist: Pillow<13,>=10.2
+Requires-Dist: huggingface_hub<2,>=0.20
+Requires-Dist: typing_extensions<5,>=4.0
+Requires-Dist: click<9,>=8.0
+Requires-Dist: rich<15,>=13.0
+Provides-Extra: ray
+Requires-Dist: ray[default]<2.59,>=2.10.0; extra == "ray"
+Provides-Extra: all
+Requires-Dist: autogluon<1.7,>=0.7; extra == "all"
+Requires-Dist: autogluon.cloud[ray]; extra == "all"
+Provides-Extra: tests
+Requires-Dist: pytest; extra == "tests"
+Requires-Dist: moto; extra == "tests"
+Requires-Dist: autogluon.common>=0.7; extra == "tests"
+Dynamic: license-file
+
+
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
+
+## Train and Deploy AutoGluon in the Cloud
+
+[![PyPI](https://img.shields.io/pypi/v/autogluon.cloud.svg)](https://pypi.org/project/autogluon.cloud/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://pypi.org/project/autogluon.cloud/)
+[![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+[![Continuous Integration](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml)
+
+[AutoGluon-Cloud Documentation](https://auto.gluon.ai/cloud/stable/index.html) | [AutoGluon Documentation](https://auto.gluon.ai)
+
+</div>
+
+AutoGluon-Cloud lets you train and deploy state-of-the-art ML models in the cloud in a few lines of code. Run [AutoGluon](https://auto.gluon.ai/stable/index.html) on [Amazon SageMaker](https://aws.amazon.com/sagemaker/) without worrying about infrastructure, dependencies, or a heavy local ML environment. It supports two workflows:
+
+- **[Train your own predictor](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html)** — the same `fit → deploy → predict` workflow as local AutoGluon, with all the heavy lifting offloaded to SageMaker.
+- **[Run pretrained foundation models](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html)** — deploy state-of-the-art pretrained models like [Chronos-2](https://huggingface.co/amazon/chronos-2) for zero-shot inference, with no training required.
+
+## 💾 Installation & setup
+
+```bash
+pip install autogluon.cloud
+```
+
+Then provision the IAM role and S3 bucket AutoGluon-Cloud needs to run on AWS:
+
+```python
+from autogluon.cloud import bootstrap
+
+bootstrap()
+```
+
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for the full walkthrough, including how to register an existing role and bucket instead.
+
+## ⚙️ Train your own model
+
+Train an AutoGluon predictor on your data and serve it from a SageMaker endpoint — same API as local AutoGluon, all heavy lifting on AWS. Full walkthrough: [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html), [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html).
+
+```python
+from autogluon.cloud import TabularCloudPredictor
+
+# `train_data` and `test_data` can be a local path, S3 URL, or pandas DataFrame
+train_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv"
+test_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv"
+
+# Train
+cloud_predictor = TabularCloudPredictor()
+cloud_predictor.fit(
+    train_data=train_data,
+    predictor_init_args={"label": "class"},  # passed to TabularPredictor()
+    predictor_fit_args={"time_limit": 120},  # passed to TabularPredictor.fit()
+)
+
+# Real-time inference endpoint
+cloud_predictor.deploy()
+result = cloud_predictor.predict_real_time(test_data)
+cloud_predictor.cleanup_deployment()
+
+# Batch prediction
+result = cloud_predictor.predict(test_data)
+```
+
+## 🚀 Run a pretrained foundation model
+
+Skip training entirely — deploy a pretrained model like Chronos-2 to SageMaker and get zero-shot predictions out of the box. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html).
+
+```python
+from autogluon.cloud import TimeSeriesFoundationModel
+
+# `data` can be a local path, S3 URL, or pandas DataFrame
+data = "https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_tiny/train.csv"
+
+model = TimeSeriesFoundationModel("chronos-2")
+
+# Batch prediction — no training required
+predictions = model.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+
+# Real-time inference endpoint
+endpoint = model.deploy()
+predictions = endpoint.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+endpoint.delete_endpoint()
+```

autogluon_cloud-0.6.0/README.md

@@ -0,0 +1,93 @@
+
+
+<div align="center">
+<img src="https://user-images.githubusercontent.com/16392542/77208906-224aa500-6aba-11ea-96bd-e81806074030.png" width="350">
+
+## Train and Deploy AutoGluon in the Cloud
+
+[![PyPI](https://img.shields.io/pypi/v/autogluon.cloud.svg)](https://pypi.org/project/autogluon.cloud/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue)](https://pypi.org/project/autogluon.cloud/)
+[![GitHub license](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](./LICENSE)
+[![Continuous Integration](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/autogluon/autogluon-cloud/actions/workflows/continuous_integration.yml)
+
+[AutoGluon-Cloud Documentation](https://auto.gluon.ai/cloud/stable/index.html) | [AutoGluon Documentation](https://auto.gluon.ai)
+
+</div>
+
+AutoGluon-Cloud lets you train and deploy state-of-the-art ML models in the cloud in a few lines of code. Run [AutoGluon](https://auto.gluon.ai/stable/index.html) on [Amazon SageMaker](https://aws.amazon.com/sagemaker/) without worrying about infrastructure, dependencies, or a heavy local ML environment. It supports two workflows:
+
+- **[Train your own predictor](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html)** — the same `fit → deploy → predict` workflow as local AutoGluon, with all the heavy lifting offloaded to SageMaker.
+- **[Run pretrained foundation models](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html)** — deploy state-of-the-art pretrained models like [Chronos-2](https://huggingface.co/amazon/chronos-2) for zero-shot inference, with no training required.
+
+## 💾 Installation & setup
+
+```bash
+pip install autogluon.cloud
+```
+
+Then provision the IAM role and S3 bucket AutoGluon-Cloud needs to run on AWS:
+
+```python
+from autogluon.cloud import bootstrap
+
+bootstrap()
+```
+
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for the full walkthrough, including how to register an existing role and bucket instead.
+
+## ⚙️ Train your own model
+
+Train an AutoGluon predictor on your data and serve it from a SageMaker endpoint — same API as local AutoGluon, all heavy lifting on AWS. Full walkthrough: [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html), [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html).
+
+```python
+from autogluon.cloud import TabularCloudPredictor
+
+# `train_data` and `test_data` can be a local path, S3 URL, or pandas DataFrame
+train_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/train.csv"
+test_data = "https://autogluon.s3.amazonaws.com/datasets/Inc/test.csv"
+
+# Train
+cloud_predictor = TabularCloudPredictor()
+cloud_predictor.fit(
+    train_data=train_data,
+    predictor_init_args={"label": "class"},  # passed to TabularPredictor()
+    predictor_fit_args={"time_limit": 120},  # passed to TabularPredictor.fit()
+)
+
+# Real-time inference endpoint
+cloud_predictor.deploy()
+result = cloud_predictor.predict_real_time(test_data)
+cloud_predictor.cleanup_deployment()
+
+# Batch prediction
+result = cloud_predictor.predict(test_data)
+```
+
+## 🚀 Run a pretrained foundation model
+
+Skip training entirely — deploy a pretrained model like Chronos-2 to SageMaker and get zero-shot predictions out of the box. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html).
+
+```python
+from autogluon.cloud import TimeSeriesFoundationModel
+
+# `data` can be a local path, S3 URL, or pandas DataFrame
+data = "https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_tiny/train.csv"
+
+model = TimeSeriesFoundationModel("chronos-2")
+
+# Batch prediction — no training required
+predictions = model.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+
+# Real-time inference endpoint
+endpoint = model.deploy()
+predictions = endpoint.predict(
+    data=data,
+    target="target",
+    prediction_length=24,
+)
+endpoint.delete_endpoint()
+```

autogluon_cloud-0.6.0/pyproject.toml

@@ -0,0 +1,109 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]  # >=77 for PEP 639 SPDX license expression support
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "autogluon.cloud"
+description = "Train and deploy ML models in the cloud"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+license = "Apache-2.0"
+license-files = ["LICENSE", "NOTICE"]
+authors = [{ name = "AutoGluon Community" }]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Education",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Customer Service",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Intended Audience :: Healthcare Industry",
+    "Intended Audience :: Telecommunications Industry",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Operating System :: Unix",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Scientific/Engineering :: Image Recognition",
+]
+# version stays dynamic and is owned by setup.py (so the RELEASE=1 -> clean
+# version, else .dev0 logic keeps working).
+dynamic = ["version"]
+dependencies = [
+    # common module provides utils with stable api across minor version
+    "autogluon.common>=0.7,<1.7",
+    # <2 because unlikely to introduce breaking changes in minor releases.
+    # TransformAmiVersion was added to the SageMaker service model in botocore 1.37.23.
+    "boto3>=1.37.23,<2",
+    "packaging>=23.0,<27",
+    # Supports forwarding inference_ami_version from Model.deploy.
+    "sagemaker>=2.240.0,<3",
+    "pyarrow>=19.0.1,<25",  # lower bound to avoid https://github.com/apache/arrow/issues/45283
+    "PyYAML~=6.0",
+    "Pillow>=10.2,<13",
+    "huggingface_hub>=0.20,<2",
+    "typing_extensions>=4.0,<5",
+    # CLI dependencies (autogluon-cloud command)
+    "click>=8.0,<9",
+    "rich>=13.0,<15",
+]
+
+[project.optional-dependencies]
+ray = ["ray[default]>=2.10.0,<2.59"]
+all = [  # To allow user to pass ag objects
+    "autogluon>=0.7,<1.7",
+    "autogluon.cloud[ray]",
+]
+tests = [
+    "pytest",
+    "moto",
+    "autogluon.common>=0.7",
+]
+
+[project.urls]
+Documentation = "https://auto.gluon.ai/cloud"
+"Bug Reports" = "https://github.com/autogluon/autogluon-cloud/issues"
+Source = "https://github.com/autogluon/autogluon-cloud/"
+"Contribute!" = "https://github.com/autogluon/autogluon-cloud/blob/master/CONTRIBUTING.md"
+
+[project.scripts]
+autogluon-cloud = "autogluon.cloud.cli:main"
+
+[tool.setuptools]
+zip-safe = true
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+namespaces = true
+
+[tool.setuptools.package-data]
+"autogluon.cloud" = [
+    "default_cluster_configs/*.yaml",
+    "utils/autogluon_dlc.json",
+    "templates/*.yaml",
+]
+
+[tool.ruff]
+line-length = 119
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "W"]
+ignore = ["E501"]
+per-file-ignores = {"*/__init__.py" = ["F401"]}
+
+[tool.ruff.lint.isort]
+known-first-party = ["autogluon"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--strict-markers"
+xfail_strict = true

autogluon_cloud-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

autogluon_cloud-0.6.0/setup.py

@@ -0,0 +1,33 @@
+import os
+
+from setuptools import setup
+
+AUTOGLUON = "autogluon"
+CLOUD = "cloud"
+
+
+def create_version_file(*, version):
+    print("-- Building version " + version)
+    version_path = os.path.join("src", AUTOGLUON, CLOUD, "version.py")
+    with open(version_path, "w") as f:
+        f.write(f'"""This is the {AUTOGLUON}.{CLOUD} version file."""\n')
+        f.write("__version__ = '{}'\n".format(version))
+
+
+def update_version(version):
+    """
+    To release a new stable version on PyPi, tag the release on github; the Github CI publishes it to PyPi
+    (see .github/workflows/pypi_release.yml, which sets RELEASE=1). Non-release builds get a `.dev0` suffix.
+    """
+    if not os.getenv("RELEASE"):
+        version += ".dev0"
+    return version
+
+
+version = "0.6.0"
+version = update_version(version)
+
+if __name__ == "__main__":
+    create_version_file(version=version)
+    # Everything except the dynamic version lives in pyproject.toml.
+    setup(version=version)

autogluon_cloud-0.6.0/src/autogluon/cloud/__init__.py

@@ -0,0 +1,37 @@
+import logging
+import os
+
+os.environ.setdefault("SAGEMAKER_SUPPRESS_V2_WARNING", "1")
+import sagemaker
+from packaging.version import Version
+
+if Version(sagemaker.__version__) >= Version("3.0"):
+    raise ImportError(
+        f"SageMaker SDK >= 3.0 is currently not supported (found {sagemaker.__version__}). "
+        "Please downgrade: pip install -U 'sagemaker<3'"
+    )
+
+from autogluon.common.utils.log_utils import _add_stream_handler
+
+from .cloud_setup import bootstrap, register, status, teardown
+from .endpoint.tabular_endpoint import TabularEndpoint
+from .endpoint.timeseries_endpoint import TimeSeriesEndpoint
+from .model.foundation_model import TabularFoundationModel, TimeSeriesFoundationModel
+from .predictor import MultiModalCloudPredictor, TabularCloudPredictor, TimeSeriesCloudPredictor
+
+_add_stream_handler()
+logging.getLogger(__name__).setLevel(logging.INFO)
+
+__all__ = [
+    "MultiModalCloudPredictor",
+    "TabularCloudPredictor",
+    "TabularEndpoint",
+    "TabularFoundationModel",
+    "TimeSeriesCloudPredictor",
+    "TimeSeriesEndpoint",
+    "TimeSeriesFoundationModel",
+    "bootstrap",
+    "register",
+    "status",
+    "teardown",
+]

{autogluon.cloud-0.4.2 → autogluon_cloud-0.6.0}/src/autogluon/cloud/backend/backend.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import pickle
+import json
+import os
 from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Union
 
@@ -9,6 +10,34 @@ import pandas as pd
 from ..endpoint.endpoint import Endpoint
 
 
+def dumps_ag_args(config: Dict[str, Any]) -> str:
+    """Serialize the remote-training config to JSON, raising a user-facing error on failure.
+
+    The config carries the user's predictor init/fit arguments. Some objects (search spaces,
+    custom metric objects, classes/callables in ``hyperparameters``) are not JSON-serializable;
+    when that happens we pinpoint the offending argument so the error names what the user passed.
+    """
+    try:
+        return json.dumps(config)
+    except TypeError as e:
+        original_error = e
+    for group in ("predictor_init_args", "predictor_fit_args"):
+        for key, value in (config.get(group) or {}).items():
+            try:
+                json.dumps(value)
+            except TypeError as e:
+                raise TypeError(
+                    f"The value passed for `{key}` is not JSON-serializable. This can happen with "
+                    f"search spaces (Real/Categorical/Int), custom metric objects, or classes/callables "
+                    f"in `hyperparameters`. Please pass these as plain values (e.g. metric names as strings). "
+                    f"Original error: {e}"
+                ) from e
+    # Culprit is outside the known arg groups; re-raise the original error with generic guidance.
+    raise TypeError(
+        f"The provided arguments are not JSON-serializable. Original error: {original_error}"
+    ) from original_error
+
+
 class Backend(ABC):
     name = "backend"
 
@@ -18,22 +47,28 @@ class Backend(ABC):
     @property
     def cloud_output_path(self) -> str:
         if not self._cloud_output_path:
-            raise ValueError(f"cloud_output_path is needed. Please pass it during init of {self.__class__.__name__}")
+            raise ValueError(
+                "No `cloud_output_path` was provided and no bucket is configured in "
+                "~/.autogluon/cloud.yaml. Either pass `cloud_output_path=` explicitly, or run "
+                "`autogluon.cloud.bootstrap()` / `register(bucket=...)` once to persist a bucket."
+            )
         return self._cloud_output_path
 
     def initialize(
-        self, local_output_path: str, predictor_type: str, cloud_output_path: Optional[str] = None, **kwargs
+        self,
+        local_output_path: str,
+        predictor_type: str,
+        cloud_output_path: Optional[str] = None,
+        resource_prefix: Optional[str] = None,
+        **kwargs,
     ) -> None:
         """Initialize the backend."""
         self.local_output_path = local_output_path
         self._cloud_output_path = cloud_output_path
         self.predictor_type = predictor_type
+        self.resource_prefix = resource_prefix or f"ag-cloud-{predictor_type}"
         self.original_features = None
-
-    @abstractmethod
-    def generate_default_permission(self, **kwargs) -> Dict[str, str]:
-        """Generate default permission file user could use to setup the corresponding entity, i.e. IAM Role in AWS"""
-        raise NotImplementedError
+        self.endpoint: Optional[Endpoint] = None
 
     @abstractmethod
     def parse_backend_fit_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
@@ -82,17 +117,19 @@ class Backend(ABC):
     def prepare_args(self, path: str, **kwargs):
         """
         prepare parameter args required to be passed to remote AG, i.e. init args and fit args
-        The args will be saved as a pickle object
+        The args will be saved as a JSON file
 
         Parameters
         ----------
         path: str
-            Path to save the pickle file
+            Path to save the JSON file
         """
         assert self.predictor_type is not None
         config = self._construct_ag_args(**kwargs)
-        with open(path, "wb") as f:
-            pickle.dump(config, f)
+        payload = dumps_ag_args(config)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as f:
+            f.write(payload)
 
     def _construct_ag_args(**kwargs):
         raise NotImplementedError
@@ -172,3 +209,10 @@ class Backend(ABC):
     def predict_proba(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
         """Batch inference probability"""
         raise NotImplementedError
+
+    def get_fit_predict_results(self) -> pd.DataFrame:
+        """
+        Retrieve predictions produced by a completed ``fit_predict`` job.
+
+        """
+        raise NotImplementedError(f"{self.__class__.__name__} does not support `fit_predict`.")

autogluon_cloud-0.6.0/src/autogluon/cloud/backend/backend_factory.py

@@ -0,0 +1,47 @@
+import logging
+
+from .backend import Backend
+from .constant import RAY_AWS, TABULAR_RAY_AWS
+from .multimodal_sagemaker_backend import MultiModalSagemakerBackend
+from .sagemaker_backend import SagemakerBackend
+from .tabular_sagemaker_backend import TabularSagemakerBackend
+from .timeseries_sagemaker_backend import TimeSeriesSagemakerBackend
+
+logger = logging.getLogger(__name__)
+
+
+class BackendFactory:
+    _SAGEMAKER_BACKENDS = {
+        SagemakerBackend.name: SagemakerBackend,
+        TabularSagemakerBackend.name: TabularSagemakerBackend,
+        MultiModalSagemakerBackend.name: MultiModalSagemakerBackend,
+        TimeSeriesSagemakerBackend.name: TimeSeriesSagemakerBackend,
+    }
+    _RAY_BACKEND_NAMES = {RAY_AWS, TABULAR_RAY_AWS}
+
+    @staticmethod
+    def get_backend_cls(backend: str) -> type[Backend]:
+        if backend in BackendFactory._SAGEMAKER_BACKENDS:
+            return BackendFactory._SAGEMAKER_BACKENDS[backend]
+        if backend in BackendFactory._RAY_BACKEND_NAMES:
+            logger.warning(
+                f"The '{backend}' backend is experimental and not fully supported. Use at your own risk; "
+                "for production workloads prefer the 'sagemaker' backend."
+            )
+            try:
+                from .ray_aws_backend import RayAWSBackend, TabularRayAWSBackend
+            except ImportError as e:
+                raise ImportError(
+                    f"The '{backend}' backend requires ray. Install with: pip install 'autogluon.cloud[ray]'"
+                ) from e
+            return {
+                RayAWSBackend.name: RayAWSBackend,
+                TabularRayAWSBackend.name: TabularRayAWSBackend,
+            }[backend]
+        supported = sorted(BackendFactory._SAGEMAKER_BACKENDS.keys() | BackendFactory._RAY_BACKEND_NAMES)
+        raise ValueError(f"{backend} not supported. Supported backends: {supported}")
+
+    @staticmethod
+    def get_backend(backend: str, **init_args) -> Backend:
+        """Return the corresponding backend"""
+        return BackendFactory.get_backend_cls(backend)(**init_args)

{autogluon.cloud-0.4.2 → autogluon_cloud-0.6.0}/src/autogluon/cloud/backend/constant.py

@@ -5,3 +5,6 @@ TIMESERIES_SAGEMAKER = "timeseries_sagemaker"
 RAY = "ray"
 RAY_AWS = "ray_aws"
 TABULAR_RAY_AWS = "tabular_ray_aws"
+
+# Backends the top-level setup API can provision via CloudFormation.
+SUPPORTED_BACKENDS = (SAGEMAKER, RAY_AWS)

{autogluon.cloud-0.4.2 → autogluon_cloud-0.6.0}/src/autogluon/cloud/backend/ray_aws_backend.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import Dict, Optional
+from typing import Optional
 
 import boto3
 
@@ -55,14 +55,9 @@ class RayAWSBackend(RayBackend):
         super().initialize(**kwargs)
         self._boto_session = boto3.session.Session()
         self.region = self._boto_session.region_name
-        assert (
-            self.region is not None
-        ), "Please setup a region via `export AWS_DEFAULT_REGION=YOUR_REGION` in the terminal"
-
-    @staticmethod
-    def generate_default_permission(**kwargs) -> Dict[str, str]:
-        """Generate default permission file user could use to setup the corresponding entity, i.e. IAM Role in AWS"""
-        return RayAWSClusterManager.generate_default_permission(**kwargs)
+        assert self.region is not None, (
+            "Please setup a region via `export AWS_DEFAULT_REGION=YOUR_REGION` in the terminal"
+        )
 
     def _setup_role_and_permission(self):
         """