docs: def create_object(self, name, experiment_id, model_id, argument_defs, arguments=None, properties=None):
          """Create a model run object with the given list of arguments. The
          initial state of the object is RUNNING.
  
          Raises ValueError if given arguments are invalid.
  
          Parameters
          ----------
          name : string
              User-provided name for the model run
          experiment_id : string
              Unique identifier of associated experiment object
          model_id : string
              Unique model identifier
          argument_defs : list(attribute.AttributeDefinition)
              Definition of valid arguments for the given model
          arguments : list(dict('name':...,'value:...')), optional
              List of attribute instances
          properties : Dictionary, optional
              Set of model run properties.
          Returns
          -------
          PredictionHandle
              Object handle for created model run
          """
          # Create a new object identifier.
          identifier = str(uuid.uuid4()).replace('-','')
          # Directory for successful model run resource files. Directories are
          # simply named by object identifier
          directory = os.path.join(self.directory, identifier)
          # Create the directory if it doesn't exists
          if not os.access(directory, os.F_OK):
              os.makedirs(directory)
          # By default all model runs are in IDLE state at creation
          state = ModelRunIdle()
          # Create the initial set of properties.
          run_properties = {
              datastore.PROPERTY_NAME: name,
              datastore.PROPERTY_STATE: str(state),
              datastore.PROPERTY_MODEL: model_id
          }
          if not properties is None:
              for prop in properties:
                  if not prop in run_properties:
                      run_properties[prop] = properties[prop]
          # If argument list is not given then the initial set of arguments is
          # empty. Here we do not validate the given arguments. Definitions of
          # valid argument sets are maintained in the model registry and are not
          # accessible by the model run manager at this point.
          run_arguments = {}
          if not arguments is None:
              # Convert arguments to dictionary of Atrribute instances. Will
              # raise an exception if values are of invalid type.
              run_arguments = attribute.to_dict(arguments, argument_defs)
          # Create the image group object and store it in the database before
          # returning it.
          obj = ModelRunHandle(
              identifier,
              run_properties,
              directory,
              state,
              experiment_id,
              model_id,
              run_arguments
          )
          self.insert_object(obj)
          return obj