Struct LeRobotDatasetInfo

pub struct LeRobotDatasetInfo {

    pub robot_type: String,
    pub codebase_version: String,
    pub total_episodes: usize,
    pub total_frames: usize,
    pub total_tasks: usize,
    pub total_videos: usize,
    pub total_chunks: usize,
    pub chunks_size: usize,
    pub data_path: String,
    pub video_path: Option<String>,
    pub image_path: Option<String>,
    pub fps: usize,
    pub features: HashMap<String, Feature>,
}

LeRobot dataset metadata.

This struct contains the metadata for a LeRobot dataset, and is loaded from the meta/info.json file of the dataset.

Fields

robot_type: String

The type of the robot.

codebase_version: String

The version of the LeRobot codebase the dataset was created for.

total_episodes: usize

The total number of unique episodes in the dataset.

total_frames: usize

The total number of unique frames in the dataset.

total_tasks: usize

The total number of unique tasks in the dataset.

total_videos: usize

The total amount of videos in the dataset.

total_chunks: usize

The total number of unique chunks in the dataset.

chunks_size: usize

The amount of episodes per chunk.

This is used to determine the path to video and data files.

data_path: String

The path template for accessing episode data files.

video_path: Option<String>

The path template for accessing video files for an episode.

image_path: Option<String>

The path template for accessing image files for an episode.

fps: usize

The frame rate of the recorded episode data.

features: HashMap<String, Feature>

A mapping of feature names to their respective Feature definitions.

Implementations

impl LeRobotDatasetInfo

pub fn load_from_json_file( filepath: impl AsRef<Path>, ) -> Result<Self, LeRobotError>

Loads LeRobotDatasetInfo from a JSON file.

The LeRobot dataset info file is typically stored under meta/info.json.

pub fn feature(&self, feature_key: &str) -> Option<&Feature>

Retrieve the metadata for a specific feature.

pub fn chunk_index(&self, episode: EpisodeIndex) -> Result<usize, LeRobotError>

Computes the storage chunk index for a given episode.

Episodes are organized into chunks to optimize storage and retrieval. This method determines which chunk a specific episode belongs to based on the dataset’s chunk size.

pub fn episode_data_path( &self, episode: EpisodeIndex, ) -> Result<PathBuf, LeRobotError>

Generates the file path for a given episode’s Parquet data.

pub fn video_path( &self, feature_key: &str, episode: EpisodeIndex, ) -> Result<PathBuf, LeRobotError>

Generates the file path for a video observation of a given episode.

Trait Implementations

impl Clone for LeRobotDatasetInfo

fn clone(&self) -> LeRobotDatasetInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LeRobotDatasetInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LeRobotDatasetInfo

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for LeRobotDatasetInfo

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

where __S: Serializer,

Serialize this value into the given Serde serializer.