nextmv 0.10.3.dev0__py3-none-any.whl → 0.35.0__py3-none-any.whl

nextmv/__about__.py

@@ -1 +1 @@
-__version__ = "v0.10.3.dev0"
+__version__ = "v0.35.0"

nextmv/__entrypoint__.py

@@ -0,0 +1,39 @@
+"""
+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
+human to use it during local development. It is the standard way in which a
+`nextmv.Model` is loaded by using mlflow.
+"""
+
+from mlflow.pyfunc import load_model
+
+import nextmv
+from nextmv import cloud
+
+
+def main() -> None:
+    """Entry point for the program."""
+
+    manifest = cloud.Manifest.from_yaml(".")
+
+    # Load the options from the manifest.
+    options = manifest.extract_options()
+
+    # Load the model.
+    loaded_model = load_model(
+        model_uri=manifest.python.model.name,
+        suppress_warnings=True,
+    )
+
+    # 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.
+    nextmv.write(output)
+
+
+if __name__ == "__main__":
+    main()

nextmv/__init__.py

@@ -1,16 +1,38 @@
 """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
 from .output import DataPoint as DataPoint
 from .output import LocalOutputWriter as LocalOutputWriter
 from .output import Output as Output
@@ -20,8 +42,43 @@ 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 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 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,20 +1,90 @@
-"""JSON class for data wrangling JSON objects."""
+"""
+Provides base functionality for handling JSON data in models.
 
-from typing import Any, Dict
+This module contains utilities for converting between dictionaries and model
+instances, facilitating data serialization and deserialization.
 
-from pydantic import BaseModel
+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.
+"""
 
-class BaseModel(BaseModel):
-    """Base class for data wrangling tasks with JSON."""
+from importlib import import_module
+from typing import Any
+
+from pydantic import BaseModel as PydanticBaseModel
+
+
+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: Dict[str, Any]):
-        """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
 
         return cls(**data)
 
-    def to_dict(self) -> Dict[str, Any]:
-        """Converts the class to a dict."""
+    def to_dict(self) -> dict[str, Any]:
+        """
+        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.
+
+    Parameters
+    ----------
+    data : dict[str, Any]
+        The data to load.
+
+    Returns
+    -------
+    Any
+        The loaded data model instance.
+    """
+
+    module = import_module(data["class"]["module"])
+    cls = getattr(module, data["class"]["name"])
+
+    return cls.from_dict(data["attributes"])

nextmv/cloud/__init__.py

@@ -1,28 +1,89 @@
 """Functionality for interacting with the Nextmv Cloud."""
 
+# These imports are kept for backwards compatibility but the preferred import path is
+# from nextmv directly. These imports will be removed in a future release.
+from nextmv.manifest import MANIFEST_FILE_NAME as MANIFEST_FILE_NAME
+from nextmv.manifest import Manifest as Manifest
+from nextmv.manifest import ManifestBuild as ManifestBuild
+from nextmv.manifest import ManifestContent as ManifestContent
+from nextmv.manifest import ManifestContentMultiFile as ManifestContentMultiFile
+from nextmv.manifest import ManifestContentMultiFileInput as ManifestContentMultiFileInput
+from nextmv.manifest import ManifestContentMultiFileOutput as ManifestContentMultiFileOutput
+from nextmv.manifest import ManifestOption as ManifestOption
+from nextmv.manifest import ManifestPython as ManifestPython
+from nextmv.manifest import ManifestPythonModel as ManifestPythonModel
+from nextmv.manifest import ManifestRuntime as ManifestRuntime
+from nextmv.manifest import ManifestType as ManifestType
+from nextmv.polling import PollingOptions as PollingOptions
+from nextmv.run import ErrorLog as ErrorLog
+from nextmv.run import ExternalRunResult as ExternalRunResult
+from nextmv.run import Format as Format
+from nextmv.run import FormatInput as FormatInput
+from nextmv.run import FormatOutput as FormatOutput
+from nextmv.run import Metadata as Metadata
+from nextmv.run import RunConfiguration as RunConfiguration
+from nextmv.run import RunInformation as RunInformation
+from nextmv.run import RunLog as RunLog
+from nextmv.run import RunQueuing as RunQueuing
+from nextmv.run import RunResult as RunResult
+from nextmv.run import RunType as RunType
+from nextmv.run import RunTypeConfiguration as RunTypeConfiguration
+from nextmv.run import TrackedRun as TrackedRun
+from nextmv.run import TrackedRunStatus as TrackedRunStatus
+from nextmv.run import run_duration as run_duration
+from nextmv.safe import safe_id as safe_id
+from nextmv.safe import safe_name_and_id as safe_name_and_id
+from nextmv.status import Status as Status
+from nextmv.status import StatusV2 as StatusV2
+
 from .acceptance_test import AcceptanceTest as AcceptanceTest
