<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:

def update(
            self,
            filepath,
            cache=False,
            remove=False,
            bumpversion=None,
            prerelease=None,
            dependencies=None,
            metadata=None,
            message=None):
        '''
        Enter a new version to a DataArchive

        Parameters
        ----------

        filepath : str
            The path to the file on your local file system

        cache : bool
            Turn on caching for this archive if not already on before update

        remove : bool
            removes a file from your local directory

        bumpversion : str
            Version component to update on write if archive is versioned. Valid
            bumpversion values are 'major', 'minor', and 'patch', representing
            the three components of the strict version numbering system (e.g.
            "1.2.3"). If bumpversion is None the version number is not updated
            on write. Either bumpversion or prerelease (or both) must be a
            non-None value. If the archive is not versioned, bumpversion is
            ignored.

        prerelease : str
            Prerelease component of archive version to update on write if
            archive is versioned. Valid prerelease values are 'alpha' and
            'beta'. Either bumpversion or prerelease (or both) must be a
            non-None value. If the archive is not versioned, prerelease is
            ignored.

        metadata : dict
            Updates to archive metadata. Pass {key: None} to remove a key from
            the archive's metadata.
        '''

        if metadata is None:
            metadata = {}

        latest_version = self.get_latest_version()

        hashval = self.api.hash_file(filepath)

        checksum = hashval['checksum']
        algorithm = hashval['algorithm']

        if checksum == self.get_latest_hash():
            self.update_metadata(metadata)

            if remove and os.path.isfile(filepath):
                os.remove(filepath)

            return

        if self.versioned:
            if latest_version is None:
                latest_version = BumpableVersion()

            next_version = latest_version.bump(
                kind=bumpversion,
                prerelease=prerelease,
                inplace=False)

        else:
            next_version = None

        next_path = self.get_version_path(next_version)

        if cache:
            self.cache(next_version)

        if self.is_cached(next_version):
            self.authority.upload(filepath, next_path)
            self.api.cache.upload(filepath, next_path, remove=remove)

        else:
            self.authority.upload(filepath, next_path, remove=remove)

        self._update_manager(
            archive_metadata=metadata,
            version_metadata=dict(
                checksum=checksum,
                algorithm=algorithm,
                version=next_version,
                dependencies=dependencies,
                message=message))