Struct OpenOptions 

pub struct OpenOptions {

    pub delimiter: Option<u8>,
    pub has_header: Option<bool>,
    pub skip_lines: Option<usize>,
    pub skip_rows: Option<usize>,
    pub skip_tail_rows: Option<usize>,
    pub compression: Option<CompressionFormat>,
    pub format: Option<FileFormat>,
    pub pages_lookahead: Option<usize>,
    pub pages_lookback: Option<usize>,
    pub max_buffered_rows: Option<usize>,
    pub max_buffered_mb: Option<usize>,
    pub row_numbers: bool,
    pub row_numbers_auto: bool,
    pub row_start_index: usize,
    pub hive: bool,
    pub left_out: Vec<(FileFormat, usize)>,
    pub read_as_plain_files_of: Option<&'static str>,
    pub files_disagree: Disagreement,
    pub single_spine_schema: bool,
    pub view: Option<String>,
    pub parse_dates: bool,
    pub parse_strings: Option<ParseStringsTarget>,
    pub parse_strings_sample_rows: usize,
    pub decompress_in_memory: bool,
    pub temp_dir: Option<PathBuf>,
    pub table: Option<String>,
    pub polars_streaming: bool,
    pub null_values: Option<Vec<String>>,
    pub infer_schema_length: Option<usize>,
    pub ignore_errors: bool,
    pub comment_char: Option<String>,
    pub header_rows: Vec<usize>,
    pub header_join: String,
    pub skip_initial_space: bool,
    pub typed_dialect: TypedDialect,
    pub debug: bool,
    pub splits: Option<Arc<Splits>>,
    pub arrow_parts: Option<Arc<Vec<Part>>>,
    pub spec_file: Option<PathBuf>,
    pub spec_fetched: Option<Arc<Spec>>,
    pub dicts: Vec<PathBuf>,
    pub spec_name: Option<String>,
    pub format_read: Option<Arc<Read>>,
    pub read_python: Vec<String>,
    pub normalize: bool,
    pub sqlite: Option<Arc<SqliteOpen>>,
    pub opened: Option<Arc<Opened>>,
    pub delimited: Option<Arc<DelimitedRead>>,
    pub read_mode: Option<ReadMode>,
    pub format_guessed: bool,
    pub read_notes: Vec<Note>,
    pub typing: Typing,
    pub hex: bool,
    pub record_size: Option<usize>,
    pub follow: bool,
    pub tail: Option<Arc<Tail>>,
    pub spool: Option<Arc<SpoolHandle>>,
    pub pipe: bool,
    pub tee: Option<PathBuf>,
    pub tee_raw: bool,
    pub force: bool,
    pub prepared: Option<Handoff>,
    pub download_unasked: Option<UnaskedDownload>,
}

Fields

delimiter: Option<u8>

has_header: Option<bool>

skip_lines: Option<usize>

skip_rows: Option<usize>

skip_tail_rows: Option<usize>

Skip this many rows at the end of the file (e.g. vendor footer or trailing garbage). Applied after load for CSV.

compression: Option<CompressionFormat>

format: Option<FileFormat>

When set, bypass extension-based format detection and use this format (e.g. for URLs or temp files without extension).

pages_lookahead: Option<usize>

pages_lookback: Option<usize>

max_buffered_rows: Option<usize>

max_buffered_mb: Option<usize>

row_numbers: bool

row_numbers_auto: bool

Neither the flag nor the config said: # is on for text and logs (crate::config::RowNumbers::Auto), decided once the format is known.

row_start_index: usize

hive: bool

When true, use hive load path for directory/glob; single file uses normal load.

left_out: Vec<(FileFormat, usize)>

Data files in the directory being opened that this read passes over, by format and count.

A directory of more than one format is read as the commonest of them — a thousand CSVs and one stray JSON is a directory of CSVs — and this is what the stray was, so the dataset can say what it left out rather than the directory being refused over it. Empty for every other open, which is all of them but one.

read_as_plain_files_of: Option<&'static str>

Set when the directory being opened is a lake table and this read is of its plain files: "Delta", "Iceberg" or "Hudi".

