Enum AppEvent 

pub enum AppEvent {
    Key(KeyEvent),
    Press(KeyEvent),
    Terminal(Event),
    Wake,
    TerminalBackground(ThemeMode),
    TerminalFocused,
    SettingsRead(Box<Result<Settings>>),
    OpenNamed(Vec<PathBuf>, OpenOptions),
    NamedPathMissing(PathBuf),
    Open(Vec<PathBuf>, OpenOptions),
    OpenLazyFrame(Box<LazyFrame>, OpenOptions),
    HomeListingReady {
        generation: u64,
        listing: Box<Listing>,
        known: HashMap<PathBuf, DatasetFacts>,
        visits: HashMap<PathBuf, Visits>,
        newest: Option<PathBuf>,
        folds: Option<HashMap<String, bool>>,
    },
    HomeListingFailed,
    HomePathListed {
        listing: Box<PathListing>,
    },
    HomePathCompleted {
        generation: u64,
        typed: String,
        completed: String,
        candidates: usize,
    },
    HomePreviewReady {
        path: PathBuf,
        stamp: Stamp,
        read_at: Option<Stamp>,
        rows: Option<Arc<PreviewRows>>,
        prepared: Handoff,
    },
    HomeSchemaReady {
        generation: u64,
        path: PathBuf,
        preview: Option<SchemaPreview>,
    },
    HomeMeasured {
        measured: Vec<(PathBuf, Measured)>,
        done: bool,
    },
    HomeSized {
        path: PathBuf,
        measured: Measured,
    },
    HomeWebGone {
        path: PathBuf,
        gone: HttpGone,
    },
    HomeClassified {
        measured: Vec<(PathBuf, Measured)>,
        done: bool,
    },
    HomeSearchBatch {
        generation: u64,
        root: PathBuf,
        found: Vec<Entry>,
        scanned: usize,
    },
    HomeSearchScored {
        epoch: u64,
        matches: Option<Box<Matches>>,
    },
    HomeSearchDone {
        generation: u64,
        root: PathBuf,
        scanned: usize,
        limited: Option<String>,
    },
    HomeCloudSources {
        sources: Vec<CloudSource>,
    },
    HomeCloudListed {
        id: String,
        buckets: Vec<PathBuf>,
        details: Vec<(PathBuf, Vec<(String, String)>)>,
        failure: Option<(String, String)>,
        listed_at: SystemTime,
    },
    HomeProbeReady {
        root: PathBuf,
        rows: Option<Vec<Entry>>,
        cut_short: bool,
    },
    HomeProbeProgress {
        root: PathBuf,
        rows: Vec<Entry>,
    },
    HomeCloudKinds {
        kinds: Vec<(PathBuf, (EntryKind, Holds))>,
        failed: Vec<PathBuf>,
    },
    HomeProbeCancelled {
        root: PathBuf,
    },
    HomeNarrowed {
        dir: PathBuf,
        prefix: String,
        listed: Option<(Vec<Entry>, bool)>,
    },
    HomeProbeFailed {
        root: PathBuf,
        message: String,
    },
    DoExport(ExportRequest),
    Followed(News),
    FollowedDetail {
        dataset_generation: u64,
        detail: Box<Detail>,
    },
    Exit,
    Crash(String),
    QQuery(String),
    SqlQuery(String),
    Filter(Vec<FilterStatement>),
    Sort(Vec<String>, Vec<bool>),
    ColumnOrder(Vec<String>, usize),
    Pivot(PivotSpec),
    Melt(MeltSpec),
    Export(ExportRequest),
    CopyTable {
        format: CopyFormat,
        header: bool,
    },
    ChartExport(ChartExportRequest),
    OpenLink(String),
    DoChartExport(ChartExportRequest),
    Collect,
    Update,
    Reset,
    Resize(u16, u16),
    DoScrollDown,
    DoScrollUp,
    DoScrollNext,
    DoScrollPrev,
    DoScrollEnd,
    DoScrollHome,
    DoScrollHalfDown,
    DoScrollHalfUp,
    GoToLine(usize),
    AnalysisChunk,
    AnalysisDistributionCompute,
    AnalysisCorrelationCompute,
    AnalysisDataQualityCompute,
    BackgroundQualitySampleKept {
        kept: KeptQualitySample,
    },
    BackgroundQualityCopyKept {
        dataset_generation: u64,
        copy: Option<Arc<LocalCopy>>,
    },
    BackgroundLenReady {
        len_generation: u64,
        num_rows: usize,
        file_row_groups: Option<Vec<Vec<usize>>>,
    },
    BackgroundLenFailed {
        len_generation: u64,
    },
    FramePainted,
    BackgroundFootersJoined {
        generation: u64,
    },
    LinesIndexed {
        generation: u64,
        rows: usize,
    },
    BackgroundChartReady,
    QualityReportExport(PathBuf, ReportFormat, Overwrite),
    LookThenOpenDirectory(PathBuf, OpenOptions),
    ClassifyThenOpen {
        path: PathBuf,
        jump: bool,
    },
    JobEnded(Ticket),
    JobProgress {
        ticket: Ticket,
        progress: Progress,
    },
}

