Rico.py

import abc
import json
import math
import pathlib
import re
from collections import defaultdict
from dataclasses import asdict, dataclass
from typing import Any, Dict, List, Optional, Tuple, TypedDict

import datasets as ds
import numpy as np
import pandas as pd
from datasets.utils.logging import get_logger
from PIL import Image
from PIL.Image import Image as PilImage

logger = get_logger(__name__)

JsonDict = Dict[str, Any]

_DESCRIPTION = """
THE DATASET: We mined over 9.3k free Android apps from 27 categories to create the Rico dataset. Apps in the dataset had an average user rating of 4.1. The Rico dataset contains visual, textual, structural, and interactive design properties of more than 66k unique UI screens and 3M UI elements.
"""

_CITATION = """\
@inproceedings{deka2017rico,
  title={Rico: A mobile app dataset for building data-driven design applications},
  author={Deka, Biplab and Huang, Zifeng and Franzen, Chad and Hibschman, Joshua and Afergan, Daniel and Li, Yang and Nichols, Jeffrey and Kumar, Ranjitha},
  booktitle={Proceedings of the 30th annual ACM symposium on user interface software and technology},
  pages={845--854},
  year={2017}
}
"""

_HOMEPAGE = "http://www.interactionmining.org/rico.html"

_LICENSE = "Unknown"


def to_snake_case(name):
    name = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", name)
    name = re.sub("__([A-Z])", r"_\1", name)
    name = re.sub("([a-z0-9])([A-Z])", r"\1_\2", name)
    return name.lower()


class TrainValidationTestSplit(TypedDict):
    train: List[Any]
    validation: List[Any]
    test: List[Any]


class UiLayoutVectorSample(TypedDict):
    vector: np.ndarray
    name: str


@dataclass(eq=True)
class RicoProcessor(object, metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def get_features(self) -> ds.Features:
        raise NotImplementedError

    @abc.abstractmethod
    def load_examples(self, *args, **kwargs) -> List[Any]:
        raise NotImplementedError

    @abc.abstractmethod
    def split_generators(self, *args, **kwargs) -> List[ds.SplitGenerator]:
        raise NotImplementedError

    @abc.abstractmethod
    def generate_examples(self, examples: List[Any]):
        raise NotImplementedError


class RicoTaskProcessor(RicoProcessor, metaclass=abc.ABCMeta):
    def _flatten_children(
        self,
        children,
        children_id: Optional[int] = None,
        result: Optional[Dict[str, Any]] = None,
    ):
        result = result or defaultdict(list)
        if children is None:
            return result

        children_id = children_id or 0

        for child in children:
            if not child:
                continue

            if "children" not in child:
                continue

            result = self._flatten_children(
                children=child.pop("children"),
                children_id=children_id + 1,
                result=result,
            )
            assert result is not None
            result[f"children_{children_id}"].append(child)

        return result

    def _load_image(self, file_path: pathlib.Path) -> PilImage:
        logger.debug(f"Load from {file_path}")
        return Image.open(file_path)

    def _load_json(self, file_path: pathlib.Path) -> JsonDict:
        logger.debug(f"Load from {file_path}")
        with file_path.open("r") as rf:
            json_dict = json.load(rf)
        return json_dict

    def _split_dataset(
        self,
        examples: List[Any],
        train_ratio: float,
        validation_ratio: float,
        test_ratio: float,
    ) -> TrainValidationTestSplit:
        assert train_ratio + validation_ratio + test_ratio == 1.0
        num_examples = len(examples)

        num_tng = math.ceil(num_examples * train_ratio)  # type: ignore
        num_val = math.ceil(num_examples * validation_ratio)  # type: ignore
        num_tst = math.ceil(num_examples * test_ratio)  # type: ignore

        tng_examples = examples[:num_tng]
        val_examples = examples[num_tng : num_tng + num_val]
        tst_examples = examples[num_tng + num_val : num_tng + num_val + num_tst]
        assert len(tng_examples) + len(val_examples) + len(tst_examples) == num_examples

        return {
            "train": tng_examples,
            "validation": val_examples,
            "test": tst_examples,
        }

    def _load_and_split_dataset(
        self,
        base_dir: pathlib.Path,
        train_ratio: float,
        validation_ratio: float,
        test_ratio: float,
    ) -> TrainValidationTestSplit:
        examples = self.load_examples(base_dir)
        return self._split_dataset(
            examples=examples,
            train_ratio=train_ratio,
            validation_ratio=validation_ratio,
            test_ratio=test_ratio,
        )

    def split_generators(
        self,
        base_dir: pathlib.Path,
        train_ratio: float,
        validation_ratio: float,
        test_ratio: float,
    ) -> List[ds.SplitGenerator]:
        split_examples = self._load_and_split_dataset(
            base_dir=pathlib.Path(base_dir),
            train_ratio=train_ratio,
            validation_ratio=validation_ratio,
            test_ratio=test_ratio,
        )

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,  # type: ignore
                gen_kwargs={"examples": split_examples["train"]},
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,  # type: ignore
                gen_kwargs={"examples": split_examples["validation"]},
            ),
            ds.SplitGenerator(
                name=ds.Split.TEST,  # type: ignore
                gen_kwargs={"examples": split_examples["test"]},
            ),
        ]

    @abc.abstractmethod
    def load_examples(self, base_dir: pathlib.Path) -> List[Any]:
        raise NotImplementedError