The files are not the table. A delete leaves its rows on disk, an update leaves the version it replaced, and compaction leaves both sides — so this read counts rows no query of the table would return. datui does it anyway, because the alternative was a directory the user could see and could not read at all, and every other engine at least lets you look. What makes it honest rather than wrong is that it is never silent: a note and a chip in the control bar say so, and both are load-bearing.

files_disagree: Disagreement

How the directory’s own files differed, when they did.

Only for the formats with no footer. A Parquet dataset’s footers are read anyway, and say this per column and per file in far more detail — which columns, in how many files, and where — so saying it twice would be one vague note above several exact ones.

single_spine_schema: bool

When true (default), infer Hive/partitioned Parquet schema from one file for faster “Reading schema”. When false, use Polars collect_schema().

view: Option<String>

--view NAME: the view to apply to the dataset named on the command line, once it is on screen. Applied to that open only; what later opens get is [views] auto_apply’s business.

parse_dates: bool

When true, CSV and JSON string columns that look like dates or ISO 8601 timestamps become Date or Datetime.

parse_strings: Option<ParseStringsTarget>

When set, trim and parse CSV string columns: None = off, Some(true) = all columns, Some(cols) = those columns only.

parse_strings_sample_rows: usize

Sample size (rows) for inferring types when parse_strings is enabled; single file or multiple/partitioned.

decompress_in_memory: bool

When true, decompress a compressed CSV, TSV or PSV into memory (eager read). When false (default), decompress to a temp file and use lazy scan.

temp_dir: Option<PathBuf>

Directory for decompression temp files. None = system default (e.g. TMPDIR).

table: Option<String>

--table: which table of a file that holds several: an NMEA log’s sentence types, an Excel sheet (0-based index or name), a spec’s variant. None is the file’s main table.

polars_streaming: bool

When true, use Polars streaming engine for LazyFrame collect when the streaming feature is enabled.

null_values: Option<Vec<String>>

Null value specs for CSV: global strings and/or “COL=VAL” for per-column. Empty = use Polars default.

infer_schema_length: Option<usize>

Number of rows to use when inferring CSV schema. None = Polars default (100). Larger values reduce risk of inferring wrong type (e.g. int then N/A).

ignore_errors: bool

When true, CSV reader ignores parse errors and continues with the next batch.

comment_char: Option<String>

CSV lines starting with this are comments, wherever they are (commentChar).

header_rows: Vec<usize>

The 1-based lines, counted from the top of the file, that hold a CSV’s header (headerRows). Empty = Polars’ own header. A layout flag, like skip_lines.

header_join: String

What joins a column’s pieces when header_rows names several lines.

skip_initial_space: bool

Ignore the spaces after a CSV delimiter (skipInitialSpace).

typed_dialect: TypedDialect

Which dialect options were typed on the command line, so a spec leaves them.

debug: bool

The debug overlay (session info, performance, query): DATUI_DEBUG=1.

splits: Option<Arc<Splits>>

The split of a Hugging Face cache directory this read chose, the others and the map() files it left out. Found by the read, or by a bucket listing, and carried to the dataset as left_out is. None for every other open.

arrow_parts: Option<Arc<Vec<Part>>>

Where each Arrow input’s rows are once its streams are converted: the IPC files read in place and the streams’ rows in the converted file the scan names. Set by the load, after a conversion or a bucket’s listing, never by a request.

spec_file: Option<PathBuf>

--format FILE: read the path through this format spec, whatever else matches it. A URL is fetched when the open starts, into spec_fetched.

spec_fetched: Option<Arc<Spec>>

The spec a remote spec_file names, fetched by the open (Phase::ReadingSpec).

dicts: Vec<PathBuf>

--dict FILE: FIX dictionaries and DBC files over the search path’s, each taken by the reader of its kind.

spec_name: Option<String>

The format spec named by --format NAME, or picked with b.

format_read: Option<Arc<Read>>

What a read through a format spec found, carried from the scan to the dataset.

read_python: Vec<String>

What the open did to the rows its reader gave — CSV column names trimmed, text columns typed — as Python method calls for Copy as Python. Found by the scan, carried to the dataset as left_out is. Empty for every other open.

