code: def save_model(
      spacy_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,
  ):
      """Save a spaCy model to a path on the local file system.
  
      Args:
          spacy_model: spaCy model to be saved.
          path: Local path where the 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` this flavor is being added to.
  
          signature: :py:class:`ModelSignature <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
  
                        train = df.drop_column("target_label")
                        predictions = ...  # compute model predictions
                        signature = infer_signature(train, 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.
      """
      import spacy
  
      _validate_env_arguments(
          conda_env, pip_requirements, extra_pip_requirements
      )
  
      path = os.path.abspath(path)
      _validate_and_prepare_target_save_path(path)
  
      model_data_subpath = "model.spacy"
      model_data_path = os.path.join(path, model_data_subpath)
      os.makedirs(model_data_path)
      code_dir_subpath = _validate_and_copy_code_paths(code_paths, 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, path)
      if metadata is not None:
          mlflow_model.metadata = metadata
  
      # Save spacy-model
      spacy_model.to_disk(path=model_data_path)
      # Save the pyfunc flavor if at least one text categorizer in spaCy pipeline
      if any(
          isinstance(pipe_component[1], spacy.pipeline.TextCategorizer)
          for pipe_component in spacy_model.pipeline
      ):
          pyfunc.add_to_model(
              mlflow_model,
              loader_module="mlflow.spacy",
              data=model_data_subpath,
              conda_env=_CONDA_ENV_FILE_NAME,
              python_env=_PYTHON_ENV_FILE_NAME,
              code=code_dir_subpath,
          )
      else:
          _logger.warning(
              "Generating only the spacy flavor for the provided spacy model. This means the model "
              "can be loaded back via `mlflow.spacy.load_model`, but cannot be loaded back using "
              "pyfunc APIs like `mlflow.pyfunc.load_model` or via the `mlflow models` CLI commands. "
              "MLflow will only generate the pyfunc flavor for spacy models containing a pipeline "
              "component that is an instance of spacy.pipeline.TextCategorizer."
          )
  
      mlflow_model.add_flavor(
          FLAVOR_NAME,
          spacy_version=spacy.__version__,
          data=model_data_subpath,
          code=code_dir_subpath,
      )
      if size := get_total_file_size(path):
          mlflow_model.model_size_bytes = size
      mlflow_model.save(os.path.join(path, MLMODEL_FILE_NAME))
  
      if conda_env is None:
          if pip_requirements is None:
              default_reqs = get_default_pip_requirements()
              # To ensure `_load_pyfunc` can successfully load the model during the dependency
              # inference, `mlflow_model.save` must be called beforehand to save an MLmodel file.
              inferred_reqs = mlflow.models.infer_pip_requirements(
                  model_data_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 open(os.path.join(path, _CONDA_ENV_FILE_NAME), "w") as f:
          yaml.safe_dump(conda_env, stream=f, default_flow_style=False)
  
      # Save `constraints.txt` if necessary
      if pip_constraints:
          write_to(
              os.path.join(path, _CONSTRAINTS_FILE_NAME),
              "\n".join(pip_constraints),
          )
  
      # Save `requirements.txt`
      write_to(
          os.path.join(path, _REQUIREMENTS_FILE_NAME),
          "\n".join(pip_requirements),
      )
  
      _PythonEnv.current().to_yaml(
          os.path.join(path, _PYTHON_ENV_FILE_NAME)
      )
  
imports: import logging
  import os
  from typing import Any, Dict, Optional
  import pandas
  import yaml
  import mlflow
  from mlflow import pyfunc
  from mlflow.exceptions import MlflowException
  from mlflow.models import Model, ModelSignature
  from mlflow.models.model import MLMODEL_FILE_NAME
  from mlflow.models.utils import ModelInputExample, _save_example
  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, write_to
  from mlflow.utils.model_utils import _add_code_from_conf_to_system_path, _get_flavor_configuration, _validate_and_copy_code_paths, _validate_and_prepare_target_save_path
  from mlflow.utils.requirements_utils import _get_pinned_requirement
label_desc: Use image node_id 3 for calling a global function with example usage: save_model(spacy_model, path, conda_env, code_paths, mlflow_model, signature, input_example, pip_requirements, extra_pip_requirements, metadata) without return types