class RicoMetadataProcessor(RicoProcessor, metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def load_examples(self, csv_file: pathlib.Path) -> List[Any]:
        raise NotImplementedError

    @abc.abstractmethod
    def split_generators(self, csv_file: pathlib.Path) -> List[ds.SplitGenerator]:
        raise NotImplementedError


@dataclass
class ActivityClass(object):
    abs_pos: bool
    adapter_view: bool
    ancestors: List[str]
    bounds: Tuple[int, int, int, int]
    clickable: bool
    content_desc: List[str]
    draw: bool
    enabled: bool
    focused: bool
    focusable: bool
    klass: str
    long_clickable: bool
    pressed: bool
    pointer: str
    scrollable_horizontal: bool
    scrollable_vertical: bool
    selected: bool
    visibility: str
    visible_to_user: bool

    package: Optional[str] = None
    resource_id: Optional[str] = None
    rel_bounds: Optional[Tuple[int, int, int, int]] = None

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "ActivityClass":
        json_dict = {k.replace("-", "_"): v for k, v in json_dict.items()}
        json_dict["klass"] = json_dict.pop("class")
        return cls(**json_dict)


@dataclass
class UiComponent(object):
    ancestors: List[str]
    bounds: Tuple[int, int, int, int]
    component_label: str
    clickable: bool
    klass: str

    icon_class: Optional[str] = None
    resource_id: Optional[str] = None

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "UiComponent":
        json_dict = {
            to_snake_case(k.replace("-", "_")): v for k, v in json_dict.items()
        }
        json_dict["klass"] = json_dict.pop("class")
        return cls(**json_dict)


@dataclass
class Activity(object):
    root: ActivityClass
    children: List[List[ActivityClass]]
    added_fragments: List[str]
    active_fragments: List[str]

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "Activity":
        root = ActivityClass.from_dict(json_dict.pop("root"))
        children = [
            [
                ActivityClass.from_dict(activity_class)
                for activity_class in activity_classes
            ]
            for activity_classes in json_dict.pop("children")
        ]
        return cls(root=root, children=children, **json_dict)


@dataclass
class InteractionTracesData(object):
    activity_name: str
    activity: Activity
    is_keyboard_deployed: str
    request_id: str

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "InteractionTracesData":
        activity_dict = json_dict.pop("activity")
        activity = Activity.from_dict(activity_dict)
        return cls(activity=activity, **json_dict)


@dataclass
class UiScreenshotsAndViewHierarchiesData(InteractionTracesData):
    screenshot: PilImage

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "UiScreenshotsAndViewHierarchiesData":
        activity_dict = json_dict.pop("activity")
        activity = Activity.from_dict(activity_dict)
        return cls(activity=activity, **json_dict)


@dataclass
class UiScreenshotsAndHierarchiesWithSemanticAnnotationsData(object):
    ancestors: List[str]
    klass: str
    bounds: Tuple[int, int, int, int]
    clickable: bool
    children: List[List[UiComponent]]
    screenshot: PilImage

    @classmethod
    def from_dict(
        cls, json_dict: JsonDict
    ) -> "UiScreenshotsAndHierarchiesWithSemanticAnnotationsData":
        json_dict["klass"] = json_dict.pop("class")
        children = [
            [UiComponent.from_dict(ui_component) for ui_component in ui_components]
            for ui_components in json_dict.pop("children")
        ]
        return cls(children=children, **json_dict)


@dataclass
class Gesture(object):
    ui_id: int
    xy: List[Tuple[float, float]]

    @classmethod
    def from_dict_to_gestures(cls, json_dict: JsonDict) -> List["Gesture"]:
        return [Gesture(ui_id=int(k), xy=v) for k, v in json_dict.items()]


class InteractionTracesProcessor(RicoTaskProcessor):
    def get_activity_class_features_dict(self):
        return {
            "abs_pos": ds.Value("bool"),
            "adapter_view": ds.Value("bool"),
            "ancestors": ds.Sequence(ds.Value("string")),
            "bounds": ds.Sequence(ds.Value("int64")),
            "clickable": ds.Value("bool"),
            "content_desc": ds.Sequence(ds.Value("string")),
            "draw": ds.Value("bool"),
            "enabled": ds.Value("bool"),
            "focusable": ds.Value("bool"),
            "focused": ds.Value("bool"),
            "klass": ds.Value("string"),
            "long_clickable": ds.Value("bool"),
            "package": ds.Value("string"),
            "pressed": ds.Value("string"),
            "pointer": ds.Value("string"),
            "rel_bounds": ds.Sequence(ds.Value("int64")),
            "resource_id": ds.Value("string"),
            "scrollable_horizontal": ds.Value("bool"),
            "scrollable_vertical": ds.Value("bool"),
            "selected": ds.Value("bool"),
            "visibility": ds.Value("string"),
            "visible_to_user": ds.Value("bool"),
        }

    def get_activity_features_dict(self, activity_class):
        return {
            "activity_name": ds.Value("string"),
            "activity": {
                "root": activity_class,
                "children": ds.Sequence(ds.Sequence(activity_class)),
                "added_fragments": ds.Sequence(ds.Value("string")),
                "active_fragments": ds.Sequence(ds.Value("string")),
            },
            "is_keyboard_deployed": ds.Value("bool"),
            "request_id": ds.Value("string"),
        }

    def get_features(self) -> ds.Features:
        activity_class = self.get_activity_class_features_dict()
        activity = self.get_activity_features_dict(activity_class)
        return ds.Features(
            {
                "screenshots": ds.Sequence(ds.Image()),
                "view_hierarchies": ds.Sequence(activity),
                "gestures": ds.Sequence(
                    {
                        "ui_id": ds.Value("int32"),
                        "xy": ds.Sequence(ds.Sequence(ds.Value("float32"))),
                    }
                ),
            }
        )

    def load_examples(self, base_dir: pathlib.Path) -> List[pathlib.Path]:
        task_dir = base_dir / "filtered_traces"
        return [d for d in task_dir.iterdir() if d.is_dir()]

    def generate_examples(self, examples: List[pathlib.Path]):
        idx = 0
        for trace_base_dir in examples:
            for trace_dir in trace_base_dir.iterdir():
                screenshots_dir = trace_dir / "screenshots"
                screenshots = [
                    self._load_image(f)
                    for f in screenshots_dir.iterdir()
                    if not f.name.startswith("._")
                ]

                view_hierarchies_dir = trace_dir / "view_hierarchies"
                view_hierarchies_json_files = [
                    f
                    for f in view_hierarchies_dir.iterdir()
                    if f.suffix == ".json" and not f.name.startswith("._")
                ]
                view_hierarchies_jsons = []
                for json_file in view_hierarchies_json_files:
                    json_dict = self._load_json(json_file)
                    if json_dict is None:
                        logger.warning(f"Invalid json file: {json_file}")
                        continue

                    children = self._flatten_children(
                        children=json_dict["activity"]["root"].pop("children")
                    )

                    json_dict["activity"]["children"] = [v for v in children.values()]
                    data = InteractionTracesData.from_dict(json_dict)
                    view_hierarchies_jsons.append(asdict(data))

                gestures_json = trace_dir / "gestures.json"
                with gestures_json.open("r") as rf:
                    gestures_dict = json.load(rf)
                gestures = Gesture.from_dict_to_gestures(gestures_dict)

                example = {
                    "screenshots": screenshots,
                    "view_hierarchies": view_hierarchies_jsons,
                    "gestures": [asdict(gesture) for gesture in gestures],
                }
                yield idx, example
                idx += 1


class UiScreenshotsAndViewHierarchiesProcessor(InteractionTracesProcessor):
    def get_features(self) -> ds.Features:
        activity_class = self.get_activity_class_features_dict()
        activity = {
            "screenshot": ds.Image(),
            **self.get_activity_features_dict(activity_class),
        }
        return ds.Features(activity)

    def load_examples(self, base_dir: pathlib.Path) -> List[Any]:
        task_dir = base_dir / "combined"
        json_files = [f for f in task_dir.iterdir() if f.suffix == ".json"]
        return json_files

    def generate_examples(self, examples: List[pathlib.Path]):
        for i, json_file in enumerate(examples):
            with json_file.open("r") as rf:
                json_dict = json.load(rf)
                children = self._flatten_children(
                    children=json_dict["activity"]["root"].pop("children")
                )
                json_dict["activity"]["children"] = [v for v in children.values()]
                json_dict["screenshot"] = self._load_image(
                    json_file.parent / f"{json_file.stem}.jpg"
                )
                data = UiScreenshotsAndViewHierarchiesData.from_dict(json_dict)
                example = asdict(data)
                yield i, example


class UiLayoutVectorsProcessor(RicoTaskProcessor):
    def get_features(self) -> ds.Features:
        return ds.Features(
            {"vector": ds.Sequence(ds.Value("float32")), "name": ds.Value("string")}
        )

    def _load_ui_vectors(self, file_path: pathlib.Path) -> np.ndarray:
        logger.debug(f"Load from {file_path}")
        ui_vectors = np.load(file_path)
        assert ui_vectors.shape[1] == 64
        return ui_vectors

    def _load_ui_names(self, file_path: pathlib.Path) -> List[str]:
        with file_path.open("r") as rf:
            json_dict = json.load(rf)
        return json_dict["ui_names"]

    def load_examples(self, base_dir: pathlib.Path) -> List[UiLayoutVectorSample]:
        task_dir = base_dir / "ui_layout_vectors"
        ui_vectors = self._load_ui_vectors(file_path=task_dir / "ui_vectors.npy")
        ui_names = self._load_ui_names(file_path=task_dir / "ui_names.json")
        assert len(ui_vectors) == len(ui_names)

        return [
            {"vector": vector, "name": name}
            for vector, name in zip(ui_vectors, ui_names)
        ]

    def generate_examples(self, examples: List[UiLayoutVectorSample]):
        for i, sample in enumerate(examples):
            sample["vector"] = sample["vector"].tolist()
            yield i, sample


class AnimationsProcessor(RicoTaskProcessor):
    def get_features(self) -> ds.Features:
        raise NotImplementedError

    def load_examples(self, base_dir: pathlib.Path) -> List[Any]:
        raise NotImplementedError

    def generate_examples(self, examples: List[Any]):
        raise NotImplementedError


class UiScreenshotsAndHierarchiesWithSemanticAnnotationsProcessor(RicoTaskProcessor):
    def get_features(self) -> ds.Features:
        ui_component = {
            "ancestors": ds.Sequence(ds.Value("string")),
            "bounds": ds.Sequence(ds.Value("int64")),
            "component_label": ds.ClassLabel(
                num_classes=25,
                names=[
                    "Text",
                    "Image",
                    "Icon",
                    "Text Button",
                    "List Item",
                    "Input",
                    "Background Image",
                    "Card",
                    "Web View",
                    "Radio Button",
                    "Drawer",
                    "Checkbox",
                    "Advertisement",
                    "Modal",
                    "Pager Indicator",
                    "Slider",
                    "On/Off Switch",
                    "Button Bar",
                    "Toolbar",
                    "Number Stepper",
                    "Multi-Tab",
                    "Date Picker",
                    "Map View",
                    "Video",
                    "Bottom Navigation",
                ],
            ),
            "clickable": ds.Value("bool"),
            "klass": ds.Value("string"),
            "icon_class": ds.Value("string"),
            "resource_id": ds.Value("string"),
        }
        return ds.Features(
            {
                "ancestors": ds.Sequence(ds.Value("string")),
                "klass": ds.Value("string"),
                "bounds": ds.Sequence(ds.Value("int64")),
                "clickable": ds.Value("bool"),
                "children": ds.Sequence(ds.Sequence(ui_component)),
                "screenshot": ds.Image(),
            }
        )

    def load_examples(self, base_dir: pathlib.Path) -> List[Any]:
        task_dir = base_dir / "semantic_annotations"
        json_files = [f for f in task_dir.iterdir() if f.suffix == ".json"]
        return json_files

    def generate_examples(self, examples: List[pathlib.Path]):
        for i, json_file in enumerate(examples):
            with json_file.open("r") as rf:
                json_dict = json.load(rf)

                children = self._flatten_children(children=json_dict.pop("children"))
                json_dict["children"] = [v for v in children.values()]
                json_dict["screenshot"] = self._load_image(
                    json_file.parent / f"{json_file.stem}.png"
                )
                data = UiScreenshotsAndHierarchiesWithSemanticAnnotationsData.from_dict(
                    json_dict
                )
                yield i, asdict(data)


class UiMetadataProcessor(RicoMetadataProcessor):
    def get_features(self) -> ds.Features:
        return ds.Features(
            {
                "ui_number": ds.Value("int32"),
                "app_package_name": ds.Value("string"),
                "interaction_trace_number": ds.Value("string"),
                "ui_number_in_trace": ds.Value("string"),
            }
        )

    def load_examples(self, csv_file: pathlib.Path) -> List[Any]:
        df = pd.read_csv(csv_file)  # 66261 col
        df.columns = ["_".join(col.split()) for col in df.columns.str.lower()]
        return df.to_dict(orient="records")

    def split_generators(
        self, csv_file: pathlib.Path, **kwargs
    ) -> List[ds.SplitGenerator]:
        metadata = self.load_examples(csv_file)
        return [ds.SplitGenerator(name="metadata", gen_kwargs={"examples": metadata})]

    def generate_examples(self, examples: List[Any]):
        for i, metadata in enumerate(examples):
            yield i, metadata


class PlayStoreMetadataProcessor(RicoMetadataProcessor):
    def get_features(self) -> ds.Features:
        return ds.Features(
            {
                "app_package_name": ds.Value("string"),
                "play_store_name": ds.Value("string"),
                "category": ds.ClassLabel(
                    num_classes=27,
                    names=[
                        "Books & Reference",
                        "Comics",
                        "Health & Fitness",
                        "Social",
                        "Entertainment",
                        "Weather",
                        "Communication",
                        "Sports",
                        "News & Magazines",
                        "Finance",
                        "Shopping",
                        "Education",
                        "Travel & Local",
                        "Business",
                        "Medical",
                        "Beauty",
                        "Food & Drink",
                        "Dating",
                        "Auto & Vehicles",
                        "Music & Audio",
                        "House & Home",
                        "Maps & Navigation",
                        "Lifestyle",
                        "Art & Design",
                        "Parenting",
                        "Events",
                        "Video Players & Editors",
                    ],
                ),
                "average_rating": ds.Value("float32"),
                "number_of_ratings": ds.Value("int32"),
                "number_of_downloads": ds.ClassLabel(
                    num_classes=15,
                    names=[
                        "100,000 - 500,000",
                        "10,000 - 50,000",
                        "50,000,000 - 100,000,000",
                        "50,000 - 100,000",
                        "1,000,000 - 5,000,000",
                        "5,000,000 - 10,000,000",
                        "500,000 - 1,000,000",
                        "1,000 - 5,000",
                        "10,000,000 - 50,000,000",
                        "5,000 - 10,000",
                        "100,000,000 - 500,000,000",
                        "500,000,000 - 1,000,000,000",
                        "500 - 1,000",
                        "1,000,000,000 - 5,000,000,000",
                        "100 - 500",
                    ],
                ),
                "date_updated": ds.Value("string"),
                "icon_url": ds.Value("string"),
            }
        )

    def cleanup_metadata(self, df: pd.DataFrame) -> pd.DataFrame:
        df = df.assign(
            number_of_downloads=df["number_of_downloads"].str.strip(),
            number_of_ratings=df["number_of_ratings"]
            .str.replace('"', "")
            .str.strip()
            .astype(int),
        )

        def remove_noisy_data(df: pd.DataFrame) -> pd.DataFrame:
            old_num = len(df)
            df = df[
                (df["category"] != "000 - 1")
                | (df["number_of_downloads"] != "January 10, 2015")
            ]
            new_num = len(df)
            assert new_num == old_num - 1
            return df

        df = remove_noisy_data(df)

        return df

    def load_examples(self, csv_file: pathlib.Path) -> List[Any]:
        df = pd.read_csv(csv_file)
        df.columns = ["_".join(col.split()) for col in df.columns.str.lower()]
        df = self.cleanup_metadata(df)
        return df.to_dict(orient="records")

    def split_generators(
        self, csv_file: pathlib.Path, **kwargs
    ) -> List[ds.SplitGenerator]:
        metadata = self.load_examples(csv_file)
        return [ds.SplitGenerator(name="metadata", gen_kwargs={"examples": metadata})]

    def generate_examples(self, examples: List[Any]):
        for i, metadata in enumerate(examples):
            yield i, metadata


@dataclass
class RicoConfig(ds.BuilderConfig):
    train_ratio: float = 0.85
    validation_ratio: float = 0.05
    test_ratio: float = 0.10
    random_state: int = 0
    data_url: Optional[str] = None
    processor: Optional[RicoProcessor] = None

    def __post_init__(self):
        assert self.data_url is not None
        assert self.processor is not None
        assert self.train_ratio + self.validation_ratio + self.test_ratio == 1.0


class RicoDataset(ds.GeneratorBasedBuilder):
    VERSION = ds.Version("1.0.0")
    BUILDER_CONFIGS = [
        RicoConfig(
            name="ui-screenshots-and-view-hierarchies",
            version=VERSION,
            description="Contains 66k+ unique UI screens",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/unique_uis.tar.gz",
            processor=UiScreenshotsAndViewHierarchiesProcessor(),
        ),
        RicoConfig(
            name="ui-layout-vectors",
            version=VERSION,
            description="Contains 64-dimensional vector representations for each UI screen that encode layout based on the distribution of text and images.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/ui_layout_vectors.zip",
            processor=UiLayoutVectorsProcessor(),
        ),
        RicoConfig(
            name="interaction-traces",
            version=VERSION,
            description="Contains user interaction traces organized by app.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/traces.tar.gz",
            processor=InteractionTracesProcessor(),
        ),
        RicoConfig(
            name="animations",
            version=VERSION,
            description="Contains GIFs that demonstrate how screens animated in response to a user interaction; follows the same folder structure introduced for interaction traces.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/animations.tar.gz",
            processor=AnimationsProcessor(),
        ),
        RicoConfig(
            name="ui-screenshots-and-hierarchies-with-semantic-annotations",
            version=VERSION,
            description="Contains 66k+ UI screens and hierarchies augmented with semantic annotations that describe what elements on the screen mean and how they are used.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/semantic_annotations.zip",
            processor=UiScreenshotsAndHierarchiesWithSemanticAnnotationsProcessor(),
        ),
        RicoConfig(
            name="ui-metadata",
            version=VERSION,
            description="Contains metadata about each UI screen: the name of the app it came from, the user interaction trace within that app.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/ui_details.csv",
            processor=UiMetadataProcessor(),
        ),
        RicoConfig(
            name="play-store-metadata",
            version=VERSION,
            description="Contains metadata about the apps in the dataset including an app’s category, average rating, number of ratings, and number of downloads.",
            data_url="https://storage.googleapis.com/crowdstf-rico-uiuc-4540/rico_dataset_v0.1/app_details.csv",
            processor=PlayStoreMetadataProcessor(),
        ),
    ]

    def _info(self) -> ds.DatasetInfo:
        processor: RicoProcessor = self.config.processor
        return ds.DatasetInfo(
            description=_DESCRIPTION,
            citation=_CITATION,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            features=processor.get_features(),
        )

    def _split_generators(self, dl_manager: ds.DownloadManager):
        config: RicoConfig = self.config
        assert config.processor is not None
        processor: RicoProcessor = config.processor

        return processor.split_generators(
            dl_manager.download_and_extract(self.config.data_url),
            train_ratio=config.train_ratio,
            validation_ratio=config.validation_ratio,
            test_ratio=config.test_ratio,
        )

    def _generate_examples(self, **kwargs):
        config: RicoConfig = self.config
        assert config.processor is not None
        processor: RicoProcessor = config.processor
        yield from processor.generate_examples(**kwargs)