nextmv 0.28.3.dev1__tar.gz → 0.28.3.dev2__tar.gz

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nextmv
-Version: 0.28.3.dev1
+Version: 0.28.3.dev2
 Summary: The all-purpose Python SDK for Nextmv
 Project-URL: Homepage, https://www.nextmv.io
 Project-URL: Documentation, https://www.nextmv.io/docs/python-sdks/nextmv/installation

nextmv-0.28.3.dev2/nextmv/__about__.py

@@ -0,0 +1 @@
+__version__ = "v0.28.3.dev2"

nextmv-0.28.3.dev2/nextmv/_serialization.py

@@ -0,0 +1,96 @@
+import datetime
+import json
+from typing import Any, Union
+
+
+def deflated_serialize_json(obj: Union[dict, list], json_configurations: dict[str, Any] = None) -> str:
+    """
+    Serialize a Python object (dict or list) to a JSON string with default configuration for a deflated format.
+
+    Parameters
+    ----------
+    obj : Union[dict, list]
+        The Python object to serialize.
+    json_configurations : dict, optional
+        Additional configurations for JSON serialization. This allows customization
+        of the Python `json.dumps` function. You can specify parameters like `indent`
+        for pretty printing or `default` for custom serialization functions.
+
+    Returns
+    -------
+    str
+        A JSON string representation of the object.
+    """
+
+    # Apply a default configuration if not provided targeting a deflated format
+    json_configurations = json_configurations or {}
+    if "default" not in json_configurations:
+        json_configurations["default"] = _custom_serial
+    if "separators" not in json_configurations:
+        json_configurations["separators"] = (",", ":")
+
+    return json.dumps(
+        obj,
+        **json_configurations,
+    )
+
+
+def serialize_json(obj: Union[dict, list], json_configurations: dict[str, Any] = None) -> str:
+    """
+    Serialize a Python object (dict or list) to a JSON string.
+
+    Parameters
+    ----------
+    obj : Union[dict, list]
+        The Python object to serialize.
+    json_configurations : dict, optional
+        Additional configurations for JSON serialization. This allows customization
+        of the Python `json.dumps` function. You can specify parameters like `indent`
+        for pretty printing or `default` for custom serialization functions.
+
+    Returns
+    -------
+    str
+        A JSON string representation of the object.
+    """
+
+    # Apply some default configuration if not provided
+    json_configurations = json_configurations or {}
+    if "default" not in json_configurations:
+        json_configurations["default"] = _custom_serial
+    if "indent" not in json_configurations:
+        json_configurations["indent"] = 2
+
+    return json.dumps(
+        obj,
+        **json_configurations,
+    )
+
+
+def _custom_serial(obj: Any) -> str:
+    """
+    JSON serializer for objects not serializable by default json serializer.
+
+    This function provides custom serialization for datetime objects, converting
+    them to ISO format strings.
+
+    Parameters
+    ----------
+    obj : Any
+        The object to serialize.
+
+    Returns
+    -------
+    str
+        The serialized representation of the object.
+
+    Raises
+    ------
+    TypeError
+        If the object type is not supported for serialization.
+    """
+
+    if isinstance(obj, (datetime.datetime, datetime.date)):
+        return obj.isoformat()
+
+    raise TypeError(f"Type {type(obj)} not serializable")

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/nextmv/cloud/application.py

@@ -33,6 +33,7 @@ from typing import Any, Optional, Union
 
 import requests
 
+from nextmv._serialization import deflated_serialize_json
 from nextmv.base_model import BaseModel
 from nextmv.cloud import package
 from nextmv.cloud.acceptance_test import AcceptanceTest, ExperimentStatus, Metric
@@ -184,10 +185,12 @@ class PollingOptions:
     """
     max_delay: float = 20
     """Maximum delay to use between polls, in seconds."""
-    max_duration: float = 300
-    """Maximum duration of the polling strategy, in seconds."""
-    max_tries: int = 100
-    """Maximum number of tries to use."""
+    max_duration: float = -1
+    """
+    Maximum duration of the polling strategy, in seconds. A negative value means no limit.
+    """
+    max_tries: int = -1
+    """Maximum number of tries to use. A negative value means no limit."""
     jitter: float = 1
     """
     Jitter to use for the polling strategy. A uniform distribution is sampled
