code: def create_output_model(
      model,  # type: Optional[Any]
      saved_path,  # type: Optional[str]
      framework,  # type: Optional[str]
      task,  # type: Optional[Task]
      singlefile=False,  # type: bool
      model_name=None,  # type: Optional[str]
      config_obj=None,  # type: Optional[Union[str, dict]]
  ):
      # type: (...) -> str
      if task is None:
          return saved_path
  
      # Make sure that if we have a deferred object it is completed
      task.id  # noqa
  
      try:
          WeightsFileHandler._model_store_lookup_lock.acquire()
  
          # # disable model reuse, let Model module try to find it for use
          trains_out_model, ref_model = None, None  # noqa: F841
          # check if object already has InputModel
          # trains_out_model, ref_model = WeightsFileHandler._model_out_store_lookup.get(
          #     id(model) if model is not None else None, (None, None))
          # # notice ref_model() is not an error/typo this is a weakref object call
          # # noinspection PyCallingNonCallable
          # if ref_model is not None and model != ref_model():
          #     # old id pop it - it was probably reused because the object is dead
          #     WeightsFileHandler._model_out_store_lookup.pop(id(model))
          #     trains_out_model, ref_model = None, None
  
          try:
              local_model_path = (
                  os.path.abspath(saved_path)
                  if saved_path
                  else saved_path
              )
          except TypeError:
              # not a recognized type:
              return saved_path
  
          model_info = WeightsFileHandler.ModelInfo(
              model=trains_out_model,
              upload_filename=None,
              local_model_path=local_model_path,
              local_model_id=saved_path,
              framework=framework,
              task=task,
          )
  
          if not model_info.local_model_path:
              # get_logger(TrainsFrameworkAdapter).debug(
              #     "Could not retrieve model location, skipping auto model logging")
              return saved_path
  
          # check if we have output storage, and generate list of files to upload
          if Path(model_info.local_model_path).is_dir():
              files = [
                  str(f)
                  for f in Path(model_info.local_model_path).rglob("*")
              ]
          elif singlefile:
              files = [
                  str(Path(model_info.local_model_path).absolute())
              ]
          else:
              files = [
                  str(f)
                  for f in Path(
                      model_info.local_model_path
                  ).parent.glob(
                      str(Path(model_info.local_model_path).name) + ".*"
                  )
              ]
  
          target_filename = None
          if len(files) > 1:
              # noinspection PyBroadException
              try:
                  target_filename = Path(
                      model_info.local_model_path
                  ).stem
              except Exception:
                  pass
          else:
              target_filename = Path(files[0]).name
  
          # pass model object to ModelInfo object, maybe someone can use it
          model_info.weights_object = model
          # call pre model callback functions
          model_info.upload_filename = target_filename
          for cb in list(
              WeightsFileHandler._model_pre_callbacks.values()
          ):
              # noinspection PyBroadException
              try:
                  model_info = cb(
                      WeightsFileHandler.CallbackType.save, model_info
                  )
              except Exception:
                  pass
          # making sure we do not store an additional reference to the original model
          model_info.weights_object = None
  
          # if callbacks force us to leave they return None
          if model_info is None:
              # callback forced quit
              return saved_path
  
          # update the trains_out_model after the pre callbacks
          trains_out_model = model_info.model
  
          # check if object already has InputModel
          if trains_out_model is None:
              # noinspection PyProtectedMember
              in_model_id, model_uri = Model._local_model_to_id_uri.get(
                  model_info.local_model_id
                  or model_info.local_model_path,
                  (None, None),
              )
  
              if not in_model_id:
                  # if we are overwriting a local file, try to load registered model
                  # if there is an output_uri, then by definition we will not overwrite previously stored models.
                  if not task.output_uri:
                      # noinspection PyBroadException
                      try:
                          in_model_id = InputModel.load_model(
                              weights_url=model_info.local_model_path
                          )
                          if in_model_id:
                              in_model_id = in_model_id.id
  
                              get_logger(TrainsFrameworkAdapter).info(
                                  "Found existing registered model id={} [{}] reusing it.".format(
                                      in_model_id,
                                      model_info.local_model_path,
                                  )
                              )
                      except Exception:
                          in_model_id = None
                  else:
                      in_model_id = None
  
              trains_out_model = OutputModel(
                  task=task,
                  config_dict=config_obj
                  if isinstance(config_obj, dict)
                  else None,
                  config_text=config_obj
                  if isinstance(config_obj, str)
                  else None,
                  name=None
                  if in_model_id
                  else "{} - {}".format(
                      task.name,
                      model_name
                      or Path(model_info.local_model_path).stem,
                  ),
                  label_enumeration=task.get_labels_enumeration(),
                  framework=framework,
                  base_model_id=in_model_id,
              )
              # # disable model reuse, let Model module try to find it for use
              # if model is not None:
              #     # noinspection PyBroadException
              #     try:
              #         ref_model = weakref.ref(model)
              #     except Exception:
              #         ref_model = None
              #     WeightsFileHandler._model_out_store_lookup[id(model)] = (trains_out_model, ref_model)
  
          model_info.model = trains_out_model
          # pass model object to ModelInfo object, maybe someone can use it
          model_info.weights_object = model
          # call post model callback functions
          for cb in list(
              WeightsFileHandler._model_post_callbacks.values()
          ):
              # noinspection PyBroadException
              try:
                  model_info = cb(
                      WeightsFileHandler.CallbackType.save, model_info
                  )
              except Exception:
                  pass
          # making sure we do not store an additional reference to the original model
          model_info.weights_object = None
  
          trains_out_model = model_info.model
          target_filename = model_info.upload_filename
  
          # upload files if we found them, or just register the original path
          if trains_out_model.upload_storage_uri:
              if len(files) > 1:
                  trains_out_model.update_weights_package(
                      weights_filenames=files,
                      auto_delete_file=False,
                      target_filename=target_filename,
                  )
              else:
                  # create a copy of the stored file,
                  # protect against someone deletes/renames the file before async upload finish is done
  
                  # HACK: if pytorch-lightning is used, remove the temp '.part' file extension
                  if sys.modules.get(
                      "pytorch_lightning"
                  ) and target_filename.lower().endswith(".part"):
                      target_filename = target_filename[: -len(".part")]
                  fd, temp_file = mkstemp(
                      prefix=".clearml.upload_model_", suffix=".tmp"
                  )
                  os.close(fd)
                  shutil.copy(files[0], temp_file)
                  trains_out_model.update_weights(
                      weights_filename=temp_file,
                      auto_delete_file=True,
                      target_filename=target_filename,
                      update_comment=False,
                  )
          else:
              trains_out_model.update_weights(
                  weights_filename=None,
                  register_uri=model_info.local_model_path,
                  is_package=bool(len(files) > 1),
              )
  
          # update back the internal Model lookup, and replace the local file with our file
          # noinspection PyProtectedMember
          Model._local_model_to_id_uri[model_info.local_model_id] = (
              trains_out_model.id,
              trains_out_model.url,
          )
  
      except Exception as ex:
          get_logger(TrainsFrameworkAdapter).debug(str(ex))
      finally:
          WeightsFileHandler._model_store_lookup_lock.release()
  
      return saved_path
  
imports: import os
  import shutil
  import sys
  import threading
  from enum import Enum
  from random import randint
  from tempfile import mkstemp
  from typing import TYPE_CHECKING, Callable, Dict, Optional, Any, Union
  import six
  from pathlib2 import Path
  from ...backend_interface.model import Model
  from ...config import running_remotely
  from ...debugging.log import get_logger
  from ...model import InputModel, OutputModel
label_desc: Use image node_id 8 for calling the WeightsFileHandler obj's underlying member method code with example usage: obj.create_output_model(model, saved_path, framework, task, singlefile, model_name, config_obj) and returns: saved_path, saved_path, saved_path, saved_path, saved_path