Deploy (see actual commits on https://github.com/mlcommons/croissant).

Dockerfile

@@ -0,0 +1,23 @@
+# app/Dockerfile
+
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    git \
+    python3-pip \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY ./ /app/
+
+RUN python3 -m pip install -r requirements.txt
+
+EXPOSE 8501
+
+HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+
+ENTRYPOINT ["streamlit", "run", "app.py"]

core/data_types.py

@@ -17,3 +17,30 @@ def convert_dtype(dtype: Any):
         return mlc.DataType.TEXT
     else:
         raise NotImplementedError(dtype)
+
+
+MLC_DATA_TYPES = [
+    mlc.DataType.TEXT,
+    mlc.DataType.FLOAT,
+    mlc.DataType.INTEGER,
+    mlc.DataType.BOOL,
+    mlc.DataType.URL,
+]
+
+STR_DATA_TYPES = [
+    str(data_type).replace("https://schema.org/", "") for data_type in MLC_DATA_TYPES
+]
+
+
+def str_to_mlc_data_type(data_type: str) -> mlc.DataType | None:
+    for str_data_type, mlc_data_type in zip(STR_DATA_TYPES, MLC_DATA_TYPES):
+        if data_type == str_data_type:
+            return mlc_data_type
+    return None
+
+
+def mlc_to_str_data_type(data_type: str) -> mlc.DataType | None:
+    for str_data_type, mlc_data_type in zip(STR_DATA_TYPES, MLC_DATA_TYPES):
+        if data_type == mlc_data_type:
+            return str_data_type
+    return None

core/data_types_test.py

@@ -3,7 +3,10 @@
 import numpy as np
 import pytest
 
+import mlcroissant as mlc
+
 from .data_types import convert_dtype
+from .data_types import str_to_mlc_data_type
 
 
 def test_convert_dtype():
@@ -13,3 +16,8 @@ def test_convert_dtype():
     convert_dtype(np.str_) == "https://schema.org/Text"
     with pytest.raises(NotImplementedError):
         convert_dtype(np.float32)
+
+
+def test_str_to_mlc_data_type():
+    assert str_to_mlc_data_type("Integer") == mlc.DataType.INTEGER
+    assert str_to_mlc_data_type("Foo") == None

core/files.py

@@ -8,6 +8,7 @@ import pandas as pd
 import requests
 
 from .names import find_unique_name
+from .path import get_resource_path
 from .state import FileObject
 from .state import FileSet
 
@@ -30,6 +31,8 @@ class FileTypes:
         encoding_format="application/vnd.ms-excel",
         extensions=["xls", "xlsx", "xlsm"],
     )
+    GZIP = FileType(name="GZIP", encoding_format="application/gzip", extensions=["gz"])
+    JPEG = FileType(name="JPEG", encoding_format="image/jpeg", extensions=["json"])
     JSON = FileType(
         name="JSON", encoding_format="application/json", extensions=["json"]
     )
@@ -43,20 +46,60 @@ class FileTypes:
         encoding_format="application/vnd.apache.parquet",
         extensions=["parquet"],
     )
+    TAR = FileType(
+        name="Archive (TAR)",
+        encoding_format="application/x-tar",
+        extensions=["tar"],
+    )
+    TXT = FileType(
+        name="Text",
+        encoding_format="plain/text",
+        extensions=["txt"],
+    )
+    ZIP = FileType(
+        name="ZIP",
+        encoding_format="application/zip",
+        extensions=["zip"],
+    )
+
+
+def _full_name(file_type: FileType):
+    return f"{file_type.name} ({file_type.encoding_format})"
 
 
 FILE_TYPES: dict[str, FileType] = {
-    file_type.name: file_type
+    _full_name(file_type): file_type
     for file_type in [
         FileTypes.CSV,
         FileTypes.EXCEL,
+        FileTypes.GZIP,
+        FileTypes.JPEG,
         FileTypes.JSON,
         FileTypes.JSONL,
         FileTypes.PARQUET,
+        FileTypes.TAR,
+        FileTypes.TXT,
+        FileTypes.ZIP,
     ]
 }
 
 
