autogluon.cloud 0.5.0__tar.gz → 0.7.0__tar.gz

{autogluon_cloud-0.5.0/src/autogluon.cloud.egg-info → autogluon_cloud-0.7.0}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.4
 Name: autogluon.cloud
-Version: 0.5.0
-Summary: Train and deploy AutoGluon backed models on the cloud
-Home-page: https://github.com/autogluon/autogluon-cloud
+Version: 0.7.0
+Summary: Train and deploy ML models in the cloud
 Author: AutoGluon Community
-License: Apache-2.0
-Project-URL: Documentation, https://auto.gluon.ai
+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
@@ -17,7 +16,6 @@ Classifier: Intended Audience :: Customer Service
 Classifier: Intended Audience :: Financial and Insurance Industry
 Classifier: Intended Audience :: Healthcare Industry
 Classifier: Intended Audience :: Telecommunications Industry
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX
@@ -31,44 +29,27 @@ 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.10, <3.14
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: autogluon.common<1.6,>=0.7
-Requires-Dist: boto3<2,>=1.10
+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.126.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: typing_extensions<5,>=4.5
 Requires-Dist: click<9,>=8.0
 Requires-Dist: rich<15,>=13.0
-Provides-Extra: ray
-Requires-Dist: ray[default]<2.56,>=2.10.0; extra == "ray"
 Provides-Extra: all
-Requires-Dist: autogluon<1.6,>=0.7; extra == "all"
-Requires-Dist: ray[default]<2.56,>=2.10.0; extra == "all"
+Requires-Dist: autogluon<1.7,>=0.7; extra == "all"
 Provides-Extra: tests
-Requires-Dist: moto; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
+Requires-Dist: moto; extra == "tests"
 Requires-Dist: autogluon.common>=0.7; extra == "tests"
-Requires-Dist: pytest-cov; extra == "tests"
-Requires-Dist: tox; extra == "tests"
-Dynamic: author
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
 Dynamic: license-file
-Dynamic: project-url
-Dynamic: provides-extra
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 
 
@@ -78,7 +59,7 @@ Dynamic: summary
 ## 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/)
