giftag 1.0.0__tar.gz

giftag-1.0.0/.gitignore

@@ -0,0 +1,10 @@
+.venv/
+__pycache__/
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+*.partial/
+.DS_Store
+docs/_site/
+docs/.quarto/

giftag-1.0.0/CHANGELOG.md

@@ -0,0 +1,122 @@
+# giftag changelog
+
+Code, command-line and database-build changes. Newest first. Timestamps are
+UTC.
+
+giftag has two versions. The **package version** below follows this file. The
+**database format** (`DB_FORMAT` in `giftag/__init__.py`, currently 1) changes
+only when a directory written by `giftag build` can no longer be read by
+`giftag annotate`; a format change is called out in its entry.
+
+---
+
+## 1.0.0 — 2026-10-05T04:15Z
+
+### First release on PyPI
+
+**What changed.** giftag is published on PyPI, so `pip install giftag` works. A GitHub Actions workflow builds the distributions, runs the tests against the built wheel, and uploads to PyPI through trusted publishing when a GitHub release is published. The source distribution now holds only the package, its offline tests, the README, the licence and this changelog; the benchmarks and the documentation site stay in the repository. The "under development" badge and note are replaced by a PyPI version badge.
+
+**Why.** The quickstart has told users to run `pip install giftag` since the documentation site went up, but the package had never been uploaded. The source distribution was also shipping about 470 KB of benchmark results and documentation sources that an installation never uses.
+
+**Effect.** Packaging and release process only. Annotation, search rules, output files and the database format (still 1) are unchanged from 0.2.0. The version is 1.0.0 because the command line and output files are now treated as stable.
+
+### A dedicated documentation site connects giftag to gifter
+
+**What changed.** A Quarto site now documents the build and annotation commands, output schema, marker-search coverage, source rules, validation limits, and the direct handoff to gifter. It uses gifter's palette, typography and logo, with navigation back to gifter. GitHub Actions renders it on pull requests and deploys it from `main`. The README is now a short entry point to those guides.
+
+**Why.** giftag's CLI and coverage ledger need their own reference, while the interpretation of a GIFT call belongs in gifter's documentation.
+
+**Effect.** Documentation and deployment workflow only. Annotation, search rules and output files are unchanged.
+
+## 0.2.0 — 2026-10-04T05:05Z
+
+### dbCAN-sub is searched on every protein
+
+**What changed.** `annotate` now searches the dbCAN-sub clusters on every
+protein. The earlier behaviour, searching a family's clusters only on proteins
+with a domain of that family, is the opt-in `--gate-subfamilies`.
+
+**Why.** The gate was meant to keep a subfamily call from standing without its
+family. Measured against run_dbcan on *Bacteroides thetaiotaomicron* VPI-5482
+it dropped 74 of 157 subfamily calls. Most of that was a bug: the gate looked
+for a family hit named exactly `GH43` and ignored hits to dbCAN's official
+subfamily models such as `GH43_18`. With that fixed it still dropped 13, and
+gifter's subfamily evidence was curated against what run_dbcan emits.
+
+**Effect.** Subfamily calls match run_dbcan on the kept clusters, 157 of 157.
+The dbCAN step takes about twice as long; a genome takes about 45 s on 8 cores.
+With `--gate-subfamilies` the result is 144 of 157.
+
+### A hit to an official subfamily model counts as its family
+
+**What changed.** When a dbCAN family-library hit is to a subfamily model
+(`GH43_18`), giftag also emits the parent family marker (`GH43`). The row keeps
+the subfamily model in its `profile` column.
+
+**Why.** run_dbcan reports only the model that wins a region, so a GH43 protein
+whose best hit is `GH43_18` carries no `GH43` accession. Fourteen of gifter's 53
+CAZy family markers are in families with subfamily models, and those markers
+missed every such protein. The narrower hit licenses the broader marker, never
+the reverse.
+
+**Effect.** This is the one place giftag's markers differ from run_dbcan's
+literal output. On *B. thetaiotaomicron* it raises family marker rows from 104
+to 191.
+
+### dbCAN-sub is downloaded by byte range
+
+**What changed.** `build` locates the blocks of the CAZy families gifter uses in
+`dbCAN_sub.hmm` with range requests and downloads only those. A table of
+profile counts per family ships for the pinned release
+(`giftag/data/dbcan_sub_db_v5-2-9_5-5-2026.tsv`); every fetched block is checked
+against it, and it supplies run_dbcan's Z. On a mismatch, or for a release
+without a table, the whole library is streamed as before.
+
+**Why.** The library is 5.1 GB and gifter needs the clusters of 47 of its 500
+families.
+
+**Effect.** 1.25 GB is downloaded instead of 5.1 GB, and the kept profiles are
+byte-identical to the streamed result. A full build downloads about 2.9 GB.
+
+### KOfam is fetched over FTP first
+
+**What changed.** KOfam is downloaded from GenomeNet's FTP server, with HTTPS as
+the fallback.
+
+**Why.** GenomeNet throttles each HTTPS connection to tens of KB/s, which made
+the 1.5 GB archive a day-long download. FTP is about thirty times faster.
+
+**Effect.** KOfam takes about 25 minutes on an ordinary connection.
+
+### Command line on Typer and Rich
+
+**What changed.** The command line is rebuilt on Typer and Rich: grouped option
+panels, live download and genome progress bars, elapsed-time log lines, and a
+summary table after `build`, `annotate` and `info`. New global options
+`--verbose`, `--quiet` and `--log-file PATH` go before the command. `-i`
+accepts directories. A `version` command is added.
+
+**Why.** A build downloads for the better part of an hour and an annotation run
+may cover thousands of genomes; both need visible progress and a log that can
+be kept.
+
+**Effect.** Off a terminal the bars become plain periodic lines. `annotate()`
+now returns a summary dictionary instead of a row count. `typer` and `rich` are
+new dependencies. `--dbcan-dir` accepts `dbCAN-sub.hmm` as well as
+`dbCAN_sub.hmm`. `annotate` writes its tables genome by genome, so an
+interrupted run keeps what it finished; `giftag_run.json` marks a complete run.
+
+## 0.1.0 — 2026-10-04T03:13Z
+
+**What changed.** First version. `giftag build` compiles a profile database
+from the KOfam, NCBIfam, Pfam and dbCAN releases gifter is curated against,
+keeping the profiles gifter's markers need and the dbCAN profiles they compete
+with. `giftag annotate` calls genes with pyrodigal, applies each source's own
+acceptance rule, and writes the `genome_id`, `gene_id`, `namespace`,
+`accession` table gifter reads.
+
+**Why.** gifter's markers span four profile collections, and gifter cannot tell
+an unsearched marker from an absent gene.
+
+**Effect.** Database format 1. Every gifter marker gets a recorded status, and
+those that cannot be searched are reported.