+def name_to_code(file_type_name: str) -> str | None:
+    """Maps names to the encoding format: Text => plain/text."""
+    for name, file_type in FILE_TYPES.items():
+        if file_type_name == name:
+            return file_type.encoding_format
+    return None
+
+
+def code_to_index(encoding_format: str) -> int | None:
+    """Maps the encoding format to its index in the list of keys: plain/text => 12."""
+    for i, file_type in enumerate(FILE_TYPES.values()):
+        if file_type.encoding_format == encoding_format:
+            return i
+    return None
+
+
 def _sha256(content: bytes):
     """Computes the sha256 digest of the byte string."""
     return hashlib.sha256(content).hexdigest()
@@ -97,7 +140,9 @@ def get_dataframe(file_type: FileType, file: io.BytesIO | epath.Path) -> pd.Data
         raise NotImplementedError()
 
 
-def file_from_url(file_type: FileType, url: str, names: set[str]) -> FileObject:
+def file_from_url(
+    file_type: FileType, url: str, names: set[str], folder: epath.Path
+) -> FileObject:
     """Downloads locally and extracts the file information."""
     file_path = hash_file_path(url)
     if not file_path.exists():
@@ -112,30 +157,38 @@ def file_from_url(file_type: FileType, url: str, names: set[str]) -> FileObject:
         encoding_format=file_type.encoding_format,
         sha256=sha256,
         df=df,
+        folder=folder,
     )
 
 
 def file_from_upload(
-    file_type: FileType, file: io.BytesIO, names: set[str]
+    file_type: FileType, file: io.BytesIO, names: set[str], folder: epath.Path
 ) -> FileObject:
     """Uploads locally and extracts the file information."""
-    sha256 = _sha256(file.getvalue())
+    value = file.getvalue()
+    content_url = f"data/{file.name}"
+    sha256 = _sha256(value)
+    with get_resource_path(content_url).open("wb") as f:
+        f.write(value)
     df = get_dataframe(file_type, file).infer_objects()
     return FileObject(
         name=find_unique_name(names, file.name),
         description="",
-        content_url=f"data/{file.name}",
+        content_url=content_url,
         encoding_format=file_type.encoding_format,
         sha256=sha256,
         df=df,
+        folder=folder,
     )
 
 
-def file_from_form(type: str, names: set[str]) -> FileObject | FileSet:
+def file_from_form(
+    type: str, names: set[str], folder: epath.Path
+) -> FileObject | FileSet:
     """Creates a file based on manually added fields."""
     if type == FILE_OBJECT:
-        return FileObject(name=find_unique_name(names, "file_object"))
+        return FileObject(name=find_unique_name(names, "file_object"), folder=folder)
     elif type == FILE_SET:
-        return FileSet(name=find_unique_name(names, "file_set"))
+        return FileSet(name=find_unique_name(names, "file_set"), folder=folder)
     else:
         raise ValueError("type has to be one of FILE_OBJECT, FILE_SET")

core/files_test.py

@@ -18,10 +18,10 @@ def test_check_file_csv():
         f.write("a,1\n")
         f.write("b,2\n")
         f.write("c,3\n")
-    file = file_from_url(FileTypes.CSV, "https://my.url", set())
+    file = file_from_url(FileTypes.CSV, "https://my.url", set(), epath.Path())
     pd.testing.assert_frame_equal(
         file.df, pd.DataFrame({"column1": ["a", "b", "c"], "column2": [1, 2, 3]})
     )
     # Fails with unknown encoding_format:
     with pytest.raises(NotImplementedError):
-        file_from_url("unknown", "https://my.url", set())
+        file_from_url("unknown", "https://my.url", set(), epath.Path())

core/path.py

@@ -0,0 +1,13 @@
+from etils import epath
+import streamlit as st
+
+from core.state import CurrentProject
+
+
+def get_resource_path(content_url: str) -> epath.Path:
+    """Gets the path on disk of the resource with `content_url`."""
+    project: CurrentProject = st.session_state[CurrentProject]
+    path = project.path / content_url
+    if not path.parent.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+    return path

core/state.py

@@ -137,6 +137,7 @@ class FileObject:
     sha256: str | None = None
     df: pd.DataFrame | None = None
     rdf: mlc.Rdf = dataclasses.field(default_factory=mlc.Rdf)
+    folder: epath.PathLike | None = None
 
 
 @dataclasses.dataclass

events/fields.py

@@ -3,6 +3,7 @@ from typing import Any
 
 import streamlit as st
 
+from core.data_types import str_to_mlc_data_type
 from core.state import Field
 from core.state import Metadata
 import mlcroissant as mlc
