Merge branch 'feature/eng-4278-complete-cloud-api' into feature/eng-4277-create-workflow-for-publishingdistributing-the-package

Author: sebastian-quintero

nextmv/cloud/__init__.py

@@ -1,10 +1,10 @@
 """Functionality for interacting with the Nextmv Cloud."""
 
 from .acceptance_test import AcceptanceTest as AcceptanceTest
-from .acceptance_test import AcceptanceTestParams as AcceptanceTestParams
 from .acceptance_test import Comparison as Comparison
 from .acceptance_test import ComparisonInstance as ComparisonInstance
 from .acceptance_test import Metric as Metric
+from .acceptance_test import MetricParams as MetricParams
 from .acceptance_test import MetricType as MetricType
 from .application import Application as Application
 from .application import DownloadURL as DownloadURL

nextmv/cloud/acceptance_test.py

@@ -34,7 +34,7 @@ class Comparison(str, Enum):
     """Not equal to metric type."""
 
 
-class AcceptanceTestParams(BaseModel):
+class MetricParams(BaseModel):
     """Parameters of an acceptance test."""
 
     operator: Comparison
@@ -49,14 +49,14 @@ class Metric(BaseModel):
     """Field of the metric."""
     metric_type: MetricType
     """Type of the metric."""
-    params: AcceptanceTestParams
+    params: MetricParams
     """Parameters of the metric."""
     statistic: str
     """Statistic of the metric."""
 
 
 class ComparisonInstance(BaseModel):
-    """An instance used for a comparison."""
+    """An app instance used for a comparison."""
 
     instance_id: str
     """ID of the instance."""

nextmv/cloud/application.py

@@ -11,6 +11,10 @@
 from nextmv.cloud.client import Client, get_size
 from nextmv.cloud.input_set import InputSet
 
+_MAX_RUN_SIZE: int = 5 * 1024 * 1024
+"""Maximum size of the run input/output. This value is used to determine
+whether to use the large input upload and/or result download endpoints."""
+
 
 class DownloadURL(BaseModel):
     """Result of getting a download URL."""
@@ -122,9 +126,6 @@ class Application:
     """Base endpoint for the application."""
     experiments_endpoint: str = "{base}/experiments"
     """Base endpoint for the experiments in the application."""
-    max_run_size: int = 5 * 1024 * 1024
-    """Maximum size of the run input/output. This value is used to determine
-    whether to use the large input upload and/or result download endpoints."""
 
     def __post_init__(self):
         """Logic to run after the class is initialized."""
@@ -470,7 +471,7 @@ def new_run(
             input_size = get_size(input)
 
         upload_id_used = upload_id is not None
-        if not upload_id_used and input_size > self.max_run_size:
+        if not upload_id_used and input_size > _MAX_RUN_SIZE:
             upload_url = self.upload_url()
             self.upload_large_input(upload_url=upload_url, input=input)
             upload_id = upload_url.upload_id
@@ -509,7 +510,7 @@ def new_run_with_result(
         description: str | None = None,
         upload_id: str | None = None,
         run_options: dict[str, Any] | None = None,
-        polling_options: PollingOptions | None = None,
+        polling_options: PollingOptions = None,
     ) -> RunResult:
         """
         Submit an input to start a new run of the application and poll for the
@@ -703,7 +704,7 @@ def _run_result(
         """
         query_params = None
         large_output = False
-        if run_information.metadata.output_size > self.max_run_size:
+        if run_information.metadata.output_size > _MAX_RUN_SIZE:
             query_params = {"format": "url"}
             large_output = True
 

nextmv/cloud/client.py

@@ -1,14 +1,17 @@
 """Module with the client class."""
 
+import json
 import os
-import sys
 from dataclasses import dataclass, field
 from typing import Any
 from urllib.parse import urljoin
 
 import requests
 from requests.adapters import HTTPAdapter, Retry
 
+_MAX_LAMBDA_PAYLOAD_SIZE: int = 500 * 1024 * 1024
+"""Maximum size of the payload handled by the Nextmv Cloud API."""
+
 
 @dataclass
 class Client:
@@ -37,8 +40,6 @@ class Client:
     seconds."""
     headers: dict[str, str] | None = None
     """Headers to use for requests to the Nextmv Cloud API."""
-    max_lambda_payload_size: int = 500 * 1024 * 1024
-    """Maximum size of the payload handled by the Nextmv Cloud API."""
     max_retries: int = 10
     """Maximum number of retries to use for requests to the Nextmv Cloud
     API."""
@@ -102,16 +103,16 @@ def request(
         if payload is not None and data is not None:
             raise ValueError("cannot use both data and payload")
 
-        if payload is not None and get_size(payload) > self.max_lambda_payload_size:
+        if payload is not None and get_size(payload) > _MAX_LAMBDA_PAYLOAD_SIZE:
             raise ValueError(
                 f"payload size of {get_size(payload)} bytes exceeds the maximum "
-                f"allowed size of {self.max_lambda_payload_size} bytes"
+                f"allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
             )
 
-        if data is not None and get_size(data) > self.max_lambda_payload_size:
+        if data is not None and get_size(data) > _MAX_LAMBDA_PAYLOAD_SIZE:
             raise ValueError(
                 f"data size of {get_size(data)} bytes exceeds the maximum "
-                f"allowed size of {self.max_lambda_payload_size} bytes"
+                f"allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
             )
 
         session = requests.Session()
@@ -150,24 +151,8 @@ def request(
         return response
 
 
-def get_size(obj: dict | Any, seen: set | Any = None) -> int:
-    """Recursively finds size of objects"""
-
-    size = sys.getsizeof(obj)
-    if seen is None:
-        seen = set()
-    obj_id = id(obj)
-    if obj_id in seen:
-        return 0
-
-    # Important mark as seen *before* entering recursion to gracefully handle
-    # self-referential objects
-    seen.add(obj_id)
-    if isinstance(obj, dict):
-        size += sum([get_size(v, seen) for v in obj.values()])
-        size += sum([get_size(k, seen) for k in obj.keys()])
-    elif hasattr(obj, "__dict__"):
-        size += get_size(obj.__dict__, seen)
-    elif hasattr(obj, "__iter__") and not isinstance(obj, str | bytes | bytearray):
-        size += sum([get_size(i, seen) for i in obj])
-    return size
+def get_size(obj: dict[str, Any]) -> int:
+    """Finds the size of an object in bytes."""
+
+    obj_str = json.dumps(obj, separators=(",", ":"))
+    return len(obj_str.encode("utf-8"))