normalize: bool

[read] audio_float: integer audio samples as float in [-1, 1].

sqlite: Option<Arc<SqliteOpen>>

A SQLite table opened in place, carried from the scan to the dataset.

opened: Option<Arc<Opened>>

What the reader found besides the frame: a window read straight from the file, its row count, its Info panel tab, other tables and notes. Found by the scan and carried to the dataset as left_out is. None for a reader with nothing to add.

delimited: Option<Arc<DelimitedRead>>

The delimited spec the file is read through, once chosen: its dialect is in these options, and the read’s units and metadata ride with it to the dataset.

read_mode: Option<ReadMode>

How the scan found the data is read: lazily, through a copy, or into memory. Found by the scan and carried to the dataset for the Info panel’s Read: line.

format_guessed: bool

The format was guessed from the first bytes of text no format’s signature claims, rather than named, so a note can say how to read it otherwise.

read_notes: Vec<Note>

What the read of several files found to say of them, for the dataset’s notes. Found by the scan and carried to the dataset as left_out is.

typing: Typing

The columns the read gave a type and the frame before, carried to the dataset as left_out is, for the count of the values that did not fit.

hex: bool

--hex: show the file’s bytes in the hex view, whatever it holds.

record_size: Option<usize>

--hex-width N: the bytes a row of the hex view holds.

follow: bool

--follow: show rows as they are appended to the file, or arrive on standard input, until stopped.

tail: Option<Arc<Tail>>

Where the followed file’s complete records end, counted by the scan and carried to the dataset as left_out is, for its watcher to read on from.

spool: Option<Arc<SpoolHandle>>

Standard input still being copied to the file a follow reads.

pipe: bool

Standard input shown as it arrives without --follow: read by the follow’s watcher until it ends, the view staying where it is rather than at the end.

tee: Option<PathBuf>

--tee FILE: standard input is recorded to FILE, which is what is read.

tee_raw: bool

--tee-raw: FILE is the bytes exactly as they came, a WAV header included.

force: bool

--force: FILE may replace a file that is there.

prepared: Option<Handoff>

The dataset the home screen’s preview built and read the first page of, for this open to install rather than read again. Taken once.

download_unasked: Option<UnaskedDownload>

A file of the built-in catalog: downloaded without asking when it is small.

Implementations

impl OpenOptions

pub fn new() -> Self

impl OpenOptions

pub fn with_skip_lines(self, skip_lines: usize) -> Self

pub fn with_skip_rows(self, skip_rows: usize) -> Self

pub fn with_delimiter(self, delimiter: u8) -> Self

pub fn with_has_header(self, has_header: bool) -> Self

pub fn separator_or(&self, format_default: u8) -> u8

The separator a delimited file is read with: --delimiter when given, else the one its format implies (FileFormat::separator).

pub fn with_compression(self, compression: CompressionFormat) -> Self

pub fn header_rows(&self) -> Option<&[usize]>

The lines --header-rows named, unless the file is being read without a header (--no-header, or H), which reads them as data.

pub fn csv_try_parse_dates(&self) -> bool

When loading CSV: use Polars try_parse_dates only if parse_strings is not set. When parse_strings is set we do our own date parsing (with strict: false), so we disable Polars’ try_parse_dates to avoid “could not find an appropriate format” errors.

pub fn effective_cloud(&self, cloud: &CloudConfig) -> CloudConfig

The S3 settings every cloud path uses: the environment over the [cloud] config. run() folds this into the config the App keeps, so opening, sizing, downloading, discovery and listing all see one answer and a bucket that is listed is reached the way it will be opened. The environment is read here, not when the options are built, so a caller that starts from OpenOptions::default() — the Python bindings do — still honours it.

impl OpenOptions

pub fn from_args_and_config(args: &Args, config: &AppConfig) -> Self

The options the command line and the config give an open. The config has had -c laid over it; a flag here beats both.

Trait Implementations

impl Clone for OpenOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for OpenOptions

fn default() -> Self

Returns the “default value” for a type.

impl From<&Args> for OpenOptions

fn from(args: &Args) -> Self

Converts to this type from the input type.