Initialize (#1)

* [WIP] add files

* update Rico.py

* update

* update

* update

* update

* update README

* add settings for CI

* update README.md

* update README

* update

.github/workflows/ci.yaml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+    paths-ignore:
+      - "README.md"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10"]
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          pip install -U pip setuptools wheel poetry
+          poetry install
+
+      - name: Format
+        run: |
+          poetry run black --check .
+
+      - name: Lint
+        run: |
+          poetry run ruff .
+
+      - name: Type check
+        run: |
+          poetry run mypy . \
+            --ignore-missing-imports \
+            --no-strict-optional \
+            --no-site-packages \
+            --cache-dir=/dev/null
+
+      - name: Run tests
+        run: |
+          poetry run pytest --color=yes -rf

.github/workflows/push_to_hub.yaml

@@ -0,0 +1,26 @@
+name: Sync to Hugging Face Hub
+
+on:
+  workflow_run:
+    workflows:
+      - CI
+    branches:
+      - main
+    types:
+      - completed
+
+jobs:
+  push_to_hub:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Push to Huggingface hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: ${{ secrets.HF_USERNAME }}
+        run: |
+          git fetch --unshallow
+          git push --force https://${HF_USERNAME}:${HF_TOKEN}@huggingface.co/datasets/${HF_USERNAME}/Rico main

.gitignore

@@ -0,0 +1,176 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python

README.md

@@ -0,0 +1,236 @@
+---
+annotations_creators:
+- found
+language:
+- en
+language_creators:
+- found
+license:
+- unknown
+multilinguality:
+- monolingual
+pretty_name: Rico
+size_categories: []
+source_datasets:
+- original
+tags:
+- graphic design
+task_categories:
+- other
+task_ids: []
+---
+
+# Dataset Card for Rico
+
+[![CI](https://github.com/shunk031/huggingface-datasets_Rico/actions/workflows/ci.yaml/badge.svg)](https://github.com/shunk031/huggingface-datasets_Rico/actions/workflows/ci.yaml)
+
+## Table of Contents
+- [Dataset Card Creation Guide](#dataset-card-creation-guide)
+  - [Table of Contents](#table-of-contents)
+  - [Dataset Description](#dataset-description)
+    - [Dataset Summary](#dataset-summary)
+    - [Supported Tasks and Leaderboards](#supported-tasks-and-leaderboards)
+    - [Languages](#languages)
+  - [Dataset Structure](#dataset-structure)
+    - [Data Instances](#data-instances)
+    - [Data Fields](#data-fields)
+    - [Data Splits](#data-splits)
+  - [Dataset Creation](#dataset-creation)
+    - [Curation Rationale](#curation-rationale)
+    - [Source Data](#source-data)
+      - [Initial Data Collection and Normalization](#initial-data-collection-and-normalization)
+      - [Who are the source language producers?](#who-are-the-source-language-producers)
+    - [Annotations](#annotations)
+      - [Annotation process](#annotation-process)
+      - [Who are the annotators?](#who-are-the-annotators)
+    - [Personal and Sensitive Information](#personal-and-sensitive-information)
+  - [Considerations for Using the Data](#considerations-for-using-the-data)
+    - [Social Impact of Dataset](#social-impact-of-dataset)
+    - [Discussion of Biases](#discussion-of-biases)
+    - [Other Known Limitations](#other-known-limitations)
+  - [Additional Information](#additional-information)
+    - [Dataset Curators](#dataset-curators)
+    - [Licensing Information](#licensing-information)
+    - [Citation Information](#citation-information)
+    - [Contributions](#contributions)
+
+## Dataset Description
+
+- **Homepage:** http://www.interactionmining.org/rico.html
+- **Repository:** https://github.com/shunk031/huggingface-datasets_Rico
+- **Paper (UIST2017):** https://dl.acm.org/doi/10.1145/3126594.3126651
+
+### Dataset Summary
+
+Rico: A Mobile App Dataset for Building Data-Driven Design Applications
+
+### Supported Tasks and Leaderboards
+
+[More Information Needed]
+
+### Languages
+
+[More Information Needed]
+
+## Dataset Structure
+
+### Data Instances
+
+- UI screenshots and view hierarchies
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="ui-screenshots-and-view-hierarchies",
+)
+```
+
+- UI metadata
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="ui-metadata",
+)
+```
+
+- UI layout vectors
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="ui-layout-vectors",
+)
+```
+
+- Interaction traces
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="interaction-traces",
+)
+```
+
+- [WIP] Animations
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="animations",
+)
+```
+
+- Play store metadata
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="play-store-metadata",
+)
+```
+
+- UI screenshots and hierarchies with semantic annotations
+
+```python
+import datasets as ds
+
+dataset = ds.load_dataset(
+    path="shunk031/Rico",
+    name="ui-screenshots-and-hierarchies-with-semantic-annotations",
+)
+```
+
+### Data Fields
+
+[More Information Needed]
+
+### Data Splits
+
+[More Information Needed]
+
+## Dataset Creation
+
+### Curation Rationale
+
+[More Information Needed]
+
+### Source Data
+
+[More Information Needed]
+
+#### Initial Data Collection and Normalization
+
+[More Information Needed]
+
+#### Who are the source language producers?
+
+[More Information Needed]
+
+### Annotations
+
+[More Information Needed]
+
+#### Annotation process
+
+[More Information Needed]
+
+#### Who are the annotators?
+
+[More Information Needed]
+
+### Personal and Sensitive Information
+
+[More Information Needed]
+
+## Considerations for Using the Data
+
+### Social Impact of Dataset
+
+[More Information Needed]
+
+### Discussion of Biases
+
+[More Information Needed]
+
+### Other Known Limitations
+
+[More Information Needed]
+
+## Additional Information
+
+### Dataset Curators
+
+[More Information Needed]
+
+### Licensing Information
+
+[More Information Needed]
+
+### Citation Information
+
+```bibtex
+@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}
+}
+```
+
+### Contributions
+
+Thanks to [DATA DRIVEN DESIGN GROUP UNIVERSITY OF ILLINOIS AT URBANA-CHAMPAIGN](http://ranjithakumar.net/) for creating this dataset.

Rico.py

@@ -0,0 +1,810 @@
+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)

pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "huggingface-datasets-rico"
+version = "0.1.0"
+description = ""
+authors = ["Shunsuke KITADA <[email protected]>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+datasets = {extras = ["vision"], version = "^2.14.6"}
+
+
+[tool.poetry.group.dev.dependencies]
+ruff = "^0.1.1"
+black = "^23.10.1"
+mypy = "^1.6.1"
+pytest = "^7.4.2"
+types-pillow = "^10.1.0.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tests/Rico_test.py

@@ -0,0 +1,63 @@
+import os
+
+import datasets as ds
+import pytest
+
+
+@pytest.fixture
+def dataset_path() -> str:
+    return "Rico.py"
+
+
+@pytest.mark.skipif(
+    condition=bool(os.environ.get("CI", False)),
+    reason=(
+        "Because this loading script downloads a large dataset, "
+        "we will skip running it on CI."
+    ),
+)
+@pytest.mark.parametrize(
+    argnames=(
+        "dataset_task",
+        "expected_num_train",
+        "expected_num_valid",
+        "expected_num_test",
+    ),
+    argvalues=(
+        ("ui-screenshots-and-view-hierarchies", 56322, 3314, 6625),
+        ("ui-layout-vectors", 61288, 3606, 7209),
+        ("interaction-traces", 8749, 513, 1030),
+        # "animations",
+        ("ui-screenshots-and-hierarchies-with-semantic-annotations", 56322, 3314, 6625),
+    ),
+)
+def test_load_dataset(
+    dataset_path: str,
+    dataset_task: str,
+    expected_num_train: int,
+    expected_num_valid: int,
+    expected_num_test: int,
+):
+    dataset = ds.load_dataset(path=dataset_path, name=dataset_task)
+    assert dataset["train"].num_rows == expected_num_train
+    assert dataset["validation"].num_rows == expected_num_valid
+    assert dataset["test"].num_rows == expected_num_test
+
+
+@pytest.mark.skipif(
+    condition=bool(os.environ.get("CI", False)),
+    reason=(
+        "Because this loading script downloads a large dataset, "
+        "we will skip running it on CI."
+    ),
+)
+@pytest.mark.parametrize(
+    argnames=("dataset_task", "expected_num_data"),
+    argvalues=(
+        ("ui-metadata", 66261),
+        ("play-store-metadata", 9384 - 1),  # There is one invalid data
+    ),
+)
+def test_load_metadata(dataset_path: str, dataset_task: str, expected_num_data: int):
+    metadata = ds.load_dataset(path=dataset_path, name=dataset_task)
+    assert metadata["metadata"].num_rows == expected_num_data