def _copy_predictive_object_files(source_path, target_path, is_dir, src_credentials, tgt_credentials):
    Copy either file or folder from source location to target location
    # Cleanup existing file path if exists
    if _file_util.is_local_path(target_path) and _os.path.exists(target_path):

    if _file_util.is_s3_path(source_path) and _file_util.is_s3_path(target_path):

        # compare credentials
        _check_aws_credentials(src_credentials, tgt_credentials, source_path)

        # intra s3 copy model
        _file_util.intra_s3_copy_model(source_path, target_path, is_dir, tgt_credentials)
    elif _file_util.is_local_path(source_path):

        _file_util.copy_from_local(source_path, target_path, is_dir = is_dir)

        tmp_dir = _tempfile.mkdtemp(prefix = 'copy_predictive_object')
            # download to local first
            local_path = _os.path.join(tmp_dir, 'temp_po_file')
            if _file_util.is_s3_path(source_path):
            elif _file_util.is_hdfs_path(source_path):
                _file_util.download_from_hdfs(source_path, local_path, is_dir = False)
                raise RuntimeError('Unsupported file system type: %s' % source_path)

            # upload from local to remote
            if _file_util.is_s3_path(target_path):
                _file_util.upload_to_s3(local_path, target_path, is_dir=is_dir,
                    aws_credentials=tgt_credentials, silent=False)
            elif _file_util.is_hdfs_path(target_path):
                _file_util.upload_to_hdfs(local_path, target_path, force=True, silent=False)
                _file_util.upload_to_local(local_path, target_path, is_dir=is_dir, silent=False)

def copy_ec2_predictive_object(source_ps, target_ps, source_po_name, target_po_name=None, update=False):
    Copy a predictive object from a source Predictive Service to a target
    Predictive Service.

    source_ps : Predictive Service object
        The source Predictive Service that holds the predictive object specified
        in source_po_name.

    target_ps : Predictive Service object
        The target Predictive Service that will accept the predictive object
        copied from the source Predictive Service.

    source_po_name : str
        The name of the predictive object to be copied. Must exist on the
        source Predictive Service.

    target_po_name : str, optional
        The name of the predictive object to be stored to the target Predictive
        Service. If target_po_name is None, the target Predictive Service would use
        source_po_name as the predictive object name. Default value is None.

    update : boolean, optional
        If a predictive object already exists on the target Predictive Service
        with the name specified by target_po_name, set this to True if you want to
        update the existing predictive object on the target Predictive Service
        with the predictive object from the source Predictive Service. Otherwise,
        leave this to the default value False to prevent update.

    This operation will by-pass `apply_changes` operation on the target Predictive
    Service to add/update the predictive object.

    To copy a predictive object named 'recommender' from a source Predictive
    Service to a target Predictive Service:

        >>> gl.deploy.predictive_service.copy_predictive_object(source_ps, target_ps, 'recommender')

    To update the 'recommender' predictive object on the target Predictive Service
    with the 'recommender' predictive object from the source Predictive Service:

        >>> gl.deploy.predictive_service.copy_predictive_object(source_ps, target_ps, 'recommender', update=True)

    To copy the 'recommender' predictive object from the source Predictive Service
    to the target Predictive Service and rename it 'rec':

        >>> gl.deploy.predictive_service.copy_predictive_object(source_ps, target_ps, 'recommender', 'rec')

    if not source_ps or type(source_ps) is not _PredictiveService:
        raise ValueError("Invalid source Predictive Service.")

    if not target_ps or type(target_ps) is not _PredictiveService:
        raise ValueError("Invalid target Predictive Service.")


    # make sure both predictive services are deployed on AWS
    if not _file_util.is_s3_path(source_ps._state_path) or not _file_util.is_s3_path(target_ps._state_path):
        raise ValueError("Both source and target Predictive Services must be deployed on EC2")

    # if source is version 1, fail
    if source_ps._schema_version == 1:
        raise ValueError("The Predictive Service that you are trying to " \
                         "load is running version 1, which is no " \
                         "longer supported. Please re-create your " \
                         "Predictive Service using your current version " \
                         "of GraphLab Create.")

    # if source is newer than target, fail
    if source_ps._schema_version > target_ps._schema_version:
        raise ValueError("Cannot copy from a version %d Predictive Service " \
                         "to a version %d Predictive Service." % \
                         (source_ps._schema_version, target_ps._schema_version))

    if target_ps._schema_version != PREDICTIVE_SERVICE_SCHEMA_VERSION:
        raise RuntimeError('Target Predictive Service has schema version %s, '
            'copy_predictive_object is only supported if target Predictive Service '
            'is of schema version %s' % (target_ps._schema_version, PREDICTIVE_SERVICE_SCHEMA_VERSION))

    # make sure no extra local changes

    if source_po_name not in source_ps.deployed_predictive_objects:
        raise ValueError("No predictive object named \"%s\" in the source " \
                         "Predictive Service (%s)" % (str(source_po_name), str(

    # set the target predictive object name
    target_po_name = source_po_name if not target_po_name else target_po_name

    # get the version for the target predictive service
    if target_po_name in target_ps.deployed_predictive_objects:
        if update is False:
            raise RuntimeError("Cannot update the predictive object %s in the target Predictive Service." \
                            "Please set update to True if you want to update this predictive object in the" \
                            "target Predictive Service." % target_po_name)

        target_version = 1 + target_ps.deployed_predictive_objects[target_po_name]['version']
        target_version = 1

    # get predictive object info
    source_po_info = source_ps._endpoints[source_po_name]

    po_info = {'version': target_version,
               'docstring': source_po_info['docstring'],
               'cache_state': source_po_info['cache_state'],
               'schema_version': source_po_info['schema_version'],
               'type': source_po_info.get('type', 'model'),
               'description': source_po_info['description']}

    # get path for predictive objects
    if source_po_info.get('type', 'model') == 'model':
        # check if source po is directory or file
        is_dir = True
        if source_po_info['schema_version'] < 3:
            is_dir = False

        source_path = source_ps._get_predictive_object_save_path(source_po_name, source_po_info['version'])
        target_path = target_ps._get_predictive_object_save_path(target_po_name, target_version)

        # compare credentials
                               target_ps._environment.aws_credentials, source_path)

        # intra s3 copy model
        _file_util.intra_s3_copy_model(source_path, target_path, is_dir, target_ps._environment.aws_credentials)

    # add po_info to target_ps
    target_ps._endpoints[target_po_name] = po_info

    # save state to s3
    except _ConnectionError as e:
        _logger.warn("Unable to connect to target Predictive Service: %s" %
    target_ps._update_local_state()"Successfully copied predictive object \"%s\" from Predictive Service (%s) " \
                 "to Predictive Service (%s)." % (str(source_po_name),
                 str(, str(