Variants

Key(KeyEvent)

Press(KeyEvent)

A key to take as if typed: what Enter on a help line presses. The event pump offers it as the next typed key, through classify, so it is held, converted or dropped as a typed key would be; outside the pump it is a Key.

Terminal(Event)

Read from the terminal by terminal_input::TerminalInput: a key press or a resize. event_pump::EventPump takes it off the channel and decides what a key does while the app is busy; the app itself only ever sees Key/Resize.

Wake

Something polled rather than sent changed (a background panic, a Polars warning): the loop should look. Handled as nothing.

TerminalBackground(ThemeMode)

The terminal said what its background is (an OSC 11 reply, taken off the input stream by terminal_input). Under theme.mode = "auto" the palette follows.

TerminalFocused

The terminal window came back into focus: under auto the background is asked again, since the scheme may have changed while it was away.

SettingsRead(Box<Result<Settings>>)

The settings run reads on a worker before it can build the app. Never reaches the app: run waits for it before there is one.

OpenNamed(Vec<PathBuf>, OpenOptions)

The paths named on the command line or by the Python binding: whether each is there and whether one is a directory is asked on a worker (JobKind::OpenNamed), a local-looking path being no promise of a fast mount.

NamedPathMissing(PathBuf)

A path named on the command line is not there: the session ends as a missing file always has. The continuation of the look’s answer.

Open(Vec<PathBuf>, OpenOptions)

Open these paths. Its phases are the loading controller’s: each worker’s answer starts the next, and the dataset is installed when its schema is read.

OpenLazyFrame(Box<LazyFrame>, OpenOptions)

Open with an existing LazyFrame (e.g. from Python binding); no file load.

HomeListingReady

A home listing built off-thread is ready.

Fields

generation: u64

listing: Box<Listing>

known: HashMap<PathBuf, DatasetFacts>

What earlier runs measured, read from the cache with the listing.

visits: HashMap<PathBuf, Visits>

How often and how lately each recent was opened.

newest: Option<PathBuf>

The recent opened last, where the cursor lands.

folds: Option<HashMap<String, bool>>

The saved folds, when entering the home screen asked for them.

HomeListingFailed

The worker building a home listing panicked, so no listing is coming. The panic is flashed like any other raw worker’s.

HomePathListed

The directory the ~ prompt is typing, read off-thread.

Fields

listing: Box<PathListing>

HomePathCompleted

A completed path, worked out off-thread.

Fields

generation: u64

typed: String

What was typed when completion was asked for; a later keystroke makes the answer stale.

completed: String

candidates: usize

HomePreviewReady

The first rows of the highlighted file, read off-thread the way its open reads them, and the dataset that read built, for the open to install.

Fields

path: PathBuf

stamp: Stamp

The row’s stamp when it was asked for: what the rows are kept under.

read_at: Option<Stamp>

The file’s stamp when it was read: what the dataset is installed under.

rows: Option<Arc<PreviewRows>>

prepared: Handoff

HomeSchemaReady