@@ -1490,6 +1493,7 @@ class Application:
         configuration: Optional[Union[RunConfiguration, dict[str, Any]]] = None,
         batch_experiment_id: Optional[str] = None,
         external_result: Optional[Union[ExternalRunResult, dict[str, Any]]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> str:
         """
         Submit an input to start a new run of the application. Returns the
@@ -1538,6 +1542,9 @@ class Application:
             configuration. This is used when the run is an external run. We
             suggest that instead of specifying this parameter, you use the
             `track_run` method of the class.
+        json_configurations: Optional[dict[str, Any]]
+            Optional configurations for JSON serialization. This is used to
+            customize the serialization before data is sent.
 
         Returns
         ----------
@@ -1588,7 +1595,7 @@ class Application:
                     if isinstance(v, str):
                         options_dict[k] = v
                     else:
-                        options_dict[k] = json.dumps(v)
+                        options_dict[k] = deflated_serialize_json(v, json_configurations=json_configurations)
 
         payload = {}
         if upload_id_used:
@@ -1626,6 +1633,7 @@ class Application:
             endpoint=f"{self.endpoint}/runs",
             payload=payload,
             query_params=query_params,
+            json_configurations=json_configurations,
         )
 
         return response.json()["run_id"]
@@ -2791,6 +2799,7 @@ class Application:
         self,
         input: Union[dict[str, Any], str],
         upload_url: UploadURL,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> None:
         """
         Upload large input data to the provided upload URL.
@@ -2806,6 +2815,9 @@ class Application:
             converted to JSON, or a pre-formatted JSON string.
         upload_url : UploadURL
             Upload URL object containing the pre-signed URL to use for uploading.
+        json_configurations : Optional[dict[str, Any]], default=None
+            Optional configurations for JSON serialization. If provided, these
+            configurations will be used when serializing the data via `json.dumps`.
 
         Returns
         -------
@@ -2830,7 +2842,7 @@ class Application:
         """
 
         if isinstance(input, dict):
-            input = json.dumps(input)
+            input = deflated_serialize_json(input, json_configurations=json_configurations)
 
         self.client.upload_to_presigned_url(
             url=upload_url.upload_url,
@@ -3174,7 +3186,11 @@ class Application:
         raise ValueError(f"Unknown scenario input type: {scenario.scenario_input.scenario_input_type}")
 
 
-def poll(polling_options: PollingOptions, polling_func: Callable[[], tuple[Any, bool]]) -> Any:  # noqa: C901
+def poll(  # noqa: C901
+    polling_options: PollingOptions,
+    polling_func: Callable[[], tuple[Any, bool]],
+    __sleep_func: Callable[[float], None] = time.sleep,
+) -> Any:
     """
     Poll a function until it succeeds or the polling strategy is exhausted.
 
@@ -3247,14 +3263,20 @@ def poll(polling_options: PollingOptions, polling_func: Callable[[], tuple[Any,
     if polling_options.verbose:
         log(f"polling | sleeping for initial delay: {polling_options.initial_delay}")
 
-    time.sleep(polling_options.initial_delay)
+    __sleep_func(polling_options.initial_delay)
 
     start_time = time.time()
     stopped = False
 
     # Begin the polling process.
     max_reached = False
-    for ix in range(polling_options.max_tries):
+    ix = 0
+    while True:
+        # Check if we reached the maximum number of tries. Break if so.
+        if ix >= polling_options.max_tries and polling_options.max_tries >= 0:
+            break
+        ix += 1
+
         # Check is we should stop polling according to the stop callback.
         if polling_options.stop is not None and polling_options.stop():
             stopped = True
@@ -3274,13 +3296,12 @@ def poll(polling_options: PollingOptions, polling_func: Callable[[], tuple[Any,
         if polling_options.verbose:
             log(f"polling | elapsed time: {passed}")
 
-        if passed >= polling_options.max_duration:
+        if passed >= polling_options.max_duration and polling_options.max_duration >= 0:
             raise TimeoutError(
                 f"polling did not succeed after {passed} seconds, exceeds max duration: {polling_options.max_duration}",
             )
 
         # Calculate the delay.
-        delay = 0.0
         if max_reached:
             # If we already reached the maximum, we don't want to further calculate the
             # delay to avoid overflows.
@@ -3301,7 +3322,7 @@ def poll(polling_options: PollingOptions, polling_func: Callable[[], tuple[Any,
         if polling_options.verbose:
             log(f"polling | sleeping for duration: {sleep_duration}")
 
-        time.sleep(sleep_duration)
+        __sleep_func(sleep_duration)
 
     if stopped:
         log("polling | stop condition met, stopping polling")

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/nextmv/cloud/client.py

@@ -14,7 +14,6 @@ get_size(obj)
     Finds the size of an object in bytes.
 """
 
-import json
 import os
 from dataclasses import dataclass, field
 from typing import IO, Any, Optional, Union
@@ -24,6 +23,8 @@ import requests
 import yaml
 from requests.adapters import HTTPAdapter, Retry
 
+from nextmv._serialization import deflated_serialize_json
+
 _MAX_LAMBDA_PAYLOAD_SIZE: int = 500 * 1024 * 1024
 """int: Maximum size of the payload handled by the Nextmv Cloud API.
 
@@ -199,6 +200,7 @@ class Client:
         headers: Optional[dict[str, str]] = None,
         payload: Optional[dict[str, Any]] = None,
         query_params: Optional[dict[str, Any]] = None,
+        json_configurations: Optional[dict[str, Any]] = None,
     ) -> requests.Response:
         """
         Makes a request to the Nextmv Cloud API.
@@ -221,6 +223,11 @@ class Client:
             provided.
         query_params : dict[str, Any], optional
             Query parameters to append to the request URL.
+        json_configurations : dict[str, Any], optional
+            Additional configurations for JSON serialization. This allows
+            customization of the Python `json.dumps` function, such as
+            specifying `indent` for pretty printing or `default` for custom
+            serialization functions.
 
         Returns
         -------
@@ -261,16 +268,19 @@ class Client:
         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) > _MAX_LAMBDA_PAYLOAD_SIZE:
+        if (
+            payload is not None
+            and get_size(payload, json_configurations=json_configurations) > _MAX_LAMBDA_PAYLOAD_SIZE
+        ):
             raise ValueError(
-                f"payload size of {get_size(payload)} bytes exceeds the maximum "
-                f"allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
+                f"payload size of {get_size(payload, json_configurations=json_configurations)} bytes exceeds "
+                + f"the maximum allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
             )
 
-        if data is not None and get_size(data) > _MAX_LAMBDA_PAYLOAD_SIZE:
+        if data is not None and get_size(data, json_configurations=json_configurations) > _MAX_LAMBDA_PAYLOAD_SIZE:
             raise ValueError(
-                f"data size of {get_size(data)} bytes exceeds the maximum "
-                f"allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
+                f"data size of {get_size(data, json_configurations=json_configurations)} bytes exceeds "
+                + f"the maximum allowed size of {_MAX_LAMBDA_PAYLOAD_SIZE} bytes"
             )
 
         session = requests.Session()
@@ -293,7 +303,11 @@ class Client:
         if data is not None:
             kwargs["data"] = data
         if payload is not None:
-            kwargs["json"] = payload
+            if isinstance(payload, (dict, list)):
+                data = deflated_serialize_json(payload, json_configurations=json_configurations)
+                kwargs["data"] = data
+            else:
+                raise ValueError("payload must be a dictionary or a list")
         if query_params is not None:
             kwargs["params"] = query_params
 
@@ -308,7 +322,9 @@ class Client:
 
         return response
 
-    def upload_to_presigned_url(self, data: Union[dict[str, Any], str], url: str) -> None:
+    def upload_to_presigned_url(
+        self, data: Union[dict[str, Any], str], url: str, json_configurations: Optional[dict[str, Any]] = None
+    ) -> None:
         """
         Uploads data to a presigned URL.
 
@@ -323,6 +339,11 @@ class Client:
             as is.
         url : str
             The presigned URL to which the data will be uploaded.
+        json_configurations : dict[str, Any], optional
+            Additional configurations for JSON serialization. This allows
+            customization of the Python `json.dumps` function, such as
+            specifying `indent` for pretty printing or `default` for custom
+            serialization functions.
 
         Raises
         ------
@@ -341,7 +362,7 @@ class Client:
 
         upload_data: Optional[str] = None
         if isinstance(data, dict):
-            upload_data = json.dumps(data, separators=(",", ":"))
+            upload_data = deflated_serialize_json(data, json_configurations=json_configurations)
         elif isinstance(data, str):
             upload_data = data
         else:
@@ -393,7 +414,7 @@ class Client:
         }
 
 
-def get_size(obj: Union[dict[str, Any], IO[bytes], str]) -> int:
+def get_size(obj: Union[dict[str, Any], IO[bytes], str], json_configurations: Optional[dict[str, Any]] = None) -> int:
     """
     Finds the size of an object in bytes.
 
@@ -407,6 +428,11 @@ def get_size(obj: Union[dict[str, Any], IO[bytes], str]) -> int:
         - If a dict, it's converted to a JSON string.
         - If a file-like object (e.g., opened file), its size is read.
         - If a string, its UTF-8 encoded byte length is calculated.
+    json_configurations : dict[str, Any], optional
+        Additional configurations for JSON serialization. This allows
+        customization of the Python `json.dumps` function, such as specifying
+        `indent` for pretty printing or `default` for custom serialization
+        functions.
 
     Returns
     -------
@@ -436,7 +462,7 @@ def get_size(obj: Union[dict[str, Any], IO[bytes], str]) -> int:
     """
 
     if isinstance(obj, dict):
-        obj_str = json.dumps(obj, separators=(",", ":"))
+        obj_str = deflated_serialize_json(obj, json_configurations=json_configurations)
         return len(obj_str.encode("utf-8"))
 
     elif hasattr(obj, "read"):

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/nextmv/cloud/run.py

@@ -39,7 +39,6 @@ run_duration(start, end)
     Calculate the duration of a run in milliseconds.
 """
 
-import json
 from dataclasses import dataclass
 from datetime import datetime
 from enum import Enum
@@ -47,6 +46,7 @@ from typing import Any, Optional, Union
 
 from pydantic import AliasChoices, Field
 
+from nextmv._serialization import serialize_json
 from nextmv.base_model import BaseModel
 from nextmv.cloud.status import Status, StatusV2
 from nextmv.input import Input, InputFormat
@@ -628,7 +628,7 @@ class TrackedRun:
                 raise ValueError("Input.input_format must be JSON.")
         elif isinstance(self.input, dict):
             try:
-                _ = json.dumps(self.input)
+                _ = serialize_json(self.input)
             except (TypeError, OverflowError) as e:
                 raise ValueError("Input is dict[str, Any] but it is not JSON serializable") from e
 
@@ -637,7 +637,7 @@ class TrackedRun:
                 raise ValueError("Output.output_format must be JSON.")
         elif isinstance(self.output, dict):
             try:
-                _ = json.dumps(self.output)
+                _ = serialize_json(self.output)
             except (TypeError, OverflowError) as e:
                 raise ValueError("Output is dict[str, Any] but it is not JSON serializable") from e
 

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/nextmv/input.py

@@ -31,6 +31,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Optional, Union
 
+from nextmv._serialization import serialize_json
 from nextmv.deprecated import deprecated
 from nextmv.options import Options
 
@@ -139,7 +140,7 @@ class Input:
 
         if self.input_format == InputFormat.JSON:
             try:
-                _ = json.dumps(self.data)
+                _ = serialize_json(self.data)
             except (TypeError, OverflowError) as e:
                 raise ValueError(
                     f"Input has input_format InputFormat.JSON and "

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/nextmv/output.py

@@ -42,8 +42,6 @@ write
 
 import copy
 import csv
-import datetime
-import json
 import os
 import sys
 from dataclasses import dataclass
@@ -52,6 +50,7 @@ from typing import Any, Optional, Union
 
 from pydantic import AliasChoices, Field
 
+from nextmv._serialization import serialize_json
 from nextmv.base_model import BaseModel
 from nextmv.deprecated import deprecated
 from nextmv.logger import reset_stdout
@@ -644,7 +643,7 @@ class Output:
 
         if self.output_format == OutputFormat.JSON:
             try:
-                _ = json.dumps(self.solution, default=_custom_serial)
+                _ = serialize_json(self.solution)
             except (TypeError, OverflowError) as e:
                 raise ValueError(
                     f"Output has output_format OutputFormat.JSON and "
@@ -722,12 +721,6 @@ class Output:
             and self.csv_configurations != {}
         ):
             output_dict["csv_configurations"] = self.csv_configurations
-        elif (
-            self.output_format == OutputFormat.JSON
-            and self.json_configurations is not None
-            and self.json_configurations != {}
-        ):
-            output_dict["json_configurations"] = self.json_configurations
 
         return output_dict
 
@@ -822,19 +815,9 @@ class LocalOutputWriter(OutputWriter):
         if hasattr(output, "json_configurations") and output.json_configurations is not None:
             json_configurations = output.json_configurations
 
-        indent, custom_serial = 2, _custom_serial
-        if "indent" in json_configurations:
-            indent = json_configurations["indent"]
-            del json_configurations["indent"]
-        if "default" in json_configurations:
-            custom_serial = json_configurations["default"]
-            del json_configurations["default"]
-
-        serialized = json.dumps(
+        serialized = serialize_json(
             output_dict,
-            indent=indent,
-            default=custom_serial,
-            **json_configurations,
+            json_configurations=json_configurations,
         )
 
         if path is None or path == "":
@@ -877,13 +860,17 @@ class LocalOutputWriter(OutputWriter):
         if not os.path.exists(dir_path):
             os.makedirs(dir_path)
 
-        serialized = json.dumps(
+        json_configurations = {}
+        if hasattr(output, "json_configurations") and output.json_configurations is not None:
+            json_configurations = output.json_configurations
+
+        serialized = serialize_json(
             {
                 "options": output_dict.get("options", {}),
                 "statistics": output_dict.get("statistics", {}),
                 "assets": output_dict.get("assets", []),
             },
-            indent=2,
+            json_configurations=json_configurations,
         )
         print(serialized, file=sys.stdout)
 
@@ -1118,32 +1105,3 @@ def write(
     """
 
     writer.write(output, path, skip_stdout_reset)
-
-
-def _custom_serial(obj: Any) -> str:
-    """
-    JSON serializer for objects not serializable by default json serializer.
-
-    This function provides custom serialization for datetime objects, converting
-    them to ISO format strings.
-
-    Parameters
-    ----------
-    obj : Any
-        The object to serialize.
-
-    Returns
-    -------
-    str
-        The serialized representation of the object.
-
-    Raises
-    ------
-    TypeError
-        If the object type is not supported for serialization.
-    """
-
-    if isinstance(obj, (datetime.datetime | datetime.date)):
-        return obj.isoformat()
-
-    raise TypeError(f"Type {type(obj)} not serializable")

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/tests/cloud/test_application.py

@@ -4,6 +4,11 @@ from typing import Any
 from nextmv.cloud.application import PollingOptions, poll
 
 
+# This is a dummy function to avoid actually sleeping during tests.
+def no_sleep(value: float) -> None:
+    return
+
+
 class TestApplication(unittest.TestCase):
     def test_poll(self):
         counter = 0
@@ -17,9 +22,9 @@ class TestApplication(unittest.TestCase):
 
             return "result", True
 
-        polling_options = PollingOptions(verbose=True)
+        polling_options = PollingOptions()
 
-        result = poll(polling_options, polling_func)
+        result = poll(polling_options, polling_func, no_sleep)
 
         self.assertEqual(result, "result")
 
@@ -42,8 +47,29 @@ class TestApplication(unittest.TestCase):
             if counter == 3:
                 return True
 
-        polling_options = PollingOptions(verbose=True, stop=stop)
+        polling_options = PollingOptions(stop=stop)
 
-        result = poll(polling_options, polling_func)
+        result = poll(polling_options, polling_func, no_sleep)
 
         self.assertIsNone(result)
+
+    def test_poll_long(self):
+        counter = 0
+        max_tries = 1000000
+
+        def polling_func() -> tuple[Any, bool]:
+            nonlocal counter
+            counter += 1
+
+            if counter < max_tries:
+                return "result", False
+
+            return "result", True
+
+        polling_options = PollingOptions(
+            max_tries=max_tries + 1,
+        )
+
+        result = poll(polling_options, polling_func, no_sleep)
+
+        self.assertEqual(result, "result")

{nextmv-0.28.3.dev1 → nextmv-0.28.3.dev2}/tests/test_output.py

@@ -118,13 +118,6 @@ class TestOutput(unittest.TestCase):
         result = output.to_dict()
         self.assertEqual(result["assets"][0]["name"], "asset3")
 
-        # Test with JSON configurations
-        json_config = {"indent": 4, "sort_keys": True}
-        output = nextmv.Output(output_format=nextmv.OutputFormat.JSON, json_configurations=json_config)
-        result = output.to_dict()
-        self.assertEqual(result["json_configurations"]["indent"], 4)
-        self.assertEqual(result["json_configurations"]["sort_keys"], True)
-
         # Test with CSV configurations
         csv_config = {"delimiter": ";", "quoting": csv.QUOTE_NONNUMERIC}
         output = nextmv.Output(output_format=nextmv.OutputFormat.CSV_ARCHIVE, csv_configurations=csv_config)
@@ -183,7 +176,6 @@ class TestOutput(unittest.TestCase):
         self.assertEqual(result["assets"][0]["name"], "asset1")
         self.assertEqual(result["assets"][0]["visual"]["schema"], "chartjs")
         self.assertEqual(result["solution"]["value"], 42)
-        self.assertEqual(result["json_configurations"]["indent"], 4)
 
     def test_local_writer_json_stdout_default(self):
         output = nextmv.Output(
@@ -262,7 +254,7 @@ class TestOutput(unittest.TestCase):
 
             self.assertEqual(
                 mock_stdout.getvalue(),
-                '{"assets":[],"json_configurations":{"separators":[",",":"],"sort_keys":true},"options":{},"solution":{"empanadas":"are_life"},"statistics":{"foo":"bar"}}\n',
+                '{"assets":[],"options":{},"solution":{"empanadas":"are_life"},"statistics":{"foo":"bar"}}\n',
             )
 
     def test_local_writer_json_stdout_with_options(self):

nextmv-0.28.3.dev2/tests/test_serialization.py

@@ -0,0 +1,96 @@
+import datetime
+import json
+import unittest
+
+import nextmv._serialization
+
+
+class TestSerialization(unittest.TestCase):
+    """Tests for the common serialization functionality."""
+
+    def test_default_serialization(self):
+        """Test the default serialization"""
+
+        data = {
+            "name": "Test",
+            "value": 42,
+            "timestamp": nextmv._serialization._custom_serial(datetime.datetime(2023, 10, 1)),
+        }
+        serialized = nextmv._serialization.serialize_json(data)
+        expected = json.dumps(
+            {
+                "name": "Test",
+                "value": 42,
+                "timestamp": "2023-10-01T00:00:00",
+            },
+            indent=2,
+        )
+        self.assertEqual(serialized, expected)
+
+    def test_default_deflated_serialization(self):
+        """Test the default deflated serialization"""
+
+        data = {
+            "name": "Test",
+            "value": 42,
+            "timestamp": nextmv._serialization._custom_serial(datetime.datetime(2023, 10, 1)),
+        }
+        serialized = nextmv._serialization.deflated_serialize_json(data)
+        expected = json.dumps(
+            {
+                "name": "Test",
+                "value": 42,
+                "timestamp": "2023-10-01T00:00:00",
+            },
+            separators=(",", ":"),
+        )
+        self.assertEqual(serialized, expected)
+
+    def test_custom_serialization(self):
+        """Test custom serialization with additional configurations"""
+
+        data = {
+            "name": "Test",
+            "value": 42,
+            "timestamp": nextmv._serialization._custom_serial(datetime.datetime(2023, 10, 1)),
+        }
+        json_configurations = {
+            "indent": 2,
+            "default": nextmv._serialization._custom_serial,
+            "separators": (",", ": "),
+        }
+        serialized = nextmv._serialization.serialize_json(data, json_configurations)
+        expected = json.dumps(
+            {
+                "name": "Test",
+                "value": 42,
+                "timestamp": "2023-10-01T00:00:00",
+            },
+            indent=2,
+            separators=(",", ": "),
+        )
+        self.assertEqual(serialized, expected)
+
+    def test_compressed_serialization(self):
+        """Test a requested compressed serialization"""
+
+        data = {
+            "name": "Test",
+            "value": 42,
+            "timestamp": nextmv._serialization._custom_serial(datetime.datetime(2023, 10, 1)),
+        }
+        json_configurations = {
+            "separators": (",", ":"),  # Remove spaces for a compressed format
+            "indent": None,  # No indentation for compressed format
+        }
+        serialized = nextmv._serialization.serialize_json(data, json_configurations)
+        expected = json.dumps(
+            {
+                "name": "Test",
+                "value": 42,
+                "timestamp": "2023-10-01T00:00:00",
+            },
+            separators=(",", ":"),
+            indent=None,
+        )
+        self.assertEqual(serialized, expected)

nextmv-0.28.3.dev1/nextmv/__about__.py

@@ -1 +0,0 @@
-__version__ = "v0.28.3.dev1"