bqcsv 1.0.0__py3-none-any.whl

bqcsv/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

bqcsv/cli.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from bqcsv.config import (
+    CONFIG_KEYS,
+    CONFIG_PATH,
+    load_config,
+    resolve_setting,
+    save_config,
+    unset_config,
+)
+from bqcsv.uploader import upload_csv
+
+
+def _upload_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bqcsv",
+        description="Upload a local CSV file to BigQuery using the authenticated `bq` CLI.",
+    )
+    parser.add_argument("csv_path", type=Path, help="Path to the local CSV file to upload")
+    parser.add_argument("--project", help="GCP project ID (overrides config)")
+    parser.add_argument("--dataset", help="BigQuery dataset ID (overrides config)")
+    parser.add_argument(
+        "--table",
+        help="BigQuery table ID (overrides config; defaults to the CSV file name without extension)",
+    )
+    parser.add_argument(
+        "--replace",
+        action="store_true",
+        help="Replace the destination table instead of appending rows",
+    )
+    parser.add_argument(
+        "--no-header",
+        action="store_true",
+        help="Treat the first row as data instead of a header row",
+    )
+    parser.add_argument(
+        "--schema",
+        type=Path,
+        help="Optional JSON schema file for the table (disables autodetect)",
+    )
+    parser.add_argument(
+        "--output",
+        choices=("text", "json"),
+        default="text",
+        help="Output format: text prints progress as it runs; json prints a single JSON object at the end",
+    )
+    return parser
+
+
+def _config_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="bqcsv config")
+    subparsers = parser.add_subparsers(dest="config_command", required=True)
+
+    show_parser = subparsers.add_parser("show", help="Show saved defaults")
+    show_parser.set_defaults(func=_run_config_show)
+
+    set_parser = subparsers.add_parser("set", help="Save default project/dataset/table")
+    set_parser.add_argument("--project", help="Default GCP project ID")
+    set_parser.add_argument("--dataset", help="Default BigQuery dataset ID")
+    set_parser.add_argument("--table", help="Default BigQuery table ID")
+    set_parser.set_defaults(func=_run_config_set)
+
+    unset_parser = subparsers.add_parser("unset", help="Remove saved defaults")
+    unset_parser.add_argument("--project", action="store_true", help="Remove default project")
+    unset_parser.add_argument("--dataset", action="store_true", help="Remove default dataset")
+    unset_parser.add_argument("--table", action="store_true", help="Remove default table")
+    unset_parser.set_defaults(func=_run_config_unset)
+
+    return parser
+
+
+def resolve_table_name(
+    csv_path: Path,
+    cli_table: str | None,
+    config: dict[str, str],
+) -> str:
+    table = resolve_setting(cli_table, config, "table")
+    if table:
+        return table
+    return csv_path.expanduser().resolve().stem
+
+
+def _emit_upload_result(
+    *,
+    output: str,
+    logs: list[str],
+    status: str,
+) -> None:
+    if output == "json":
+        print(json.dumps({"logs": "\n".join(logs), "status": status}))
+        return
+    for line in logs:
+        print(line, file=sys.stderr if status == "error" else sys.stdout)
+    print(f"Status: {status}.")
+
+
+def _run_upload(argv: list[str]) -> int:
+    args = _upload_parser().parse_args(argv)
+    config = load_config()
+    csv_path = args.csv_path.expanduser().resolve()
+    project = resolve_setting(args.project, config, "project")
+    dataset = resolve_setting(args.dataset, config, "dataset")
+    table = resolve_table_name(csv_path, args.table, config)
+    json_output = args.output == "json"
+    logs: list[str] = []
+
+    missing = [
+        name
+        for name, value in (("project", project), ("dataset", dataset))
+        if not value
+    ]
+    if missing:
+        names = ", ".join(f"--{name}" for name in missing)
+        logs.append(
+            f"Missing required setting(s): {names}. "
+            f"Set them on the command line or via `bqcsv config set`."
+        )
+        _emit_upload_result(output=args.output, logs=logs, status="error")
+        return 2
+
+    try:
+        upload_csv(
+            csv_path,
+            project=project,
+            dataset=dataset,
+            table=table,
+            replace=args.replace,
+            skip_header=not args.no_header,
+            schema_path=args.schema.expanduser().resolve() if args.schema else None,
+            on_log=logs.append if json_output else None,
+        )
+    except Exception as exc:
+        logs.append(str(exc))
+        _emit_upload_result(output=args.output, logs=logs, status="error")
+        return 1
+
+    destination = f"{project}:{dataset}.{table}" if project else f"{dataset}.{table}"
+    logs.append(f"Uploaded {args.csv_path} to {destination}")
+    _emit_upload_result(output=args.output, logs=logs, status="success")
+    return 0
+
+
+def _run_config_show(_: argparse.Namespace) -> int:
+    config = load_config()
+    if not config:
+        print(f"No config saved at {CONFIG_PATH}")
+        return 0
+    for key in CONFIG_KEYS:
+        if key in config:
+            print(f"{key} = {config[key]}")
+    print(f"\nConfig file: {CONFIG_PATH}")
+    return 0
+
+
+def _run_config_set(args: argparse.Namespace) -> int:
+    updates = {
+        key: value
+        for key, value in (
+            ("project", args.project),
+            ("dataset", args.dataset),
+            ("table", args.table),
+        )
+        if value
+    }
+    if not updates:
+        print("Provide at least one of --project, --dataset, or --table.", file=sys.stderr)
+        return 2
+    save_config(updates)
+    print(f"Saved defaults to {CONFIG_PATH}")
+    return 0
+
+
+def _run_config_unset(args: argparse.Namespace) -> int:
+    keys = [key for key in CONFIG_KEYS if getattr(args, key)]
+    if not keys:
+        print("Provide at least one of --project, --dataset, or --table.", file=sys.stderr)
+        return 2
+    unset_config(keys)
+    print(f"Removed {', '.join(keys)} from {CONFIG_PATH}")
+    return 0
+
+
+def _run_config(argv: list[str]) -> int:
+    args = _config_parser().parse_args(argv)
+    return args.func(args)
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "config":
+        return _run_config(argv[1:])
+    return _run_upload(argv)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