A schema read off-thread for the highlighted dataset.

Fields

generation: u64

path: PathBuf

preview: Option<SchemaPreview>

HomeMeasured

Measurements for rows the home screen asked about, sent as each row is read so a slow row does not hold back the ones before it. done marks the end of the batch and frees the slot for the next one.

No generation, unlike its neighbors: what a look found is keyed by path and true of that path whichever listing asked, so an answer that outlives its listing is still the answer.

Fields

measured: Vec<(PathBuf, Measured)>

done: bool

HomeSized

What a HEAD said an HTTP(S) file on home weighs: its row, measured.

Fields

path: PathBuf

measured: Measured

HomeWebGone

What a HEAD settled about an HTTP(S) file on home: it cannot be had.

Fields

path: PathBuf

gone: HttpGone

HomeClassified

What the rows on screen turned out to be. The same payload as AppEvent::HomeMeasured and folded in the same way: a kind is one of the things a look into a row produces.

Fields

measured: Vec<(PathBuf, Measured)>

done: bool

HomeSearchBatch

A batch of datasets found by the background search below the working directory. Sent repeatedly while the walk runs, so a cold tree fills in rather than arriving all at once at the end.

Fields

generation: u64

root: PathBuf

found: Vec<Entry>

scanned: usize

HomeSearchScored

The filter scored against the search’s files, for the walk epoch names.

Fields

epoch: u64

matches: Option<Box<Matches>>

None from a worker that died.

HomeSearchDone

The background search has stopped, with limited saying why if it stopped short of walking everything.

Fields

generation: u64

root: PathBuf

scanned: usize

limited: Option<String>

HomeCloudSources

The cloud sources on this machine, with whatever was listed on an earlier run. Sent before anything is fetched, so the rows are there on the first frame.

Fields

sources: Vec<CloudSource>

HomeCloudListed

One source’s buckets have been listed, or could not be. Each source reports on its own, so a slow endpoint holds up nobody else’s row.

Fields

id: String

buckets: Vec<PathBuf>

details: Vec<(PathBuf, Vec<(String, String)>)>

Lines for the details pane of each listed place that has any.

failure: Option<(String, String)>

(short, detail) when the listing failed.

listed_at: SystemTime

HomeProbeReady

A network root has been listed off-thread, or could not be.

Fields

root: PathBuf

rows: Option<Vec<Entry>>

cut_short: bool

The listing stopped at crate::discover::MAX_ENTRIES_PER_DIR.

HomeProbeProgress

The rows of a network directory read so far, while its listing goes on.

Fields

root: PathBuf

rows: Vec<Entry>

HomeCloudKinds

What peeking inside some directories of a cloud listing found: the ones that are partitioned or Parquet datasets.

Fields

kinds: Vec<(PathBuf, (EntryKind, Holds))>

failed: Vec<PathBuf>

Directories whose peek failed or was lost: not answered, so not labelled as if they were.

HomeProbeCancelled

A cloud listing stopped because its place was left. Nothing is known about the place, so it is listed again when it is entered again.

Fields

root: PathBuf

HomeNarrowed

The names under prefix in a cloud directory cut short, asked for by a filter; None when the listing failed or was stopped.

Fields

dir: PathBuf

prefix: String

listed: Option<(Vec<Entry>, bool)>

HomeProbeFailed

A cloud listing was refused, with the service’s reason.

Fields

root: PathBuf

message: String

DoExport(ExportRequest)

Run the export, from plan to committed file, once the UI has drawn its progress.

Followed(News)

A followed file’s watcher found more rows, or that the file went.

FollowedDetail

The Info tab of a piped journal, read again once it ended, for the dataset of that generation.

Fields

dataset_generation: u64

detail: Box<Detail>

Exit

Crash(String)

QQuery(String)

SqlQuery(String)

Filter(Vec<FilterStatement>)

Sort(Vec<String>, Vec<bool>)

ColumnOrder(Vec<String>, usize)

Pivot(PivotSpec)

Melt(MeltSpec)

Export(ExportRequest)

CopyTable

Collect and format the whole view off-thread for a table-scope copy.

