Output Module¶
This section documents the output components of the Nextmv Python SDK.
output
¶
Module for handling output destinations and data.
This module provides classes and functions for handling the output of decision problems, including formatting, serialization, and writing to various destinations.
CLASS | DESCRIPTION |
---|---|
RunStatistics |
Statistics about a general run. |
ResultStatistics |
Statistics about a specific result. |
DataPoint |
A data point representing a 2D coordinate. |
Series |
A series of data points for visualization or analysis. |
SeriesData |
Data container for multiple series of data points. |
Statistics |
Complete statistics container for a solution, including run metrics and result data. |
OutputFormat |
Enumeration of supported output formats. |
SolutionFile |
Represents a solution to be written as a file. |
VisualSchema |
Enumeration of supported visualization schemas. |
Visual |
Visual schema definition for an asset. |
Asset |
Represents downloadable information that is part of the |
Output |
A class for representing the output of a decision problem. |
OutputWriter |
Base class for writing outputs to different destinations. |
LocalOutputWriter |
Class for writing outputs to local files or stdout. |
FUNCTION | DESCRIPTION |
---|---|
write |
Write the output to the specified destination. |
Asset
¶
Bases: BaseModel
Represents downloadable information that is part of the Output
.
You can import the Asset
class directly from nextmv
:
An asset contains content that can be serialized to JSON and optionally includes visual information for rendering in the Nextmv Console.
PARAMETER | DESCRIPTION |
---|---|
|
Name of the asset.
TYPE:
|
|
Content of the asset. The type must be serializable to JSON.
TYPE:
|
|
Content type of the asset. Only "json" is currently supported. Default is "json".
TYPE:
|
|
Description of the asset. Default is None.
TYPE:
|
|
Visual schema of the asset. Default is None.
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If the content_type is not "json". |
Examples:
>>> from nextmv.output import Asset, Visual, VisualSchema
>>> visual = Visual(visual_schema=VisualSchema.CHARTJS, label="Solution Progress")
>>> asset = Asset(
... name="optimization_progress",
... content={"iterations": [1, 2, 3], "values": [10, 8, 7]},
... description="Optimization progress over iterations",
... visual=visual
... )
>>> asset.name
'optimization_progress'
DataPoint
¶
LocalOutputWriter
¶
Bases: OutputWriter
Class for writing outputs to local files or stdout.
You can import the LocalOutputWriter
class directly from nextmv
:
This class implements the OutputWriter interface to write output data to local files or stdout. The destination and format depend on the output format and the provided path.
Examples:
>>> from nextmv.output import LocalOutputWriter, Output, Statistics
>>> writer = LocalOutputWriter()
>>> output = Output(solution={"result": 42}, statistics=Statistics())
>>> # Write to stdout
>>> writer.write(output, path=None)
>>> # Write to a file
>>> writer.write(output, path="results.json")
FILE_WRITERS
class-attribute
instance-attribute
¶
FILE_WRITERS = {
JSON: _write_json,
CSV_ARCHIVE: _write_archive,
MULTI_FILE: _write_multi_file,
}
Dictionary mapping output formats to writer functions.
write
¶
write(
output: Union[Output, dict[str, Any], BaseModel],
path: Optional[str] = None,
skip_stdout_reset: bool = False,
) -> None
Write the output to the local filesystem or stdout.
This method writes the provided output to the specified path or to stdout, depending on the output format and the path parameter.
PARAMETER | DESCRIPTION |
---|---|
|
Output data to write. Can be an Output object, a dictionary, or a BaseModel.
TYPE:
|
|
Path to write the output data to. The interpretation depends on the output format: - For OutputFormat.JSON: File path for the JSON output. If None or empty, writes to stdout. - For OutputFormat.CSV_ARCHIVE: Directory path for CSV files. If None or empty, writes to a directory named "output" in the current working directory.
TYPE:
|
|
Skip resetting stdout before writing the output data. Default is False.
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If the Output.output_format is not supported. |
TypeError
|
If the output is of an unsupported type. |
Notes
This function detects if stdout was redirected and resets it to avoid unexpected behavior. If you want to skip this behavior, set the skip_stdout_reset parameter to True.
If the output is a dict or a BaseModel, it will be written as JSON. If the output is an Output object, it will be written according to its output_format.
Examples:
>>> from nextmv.output import LocalOutputWriter, Output
>>> writer = LocalOutputWriter()
>>> # Write JSON to a file
>>> writer.write(Output(solution={"result": 42}), path="result.json")
>>> # Write JSON to stdout
>>> writer.write({"simple": "data"})
Source code in nextmv/nextmv/output.py
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 |
|
Output
dataclass
¶
Output(
options: Optional[
Union[Options, dict[str, Any]]
] = None,
output_format: Optional[OutputFormat] = JSON,
solution: Optional[
Union[
Union[dict[str, Any], Any],
dict[str, list[dict[str, Any]]],
]
] = None,
statistics: Optional[
Union[Statistics, dict[str, Any]]
] = None,
csv_configurations: Optional[dict[str, Any]] = None,
json_configurations: Optional[dict[str, Any]] = None,
assets: Optional[
list[Union[Asset, dict[str, Any]]]
] = None,
solution_files: Optional[list[SolutionFile]] = None,
)
Output of a decision problem.
You can import the Output
class directly from nextmv
:
This class is used to structure the output of a decision problem that can later be written to various destinations. It supports different output formats and allows for customization of the serialization process.
The solution
's type must match the output_format
:
OutputFormat.JSON
: the data must bedict[str, Any]
orAny
.OutputFormat.CSV_ARCHIVE
: the data must bedict[str, list[dict[str, Any]]]
. The keys represent the file names where the data should be written. The values are lists of dictionaries, where each dictionary represents a row in the CSV file.
If you are working with OutputFormat.MULTI_FILE
, you should use
solution_files
instead of solution
. When solution_files
is not
None
, then the output_format
must be OutputFormat.MULTI_FILE
.
solution_files
is a list of SolutionFile
objects, which allows you to
define the name of the file, the data to be written, and the writer
function that will handle the serialization of the data. This is useful when
you need to write the solution to multiple files with different formats or
configurations.
There are convenience functions to create SolutionFile
objects for
common use cases, such as:
json_solution_file
: for writing JSON data to a file.csv_solution_file
: for writing CSV data to a file.text_solution_file
: for writing utf-8 encoded data to a file.
For other data types, such as Excel, you can create your own SolutionFile
objects by providing a name
, data
, and a writer
function that will
handle the serialization of the data.
PARAMETER | DESCRIPTION |
---|---|
|
Options that the
TYPE:
|
|
Format of the output data. Default is
TYPE:
|
|
The solution to the decision problem. The type must match the
TYPE:
|
|
Statistics of the solution. Default is None.
TYPE:
|
|
Configuration for writing CSV files. Default is None.
TYPE:
|
|
Configuration for writing JSON files. Default is None.
TYPE:
|
|
List of assets to be included in the output. Default is None.
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If the solution is not compatible with the specified output_format. |
TypeError
|
If options, statistics, or assets have unsupported types. |
Examples:
>>> from nextmv.output import Output, OutputFormat, Statistics, RunStatistics
>>> run_stats = RunStatistics(duration=30.0, iterations=100)
>>> stats = Statistics(run=run_stats)
>>> solution = {"routes": [{"vehicle": 1, "stops": [1, 2, 3]}, {"vehicle": 2, "stops": [4, 5]}]}
>>> output = Output(
... output_format=OutputFormat.JSON,
... solution=solution,
... statistics=stats,
... json_configurations={"indent": 4}
... )
>>> output_dict = output.to_dict()
>>> "solution" in output_dict and "statistics" in output_dict
True
assets
class-attribute
instance-attribute
¶
assets: Optional[list[Union[Asset, dict[str, Any]]]] = None
Optional list of assets to be included in the output. These assets can be of
type Asset
or a simple dictionary. If the assets are of type Asset
, they
will be serialized to a dictionary using the to_dict
method. If they are a
dictionary, they will be used as is. If the assets are not provided, an
empty list will be used.
csv_configurations
class-attribute
instance-attribute
¶
Optional configuration for writing CSV files, to be used when the
output_format
is OutputFormat.CSV_ARCHIVE
. These configurations are
passed as kwargs to the DictWriter
class from the csv
module.
json_configurations
class-attribute
instance-attribute
¶
Optional configuration for writing JSON files, to be used when the
output_format
is OutputFormat.JSON
. These configurations are passed as
kwargs to the json.dumps
function.
options
class-attribute
instance-attribute
¶
Options that the Output
was created with. These options can be of type
Options
or a simple dictionary. If the options are of type Options
,
they will be serialized to a dictionary using the to_dict
method. If
they are a dictionary, they will be used as is. If the options are not
provided, an empty dictionary will be used. If the options are of type
dict
, then the dictionary should have the following structure:
output_format
class-attribute
instance-attribute
¶
output_format: Optional[OutputFormat] = JSON
Format of the output data. Default is OutputFormat.JSON
. When set to
OutputFormat.MULTI_FILE
, the solution_files
field must be specified and
cannot be None
.
solution
class-attribute
instance-attribute
¶
The solution to the decision problem. Use this filed when working with
output_format
of types:
OutputFormat.JSON
: the data must bedict[str, Any]
orAny
.OutputFormat.CSV_ARCHIVE
: the data must bedict[str, list[dict[str, Any]]]
. The keys represent the file names where the data will be written to. The values are lists of dictionaries, where each dictionary represents a row in the CSV file.
Note that when the output_format
is set to OutputFormat.MULTI_FILE
,
this solution
field is ignored, as you should use the solution_files
field instead.
solution_files
class-attribute
instance-attribute
¶
solution_files: Optional[list[SolutionFile]] = None
Optional list of solution files to be included in the output. These files
are of type SolutionFile
, which allows for custom serialization and
writing of the solution data to files. When this field is specified, then
the output_format
must be set to OutputFormat.MULTI_FILE
, otherwise an
exception will be raised. The SolutionFile
class allows you to define the
name of the file, the data to be written, and the writer function that will
handle the serialization of the data. This is useful when you need to write
the solution to multiple files with different formats or configurations.
There are convenience functions to create SolutionFile
objects for
common use cases, such as:
json_solution_file
: for writing JSON data to a file.csv_solution_file
: for writing CSV data to a file.text_solution_file
: for writing utf-8 encoded data to a file.
For other data types, such as Excel, you can create your own SolutionFile
objects by providing a name
, data
, and a writer
function that will
handle the serialization of the data.
statistics
class-attribute
instance-attribute
¶
statistics: Optional[Union[Statistics, dict[str, Any]]] = (
None
)
Statistics of the solution. These statistics can be of type Statistics
or a
simple dictionary. If the statistics are of type Statistics
, they will be
serialized to a dictionary using the to_dict
method. If they are a
dictionary, they will be used as is. If the statistics are not provided, an
empty dictionary will be used.
to_dict
¶
Convert the Output
object to a dictionary.
RETURNS | DESCRIPTION |
---|---|
dict[str, Any]
|
The dictionary representation of the |
Source code in nextmv/nextmv/output.py
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 |
|
OutputFormat
¶
Bases: str
, Enum
Enumeration of supported output formats.
You can import the OutputFormat
class directly from nextmv
:
This enum defines the different formats that can be used for outputting data. Each format has specific requirements and behaviors when writing.
ATTRIBUTE | DESCRIPTION |
---|---|
JSON |
JSON format, utf-8 encoded.
TYPE:
|
CSV_ARCHIVE |
CSV archive format: multiple CSV files.
TYPE:
|
MULTI_FILE |
Multi-file format: multiple files in a directory.
TYPE:
|
OutputWriter
¶
Base class for writing outputs.
You can import the OutputWriter
class directly from nextmv
:
This is an abstract base class that defines the interface for writing outputs
to different destinations. Subclasses should implement the write
method.
Examples:
>>> class CustomOutputWriter(OutputWriter):
... def write(self, output, path=None, **kwargs):
... # Custom implementation for writing output
... print(f"Writing output to {path}")
write
¶
Write the output data.
This is an abstract method that should be implemented by subclasses.
RAISES | DESCRIPTION |
---|---|
NotImplementedError
|
This method must be implemented by subclasses. |
Source code in nextmv/nextmv/output.py
ResultStatistics
¶
Bases: BaseModel
Statistics about a specific result.
You can import the ResultStatistics
class directly from nextmv
:
Examples:
>>> from nextmv.output import ResultStatistics
>>> result_stats = ResultStatistics(duration=5.2, value=42.0)
>>> result_stats.value
42.0
>>> result_stats.custom = {"gap": 0.05}
>>> result_stats.to_dict()
{'duration': 5.2, 'value': 42.0, 'custom': {'gap': 0.05}}
RunStatistics
¶
Bases: BaseModel
Statistics about a general run.
You can import the RunStatistics
class directly from nextmv
:
Examples:
>>> from nextmv.output import RunStatistics
>>> stats = RunStatistics(duration=10.5, iterations=100)
>>> stats.duration
10.5
>>> stats.custom = {"convergence": 0.001}
>>> stats.to_dict()
{'duration': 10.5, 'iterations': 100, 'custom': {'convergence': 0.001}}
Series
¶
Bases: BaseModel
A series of data points for visualization or analysis.
You can import the Series
class directly from nextmv
:
Examples:
SeriesData
¶
Bases: BaseModel
Data container for multiple series of data points.
You can import the SeriesData
class directly from nextmv
:
Examples:
>>> from nextmv.output import SeriesData, Series, DataPoint
>>> value_series = Series(name="Solution Value", data_points=[DataPoint(x=0, y=10), DataPoint(x=1, y=5)])
>>> custom_series = [Series(name="Gap", data_points=[DataPoint(x=0, y=0.5), DataPoint(x=1, y=0.1)])]
>>> series_data = SeriesData(value=value_series, custom=custom_series)
>>> series_data.value.name
'Solution Value'
>>> len(series_data.custom)
1
SolutionFile
dataclass
¶
SolutionFile(
name: str,
data: Any,
writer: Callable[[str, Any], None],
writer_args: Optional[list[Any]] = None,
writer_kwargs: Optional[dict[str, Any]] = None,
)
Represents a solution to be written as a file.
You can import the SolutionFile
class directly from nextmv
:
This class is used to define a solution that will be written to a file in
the filesystem. It includes the name of the file, the data to be written,
and the writer function that will handle the serialization of the data.
This SolutionFile
class is typically used in the Output
, when the
Output.output_format
is set to OutputFormat.MULTI_FILE
. Given that it
is difficult to handle every edge case of how a solution is serialized, and
written to a file, this class exists so that the user can implement the
writer
callable of their choice and provide it with any writer_args
and writer_kwargs
they might need.
PARAMETER | DESCRIPTION |
---|---|
|
Name of the output file. The file extension should be included in the name.
TYPE:
|
|
The actual data that will be written to the file. This can be any type
that can be given to the
TYPE:
|
|
Callable that writes the solution data to the file. This should be a
function implemented by the user. There are convenience functions that you
can use as a writer as well. The
The
TYPE:
|
|
Positional arguments to pass to the writer function.
TYPE:
|
|
Keyword arguments to pass to the writer function.
TYPE:
|
Examples:
>>> from nextmv import SolutionFile
>>> solution_file = SolutionFile(
... name="solution.csv",
... data=[{"id": 1, "value": 100}, {"id": 2, "value": 200}],
... writer=csv.DictWriter,
... writer_kwargs={"fieldnames": ["id", "value"]},
... writer_args=[open("solution.csv", "w", newline="")],
... )
data
instance-attribute
¶
The actual data that will be written to the file. This can be any type that
can be given to the writer
function. For example, if the writer
is a
csv.DictWriter
, then the data should be a list of dictionaries, where
each dictionary represents a row in the CSV file.
name
instance-attribute
¶
Name of the solution (output) file. The file extension should be included in the name.
writer
instance-attribute
¶
Callable that writes the solution data to the file. This should be a
function implemented by the user. There are convenience functions that you
can use as a writer as well. The writer
must receive, at the very
minimum, the following arguments:
file_path
: astr
argument which is the location where this solution will be written to. This includes the dir and the name of the file. As such, thename
parameter of this class is going to be passed to this function joined with the directory where the file will be written.data
: the actual data that will be written to the file. This can be any type that can be given to thewriter
function. Thedata
parameter of this class is going to be passed to thewriter
function.
The writer
can also receive additional arguments, and keyword arguments.
The writer_args
and writer_kwargs
parameters of this class can be used
to provide those additional arguments.
writer_args
class-attribute
instance-attribute
¶
Optional positional arguments to pass to the writer function. This can be used to customize the behavior of the writer.
writer_kwargs
class-attribute
instance-attribute
¶
Optional keyword arguments to pass to the writer function. This can be used to customize the behavior of the writer.
Statistics
¶
Bases: BaseModel
Complete statistics container for a solution, including run metrics and result data.
You can import the Statistics
class directly from nextmv
:
PARAMETER | DESCRIPTION |
---|---|
|
Statistics about the run.
TYPE:
|
|
Statistics about the last result.
TYPE:
|
|
Series data about some metric.
TYPE:
|
|
Schema (version). This class only supports
TYPE:
|
Examples:
>>> from nextmv.output import Statistics, RunStatistics, ResultStatistics
>>> run_stats = RunStatistics(duration=10.0, iterations=50)
>>> result_stats = ResultStatistics(value=100.0)
>>> stats = Statistics(run=run_stats, result=result_stats, statistics_schema="v1")
>>> stats.run.duration
10.0
>>> stats.result.value
100.0
result
class-attribute
instance-attribute
¶
result: Optional[ResultStatistics] = None
Statistics about the last result.
run
class-attribute
instance-attribute
¶
run: Optional[RunStatistics] = None
Statistics about the run.
series_data
class-attribute
instance-attribute
¶
series_data: Optional[SeriesData] = None
Data of the series.
statistics_schema
class-attribute
instance-attribute
¶
statistics_schema: Optional[str] = Field(
serialization_alias="schema",
validation_alias=AliasChoices(
"schema", "statistics_schema"
),
default="v1",
)
Schema (version). This class only supports v1
.
Visual
¶
Bases: BaseModel
Visual schema definition for an asset.
You can import the Visual
class directly from nextmv
:
This class defines how an asset is plotted in the Nextmv Console, including the schema type, label, and display type.
PARAMETER | DESCRIPTION |
---|---|
|
Schema of the visual asset.
TYPE:
|
|
Label for the custom tab of the visual asset in the Nextmv Console.
TYPE:
|
|
Defines the type of custom visual. Default is "custom-tab".
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If an unsupported schema or visual_type is provided. |
Examples:
>>> from nextmv.output import Visual, VisualSchema
>>> visual = Visual(visual_schema=VisualSchema.CHARTJS, label="Performance Chart")
>>> visual.visual_schema
<VisualSchema.CHARTJS: 'chartjs'>
>>> visual.label
'Performance Chart'
label
instance-attribute
¶
Label for the custom tab of the visual asset in the Nextmv Console.
visual_schema
class-attribute
instance-attribute
¶
visual_schema: VisualSchema = Field(
serialization_alias="schema",
validation_alias=AliasChoices(
"schema", "visual_schema"
),
)
Schema of the visual asset.
visual_type
class-attribute
instance-attribute
¶
visual_type: Optional[str] = Field(
serialization_alias="type",
validation_alias=AliasChoices("type", "visual_type"),
default="custom-tab",
)
Defines the type of custom visual, currently there is only one type:
custom-tab
. This renders the visual in its own tab view of the run
details.
VisualSchema
¶
Bases: str
, Enum
Enumeration of supported visualization schemas.
You can import the VisualSchema
class directly from nextmv
:
This enum defines the different visualization libraries or rendering methods that can be used to display custom asset data in the Nextmv Console.
ATTRIBUTE | DESCRIPTION |
---|---|
CHARTJS |
Tells Nextmv Console to render the custom asset data with the Chart.js library.
TYPE:
|
GEOJSON |
Tells Nextmv Console to render the custom asset data as GeoJSON on a map.
TYPE:
|
PLOTLY |
Tells Nextmv Console to render the custom asset data with the Plotly library.
TYPE:
|
CHARTJS
class-attribute
instance-attribute
¶
Tells Nextmv Console to render the custom asset data with the Chart.js library.
GEOJSON
class-attribute
instance-attribute
¶
Tells Nextmv Console to render the custom asset data as GeoJSON on a map.
PLOTLY
class-attribute
instance-attribute
¶
Tells Nextmv Console to render the custom asset data with the Plotly library.
csv_solution_file
¶
csv_solution_file(
name: str,
data: list[dict[str, Any]],
csv_configurations: Optional[dict[str, Any]] = None,
) -> SolutionFile
This is a convenience function to build a SolutionFile
. It writes the
given data
to a .csv
file with the provided name
.
You can import this function directly from nextmv
:
PARAMETER | DESCRIPTION |
---|---|
|
Name of the output file. You don't need to include the
TYPE:
|
|
The actual data that will be written to the file. This should be a list of dictionaries, where each dictionary represents a row in the CSV file. The keys of the dictionaries will be used as the column headers in the CSV file.
TYPE:
|
|
Optional configuration options for the CSV serialization process.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
SolutionFile
|
The constructed |
Examples:
>>> from nextmv import csv_solution_file
>>> solution_file = csv_solution_file(
... name="solution",
... data=[{"id": 1, "value": 100}, {"id": 2, "value": 200}]
... )
>>> solution_file.name
'solution.csv'
>>> solution_file.data
[{'id': 1, 'value': 100}, {'id': 2, 'value': 200}]
Source code in nextmv/nextmv/output.py
json_solution_file
¶
json_solution_file(
name: str,
data: dict[str, Any],
json_configurations: Optional[dict[str, Any]] = None,
) -> SolutionFile
This is a convenience function to build a SolutionFile
. It writes the
given data
to a .json
file with the provided name
.
You can import this function directly from nextmv
:
PARAMETER | DESCRIPTION |
---|---|
|
Name of the output file. You don't need to include the
TYPE:
|
|
The actual data that will be written to the file. This should be a dictionary that can be serialized to JSON.
TYPE:
|
|
Optional configuration options for the JSON serialization process. You can use these options to configure parameters such as indentation.
TYPE:
|
RETURNS | DESCRIPTION |
---|---|
SolutionFile
|
The constructed |
Examples:
>>> from nextmv import json_solution_file
>>> solution_file = json_solution_file(
... name="solution",
... data={"id": 1, "value": 100}
... )
>>> solution_file.name
'solution.json'
>>> solution_file.data
{'id': 1, 'value': 100}
Source code in nextmv/nextmv/output.py
text_solution_file
¶
text_solution_file(name: str, data: str) -> SolutionFile
This is a convenience function to build a SolutionFile
. It writes the
given data
to a utf-8 encoded file with the provided name
.
You can import this function directly from nextmv
:
You must provide the extension as part of the name
parameter.
RETURNS | DESCRIPTION |
---|---|
SolutionFile
|
The constructed |
Examples:
>>> from nextmv import text_solution_file
>>> solution_file = text_solution_file(
... name="solution.txt",
... data="This is a sample text solution."
... )
>>> solution_file.name
'solution.txt'
>>> solution_file.data
'This is a sample text solution.'
Source code in nextmv/nextmv/output.py
write
¶
write(
output: Union[Output, dict[str, Any], BaseModel],
path: Optional[str] = None,
skip_stdout_reset: bool = False,
writer: Optional[OutputWriter] = _LOCAL_OUTPUT_WRITER,
) -> None
Write the output to the specified destination.
You can import the write
function directly from nextmv
:
This is a convenience function for writing output data using a provided writer.
By default, it uses the LocalOutputWriter
to write to files or stdout.
PARAMETER | DESCRIPTION |
---|---|
|
Output data to write. Can be an Output object, a dictionary, or a BaseModel.
TYPE:
|
|
Path to write the output data to. The interpretation depends on the output format:
TYPE:
|
|
Skip resetting stdout before writing the output data. Default is False.
TYPE:
|
|
The writer to use for writing the output. Default is a
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If the Output.output_format is not supported. |
TypeError
|
If the output is of an unsupported type. |
Examples:
>>> from nextmv.output import write, Output, OutputFormat
>>> # Write JSON to a file
>>> write(Output(solution={"result": 42}), path="result.json")
>>> # Write CSV archive
>>> data = {"vehicles": [{"id": 1, "capacity": 100}, {"id": 2, "capacity": 150}]}
>>> write(Output(output_format=OutputFormat.CSV_ARCHIVE, solution=data), path="output_dir")
Source code in nextmv/nextmv/output.py
write_local
¶
write_local(
output: Union[Output, dict[str, Any]],
path: Optional[str] = None,
skip_stdout_reset: bool = False,
) -> None
Warning
write_local
is deprecated, use write
instead.
Write the output to the local filesystem or stdout.
This is a convenience function for instantiating a LocalOutputWriter
and
calling its write
method.
PARAMETER | DESCRIPTION |
---|---|
|
Output data to write. Can be an Output object or a dictionary.
TYPE:
|
|
Path to write the output data to. The interpretation depends on the output format:
TYPE:
|
|
Skip resetting stdout before writing the output data. Default is False.
TYPE:
|
RAISES | DESCRIPTION |
---|---|
ValueError
|
If the Output.output_format is not supported. |
TypeError
|
If the output is of an unsupported type. |
Notes
This function detects if stdout was redirected and resets it to avoid unexpected behavior. If you want to skip this behavior, set the skip_stdout_reset parameter to True.
Examples:
>>> from nextmv.output import write_local, Output
>>> # Write JSON to a file
>>> write_local(Output(solution={"result": 42}), path="result.json")
>>> # Write JSON to stdout
>>> write_local({"simple": "data"})