bqcsv/config.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "bqcsv"
+CONFIG_PATH = CONFIG_DIR / "config.toml"
+
+CONFIG_KEYS = ("project", "dataset", "table")
+
+
+def _ensure_config_dir() -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict[str, str]:
+    if not CONFIG_PATH.is_file():
+        return {}
+    with CONFIG_PATH.open("rb") as f:
+        data = tomllib.load(f)
+    return {key: str(data[key]) for key in CONFIG_KEYS if key in data and data[key]}
+
+
+def save_config(values: dict[str, str]) -> None:
+    _ensure_config_dir()
+    current = load_config()
+    current.update(values)
+    lines = [f'{key} = "{_escape_toml(value)}"' for key, value in current.items()]
+    CONFIG_PATH.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def unset_config(keys: list[str]) -> None:
+    if not CONFIG_PATH.is_file():
+        return
+    current = load_config()
+    for key in keys:
+        current.pop(key, None)
+    if not current:
+        CONFIG_PATH.unlink(missing_ok=True)
+        return
+    lines = [f'{key} = "{_escape_toml(value)}"' for key, value in current.items()]
+    CONFIG_PATH.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+def resolve_setting(cli_value: str | None, config: dict[str, str], key: str) -> str | None:
+    if cli_value:
+        return cli_value
+    return config.get(key)
+
+
+def _escape_toml(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')

bqcsv/schema.py

@@ -0,0 +1,212 @@
+from __future__ import annotations
+
+import csv
+import json
+import re
+import tempfile
+from pathlib import Path
+
+import pandas as pd
+from google.cloud import bigquery
+
+_CANDIDATE_DELIMITERS = ",;\t|"
+DEFAULT_FIELD_DELIMITER = ","
+_DELIMITER_SAMPLE_SIZE = 8192
+_INTEGER_RE = re.compile(r"^-?\d+$")
+_DATE_ONLY_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+_BOOLEAN_VALUES = frozenset({"true", "false"})
+
+
+class SchemaError(Exception):
+    pass
+
+
+def _delimiter_count_in_line(line: str) -> dict[str, int]:
+    return {delimiter: line.count(delimiter) for delimiter in _CANDIDATE_DELIMITERS}
+
+
+def _delimiter_from_header_line(line: str) -> str | None:
+    counts = _delimiter_count_in_line(line)
+    delimiter, count = max(counts.items(), key=lambda item: item[1])
+    if count == 0:
+        return None
+    tied = [candidate for candidate, value in counts.items() if value == count]
+    if len(tied) > 1:
+        return None
+    return delimiter
+
+
+def detect_field_delimiter(csv_path: Path) -> str:
+    with csv_path.open(newline="", encoding="utf-8") as handle:
+        sample = handle.read(_DELIMITER_SAMPLE_SIZE)
+    if not sample.strip():
+        return DEFAULT_FIELD_DELIMITER
+
+    first_line = sample.splitlines()[0]
+    header_delimiter = _delimiter_from_header_line(first_line)
+
+    try:
+        sniffed = csv.Sniffer().sniff(sample, delimiters=_CANDIDATE_DELIMITERS).delimiter
+    except csv.Error:
+        return header_delimiter if header_delimiter is not None else DEFAULT_FIELD_DELIMITER
+
+    if header_delimiter is None:
+        return sniffed
+
+    sniffed_columns = first_line.count(sniffed) + (1 if sniffed in first_line else 1)
+    header_columns = first_line.count(header_delimiter) + 1
+    if header_columns > sniffed_columns:
+        return header_delimiter
+    return sniffed
+
+
+def _non_empty_values(series: pd.Series) -> pd.Series:
+    as_string = series.astype(str).str.strip()
+    return as_string[as_string != ""]
+
+
+def _infer_bq_type_for_series(series: pd.Series) -> str:
+    values = _non_empty_values(series)
+    if values.empty:
+        return "STRING"
+
+    if pd.api.types.is_bool_dtype(series.dtype):
+        return "BOOLEAN"
+    if pd.api.types.is_integer_dtype(series.dtype):
+        return "INTEGER"
+    if pd.api.types.is_float_dtype(series.dtype):
+        if (series.dropna() % 1 == 0).all():
+            return "INTEGER"
+        return "FLOAT"
+    if pd.api.types.is_datetime64_any_dtype(series.dtype):
+        return "TIMESTAMP"
+
+    if values.str.match(_INTEGER_RE).all():
+        return "INTEGER"
+
+    if values.str.lower().isin(_BOOLEAN_VALUES).all():
+        return "BOOLEAN"
+
+    numeric = pd.to_numeric(series, errors="coerce")
+    non_null = series.notna()
+    if non_null.any() and numeric[non_null].notna().all():
+        if (numeric[non_null] % 1 == 0).all():
+            return "INTEGER"
+        return "FLOAT"
+
+    if values.str.match(_DATE_ONLY_RE).all():
+        return "DATE"
+
+    parsed = pd.to_datetime(series, errors="coerce", format="mixed")
+    if non_null.any() and parsed[non_null].notna().all():
+        return "TIMESTAMP"
+
+    return "STRING"
+
+
+def load_schema_from_json(schema_path: Path) -> list[bigquery.SchemaField]:
+    with schema_path.open(encoding="utf-8") as handle:
+        raw_schema = json.load(handle)
+    return [bigquery.SchemaField.from_api_repr(field) for field in raw_schema]
+
+
+def read_csv_dataframe(
+    csv_path: Path,
+    *,
+    field_delimiter: str,
+    skip_header: bool,
+    column_names: list[str] | None = None,
+) -> pd.DataFrame:
+    read_kwargs = {
+        "filepath_or_buffer": csv_path,
+        "sep": field_delimiter,
+        "encoding": "utf-8",
+        "dtype": str,
+        "keep_default_na": False,
+    }
+    if skip_header:
+        dataframe = pd.read_csv(**read_kwargs)
+    else:
+        dataframe = pd.read_csv(**read_kwargs, header=None)
+        if column_names is None:
+            raise SchemaError(
+                "CSV has no header row. Create the destination table first or upload a CSV with a header."
+            )
+        if len(column_names) != len(dataframe.columns):
+            raise SchemaError(
+                f"CSV has {len(dataframe.columns)} column(s) but the destination table has "
+                f"{len(column_names)} column(s)."
+            )
+        dataframe.columns = column_names
+    return dataframe
+
+
+def format_dataframe_for_bq_load(
+    dataframe: pd.DataFrame,
+    schema: list[bigquery.SchemaField],
+) -> pd.DataFrame:
+    formatted = dataframe.copy()
+    for field in schema:
+        if field.name not in formatted.columns:
+            continue
+        column = formatted[field.name]
+        if field.field_type == "TIMESTAMP":
+            parsed = pd.to_datetime(column, errors="coerce", format="mixed")
+            formatted[field.name] = parsed.dt.strftime("%Y-%m-%d %H:%M:%S.%f")
+        elif field.field_type == "DATE":
+            parsed = pd.to_datetime(column, errors="coerce", format="mixed")
+            formatted[field.name] = parsed.dt.strftime("%Y-%m-%d")
+        elif field.field_type == "INTEGER":
+            formatted[field.name] = (
+                pd.to_numeric(column, errors="coerce").astype("Int64").astype(str)
+            )
+    return formatted
+
+
+def infer_bq_schema_from_csv(
+    csv_path: Path,
+    *,
+    field_delimiter: str,
+    skip_header: bool,
+    column_names: list[str] | None = None,
+) -> list[bigquery.SchemaField]:
+    dataframe = read_csv_dataframe(
+        csv_path,
+        field_delimiter=field_delimiter,
+        skip_header=skip_header,
+        column_names=column_names,
+    )
+
+    return [
+        bigquery.SchemaField(str(column), _infer_bq_type_for_series(dataframe[column]))
+        for column in dataframe.columns
+    ]
+
+
+def format_schema(schema: list[bigquery.SchemaField]) -> str:
+    return ", ".join(f"{field.name}:{field.field_type}" for field in schema)
+
+
+def schemas_match(
+    csv_schema: list[bigquery.SchemaField],
+    table_schema: list[bigquery.SchemaField],
+) -> bool:
+    if len(csv_schema) != len(table_schema):
+        return False
+    for csv_field, table_field in zip(csv_schema, table_schema, strict=True):
+        if csv_field.name != table_field.name:
+            return False
+        if csv_field.field_type.upper() != table_field.field_type.upper():
+            return False
+    return True
+
+
+def write_schema_file(schema: list[bigquery.SchemaField]) -> Path:
+    with tempfile.NamedTemporaryFile(
+        "w",
+        suffix=".json",
+        delete=False,
+        encoding="utf-8",
+    ) as handle:
+        json.dump([field.to_api_repr() for field in schema], handle)
+        return Path(handle.name)

bqcsv/table.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from google.api_core.exceptions import NotFound
+from google.cloud import bigquery
+
+from bqcsv.schema import format_schema, schemas_match
+
+
+class TableError(Exception):
+    pass
+
+
+def table_id(*, project: str | None, dataset: str, table: str) -> str:
+    if project:
+        return f"{project}.{dataset}.{table}"
+    return f"{dataset}.{table}"
+
+
+def get_bq_client(project: str | None) -> bigquery.Client:
+    return bigquery.Client(project=project) if project else bigquery.Client()
+
+
+def ensure_table_exists(
+    client: bigquery.Client,
+    destination_table_id: str,
+    schema: list[bigquery.SchemaField],
+    *,
+    replace: bool = False,
+) -> list[bigquery.SchemaField]:
+    try:
+        existing_table = client.get_table(destination_table_id)
+    except NotFound:
+        client.create_table(bigquery.Table(destination_table_id, schema=schema))
+        return schema
+
+    table_schema = list(existing_table.schema)
+    if not schemas_match(schema, table_schema):
+        if replace:
+            return schema
+        raise TableError(
+            "CSV schema does not match the destination table schema. "
+            f"CSV: [{format_schema(schema)}]. "
+            f"Table: [{format_schema(table_schema)}]. "
+            "Use --replace to recreate the table."
+        )
+    return table_schema

bqcsv/uploader.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from collections.abc import Callable
+from pathlib import Path
+
+from google.api_core.exceptions import NotFound
+
+from bqcsv.schema import (
+    DEFAULT_FIELD_DELIMITER,
+    SchemaError,
+    detect_field_delimiter,
+    format_dataframe_for_bq_load,
+    format_schema,
+    infer_bq_schema_from_csv,
+    load_schema_from_json,
+    read_csv_dataframe,
+    write_schema_file,
+)
+from bqcsv.table import TableError, ensure_table_exists, get_bq_client, table_id
+
+
+class UploadError(Exception):
+    pass
+
+
+def ensure_bq_available() -> str:
+    bq_path = shutil.which("bq")
+    if not bq_path:
+        raise UploadError(
+            "The `bq` CLI was not found on PATH. Install the Google Cloud SDK and run "
+            "`gcloud auth login` before uploading."
+        )
+    return bq_path
+
+
+def _write_prepared_csv(
+    dataframe,
+    *,
+    field_delimiter: str,
+    skip_header: bool,
+) -> Path:
+    with tempfile.NamedTemporaryFile(
+        "w",
+        suffix=".csv",
+        delete=False,
+        newline="",
+        encoding="utf-8",
+    ) as handle:
+        dataframe.to_csv(
+            handle,
+            index=False,
+            sep=field_delimiter,
+            header=skip_header,
+        )
+        return Path(handle.name)
+
+
+def build_load_command(
+    csv_path: Path,
+    *,
+    project: str | None,
+    dataset: str,
+    table: str,
+    schema_path: Path,
+    replace: bool = False,
+    skip_header: bool = True,
+    field_delimiter: str = DEFAULT_FIELD_DELIMITER,
+) -> list[str]:
+    destination = f"{project}:{dataset}.{table}" if project else f"{dataset}.{table}"
+    cmd = ["bq", "load", "--source_format=CSV", "--noautodetect"]
+    if project:
+        cmd.extend(["--project_id", project])
+    cmd.append(f"--field_delimiter={field_delimiter}")
+    if skip_header:
+        cmd.append("--skip_leading_rows=1")
+    if replace:
+        cmd.append("--replace")
+    cmd.append(destination)
+    cmd.append(str(csv_path))
+    cmd.append(str(schema_path))
+    return cmd
+
+
+def _log(on_log: Callable[[str], None] | None, message: str) -> None:
+    if on_log is not None:
+        on_log(message)
+
+
+def upload_csv(
+    csv_path: Path,
+    *,
+    project: str | None,
+    dataset: str,
+    table: str,
+    replace: bool = False,
+    skip_header: bool = True,
+    schema_path: Path | None = None,
+    on_log: Callable[[str], None] | None = None,
+) -> None:
+    ensure_bq_available()
+    if not csv_path.is_file():
+        raise UploadError(f"CSV file not found: {csv_path}")
+    if schema_path is not None and not schema_path.is_file():
+        raise UploadError(f"Schema file not found: {schema_path}")
+
+    try:
+        field_delimiter = detect_field_delimiter(csv_path)
+        _log(on_log, f"Detected field delimiter: {field_delimiter!r}")
+        destination_table_id = table_id(project=project, dataset=dataset, table=table)
+        client = get_bq_client(project)
+
+        explicit_schema = (
+            load_schema_from_json(schema_path) if schema_path is not None else None
+        )
+
+        column_names: list[str] | None = None
+        if not skip_header:
+            if explicit_schema is not None:
+                column_names = [field.name for field in explicit_schema]
+            else:
+                try:
+                    existing_table = client.get_table(destination_table_id)
+                except NotFound as exc:
+                    raise UploadError(
+                        "CSV has no header row and destination table does not exist. "
+                        "Upload a CSV with a header or create the table first."
+                    ) from exc
+                column_names = [field.name for field in existing_table.schema]
+
+        if explicit_schema is not None:
+            csv_schema = explicit_schema
+            _log(on_log, f"Using schema from {schema_path}")
+        else:
+            csv_schema = infer_bq_schema_from_csv(
+                csv_path,
+                field_delimiter=field_delimiter,
+                skip_header=skip_header,
+                column_names=column_names,
+            )
+            _log(on_log, f"Inferred schema: [{format_schema(csv_schema)}]")
+
+        load_schema = ensure_table_exists(
+            client,
+            destination_table_id,
+            csv_schema,
+            replace=replace,
+        )
+        _log(on_log, f"Destination table ready: {destination_table_id}")
+
+        dataframe = read_csv_dataframe(
+            csv_path,
+            field_delimiter=field_delimiter,
+            skip_header=skip_header,
+            column_names=column_names,
+        )
+        prepared_csv_path = _write_prepared_csv(
+            format_dataframe_for_bq_load(dataframe, load_schema),
+            field_delimiter=field_delimiter,
+            skip_header=skip_header,
+        )
+
+        temp_schema_path = write_schema_file(load_schema)
+        try:
+            cmd = build_load_command(
+                prepared_csv_path,
+                project=project,
+                dataset=dataset,
+                table=table,
+                schema_path=temp_schema_path,
+                replace=replace,
+                skip_header=skip_header,
+                field_delimiter=field_delimiter,
+            )
+            _log(on_log, f"Running: {' '.join(cmd)}")
+            try:
+                if on_log is not None:
+                    result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+                    if result.stdout.strip():
+                        _log(on_log, result.stdout.rstrip())
+                    if result.stderr.strip():
+                        _log(on_log, result.stderr.rstrip())
+                else:
+                    subprocess.run(cmd, check=True)
+            except subprocess.CalledProcessError as exc:
+                raise UploadError(f"`bq load` failed with exit code {exc.returncode}") from exc
+        finally:
+            temp_schema_path.unlink(missing_ok=True)
+            prepared_csv_path.unlink(missing_ok=True)
+    except (SchemaError, TableError) as exc:
+        raise UploadError(str(exc)) from exc

bqcsv-1.0.0.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: bqcsv
+Version: 1.0.0
+Summary: Upload a local CSV file to a BigQuery table via the bq CLI
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: google-cloud-bigquery>=3.0
+Requires-Dist: pandas>=2.0
+
+# bqcsv
+
+Upload a local CSV file to BigQuery using the `bq` CLI and your existing `gcloud` authentication.
+
+## Why a dedicated CLI tool?
+
+Out of the box, Google's `bq` CLI cannot create a table with column names inferred from a CSV file.
+
+`bqcsv` fixes that:
+
+* detects the schema from the CSV file
+* creates a table with proper column names and types
+* loads the CSV file using `bq load`
+
+## Authentication
+
+No additional authentication is needed.
+
+`bqcsv` uses your existing authentication via `gcloud auth login`.
+
+## Requirements
+
+- Python 3.10+
+- [Google Cloud SDK](https://cloud.google.com/sdk) with `bq` on your `PATH`
+
+## How to use `bqcsv`
+
+### Upload a CSV file to a table
+
+To upload a CSV file, specify your project ID, dataset ID, and table name:
+
+```bash
+bqcsv data.csv --project my-gcp-project --dataset staging --table events_raw
+```
+
+The `--table` argument is optional. By default, `bqcsv` derives the table name from the CSV file:
+
+```bash
+bqcsv data.csv --project my-gcp-project --dataset staging
+
+# is identical to
+
+bqcsv data.csv --project my-gcp-project --dataset staging --table data
+```
+
+### Saving your configuration
+
+To avoid passing `--project`, `--dataset`, or `--table` on every run, save them to your local config:
+
+```bash
+bqcsv config set --project my-gcp-project --dataset analytics --table events
+bqcsv config show
+```
+
+Defaults are stored in `~/.config/bqcsv/config.toml`.
+
+After you set your defaults, you can call `bqcsv` without arguments:
+
+```bash
+bqcsv data.csv
+```
+
+If you have not set a default `--table` value, the table name is derived from the CSV file.
+
+## Development
+
+### Install from your local repo
+
+```bash
+pip install -e .
+```
+
+### Testing
+
+To delete a test table, use `bq`:
+
+```bash
+bq rm -f -t  PROJECT_ID:DATASET_ID.TABLE_NAME
+```
+
+You can run the module directly when working on a new feature or fixing a bug:
+
+```sh
+python -m bqcsv.cli config set --project PROJECT_ID --dataset DATASET_ID --table TEST_TABLE_NAME
+```
+
+## Releasing to PyPI
+
+1. **Bump the version** in both places (they must match):
+   - `pyproject.toml` → `[project].version`
+   - `bqcsv/__init__.py` → `__version__`
+
+2. **Install build tools** (one-time):
+
+   ```bash
+   pip install build twine
+   ```
+
+3. **Run tests** and commit the version bump.
+
+4. **Build the package**:
+
+   ```bash
+   python -m build
+   ```
+
+   This creates `dist/bqcsv-<version>.tar.gz` and `dist/bqcsv-<version>-py3-none-any.whl`.
+
+5. **Upload to PyPI**:
+
+   ```bash
+   twine upload dist/*
+   ```
+
+   On first upload, create an account at [pypi.org](https://pypi.org) and use an [API token](https://pypi.org/help/#apitoken) as the password (`__token__` as the username).
+
+6. **Tag the release** (optional but recommended):
+
+   ```bash
+   git tag v0.2.0
+   git push origin v0.2.0
+   ```
+
+After publishing, users can install the new version with:
+
+```bash
+pip install --upgrade bqcsv
+```

bqcsv-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+bqcsv/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
+bqcsv/cli.py,sha256=drFb5yv_2R-C2Pkzz5hu7goN72EQCQ8MWgg8DrdycMg,6425
+bqcsv/config.py,sha256=TA2k1eeVa041S777RTM9fbyBW-QP_sjgt4IApVOPf8Y,1569
+bqcsv/schema.py,sha256=TdNeatvKCONZmOd8PSYNE4UPCjz6fCFE-VuS5cI9G4Q,6602
+bqcsv/table.py,sha256=rfoA0v3tyUzCKhgsN0BQMBWdLDyZVH-eUpfxSRajM7s,1338
+bqcsv/uploader.py,sha256=RxAPwWwAunh7HAGrPU0lHcmklznIJ0gPuhWRV0P3Nhk,6111
+bqcsv-1.0.0.dist-info/METADATA,sha256=eMXIhk6WpbFYYb8HyzmnCLCCuQ_4cNRdvtesBXtv69k,3139
+bqcsv-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bqcsv-1.0.0.dist-info/entry_points.txt,sha256=3p_cZqU8eHNBnnkGSKkdbDXdXUEVL19gPOJeZGQ6hE8,41
+bqcsv-1.0.0.dist-info/top_level.txt,sha256=iVTsmLuF2tHvlgDaGBA-NOFo8UwVRgUETjKPVYlWfHU,6
+bqcsv-1.0.0.dist-info/RECORD,,

bqcsv-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

bqcsv-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bqcsv = bqcsv.cli:main

bqcsv-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bqcsv