@@ -88,7 +89,7 @@ def handle_field_change(
     elif change == FieldEvent.DESCRIPTION:
         field.description = value
     elif change == FieldEvent.DATA_TYPE:
-        field.data_types = [value]
+        field.data_types = [str_to_mlc_data_type(value)]
     elif change == FieldEvent.SOURCE:
         node_type = "field" if "/" in value else "distribution"
         source = mlc.Source(uid=value, node_type=node_type)

events/metadata.py

@@ -4,6 +4,86 @@ import streamlit as st
 
 from core.state import Metadata
 
+# List from:
+LICENSES_URL = "https://huggingface.co/docs/hub/repositories-licenses"
+LICENSES = {
+    "Unknown": "unknown",
+    "Other": "other",
+    "Apache license 2.0": "apache-2.0",
+    "MIT": "mit",
+    "OpenRAIL license family": "openrail",
+    "BigScience OpenRAIL-M": "bigscience-openrail-m",
+    "CreativeML OpenRAIL-M": "creativeml-openrail-m",
+    "BigScience BLOOM RAIL 1.0": "bigscience-bloom-rail-1.0",
+    "BigCode Open RAIL-M v1": "bigcode-openrail-m",
+    "Academic Free License v3.0": "afl-3.0",
+    "Artistic license 2.0": "artistic-2.0",
+    "Boost Software License 1.0": "bsl-1.0",
+    "BSD license family": "bsd",
+    "BSD 2-clause “Simplified” license": "bsd-2-clause",
+    "BSD 3-clause “New” or “Revised” license": "bsd-3-clause",
+    "BSD 3-clause Clear license": "bsd-3-clause-clear",
+    "Computational Use of Data Agreement": "c-uda",
+    "Creative Commons license family": "cc",
+    "Creative Commons Zero v1.0 Universal": "cc0-1.0",
+    "Creative Commons Attribution 2.0": "cc-by-2.0",
+    "Creative Commons Attribution 2.5": "cc-by-2.5",
+    "Creative Commons Attribution 3.0": "cc-by-3.0",
+    "Creative Commons Attribution 4.0": "cc-by-4.0",
+    "Creative Commons Attribution Share Alike 3.0": "cc-by-sa-3.0",
+    "Creative Commons Attribution Share Alike 4.0": "cc-by-sa-4.0",
+    "Creative Commons Attribution Non Commercial 2.0": "cc-by-nc-2.0",
+    "Creative Commons Attribution Non Commercial 3.0": "cc-by-nc-3.0",
+    "Creative Commons Attribution Non Commercial 4.0": "cc-by-nc-4.0",
+    "Creative Commons Attribution No Derivatives 4.0": "cc-by-nd-4.0",
+    "Creative Commons Attribution Non Commercial No Derivatives 3.0": "cc-by-nc-nd-3.0",
+    "Creative Commons Attribution Non Commercial No Derivatives 4.0": "cc-by-nc-nd-4.0",
+    "Creative Commons Attribution Non Commercial Share Alike 2.0": "cc-by-nc-sa-2.0",
+    "Creative Commons Attribution Non Commercial Share Alike 3.0": "cc-by-nc-sa-3.0",
+    "Creative Commons Attribution Non Commercial Share Alike 4.0": "cc-by-nc-sa-4.0",
+    "Community Data License Agreement – Sharing, Version 1.0": "cdla-sharing-1.0",
+    "Community Data License Agreement – Permissive, Version 1.0": "cdla-permissive-1.0",
+    "Community Data License Agreement – Permissive, Version 2.0": "cdla-permissive-2.0",
+    "Do What The F*ck You Want To Public License": "wtfpl",
+    "Educational Community License v2.0": "ecl-2.0",
+    "Eclipse Public License 1.0": "epl-1.0",
+    "Eclipse Public License 2.0": "epl-2.0",
+    "European Union Public License 1.1": "eupl-1.1",
+    "GNU Affero General Public License v3.0": "agpl-3.0",
+    "GNU Free Documentation License family": "gfdl",
+    "GNU General Public License family": "gpl",
+    "GNU General Public License v2.0": "gpl-2.0",
+    "GNU General Public License v3.0": "gpl-3.0",
+    "GNU Lesser General Public License family": "lgpl",
+    "GNU Lesser General Public License v2.1": "lgpl-2.1",
+    "GNU Lesser General Public License v3.0": "lgpl-3.0",
+    "ISC": "isc",
+    "LaTeX Project Public License v1.3c": "lppl-1.3c",
+    "Microsoft Public License": "ms-pl",
+    "Mozilla Public License 2.0": "mpl-2.0",
+    "Open Data Commons License Attribution family": "odc-by",
+    "Open Database License family": "odbl",
+    "Open Rail++-M License": "openrail++",
+    "Open Software License 3.0": "osl-3.0",
+    "PostgreSQL License": "postgresql",
+    "SIL Open Font License 1.1": "ofl-1.1",
+    "University of Illinois/NCSA Open Source License": "ncsa",
+    "The Unlicense": "unlicense",
+    "zLib License": "zlib",
+    "Open Data Commons Public Domain Dedication and License": "pddl",
+    "Lesser General Public License For Linguistic Resources": "lgpl-lr",
+    "DeepFloyd IF Research License Agreement": "deepfloyd-if-license",
+    "Llama 2 Community License Agreement": "llama2",
+}
+
+
+def find_license_index(code: str) -> int | None:
+    """Finds the index in the list of LICENSES."""
+    for index, license_code in enumerate(LICENSES.values()):
+        if license_code == code:
+            return index
+    return None
+
 
 class MetadataEvent(enum.Enum):
     """Event that triggers a metadata change."""
@@ -21,7 +101,7 @@ def handle_metadata_change(event: MetadataEvent, metadata: Metadata, key: str):
     elif event == MetadataEvent.DESCRIPTION:
         metadata.description = st.session_state[key]
     elif event == MetadataEvent.LICENSE:
-        metadata.license = st.session_state[key]
+        metadata.license = LICENSES.get(st.session_state[key])
     elif event == MetadataEvent.CITATION:
         metadata.citation = st.session_state[key]
     elif event == MetadataEvent.URL:

events/metadata_test.py

@@ -0,0 +1,7 @@
+from .metadata import find_license_index
+
+
+def test_find_license_index():
+    assert find_license_index("unknown") == 0
+    assert find_license_index("llama2") == 66
+    assert find_license_index("fooo") is None

events/resources.py

@@ -4,6 +4,8 @@ import enum
 import streamlit as st
 
 from core.files import FILE_OBJECT
+from core.files import name_to_code
+from core.path import get_resource_path
 from core.state import FileObject
 from core.state import FileSet
 from core.state import Metadata
@@ -37,7 +39,7 @@ def handle_resource_change(event: ResourceEvent, resource: Resource, key: str):
     elif event == ResourceEvent.DESCRIPTION:
         resource.description = value
     elif event == ResourceEvent.ENCODING_FORMAT:
-        resource.encoding_format = value
+        resource.encoding_format = name_to_code(value)
     elif event == ResourceEvent.INCLUDES:
         resource.includes = value
     elif event == ResourceEvent.SHA256:
@@ -47,6 +49,11 @@ def handle_resource_change(event: ResourceEvent, resource: Resource, key: str):
     elif event == ResourceEvent.CONTENT_SIZE:
         resource.content_size = value
     elif event == ResourceEvent.CONTENT_URL:
+        if resource.content_url and value:
+            old_path = get_resource_path(resource.content_url)
+            new_path = get_resource_path(value)
+            if old_path.exists() and not new_path.exists():
+                old_path.rename(new_path)
         resource.content_url = value
     elif event == ResourceEvent.TYPE:
         metadata: Metadata = st.session_state[Metadata]

utils.py

@@ -41,14 +41,3 @@ def init_state(force=False):
 
     if OpenTab not in st.session_state or force:
         st.session_state[OpenTab] = None
-
-    # Uncomment those lines if you work locally in order to avoid clicks at each reload.
-    # And comment all previous lines in `init_state`.
-    # if mlc.Dataset not in st.session_state or force:
-    #     st.session_state[mlc.Dataset] = mlc.Dataset("../datasets/titanic/metadata.json")
-    # if Metadata not in st.session_state or force:
-    #     st.session_state[Metadata] = Metadata.from_canonical(
-    #         st.session_state[mlc.Dataset].metadata
-    #     )
-    # if CurrentProject not in st.session_state or force:
-    #     st.session_state[CurrentProject] = CurrentProject.create_new()

views/files.py

@@ -1,7 +1,10 @@
+from etils import epath
 import streamlit as st
 
 from components.tree import render_tree
 from core.constants import DF_HEIGHT
+from core.constants import OAUTH_CLIENT_ID
+from core.files import code_to_index
 from core.files import file_from_form
 from core.files import file_from_upload
 from core.files import file_from_url
@@ -9,7 +12,9 @@ from core.files import FILE_OBJECT
 from core.files import FILE_SET
 from core.files import FILE_TYPES
 from core.files import RESOURCE_TYPES
+from core.path import get_resource_path
 from core.record_sets import infer_record_sets
+from core.state import CurrentProject
 from core.state import FileObject
 from core.state import FileSet
 from core.state import Metadata
@@ -23,10 +28,6 @@ Resource = FileObject | FileSet
 _DISTANT_URL_KEY = "import_from_url"
 _LOCAL_FILE_KEY = "import_from_local_file"
 _MANUAL_RESOURCE_TYPE_KEY = "create_manually_type"
-_MANUAL_NAME_KEY = "manual_object_name"
-_MANUAL_DESCRIPTION_KEY = "manual_object_description"
-_MANUAL_SHA256_KEY = "manual_object_sha256"
-_MANUAL_PARENT_KEY = "manual_object_parents"
 
 _INFO = """Resources can be `FileObjects` (single files) or `FileSets` (sets of files 
 with the same MIME type). On this page, you can upload `FileObjects`, point to external
@@ -34,6 +35,8 @@ resources on the web or manually create new resources."""
 
 
 def render_files():
+    """Renders the views of the files: warnings and panels to display information."""
+    _render_warnings()
     col1, col2, col3 = st.columns([1, 1, 1], gap="small")
     with col1:
         st.markdown("##### Upload more resources")
@@ -47,6 +50,31 @@ def render_files():
         _render_right_panel()
 
 
+def _render_warnings():
+    """Renders warnings concerning local files."""
+    metadata: Metadata = st.session_state[Metadata]
+    warning = ""
+    for resource in metadata.distribution:
+        content_url = resource.content_url
+        if content_url and not content_url.startswith("http"):
+            path = get_resource_path(content_url)
+            if not path.exists():
+                if OAUTH_CLIENT_ID:
+                    warning += (
+                        f'⚠️ Resource "{resource.name}" points to a local file, but'
+                        " doesn't exist on the disk. Fix this by changing the content"
+                        " URL.\n\n"
+                    )
+                else:
+                    warning += (
+                        f'⚠️ Resource "{resource.name}" points to a local file, but'
+                        " doesn't exist on the disk. Fix this by either downloading"
+                        f" it to {path} or changing the content URL.\n\n"
+                    )
+    if warning:
+        st.warning(warning.strip())
+
+
 def _render_resources_panel(files: list[Resource]) -> Resource | None:
     """Renders the left panel: the list of all resources."""
     filename_to_file: dict[str, list[Resource]] = {}
@@ -99,13 +127,15 @@ def _render_upload_panel():
             file_type = FILE_TYPES[file_type_name]
             metadata: Metadata = st.session_state[Metadata]
             names = metadata.names()
+            project: CurrentProject = st.session_state[CurrentProject]
+            folder = project.path
             if url:
-                file = file_from_url(file_type, url, names)
+                file = file_from_url(file_type, url, names, folder)
             elif uploaded_file:
-                file = file_from_upload(file_type, uploaded_file, names)
+                file = file_from_upload(file_type, uploaded_file, names, folder)
             else:
                 resource_type = st.session_state[_MANUAL_RESOURCE_TYPE_KEY]
-                file = file_from_form(resource_type, names)
+                file = file_from_form(resource_type, names, folder)
 
             st.session_state[Metadata].add_distribution(file)
             record_sets = infer_record_sets(file, names)
@@ -157,7 +187,7 @@ def _render_resource_details(selected_file: Resource):
             col1, col2 = st.columns([1, 1])
             col1.button("Close", key=f"{i}_close", on_click=close, type="primary")
             col2.button(
-                "Remove", key=f"{i}_remove", on_click=delete_line, type="secondary"
+                "⚠️ Remove", key=f"{i}_remove", on_click=delete_line, type="secondary"
             )
 
 
@@ -224,9 +254,10 @@ def _render_resource(prefix: int, file: FileObject | FileSet, is_file_object: bo
             args=(ResourceEvent.INCLUDES, file, key),
         )
     key = f"{prefix}_encoding"
-    st.text_input(
+    st.selectbox(
         needed_field("Encoding format"),
-        value=file.encoding_format,
+        index=code_to_index(file.encoding_format),
+        options=FILE_TYPES.keys(),
         key=key,
         on_change=handle_resource_change,
         args=(ResourceEvent.ENCODING_FORMAT, file, key),

views/metadata.py

@@ -1,42 +1,35 @@
-import enum
-
 import streamlit as st
 
 from core.state import Metadata
+from events.metadata import find_license_index
 from events.metadata import handle_metadata_change
+from events.metadata import LICENSES
+from events.metadata import LICENSES_URL
 from events.metadata import MetadataEvent
 
-# List from https://www.kaggle.com/discussions/general/116302.
-licenses = [
-    "Other",
-    "Public Domain",
-    "Public",
-    "CC-0",
-    "PDDL",
-    "CC-BY",
-    "CDLA-Permissive-1.0",
-    "ODC-BY",
-    "CC-BY-SA",
-    "CDLA-Sharing-1.0",
-    "ODC-ODbL",
-    "CC BY-NC",
-    "CC BY-ND",
-    "CC BY-NC-SA",
-    "CC BY-NC-ND",
-]
-
 
 def render_metadata():
+    """Renders the `Metadata` view."""
     metadata = st.session_state[Metadata]
-    try:
-        index = licenses.index(metadata.license)
-    except ValueError:
-        index = None
+    index = find_license_index(metadata.license)
+    key = "metadata-url"
+    st.text_input(
+        label="URL",
+        key=key,
+        value=metadata.url,
+        placeholder="URL to the dataset.",
+        on_change=handle_metadata_change,
+        args=(MetadataEvent.URL, metadata, key),
+    )
     key = "metadata-license"
     st.selectbox(
         label="License",
+        help=(
+            "More information on license names and meaning can be found"
+            f" [here]({LICENSES_URL})."
+        ),
         key=key,
-        options=licenses,
+        options=LICENSES.keys(),
         index=index,
         on_change=handle_metadata_change,
         args=(MetadataEvent.LICENSE, metadata, key),

views/overview.py

@@ -42,17 +42,6 @@ def render_overview():
         )
         if not name:
             st.stop()
-        key = "metadata-url"
-        url = st.text_input(
-            label=needed_field("URL"),
-            key=key,
-            value=metadata.url,
-            placeholder="URL to the dataset.",
-            on_change=handle_metadata_change,
-            args=(MetadataEvent.URL, metadata, key),
-        )
-        if not url:
-            st.stop()
         key = "metadata-description"
         st.text_area(
             label="Description",

views/record_sets.py

@@ -1,6 +1,7 @@
 import multiprocessing
 import textwrap
 import time
+import traceback
 from typing import TypedDict
 
 import numpy as np
@@ -8,6 +9,10 @@ import pandas as pd
 from rdflib import term
 import streamlit as st
 
+from core.data_types import MLC_DATA_TYPES
+from core.data_types import mlc_to_str_data_type
+from core.data_types import STR_DATA_TYPES
+from core.data_types import str_to_mlc_data_type
 from core.query_params import expand_record_set
 from core.query_params import is_record_set_expanded
 from core.state import Field
@@ -23,14 +28,6 @@ from views.source import handle_field_change
 from views.source import render_references
 from views.source import render_source
 
-DATA_TYPES = [
-    mlc.DataType.TEXT,
-    mlc.DataType.FLOAT,
-    mlc.DataType.INTEGER,
-    mlc.DataType.BOOL,
-    mlc.DataType.URL,
-]
-
 _NUM_RECORDS = 3
 _TIMEOUT_SECONDS = 1
 
@@ -40,7 +37,16 @@ class _Result(TypedDict):
     exception: Exception | None
 
 
-@st.cache_data(show_spinner="Generating the dataset...")
+@st.cache_data(
+    show_spinner="Generating the dataset...",
+    hash_funcs={
+        "mlcroissant.Metadata": hash,
+        "mlcroissant.Field": hash,
+        "mlcroissant.FileObject": hash,
+        "mlcroissant.FileSet": hash,
+        "mlcroissant.RecordSet": hash,
+    },
+)
 def _generate_data_with_timeout(record_set: RecordSet) -> _Result:
     """Generates the data and waits at most _TIMEOUT_SECONDS."""
     with multiprocessing.Manager() as manager:
@@ -65,7 +71,7 @@ def _generate_data(record_set: RecordSet, result: _Result) -> pd.DataFrame | Non
     """Generates the first _NUM_RECORDS records."""
     try:
         metadata: Metadata = st.session_state[Metadata]
-        if not metadata:
+        if metadata is None:
             raise ValueError(
                 "The dataset is still incomplete. Please, go to the overview to see"
                 " errors."
@@ -87,8 +93,8 @@ def _generate_data(record_set: RecordSet, result: _Result) -> pd.DataFrame | Non
                             pass
                 df.append(record)
             result["df"] = pd.DataFrame(df)
-    except Exception as exception:
-        result["exception"] = exception
+    except Exception:
+        result["exception"] = traceback.format_exc()
 
 
 def _handle_close_fields():
@@ -154,6 +160,10 @@ def _handle_create_record_set():
     metadata.add_record_set(RecordSet(name="new-record-set", description=""))
 
 
+def _handle_remove_record_set(record_set_key: int):
+    del st.session_state[Metadata].record_sets[record_set_key]
+
+
 def _handle_fields_change(record_set_key: int, record_set: RecordSet):
     expand_record_set(record_set=record_set)
     data_editor_key = _data_editor_key(record_set_key, record_set)
@@ -172,12 +182,13 @@ def _handle_fields_change(record_set_key: int, record_set: RecordSet):
             elif new_field == FieldDataFrame.DESCRIPTION:
                 field.description = new_value
             elif new_field == FieldDataFrame.DATA_TYPE:
-                field.data_types = [new_value]
+                field.data_types = [str_to_mlc_data_type(new_value)]
     for added_row in result["added_rows"]:
+        data_type = str_to_mlc_data_type(added_row.get(FieldDataFrame.DATA_TYPE))
         field = Field(
             name=added_row.get(FieldDataFrame.NAME),
             description=added_row.get(FieldDataFrame.DESCRIPTION),
-            data_types=[added_row.get(FieldDataFrame.DATA_TYPE)],
+            data_types=[data_type],
             source=mlc.Source(),
             references=mlc.Source(),
         )
@@ -296,7 +307,7 @@ def _render_left_panel():
             # TODO(https://github.com/mlcommons/croissant/issues/350): Allow to display
             # several data types, not only the first.
             data_types = [
-                field.data_types[0] if field.data_types else None
+                mlc_to_str_data_type(field.data_types[0]) if field.data_types else None
                 for field in record_set.fields
             ]
             fields = pd.DataFrame(
@@ -331,7 +342,7 @@ def _render_left_panel():
                     FieldDataFrame.DATA_TYPE: st.column_config.SelectboxColumn(
                         FieldDataFrame.DATA_TYPE,
                         help="The Croissant type",
-                        options=DATA_TYPES,
+                        options=STR_DATA_TYPES,
                         required=True,
                     ),
                 },
@@ -365,6 +376,14 @@ def _render_left_panel():
                 on_click=_handle_on_click_field,
                 args=(record_set_key, record_set),
             )
+            key = f"{prefix}-delete-record-set"
+            st.button(
+                "⚠️ Delete RecordSet",
+                type="primary",
+                key=key,
+                on_click=_handle_remove_record_set,
+                args=(record_set_key,),
+            )
     st.button(
         "Create a new RecordSet",
         key=f"create-new-record-set",
@@ -432,8 +451,8 @@ def _render_right_panel():
                     data_type = field.data_types[0]
                     if isinstance(data_type, str):
                         data_type = term.URIRef(data_type)
-                    if data_type in DATA_TYPES:
-                        data_type_index = DATA_TYPES.index(data_type)
+                    if data_type in MLC_DATA_TYPES:
+                        data_type_index = MLC_DATA_TYPES.index(data_type)
                     else:
                         data_type_index = None
                 else:
@@ -442,7 +461,7 @@ def _render_right_panel():
                 col3.selectbox(
                     needed_field("Data type"),
                     index=data_type_index,
-                    options=DATA_TYPES,
+                    options=STR_DATA_TYPES,
                     key=key,
                     on_change=handle_field_change,
                     args=(FieldEvent.DATA_TYPE, field, key),