Fields

format: CopyFormat

header: bool

ChartExport(ChartExportRequest)

OpenLink(String)

A documentation link the user confirmed, checked by link_open::checked_url: start the browser on it.

DoChartExport(ChartExportRequest)

Deferred: run the chart export once its phase is drawn.

Collect

Update

Reset

Resize(u16, u16)

DoScrollDown

DoScrollUp

DoScrollNext

DoScrollPrev

DoScrollEnd

DoScrollHome

DoScrollHalfDown

DoScrollHalfUp

GoToLine(usize)

AnalysisChunk

Run the next chunk of analysis (describe/distribution); drives per-column progress.

AnalysisDistributionCompute

Run distribution analysis (deferred so progress overlay can show first).

AnalysisCorrelationCompute

Run correlation matrix (deferred so progress overlay can show first).

AnalysisDataQualityCompute

Run the configured data-quality plan off the UI thread.

BackgroundQualitySampleKept

A Data Quality run that stopped short had already read its sample: kept, so the read it paid for is not thrown away.

Fields

kept: KeptQualitySample

BackgroundQualityCopyKept

A full scan finished copying a remote dataset’s objects locally: kept for the dataset it was fetched for, whatever becomes of the run. None when the copy did not read as the source, so later runs read the source and say why.

Fields

dataset_generation: u64

copy: Option<Arc<LocalCopy>>

BackgroundLenReady

Background task completed: exact row count for the current LazyFrame. Applied to data_table_state only if len_generation still matches (the data is unchanged). Runs concurrently with — and independently of — the first buffer paint, so the count fills in the scrollbar/total without ever blocking the initial render.

Fields

len_generation: u64

num_rows: usize

file_row_groups: Option<Vec<Vec<usize>>>

For a remote dataset of many files, the rows in each row group of each file, from their footers.

BackgroundLenFailed

Background row count failed. Clears the in-flight marker; the total stays provisional and is shown as unknown. Scrolling does not count again; End does.

Fields

len_generation: u64

FramePainted

A frame was painted. The run loop calls App::frame_painted itself; a harness that paints nothing sends this when App::count_waits_for_a_frame.

BackgroundFootersJoined

Every footer of a dataset that opened from two of them has now been read. What they say is in App::pending_footers_result; the columns they add join the dataset already on screen.

Fields

generation: u64

LinesIndexed

Every line of a text file opened from its first rows is indexed, rows of them, for the dataset of generation.

Fields

generation: u64

rows: usize

BackgroundChartReady

Background task completed: chart data for one selection is prepared. The data is in App::pending_chart_result; it belongs to App::chart_inflight, which says whether it is still wanted.

QualityReportExport(PathBuf, ReportFormat, Overwrite)

Write the Data Quality report on screen to a file, in a form. From the results in memory: nothing is read.

LookThenOpenDirectory(PathBuf, OpenOptions)

A directory named on the command line: look at it on a worker, then do with it whatever Enter on its row would do.

The look reads footers, or the front of a spread of files, which for a directory of large Parquet is seconds. It is an event rather than a call so the first frame is drawn before it starts, and the wait has the directory’s name on it, a spinner and a way out.

ClassifyThenOpen

Look at a path off the interface thread, then do with it whatever it turns out to need — browse into it, say it is a lake table, or open it.

exists, is_dir and classify_directory are all filesystem calls, and the home screen is full of paths on mounts that may not answer. Doing them where the keys are read is an uninterruptible freeze with Ctrl+C on the same thread.

Fields

path: PathBuf

jump: bool

A jump — a path typed at ~ — rather than a row that was already listed. Esc then comes back from there to the listing, not up through wherever the path happens to sit.

JobEnded(Ticket)

A background job’s outcome is in its record: [jobs::Jobs::end] takes it.

JobProgress

A report from a background job still running.

Fields

ticket: Ticket

progress: Progress

Implementations

impl AppEvent

pub fn is_progress(&self) -> bool

A report from work still going, sent many times while it runs: the run loop may fold several into one frame. Anything else is drawn as soon as it is handled.