giftag-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+Scope: this license covers the original giftag software code and documentation.
+It does not relicense any profile database giftag downloads; each source keeps
+its own terms (see the README).
+
+
+MIT No Attribution
+
+Copyright 2026 Antton Alberdi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

giftag-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.5
+Name: giftag
+Version: 1.0.0
+Summary: Annotate genomes with exactly the markers gifter evaluates.
+Project-URL: Homepage, https://github.com/alberdilab/giftag
+Project-URL: Documentation, https://alberdilab.github.io/giftag/
+Project-URL: Changelog, https://github.com/alberdilab/giftag/blob/main/CHANGELOG.md
+Project-URL: gifter, https://github.com/alberdilab/gifter
+Author: Antton Alberdi
+License-Expression: MIT-0
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Requires-Dist: pyhmmer>=0.12
+Requires-Dist: pyrodigal>=3.5
+Requires-Dist: rich>=13
+Requires-Dist: typer<1,>=0.12
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# giftag
+
+[![docs](https://github.com/alberdilab/giftag/actions/workflows/docs.yml/badge.svg)](https://github.com/alberdilab/giftag/actions/workflows/docs.yml)
+[![Documentation](https://img.shields.io/badge/docs-website-1f425f.svg)](https://alberdilab.github.io/giftag/)
+[![PyPI](https://img.shields.io/pypi/v/giftag.svg)](https://pypi.org/project/giftag/)
+[![License: MIT-0](https://img.shields.io/badge/license-MIT--0-blue.svg)](LICENSE)
+
+giftag annotates genome and protein FASTA files with the markers [gifter](https://alberdilab.github.io/gifter/) evaluates. It writes the gene-by-marker table gifter reads, together with search evidence and a record of which markers could be searched.
+
+**[Read the giftag documentation](https://alberdilab.github.io/giftag/)** for the [quickstart](https://alberdilab.github.io/giftag/get-started.html), [commands](https://alberdilab.github.io/giftag/commands.html), [output files](https://alberdilab.github.io/giftag/output.html), [marker coverage](https://alberdilab.github.io/giftag/coverage.html), [methods and validation](https://alberdilab.github.io/giftag/methods.html), and the [handoff to gifter](https://alberdilab.github.io/giftag/with-gifter.html).
+
+## Quickstart
+
+Python 3.9 or newer is required. The full database build downloads about 2.9 GB from KOfam, NCBIfam, Pfam and dbCAN onto your machine and uses about 1.5 GB of disk space. Read the [source terms](https://alberdilab.github.io/giftag/coverage.html#source-terms) before building.
+
+```sh
+pip install giftag
+giftag build
+giftag annotate -i genomes/ -o annotations/
+giftag info
+```
+
+Then use the marker table in R:
+
+```r
+markers <- read.delim("annotations/giftag_markers.tsv")
+calls <- gifter::evaluate_gifts_community(markers)
+```
+
+Each FASTA file is one genome. `giftag_markers.tsv` contains `genome_id`, `gene_id`, `namespace` and `accession` for gifter, plus the profile, rule, score and threshold behind each accepted hit. The built database's `markers.tsv` identifies markers giftag could not search. Keep it and `giftag_run.json` with an analysis: an unsearched marker otherwise looks absent to gifter.
+
+The tools make different claims. giftag observes marker evidence; gifter evaluates whether those observations complete a curated genomic capability. Neither tool infers expression, activity or phenotype from a hit.
+
+## Development
+
+```sh
+pip install -e '.[test]'
+pytest
+```
+
+Documentation source is in [`docs/`](docs/). From the repository root, run `quarto render docs` to build the site locally. The GitHub Pages workflow renders it on pull requests and deploys it from `main`.
+
+The [publication benchmark](benchmarks/RESULTS.md) compares giftag with
+KofamScan, run_dbcan, direct HMMER and two InterProScan releases on a pinned
+eight-genome panel. Its [reproduction guide](benchmarks/README.md) includes
+the Mjolnir workflow, source hashes, environments and analysis scripts.
+
+## Licensing
+
+giftag's code and original documentation are MIT-0. giftag redistributes no profile libraries. `giftag build` downloads them from their publishers, whose terms apply; see [source terms](https://alberdilab.github.io/giftag/coverage.html#source-terms).

giftag-1.0.0/README.md

@@ -0,0 +1,50 @@
+# giftag
+
+[![docs](https://github.com/alberdilab/giftag/actions/workflows/docs.yml/badge.svg)](https://github.com/alberdilab/giftag/actions/workflows/docs.yml)
+[![Documentation](https://img.shields.io/badge/docs-website-1f425f.svg)](https://alberdilab.github.io/giftag/)
+[![PyPI](https://img.shields.io/pypi/v/giftag.svg)](https://pypi.org/project/giftag/)
+[![License: MIT-0](https://img.shields.io/badge/license-MIT--0-blue.svg)](LICENSE)
+
+giftag annotates genome and protein FASTA files with the markers [gifter](https://alberdilab.github.io/gifter/) evaluates. It writes the gene-by-marker table gifter reads, together with search evidence and a record of which markers could be searched.
+
+**[Read the giftag documentation](https://alberdilab.github.io/giftag/)** for the [quickstart](https://alberdilab.github.io/giftag/get-started.html), [commands](https://alberdilab.github.io/giftag/commands.html), [output files](https://alberdilab.github.io/giftag/output.html), [marker coverage](https://alberdilab.github.io/giftag/coverage.html), [methods and validation](https://alberdilab.github.io/giftag/methods.html), and the [handoff to gifter](https://alberdilab.github.io/giftag/with-gifter.html).
+
+## Quickstart
+
+Python 3.9 or newer is required. The full database build downloads about 2.9 GB from KOfam, NCBIfam, Pfam and dbCAN onto your machine and uses about 1.5 GB of disk space. Read the [source terms](https://alberdilab.github.io/giftag/coverage.html#source-terms) before building.
+
+```sh
+pip install giftag
+giftag build
+giftag annotate -i genomes/ -o annotations/
+giftag info
+```
+
+Then use the marker table in R:
+
+```r
+markers <- read.delim("annotations/giftag_markers.tsv")
+calls <- gifter::evaluate_gifts_community(markers)
+```
+
+Each FASTA file is one genome. `giftag_markers.tsv` contains `genome_id`, `gene_id`, `namespace` and `accession` for gifter, plus the profile, rule, score and threshold behind each accepted hit. The built database's `markers.tsv` identifies markers giftag could not search. Keep it and `giftag_run.json` with an analysis: an unsearched marker otherwise looks absent to gifter.
+
+The tools make different claims. giftag observes marker evidence; gifter evaluates whether those observations complete a curated genomic capability. Neither tool infers expression, activity or phenotype from a hit.
+
+## Development
+
+```sh
+pip install -e '.[test]'
+pytest
+```
+
+Documentation source is in [`docs/`](docs/). From the repository root, run `quarto render docs` to build the site locally. The GitHub Pages workflow renders it on pull requests and deploys it from `main`.
+
+The [publication benchmark](benchmarks/RESULTS.md) compares giftag with
+KofamScan, run_dbcan, direct HMMER and two InterProScan releases on a pinned
+eight-genome panel. Its [reproduction guide](benchmarks/README.md) includes
+the Mjolnir workflow, source hashes, environments and analysis scripts.
+
+## Licensing
+
+giftag's code and original documentation are MIT-0. giftag redistributes no profile libraries. `giftag build` downloads them from their publishers, whose terms apply; see [source terms](https://alberdilab.github.io/giftag/coverage.html#source-terms).

giftag-1.0.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["hatchling>=1.18"]
+build-backend = "hatchling.build"
+
+[project]
+name = "giftag"
+dynamic = ["version"]
+description = "Annotate genomes with exactly the markers gifter evaluates."
+readme = "README.md"
+license = "MIT-0"
+license-files = ["LICENSE"]
+authors = [{ name = "Antton Alberdi" }]
+requires-python = ">=3.9"
+dependencies = [
+    "pyhmmer>=0.12",
+    "pyrodigal>=3.5",
+    "rich>=13",
+    "typer>=0.12,<1",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Operating System :: OS Independent",
+]
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://github.com/alberdilab/giftag"
+Documentation = "https://alberdilab.github.io/giftag/"
+Changelog = "https://github.com/alberdilab/giftag/blob/main/CHANGELOG.md"
+gifter = "https://github.com/alberdilab/gifter"
+
+[project.scripts]
+giftag = "giftag.cli:main"
+
+[tool.hatch.version]
+path = "src/giftag/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/giftag"]
+
+# The source distribution carries the package and its offline tests. The
+# benchmarks and the documentation site stay in the repository.
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src/giftag",
+    "/tests/conftest.py",
+    "/tests/test_giftag.py",
+    "/CHANGELOG.md",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

giftag-1.0.0/src/giftag/__init__.py

@@ -0,0 +1,11 @@
+"""giftag: annotate genomes with exactly the markers gifter evaluates."""
+
+__version__ = "1.0.0"
+
+# The layout of a database directory written by `giftag build`. `annotate`
+# refuses a directory whose format it does not know.
+DB_FORMAT = 1
+
+
+class GiftagError(Exception):
+    """An error the command line reports as a message rather than a traceback."""

giftag-1.0.0/src/giftag/__main__.py

@@ -0,0 +1,3 @@
+from giftag.cli import main
+
+raise SystemExit(main())

giftag-1.0.0/src/giftag/annotate.py

@@ -0,0 +1,163 @@
+"""`giftag annotate`: genomes or proteins in, a gifter marker table out."""
+
+import csv
+import json
+import time
+from collections import Counter
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich.markup import escape
+
+from giftag import GiftagError, __version__, ui
+from giftag.build import cazy_family
+from giftag.database import Database
+from giftag.genes import call_genes, genome_id, looks_nucleotide, read_fasta, write_fasta
+
+MARKER_COLUMNS = (
+    "genome_id", "gene_id", "namespace", "accession", "source", "profile", "rule",
+    "score", "evalue", "threshold", "coverage", "target_from", "target_to",
+)
+GENOME_COLUMNS = ("genome_id", "input", "input_type", "gene_calling", "sequences",
+                  "length_bp", "proteins", "marker_genes", "markers")
+
+
+def annotate(inputs, outdir, db_dir, threads=0, mode="auto", input_type="auto",
+             gate_subfamilies=False):
+    started = time.monotonic()
+    database = Database(db_dir)
+    inputs = [Path(p) for p in inputs]
+    if not inputs:
+        raise GiftagError("no input files")
+    ids = [genome_id(p) for p in inputs]
+    duplicated = sorted(gid for gid, n in Counter(ids).items() if n > 1)
+    if duplicated:
+        raise GiftagError(f"inputs share genome IDs: {', '.join(duplicated)}")
+    outdir = Path(outdir)
+    outdir.mkdir(parents=True, exist_ok=True)
+
+    unsearchable = database.unsearchable
+    if unsearchable:
+        ui.warning(f"{len(unsearchable)} gifter markers cannot be searched with this database "
+                   f"and will read as absent in gifter (see markers.tsv in the database)")
+    with ui.Task("loading profiles", done="profiles loaded in {elapsed}"):
+        database.load_all()
+
+    # Tables are written genome by genome, so a long run that stops part way
+    # keeps what it finished. giftag_run.json is written last and marks a run
+    # as complete.
+    (outdir / "giftag_run.json").unlink(missing_ok=True)
+    n_rows = 0
+    summary = []
+    width = len(str(len(inputs)))
+    with _Table(outdir / "giftag_markers.tsv", MARKER_COLUMNS) as markers, \
+            _Table(outdir / "giftag_genomes.tsv", GENOME_COLUMNS) as genomes, \
+            ui.Task("annotating", total=len(inputs), steps=False) as task:
+        for index, (path, gid) in enumerate(zip(inputs, ids), start=1):
+            began = time.monotonic()
+            name = escape(gid)
+
+            def stage(step):
+                task.update(description=f"{name} · {step}")
+
+            stage("reading")
+            records = read_fasta(path)
+            kind = input_type
+            if kind == "auto":
+                kind = "nucleotide" if looks_nucleotide(records) else "protein"
+            if kind == "nucleotide":
+                stage("calling genes")
+                proteins, used = call_genes(records, mode)
+                (outdir / "proteins").mkdir(exist_ok=True)
+                write_fasta(outdir / "proteins" / f"{gid}.faa", proteins)
+                calling = f"pyrodigal {used}"
+            else:
+                proteins, calling = records, "none (protein input)"
+
+            calls = database.search(proteins, cpus=threads, gate=gate_subfamilies, stage=stage)
+            rows = _label(gid, calls, database.labels)
+            markers.write(rows)
+            n_rows += len(rows)
+            row = dict(
+                genome_id=gid, input=str(path), input_type=kind, gene_calling=calling,
+                sequences=len(records),
+                length_bp=sum(len(s) for _, s in records) if kind == "nucleotide" else "",
+                proteins=len(proteins), marker_genes=len({r["gene_id"] for r in rows}),
+                markers=len({(r["namespace"], r["accession"]) for r in rows}),
+            )
+            genomes.write([row])
+            summary.append(row)
+            task.advance()
+            ui.info(f"[dim]{index:>{width}}/{len(inputs)}[/dim] [bold]{name}[/bold] · "
+                    f"{len(proteins):,} proteins · {row['markers']:,} markers · "
+                    f"{ui.format_duration(time.monotonic() - began)}")
+
+    manifest = database.manifest
+    run = {
+        "giftag_version": __version__,
+        "finished_utc": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "seconds": round(time.monotonic() - started, 1),
+        "database": {
+            "path": str(database.path.resolve()),
+            "built_utc": manifest["built_utc"],
+            "gifter": manifest["gifter"],
+            "sources": {name: {k: v for k, v in meta.items() if k != "terms"}
+                        for name, meta in manifest["sources"].items()},
+            "marker_status": manifest["marker_status"],
+        },
+        "parameters": {"mode": mode, "input_type": input_type, "threads": threads,
+                       "gate_subfamilies": gate_subfamilies},
+        "genomes": len(inputs),
+        "rows": n_rows,
+    }
+    with open(outdir / "giftag_run.json", "w") as handle:
+        json.dump(run, handle, indent=2)
+        handle.write("\n")
+    return {"outdir": outdir, "rows": n_rows, "genomes": summary,
+            "seconds": run["seconds"], "unsearchable": len(unsearchable)}
+
+
+def _label(gid, calls, labels):
+    """Translate accepted calls into gifter's namespace/accession, one row per
+    gene and marker, keeping the strongest supporting hit."""
+    best = {}
+    for call in calls:
+        found = list(labels.get((call.source, call.profile), ()))
+        if call.source == "dbcan" and cazy_family(call.profile) != call.profile:
+            # A hit to an official subfamily model (GH43_18) is a hit to its
+            # family: the narrower evidence licenses the broader marker. The
+            # row keeps the subfamily model as its `profile`.
+            found += labels.get(("dbcan", cazy_family(call.profile)), ())
+        for namespace, accession in found:
+            key = (call.gene_id, namespace, accession)
+            if key not in best or call.score > best[key].score:
+                best[key] = call
+    rows = []
+    for (gene, namespace, accession), call in best.items():
+        rows.append(dict(
+            genome_id=gid, gene_id=gene, namespace=namespace, accession=accession,
+            source=call.source, profile=call.profile, rule=call.rule,
+            score=f"{call.score:.1f}", evalue=f"{call.evalue:.3g}",
+            threshold=f"{call.threshold:g}",
+            coverage="" if call.coverage is None else f"{call.coverage:.3f}",
+            target_from=call.target_from or "", target_to=call.target_to or "",
+        ))
+    rows.sort(key=lambda r: (r["gene_id"], r["namespace"], r["accession"]))
+    return rows
+
+
+class _Table:
+    def __init__(self, path, columns):
+        self._handle = open(path, "w", newline="")
+        self._writer = csv.DictWriter(self._handle, columns, delimiter="\t", lineterminator="\n")
+        self._writer.writeheader()
+
+    def write(self, rows):
+        self._writer.writerows(rows)
+        self._handle.flush()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self._handle.close()