nextmv 0.18.0__py3-none-any.whl → 1.0.0.dev2__py3-none-any.whl

nextmv/__about__.py

@@ -1 +1 @@
-__version__ = "v0.18.0"
+__version__ = "v1.0.0.dev2"

nextmv/__entrypoint__.py

@@ -1,5 +1,5 @@
 """
-When working in a notebook environment, we don’t really create a `main.py` file
+When working in a notebook environment, we don't really create a `main.py` file
 with the main entrypoint of the program. Because the logic is mostly encoded
 inside the `Model` class, we need to create a `main.py` file that we can run in
 Nextmv Cloud. This file is used as that entrypoint. It is not intended for a
@@ -9,22 +9,17 @@ human to use it during local development. It is the standard way in which a
 
 from mlflow.pyfunc import load_model
 
-from nextmv.cloud.manifest import Manifest
-from nextmv.input import load_local
-from nextmv.options import Options
-from nextmv.output import write_local
+import nextmv
+from nextmv import cloud
 
 
 def main() -> None:
     """Entry point for the program."""
 
-    manifest = Manifest.from_yaml(".")
+    manifest = cloud.Manifest.from_yaml(".")
 
     # Load the options from the manifest.
-    options = None
-    parameters_dict = manifest.python.model.options
-    if parameters_dict is not None:
-        options = Options.from_parameters_dict(parameters_dict)
+    options = manifest.extract_options()
 
     # Load the model.
     loaded_model = load_model(
@@ -32,12 +27,12 @@ def main() -> None:
         suppress_warnings=True,
     )
 
-    # Load the input and solve the model by using mlflow’s inference API.
-    input = load_local(options=options)
+    # Load the input and solve the model by using mlflow's inference API.
+    input = nextmv.load(options=options)
     output = loaded_model.predict(input)
 
     # Write the output.
-    write_local(output)
+    nextmv.write(output)
 
 
 if __name__ == "__main__":

nextmv/__init__.py

@@ -1,17 +1,35 @@
 """Nextmv Python SDK."""
 
 from .__about__ import __version__
+from .base_model import BaseModel as BaseModel
 from .base_model import from_dict as from_dict
+from .input import DataFile as DataFile
 from .input import Input as Input
 from .input import InputFormat as InputFormat
 from .input import InputLoader as InputLoader
 from .input import LocalInputLoader as LocalInputLoader
+from .input import csv_data_file as csv_data_file
+from .input import json_data_file as json_data_file
+from .input import load as load
 from .input import load_local as load_local
+from .input import text_data_file as text_data_file
 from .logger import log as log
 from .logger import redirect_stdout as redirect_stdout
 from .logger import reset_stdout as reset_stdout
+from .manifest import MANIFEST_FILE_NAME as MANIFEST_FILE_NAME
+from .manifest import Manifest as Manifest
+from .manifest import ManifestBuild as ManifestBuild
+from .manifest import ManifestExecution as ManifestExecution
+from .manifest import ManifestOption as ManifestOption
+from .manifest import ManifestPython as ManifestPython
+from .manifest import ManifestPythonArch as ManifestPythonArch
+from .manifest import ManifestPythonModel as ManifestPythonModel
+from .manifest import ManifestRuntime as ManifestRuntime
+from .manifest import ManifestType as ManifestType
+from .manifest import default_python_manifest as default_python_manifest
 from .model import Model as Model
 from .model import ModelConfiguration as ModelConfiguration
+from .options import Option as Option
 from .options import Options as Options
 from .options import Parameter as Parameter
 from .output import Asset as Asset
@@ -24,10 +42,45 @@ from .output import ResultStatistics as ResultStatistics
 from .output import RunStatistics as RunStatistics
 from .output import Series as Series
 from .output import SeriesData as SeriesData
+from .output import SolutionFile as SolutionFile
 from .output import Statistics as Statistics
 from .output import Visual as Visual
 from .output import VisualSchema as VisualSchema
+from .output import csv_solution_file as csv_solution_file
+from .output import json_solution_file as json_solution_file
+from .output import text_solution_file as text_solution_file
+from .output import write as write
 from .output import write_local as write_local
+from .polling import DEFAULT_POLLING_OPTIONS as DEFAULT_POLLING_OPTIONS
+from .polling import PollingOptions as PollingOptions
+from .polling import default_polling_options as default_polling_options
+from .polling import poll as poll
+from .run import ErrorLog as ErrorLog
+from .run import ExternalRunResult as ExternalRunResult
+from .run import Format as Format
+from .run import FormatInput as FormatInput
+from .run import FormatOutput as FormatOutput
+from .run import Metadata as Metadata
+from .run import OptionsSummaryItem as OptionsSummaryItem
+from .run import Run as Run
+from .run import RunConfiguration as RunConfiguration
+from .run import RunInformation as RunInformation
+from .run import RunInfoStatistics as RunInfoStatistics
+from .run import RunLog as RunLog
+from .run import RunQueuing as RunQueuing
+from .run import RunResult as RunResult
+from .run import RunType as RunType
+from .run import RunTypeConfiguration as RunTypeConfiguration
+from .run import StatisticsIndicator as StatisticsIndicator
+from .run import SyncedRun as SyncedRun
+from .run import TimestampedRunLog as TimestampedRunLog
+from .run import TrackedRun as TrackedRun
+from .run import TrackedRunStatus as TrackedRunStatus
+from .run import run_duration as run_duration
+from .safe import safe_id as safe_id
+from .safe import safe_name_and_id as safe_name_and_id
+from .status import Status as Status
+from .status import StatusV2 as StatusV2
 
 VERSION = __version__
 """The version of the Nextmv Python SDK."""

nextmv/_serialization.py

@@ -0,0 +1,96 @@
+import datetime
+import json
+from typing import Any
+
+
+def deflated_serialize_json(obj: 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: 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/base_model.py

@@ -1,17 +1,52 @@
-"""JSON class for data wrangling JSON objects."""
+"""
+Provides base functionality for handling JSON data in models.
+
+This module contains utilities for converting between dictionaries and model
+instances, facilitating data serialization and deserialization.
+
+Classes
+-------
+BaseModel:
+    A base class extending Pydantic's BaseModel with additional methods for
+    JSON data serialization and deserialization.
+
+Functions
+---------
+from_dict:
+    Load a data model instance from a dictionary containing class information
+    and attributes.
+"""
 
 from importlib import import_module
-from typing import Any, Optional
+from typing import Any
 
-from pydantic import BaseModel
+from pydantic import BaseModel as PydanticBaseModel
 
 
-class BaseModel(BaseModel):
-    """Base class for data wrangling tasks with JSON."""
+class BaseModel(PydanticBaseModel):
+    """
+    Base class for data wrangling tasks with JSON.
+
+    This class extends Pydantic's `BaseModel` to provide additional methods
+    for converting between Python objects and JSON/dictionary representations.
+    """
 
     @classmethod
-    def from_dict(cls, data: Optional[dict[str, Any]] = None):
-        """Instantiates the class from a dict."""
+    def from_dict(cls, data: dict[str, Any] | None = None):
+        """
+        Instantiate the class from a dictionary.
+
+        Parameters
+        ----------
+        data : dict[str, Any], optional
+            The dictionary containing the data to instantiate the class.
+            If None, returns None.
+
+        Returns
+        -------
+        cls or None
+            An instance of the class with the given data or None if data is None.
+        """
 
         if data is None:
             return None
@@ -19,14 +54,24 @@ class BaseModel(BaseModel):
         return cls(**data)
 
     def to_dict(self) -> dict[str, Any]:
-        """Converts the class to a dict."""
+        """
+        Convert the class instance to a dictionary.
+
+        The conversion uses Pydantic's model_dump method, excluding None values
+        and using field aliases if defined.
+
+        Returns
+        -------
+        dict[str, Any]
+            Dictionary representation of the class instance.
+        """
 
         return self.model_dump(mode="json", exclude_none=True, by_alias=True)
 
 
 def from_dict(data: dict[str, Any]) -> Any:
     """
-    Load a data model instance from a dict with associated class info.
+    Load a data model instance from a `dict` with associated class info.
 
     Parameters
     ----------