def METHOD_NAME(self):
    """
    Reads a CSV file, removing content from all columns starting with "author"
    """
    # hasher for pseudonymisation
    salt = secrets.token_bytes(16)
    hasher = hashlib.blake2b(digest_size=24, salt=salt)
    hash_cache = HashCache(hasher)
    mode = self.parameters.get("mode")
    fields = self.parameters.get("fields")
    if type(fields) is str:
        fields = [field.strip() for field in fields.split(",")]
    with self.dataset.get_results_path().open("w", encoding="utf-8") as outfile:
        processed_items = 0
        if self.source_file.suffix.lower() == ".csv":
            writer = None
            filterable_fields = []
            for item in self.source_dataset.iterate_items(self):
                if not writer:
                    # initialise csv writer - we do this explicitly rather than
                    # using self.write_items_and_finish() because else we have
                    # to store a potentially very large amount of items in
                    # memory which is not a good idea
                    writer = csv.DictWriter(outfile, fieldnames=item.keys())
                    writer.writeheader()
                    # figure out which fields to filter (same for every item)
                    for field in item.keys():
                        if any([fnmatch.fnmatch(field, pattern) for pattern in fields]):
                            filterable_fields.append(field)
                processed_items += 1
                if processed_items % 500 == 0:
                    self.dataset.update_status(f"Processed {processed_items:,} of "
                                               f"{self.source_dataset.num_rows:,} items")
                    self.dataset.update_progress(processed_items / self.source_dataset.num_rows)
                for field in filterable_fields:
                    if mode == "anonymise":
                        item[field] = "REDACTED"
                    elif mode == "pseudonymise":
                        item[field] = hash_cache.update_cache(item[field])
                writer.writerow(item)
        elif self.source_file.suffix.lower() == ".ndjson":
            # Iterating through items
            # using bypass_map_item to not modify data further than necessary
            for item in self.source_dataset.iterate_items(self, bypass_map_item=True):
                # Filter author data
                if mode == "anonymise":
                    item = dict_search_and_update(item, fields, lambda v: "REDACTED")
                else:
                    item = dict_search_and_update(item, fields, hash_cache.update_cache)
                # Write modified item
                outfile.write(json.dumps(item, ensure_ascii=False) + "\n")
                # Update status
                processed_items += 1
                if processed_items % 500 == 0:
                    self.dataset.update_status(f"Processed {processed_items:,} of "
                                               f"{self.source_dataset.num_rows:,} items")
                    self.dataset.update_progress(processed_items / self.source_dataset.num_rows)
        else:
            raise NotImplementedError(f"Cannot iterate through {self.source_file.suffix} file")
    # replace original dataset with updated one
    shutil.move(self.dataset.get_results_path(), self.source_dataset.get_results_path())
    self.dataset.update_status("Data filtered, parent dataset updated.", is_final=True)
    self.dataset.finish(processed_items)