csv

type Compression uint8

type Opener func(ctx context.Context) (io.ReadCloser, error)

type Options struct {
	// Separator and Quote are single bytes. Multi-byte separators are not
	// supported: they are rare, and supporting them would put a byte-compare in
	// the innermost loop of the scanner for every file.
	Separator byte
	Quote     byte

	// Comment, if non-empty, makes any line starting with it a comment. It is a
	// byte slice rather than a byte because "//" and "#!" are both real.
	Comment []byte

	// HasHeader treats the first record as column names.
	HasHeader bool

	// ColumnNames overrides the names, whether or not there is a header. With
	// HasHeader false and no names, columns are called column_1, column_2, …
	ColumnNames []string

	// SkipRows discards this many records before the header is read. Files with a
	// banner above the header are common enough that leaving this out means
	// telling people to preprocess with sed.
	SkipRows int

	// SkipLines discards this many lines before anything is read, by their line
	// ends alone, a quote read as any byte, as Polars' skip_lines (step 358). It and
	// SkipRows are not both set, as Polars refuses them both.
	SkipLines int

	// SkipRowsAfterHeader discards this many records after the header, or at the
	// start where there is none, a blank line one, as Polars' skip_rows_after_header.
	SkipRowsAfterHeader int

	// NoQuote reads a quote as any byte, as Polars' quote_char=None: no field is
	// quoted, and a separator or a line end always ends one.
	NoQuote bool

	// PathColumn, when set, is a String column of each row's file path after the
	// files' columns, as Polars' include_file_paths (step 359).
	PathColumn string

	// Schema, if set, skips inference entirely. This is the option to reach for
	// when the file is big: inference costs a read of the sample, and an explicit
	// schema also removes the risk of a column being inferred from rows that do
	// not represent it.
	Schema *dtype.Schema

	// SchemaOverrides fixes individual columns while inferring the rest. The
	// common case is one identity column that looks numeric and must not be.
	SchemaOverrides map[string]dtype.DataType

	// InferRows bounds how many records inference reads. 0 means the whole file,
	// which is exact and, on a large file, expensive.
	InferRows int

	// NullValues are the texts that mean NULL, in addition to the empty string for
	// non-string columns. Case-sensitive.
	NullValues []string

	// TruncateRaggedLines accepts a record of too many fields, the extra ones
	// dropped, as Polars' truncate_ragged_lines. A record of too few is padded with
	// nulls whatever it says, and a blank line read as a record of nulls, as Polars
	// reads them (step 357).
	TruncateRaggedLines bool

	// MaxRecordSize bounds one record. 0 selects the default (16 MiB).
	MaxRecordSize int

	// TryParseDates infers a column of dates, instants or times of day as a Date, a
	// Datetime in microseconds, in UTC where its values have offsets, or a Time, by
	// Polars' patterns, as Polars' try_parse_dates (step 355).
	TryParseDates bool

	// IgnoreErrors reads a value its column's type cannot take as a null, as Polars'
	// ignore_errors (step 357). A record of too many fields is refused still, and
	// text that is not UTF-8, as Polars refuses them.
	IgnoreErrors bool

	// NoInference reads every column as a String but those a schema or an override
	// types, as Polars' infer_schema=False.
	NoInference bool

	// AllowEmpty reads an empty file as a frame of no columns, as Polars'
	// raise_if_empty=False; otherwise it is refused.
	AllowEmpty bool

	// DecimalComma reads a float's and a Decimal's point as a comma, 1,5, as Polars'
	// decimal_comma: a value with a '.' is then no number.
	DecimalComma bool

	// Lossy reads text that is not UTF-8 with each invalid sequence a U+FFFD, as
	// Polars' encoding="utf8-lossy"; otherwise a String's such text is refused, as
	// Polars refuses it.
	Lossy bool
}

type QuoteStyle uint8

type Source struct {
	// contains filtered or unexported fields
}

type WriteOptions struct {
	Separator byte
	Quote     byte

	// Header writes the column names as the first record.
	Header bool

	// LineTerminator defaults to "\n". Set it to "\r\n" for consumers that need it.
	LineTerminator string

	// NullValue is the text written for a null. It defaults to the empty string,
	// which reads back as null for every type. An empty String is written quoted,
	// as "", which reads back as the empty string, so the two stay apart — as
	// Polars writes and reads them. This used to say the format cannot tell them
	// apart; quoting can.
	NullValue string

	// QuoteStyle is when a field is quoted, Polars' quote_style.
	QuoteStyle QuoteStyle

	// DateFormat, DatetimeFormat and TimeFormat are the strftime formats a Date, a
	// Datetime and a Time are written in, Polars' date_format, datetime_format and
	// time_format. Empty, each is Polars' own: 2024-01-02; 2024-01-02T03:04:05.123456
	// to the instant's unit, and its offset where it has a zone, +0900; and
	// 03:04:05.000000000.
	DateFormat, DatetimeFormat, TimeFormat string

	// FloatPrecision is the digits after a float's point, Polars' float_precision;
	// -1 is as many as the float needs.
	FloatPrecision int

	// FloatScientific is 1 for every float in scientific notation, 1.5e0, and -1 for
	// none, Polars' float_scientific; 0 is Polars' text, scientific past 1e16 and
	// below 1e-5.
	FloatScientific int

	// DecimalComma writes a float's and a Decimal's point as a comma.
	DecimalComma bool

	// BOM begins the text with a UTF-8 byte-order mark, Polars' include_bom.
	BOM bool

	// Compression and CompressionLevel are the codec and its level, Polars'
	// compression and compression_level: gzip's 0 to 9, Zstandard's 1 to 22, and -1
	// the codec's default, 6 and 3.
	Compression      Compression
	CompressionLevel int

	// SkipExtensionCheck lets a file's name end as another codec's files do, which
	// CheckExtension refuses, as Polars' check_extension=False.
	SkipExtensionCheck bool
}

type Writer struct {
	// contains filtered or unexported fields
}