+from .acceptance_test import AcceptanceTestResults as AcceptanceTestResults
 from .acceptance_test import Comparison as Comparison
 from .acceptance_test import ComparisonInstance as ComparisonInstance
+from .acceptance_test import DistributionPercentiles as DistributionPercentiles
+from .acceptance_test import DistributionSummaryStatistics as DistributionSummaryStatistics
 from .acceptance_test import Metric as Metric
 from .acceptance_test import MetricParams as MetricParams
+from .acceptance_test import MetricResult as MetricResult
+from .acceptance_test import MetricStatistics as MetricStatistics
+from .acceptance_test import MetricTolerance as MetricTolerance
+from .acceptance_test import MetricToleranceType as MetricToleranceType
 from .acceptance_test import MetricType as MetricType
+from .acceptance_test import ResultStatistics as ResultStatistics
+from .acceptance_test import StatisticType as StatisticType
+from .acceptance_test import ToleranceType as ToleranceType
 from .account import Account as Account
 from .account import Queue as Queue
 from .account import QueuedRun as QueuedRun
 from .application import Application as Application
-from .application import Configuration as Configuration
-from .application import DownloadURL as DownloadURL
-from .application import ErrorLog as ErrorLog
-from .application import Metadata as Metadata
-from .application import PollingOptions as PollingOptions
-from .application import RunInformation as RunInformation
-from .application import RunResult as RunResult
-from .application import UploadURL as UploadURL
+from .application import poll as poll
 from .batch_experiment import BatchExperiment as BatchExperiment
 from .batch_experiment import BatchExperimentInformation as BatchExperimentInformation
 from .batch_experiment import BatchExperimentMetadata as BatchExperimentMetadata
 from .batch_experiment import BatchExperimentRun as BatchExperimentRun
+from .batch_experiment import ExperimentStatus as ExperimentStatus
 from .client import Client as Client
+from .client import get_size as get_size
+from .ensemble import EnsembleDefinition as EnsembleDefinition
+from .ensemble import EvaluationRule as EvaluationRule
+from .ensemble import RuleObjective as RuleObjective
+from .ensemble import RuleTolerance as RuleTolerance
+from .ensemble import RuleToleranceType as RuleToleranceType
+from .ensemble import RunGroup as RunGroup
 from .input_set import InputSet as InputSet
-from .status import Status as Status
-from .status import StatusV2 as StatusV2
+from .input_set import ManagedInput as ManagedInput
+from .instance import Instance as Instance
+from .instance import InstanceConfiguration as InstanceConfiguration
+from .scenario import Scenario as Scenario
+from .scenario import ScenarioConfiguration as ScenarioConfiguration
+from .scenario import ScenarioInput as ScenarioInput
+from .scenario import ScenarioInputType as ScenarioInputType
+from .secrets import Secret as Secret
+from .secrets import SecretsCollection as SecretsCollection
+from .secrets import SecretsCollectionSummary as SecretsCollectionSummary
+from .secrets import SecretType as SecretType
+from .url import DownloadURL as DownloadURL
+from .url import UploadURL as UploadURL
+from .version import Version as Version
+from .version import VersionExecutable as VersionExecutable
+from .version import VersionExecutableRequirements as VersionExecutableRequirements