Struct Holds 

pub struct Holds {
    pub formats: Vec<(String, usize)>,
    pub directories: usize,
    pub partitions: usize,
    pub not_read: usize,
    pub unnamed: usize,
    pub skipped: usize,
    pub skipped_names: Vec<String>,
    pub truncated: bool,
    pub dataset_dict: bool,
}

What one listing of a directory found in it, counted rather than judged.

The label a directory’s row carries comes from here, so it says what is inside rather than what Enter will do with it. A count that is wrong then costs a reader nothing: 12 parquet is true of a directory whether or not its files are one table.

Fields

formats: Vec<(String, usize)>

Data files by format, commonest first. The name is crate::FileFormat::name, kept as a string so a record written by one build reads in the next.

directories: usize

Subdirectories, partitions among them. Development builds of 0.4.0 wrote it as folders; the alias keeps a cache from one of those readable.

partitions: usize

key=value subdirectories, which are also counted in directories.

not_read: usize

Files datui has no reader for: a README, a script, a notebook. Neither data nor a writer’s own, and without a count of their own they were in nothing — a directory of twenty of them read dir with no line at all, the same as an empty one.

unnamed: usize

Files with no extension. No name says what they are, so they are neither data nor not_read: Spark and GBIF write their part files this way, and the open reads them by their bytes.

skipped: usize

Entries skipped as a writer’s own, and the first few by name for the pane.

skipped_names: Vec<String>

truncated: bool

Whether the listing stopped at MAX_ENTRIES_PER_DIR, so every count is a floor. Shown as 5000+.

dataset_dict: bool

A Hugging Face DatasetDict saved with save_to_disk: dataset_dict.json beside directories, its splits. Read as Arrow, one split at a time.

Implementations

impl Holds

pub fn data_files(&self) -> usize

Data files of every format.

pub fn one_format(&self) -> Option<&str>

The one format this directory holds, when it holds exactly one.

pub fn model_weights(&self) -> Option<(&str, usize)>

The weights’ format and file count, when this directory is a model: weights of one format with nothing beside them but JSON. See [is_model_directory].

pub fn label(&self) -> String

The label a directory’s row carries when its kind does not name itself: 12 parquet, mixed, or dir for a directory with no data directly inside.

pub fn is_empty(&self) -> bool

Whether nothing has been counted here: a file, or a directory nothing has looked into. A directory that was looked into and found empty is not this — it has no formats either, and dir is the right word for both.

pub fn line(&self, with_partitions: bool) -> Option<String>

The contains line in the details pane: the data files by format, the directories, and the partitions — what there is to open, and nothing else.

Files datui cannot read and a writer’s markers are left out. Counted here they read as a warning (“10 not read”) about a directory with nothing wrong in it; inside the directory, a row of its own says what is not shown.

Trait Implementations

impl Clone for Holds

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Holds

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Holds

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Holds

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Holds

impl PartialEq for Holds

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Holds

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Holds