+[![Python Versions](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-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)
 
@@ -86,30 +67,48 @@ Dynamic: summary
 
 </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:
+AutoGluon-Cloud lets you train and deploy state-of-the-art ML models for classification, regression, and time series forecasting on [Amazon SageMaker](https://aws.amazon.com/sagemaker/). All it takes is a few lines of code; AutoGluon-Cloud handles the infrastructure, dependencies, and glue code for you.
+
+## 💡 Why AutoGluon-Cloud?
 
-- **[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.
+- **Works like local [AutoGluon](https://auto.gluon.ai/stable/index.html).** Pass in DataFrames, get predictions back — as convenient as working locally, with the compute handled by AWS.
+- **No boilerplate.** No training scripts, inference handlers, or serialization code to write and maintain.
+- **Official AWS containers.** Everything runs in the [AutoGluon Deep Learning Containers](https://aws.github.io/deep-learning-containers/), maintained and security-patched by AWS.
+- **Sensible defaults, fully configurable.** Under the hood it's just SageMaker running in your AWS account, so you stay in full control.
 
-## 💾 Installation & setup
+## 💾 Installation
 
 ```bash
 pip install autogluon.cloud
+autogluon-cloud bootstrap  # one-time setup for IAM role and S3 bucket
 ```
 
-Then provision the IAM role and S3 bucket AutoGluon-Cloud needs to run on AWS:
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for more details.
+
+## 🚀 Foundation models
+
+Zero-shot forecasts with a pretrained model like [Chronos-2](https://huggingface.co/amazon/chronos-2) — no training required. [Full walkthrough](https://auto.gluon.ai/cloud/stable/tutorials/foundation-model-timeseries.html).
 
 ```python
-from autogluon.cloud import bootstrap
+from autogluon.cloud import TimeSeriesFoundationModel
 
-bootstrap()
-```
+# `data` can be a local path, S3 URL, or pandas DataFrame
+data = "https://autogluon.s3.amazonaws.com/datasets/timeseries/m4_hourly_tiny/train.csv"
 
-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.
+model = TimeSeriesFoundationModel("chronos-2")
+
+# Batch prediction
+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()
+```
 
-## ⚙️ Train your own model
+## ⚙️ Train your own predictor
 
-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).
+Train an AutoGluon predictor on your data and serve it from SageMaker. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html), [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.html).
 
 ```python
 from autogluon.cloud import TabularCloudPredictor
@@ -126,40 +125,11 @@ cloud_predictor.fit(
     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 = cloud_predictor.deploy()
+result = endpoint.predict(test_data)
 endpoint.delete_endpoint()
 ```

autogluon_cloud-0.7.0/README.md

@@ -0,0 +1,82 @@
+
+
+<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%20%7C%203.13-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 for classification, regression, and time series forecasting on [Amazon SageMaker](https://aws.amazon.com/sagemaker/). All it takes is a few lines of code; AutoGluon-Cloud handles the infrastructure, dependencies, and glue code for you.
+
+## 💡 Why AutoGluon-Cloud?
+
+- **Works like local [AutoGluon](https://auto.gluon.ai/stable/index.html).** Pass in DataFrames, get predictions back — as convenient as working locally, with the compute handled by AWS.
+- **No boilerplate.** No training scripts, inference handlers, or serialization code to write and maintain.
+- **Official AWS containers.** Everything runs in the [AutoGluon Deep Learning Containers](https://aws.github.io/deep-learning-containers/), maintained and security-patched by AWS.
+- **Sensible defaults, fully configurable.** Under the hood it's just SageMaker running in your AWS account, so you stay in full control.
+
+## 💾 Installation
+
+```bash
+pip install autogluon.cloud
+autogluon-cloud bootstrap  # one-time setup for IAM role and S3 bucket
+```
+
+See the [Setup tutorial](https://auto.gluon.ai/cloud/stable/tutorials/setup.html) for more details.
+
+## 🚀 Foundation models
+
+Zero-shot forecasts with a pretrained model like [Chronos-2](https://huggingface.co/amazon/chronos-2) — no training required. [Full walkthrough](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
+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()
+```
+
+## ⚙️ Train your own predictor
+
+Train an AutoGluon predictor on your data and serve it from SageMaker. Full walkthrough: [time series](https://auto.gluon.ai/cloud/stable/tutorials/predictor-timeseries.html), [tabular](https://auto.gluon.ai/cloud/stable/tutorials/predictor-tabular.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()
+)
+
+# Batch prediction
+result = cloud_predictor.predict(test_data)
+
+# Real-time inference endpoint
+endpoint = cloud_predictor.deploy()
+result = endpoint.predict(test_data)
+endpoint.delete_endpoint()
+```

autogluon_cloud-0.7.0/pyproject.toml

@@ -0,0 +1,106 @@
+[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",
+    "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.5,<5",  # 4.5 adds @deprecated (PEP 702)
+    # CLI dependencies (autogluon-cloud command)
+    "click>=8.0,<9",
+    "rich>=13.0,<15",
+]
+
+[project.optional-dependencies]
+all = [  # To allow user to pass ag objects
+    "autogluon>=0.7,<1.7",
+]
+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" = [
+    "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"]
+# Release tests are slow and expensive; run them with `-m release` (see .github/workflows/release_tests.yml).
+addopts = "--strict-markers -m 'not release'"
+markers = ["release: pre-release test that runs every registry model on its default instance"]
+xfail_strict = true

autogluon_cloud-0.7.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.7.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.5.0 → autogluon_cloud-0.7.0}/src/autogluon/cloud/__init__.py

@@ -1,19 +1,12 @@
 import logging
 
-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.multimodal_endpoint import MultiModalEndpoint
+from .endpoint.tabular_endpoint import TabularEndpoint
 from .endpoint.timeseries_endpoint import TimeSeriesEndpoint
-from .model.foundation_model import TimeSeriesFoundationModel
+from .model.foundation_model import TabularFoundationModel, TimeSeriesFoundationModel
 from .predictor import MultiModalCloudPredictor, TabularCloudPredictor, TimeSeriesCloudPredictor
 
 _add_stream_handler()
@@ -21,7 +14,10 @@ logging.getLogger(__name__).setLevel(logging.INFO)
 
 __all__ = [
     "MultiModalCloudPredictor",
+    "MultiModalEndpoint",
     "TabularCloudPredictor",
+    "TabularEndpoint",
+    "TabularFoundationModel",
     "TimeSeriesCloudPredictor",
     "TimeSeriesEndpoint",
     "TimeSeriesFoundationModel",

{autogluon_cloud-0.5.0 → autogluon_cloud-0.7.0}/src/autogluon/cloud/backend/backend.py

@@ -1,13 +1,39 @@
 from __future__ import annotations
 
+import json
 import os
-import pickle
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 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):
@@ -27,19 +53,20 @@ class Backend(ABC):
         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: str | None = None,
+        resource_prefix: str | None = 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
-        self.endpoint: Optional[Endpoint] = None
-
-    @abstractmethod
-    def parse_backend_fit_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
-        """Parse backend specific kwargs and get them ready to be sent to fit call"""
-        raise NotImplementedError
+        self.endpoint_name: str | None = None
 
     @abstractmethod
     def attach_job(self, job_name: str) -> None:
@@ -74,7 +101,7 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_fit_job_info(self) -> Dict[str, Any]:
+    def get_fit_job_info(self) -> dict[str, Any]:
         """
         Get general info of the training job.
         """
@@ -83,18 +110,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)
+        payload = dumps_ag_args(config)
         os.makedirs(os.path.dirname(path), exist_ok=True)
-        with open(path, "wb") as f:
-            pickle.dump(config, f)
+        with open(path, "w") as f:
+            f.write(payload)
 
     def _construct_ag_args(**kwargs):
         raise NotImplementedError
@@ -104,11 +132,6 @@ class Backend(ABC):
         """Fit AG on the backend"""
         raise NotImplementedError
 
-    @abstractmethod
-    def parse_backend_deploy_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
-        """Parse backend specific kwargs and get them ready to be sent to deploy call"""
-        raise NotImplementedError
-
     @abstractmethod
     def deploy(self, **kwargs) -> None:
         """Deploy and endpoint"""
@@ -120,32 +143,27 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def attach_endpoint(self, endpoint: Endpoint) -> None:
-        """Attach the backend to an existing endpoint"""
+    def attach_endpoint(self, endpoint: str) -> None:
+        """Attach the backend to an existing endpoint by name"""
         raise NotImplementedError
 
     @abstractmethod
-    def detach_endpoint(self) -> Endpoint:
-        """Detach the current endpoint and return it"""
+    def detach_endpoint(self) -> str:
+        """Detach the current endpoint and return its name"""
         raise NotImplementedError
 
     @abstractmethod
-    def predict_real_time(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
+    def predict_real_time(self, test_data: str | pd.DataFrame, **kwargs) -> pd.DataFrame | pd.Series:
         """Realtime prediction with the endpoint"""
         raise NotImplementedError
 
     @abstractmethod
-    def predict_proba_real_time(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
+    def predict_proba_real_time(self, test_data: str | pd.DataFrame, **kwargs) -> pd.DataFrame | pd.Series:
         """Realtime prediction probability with the endpoint"""
         raise NotImplementedError
 
     @abstractmethod
-    def parse_backend_predict_kwargs(self, kwargs: Dict) -> Dict[str, Any]:
-        """Parse backend specific kwargs and get them ready to be sent to predict call"""
-        raise NotImplementedError
-
-    @abstractmethod
-    def get_batch_inference_job_info(self, job_name: Optional[str] = None) -> Dict[str, Any]:
+    def get_batch_inference_job_info(self, job_name: str | None = None) -> dict[str, Any]:
         """
         Get general info of the batch inference job.
         If job_name not specified, return the info of the most recent batch inference job
@@ -153,7 +171,7 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_batch_inference_job_status(self, job_name: Optional[str] = None) -> str:
+    def get_batch_inference_job_status(self, job_name: str | None = None) -> str:
         """
         Get general status of the batch inference job.
         If job_name not specified, return the info of the most recent batch inference job
@@ -161,17 +179,17 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def get_batch_inference_jobs(self) -> List[str]:
+    def get_batch_inference_jobs(self) -> list[str]:
         """Get a list of names of all batch inference jobs"""
         raise NotImplementedError
 
     @abstractmethod
-    def predict(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
+    def predict(self, test_data: str | pd.DataFrame, **kwargs) -> pd.DataFrame | pd.Series:
         """Batch inference"""
         raise NotImplementedError
 
     @abstractmethod
-    def predict_proba(self, test_data: Union[str, pd.DataFrame], **kwargs) -> Union[pd.DataFrame, pd.Series]:
+    def predict_proba(self, test_data: str | pd.DataFrame, **kwargs) -> pd.DataFrame | pd.Series:
         """Batch inference probability"""
         raise NotImplementedError
 

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

@@ -0,0 +1,25 @@
+from .backend import Backend
+from .multimodal_sagemaker_backend import MultiModalSagemakerBackend
+from .sagemaker_backend import SagemakerBackend
+from .tabular_sagemaker_backend import TabularSagemakerBackend
+from .timeseries_sagemaker_backend import TimeSeriesSagemakerBackend
+
+
+class BackendFactory:
+    _BACKENDS = {
+        SagemakerBackend.name: SagemakerBackend,
+        TabularSagemakerBackend.name: TabularSagemakerBackend,
+        MultiModalSagemakerBackend.name: MultiModalSagemakerBackend,
+        TimeSeriesSagemakerBackend.name: TimeSeriesSagemakerBackend,
+    }
+
+    @staticmethod
+    def get_backend_cls(backend: str) -> type[Backend]:
+        if backend in BackendFactory._BACKENDS:
+            return BackendFactory._BACKENDS[backend]
+        raise ValueError(f"{backend} not supported. Supported backends: {sorted(BackendFactory._BACKENDS)}")
+
+    @staticmethod
+    def get_backend(backend: str, **init_args) -> Backend:
+        """Return the corresponding backend"""
+        return BackendFactory.get_backend_cls(backend)(**init_args)

{autogluon_cloud-0.5.0 → autogluon_cloud-0.7.0}/src/autogluon/cloud/backend/constant.py

@@ -2,9 +2,6 @@ SAGEMAKER = "sagemaker"
 TABULAR_SAGEMAKER = "tabular_sagemaker"
 MULTIMODL_SAGEMAKER = "multimodal_sagemaker"
 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)
+SUPPORTED_BACKENDS = (SAGEMAKER,)