code: def save_model(
      diviner_model,
      path,
      conda_env=None,
      code_paths=None,
      mlflow_model=None,
      signature: ModelSignature = None,
      input_example: ModelInputExample = None,
      pip_requirements=None,
      extra_pip_requirements=None,
      metadata=None,
      **kwargs,
  ):
      """Save a ``Diviner`` model object to a path on the local file system.
  
      Args:
          diviner_model: ``Diviner`` model that has been ``fit`` on a grouped temporal
              ``DataFrame``.
          path: Local path destination for the serialized model is to be saved.
          conda_env: {{ conda_env }}
          code_paths: A list of local filesystem paths to Python file dependencies (or directories
              containing file dependencies). These files are *prepended* to the system
              path when the model is loaded.
          mlflow_model: :py:mod:`mlflow.models.Model` the flavor that this model is being added to.
          signature: :py:class:`Model Signature <mlflow.models.ModelSignature>` describes model
              input and output :py:class:`Schema <mlflow.types.Schema>`. The model
              signature can be :py:func:`inferred <mlflow.models.infer_signature>`
              from datasets with valid model input (e.g. the training dataset with target
              column omitted) and valid model output (e.g. model predictions generated on
              the training dataset), for example:
  
              .. code-block:: python
  
                  from mlflow.models import infer_signature
  
                  model = diviner.GroupedProphet().fit(data, ("region", "state"))
                  predictions = model.predict(prediction_config)
                  signature = infer_signature(data, predictions)
  
          input_example: {{ input_example }}
          pip_requirements: {{ pip_requirements }}
          extra_pip_requirements: {{ extra_pip_requirements }}
          metadata: Custom metadata dictionary passed to the model and stored in the MLmodel file.
  
              .. Note:: Experimental: This parameter may change or be removed in a future
                  release without warning.
  
          kwargs: Optional configurations for Spark DataFrame storage iff the model has
              been fit in Spark.
              Current supported options:
              - `partition_by` for setting a (or several) partition columns as a list of \
              column names. Must be a list of strings of grouping key column(s).
              - `partition_count` for setting the number of part files to write from a \
              repartition per `partition_by` group. The default part file count is 200.
              - `dfs_tmpdir` for specifying the DFS temporary location where the model will \
              be stored while copying from a local file system to a Spark-supported "dbfs:/" \
              scheme.
  
      """
      import diviner
  
      _validate_env_arguments(
          conda_env, pip_requirements, extra_pip_requirements
      )
  
      path = pathlib.Path(path).absolute()
  
      _validate_and_prepare_target_save_path(str(path))
  
      # NB: When moving to native pathlib implementations, path encoding as string will not be needed.
      code_dir_subpath = _validate_and_copy_code_paths(
          code_paths, str(path)
      )
  
      if mlflow_model is None:
          mlflow_model = Model()
      if signature is not None:
          mlflow_model.signature = signature
      if input_example is not None:
          _save_example(mlflow_model, input_example, str(path))
      if metadata is not None:
          mlflow_model.metadata = metadata
  
      fit_with_spark = _save_diviner_model(
          diviner_model, path, **kwargs
      )
      flavor_conf = {_SPARK_MODEL_INDICATOR: fit_with_spark}
  
      model_bin_kwargs = {_MODEL_BINARY_KEY: _MODEL_BINARY_FILE_NAME}
      pyfunc.add_to_model(
          mlflow_model,
          loader_module="mlflow.diviner",
          conda_env=_CONDA_ENV_FILE_NAME,
          python_env=_PYTHON_ENV_FILE_NAME,
          code=code_dir_subpath,
          **model_bin_kwargs,
      )
      flavor_conf.update(
          {_MODEL_TYPE_KEY: diviner_model.__class__.__name__},
          **model_bin_kwargs,
      )
      mlflow_model.add_flavor(
          FLAVOR_NAME,
          diviner_version=diviner.__version__,
          code=code_dir_subpath,
          **flavor_conf,
      )
      if size := get_total_file_size(path):
          mlflow_model.model_size_bytes = size
      mlflow_model.save(str(path.joinpath(MLMODEL_FILE_NAME)))
  
      if conda_env is None:
          if pip_requirements is None:
              default_reqs = get_default_pip_requirements()
              inferred_reqs = mlflow.models.infer_pip_requirements(
                  str(path), FLAVOR_NAME, fallback=default_reqs
              )
              default_reqs = sorted(
                  set(inferred_reqs).union(default_reqs)
              )
          else:
              default_reqs = None
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_pip_requirements(
              default_reqs, pip_requirements, extra_pip_requirements
          )
      else:
          (
              conda_env,
              pip_requirements,
              pip_constraints,
          ) = _process_conda_env(conda_env)
  
      with path.joinpath(_CONDA_ENV_FILE_NAME).open("w") as f:
          yaml.safe_dump(conda_env, stream=f, default_flow_style=False)
  
      if pip_constraints:
          write_to(
              str(path.joinpath(_CONSTRAINTS_FILE_NAME)),
              "\n".join(pip_constraints),
          )
  
      write_to(
          str(path.joinpath(_REQUIREMENTS_FILE_NAME)),
          "\n".join(pip_requirements),
      )
  
      _PythonEnv.current().to_yaml(
          str(path.joinpath(_PYTHON_ENV_FILE_NAME))
      )
  
imports: import logging
  import os
  import pathlib
  import shutil
  from typing import Any, Dict, List, Optional, Tuple
  import pandas
  import yaml
  import mlflow
  from mlflow import pyfunc
  from mlflow.environment_variables import MLFLOW_DFS_TMP
  from mlflow.exceptions import MlflowException
  from mlflow.models import Model, ModelInputExample, ModelSignature
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.utils import _save_example
  from mlflow.protos.databricks_pb2 import INVALID_PARAMETER_VALUE
  from mlflow.tracking._model_registry import DEFAULT_AWAIT_MAX_SLEEP_SECONDS
  from mlflow.tracking.artifact_utils import _download_artifact_from_uri
  from mlflow.utils.docstring_utils import LOG_MODEL_PARAM_DOCS, format_docstring
  from mlflow.utils.environment import _CONDA_ENV_FILE_NAME, _CONSTRAINTS_FILE_NAME, _PYTHON_ENV_FILE_NAME, _REQUIREMENTS_FILE_NAME, _mlflow_conda_env, _process_conda_env, _process_pip_requirements, _PythonEnv, _validate_env_arguments
  from mlflow.utils.file_utils import get_total_file_size, shutil_copytree_without_file_permissions, write_to
  from mlflow.utils.model_utils import _add_code_from_conf_to_system_path, _get_flavor_configuration, _get_flavor_configuration_from_uri, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path
  from mlflow.utils.requirements_utils import _get_pinned_requirement
  from mlflow.utils.uri import dbfs_hdfs_uri_to_fuse_path, generate_tmp_dfs_path
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(diviner_model, path, conda_env, code_paths, mlflow_model, signature, input_example, pip_requirements, extra_pip_requirements, metadata) without return types