Initial commit

app.py

@@ -0,0 +1,12 @@
+import streamlit as st
+
+from start import start_input_form
+from edit import edit_input_form
+
+st.header("Skops model card creator")
+st.markdown("---")
+
+if not st.session_state.get("model_card"):
+    start_input_form()
+else:
+    edit_input_form()

edit.py

@@ -0,0 +1,255 @@
+from __future__ import annotations
+
+import reprlib
+from pathlib import Path
+from tempfile import mkdtemp
+
+import streamlit as st
+from huggingface_hub import hf_hub_download
+from skops import card
+from skops.card._model_card import PlotSection, split_subsection_names
+
+from utils import iterate_key_section_content, process_card_for_rendering
+from tasks import AddSectionTask, AddFigureTask, DeleteSectionTask, TaskState, UpdateFigureTask, UpdateSectionTask
+
+
+arepr = reprlib.Repr()
+arepr.maxstring = 24
+tmp_path = Path(mkdtemp(prefix="skops-"))  # temporary files
+hf_path = Path(mkdtemp(prefix="skops-"))   # hf repo
+
+
+def load_model_card_from_repo(repo_id: str) -> card.Card:
+    print("downloading model card")
+    path = hf_hub_download(repo_id, "README.md")
+    model_card = card.parse_modelcard(path)
+    return model_card
+
+
+def _update_model_card(
+    model_card: card.Card, key: str, section_name: str, content: str, is_fig: bool,
+) -> None:
+    # This is a very roundabout way to update the model card but it's necessary
+    # because of how streamlit handles session state. Basically, there have to
+    # be "key" arguments, which have to be retrieved from the session_state, as
+    # they are up-to-date. Just getting the Python variables is not enough, as
+    # they can be out of date.
+
+    # key names must match with those used in form
+    new_title = st.session_state[f"{key}.title"]
+    new_content = st.session_state[f"{key}.content"]
+
+    # determine if title is the same
+    old_title_split = split_subsection_names(section_name)
+    new_title_split = old_title_split[:-1] + [new_title]
+    is_title_same = old_title_split == new_title_split
+
+    # determine if content is the same
+    if is_fig:
+        if isinstance(new_content, PlotSection):
+            is_content_same = content == new_content
+        else:
+            is_content_same = not bool(new_content)
+    else:
+        is_content_same = content == new_content
+
+    if is_title_same and is_content_same:
+        return
+
+    if is_fig:
+        fpath = None
+        if new_content:  # new figure uploaded
+            fname = new_content.name.replace(" ", "_")
+            fpath = tmp_path / fname
+        task = UpdateFigureTask(
+            model_card,
+            key=key,
+            old_name=section_name,
+            new_name=new_title,
+            data=new_content,
+            path=fpath,
+        )
+    else:
+        task = UpdateSectionTask(
+            model_card,
+            key=key,
+            old_name=section_name,
+            new_name=new_title,
+            old_content=content,
+            new_content=new_content,
+        )
+    st.session_state.task_state.add(task)
+
+
+def _add_section(model_card: card.Card, key: str) -> None:
+    section_name = f"{key}/Untitled"
+    task = AddSectionTask(model_card, title=section_name, content="[More Information Needed]")
+    st.session_state.task_state.add(task)
+
+
+def _add_figure(model_card: card.Card, key: str) -> None:
+    section_name = f"{key}/Untitled"
+    task = AddFigureTask(model_card, title=section_name, content="cat.png")
+    st.session_state.task_state.add(task)
+
+
+def _delete_section(model_card: card.Card, key: str) -> None:
+    task = DeleteSectionTask(model_card, key=key)
+    st.session_state.task_state.add(task)
+
+
+def _add_section_form(
+    model_card: card.Card, key: str, section_name: str, old_title: str, content: str
+) -> None:
+    with st.form(key, clear_on_submit=False):
+        st.header(section_name)
+        # setting the 'key' argument below to update the session_state
+        st.text_input("Section name", value=old_title, key=f"{key}.title")
+        st.text_area("Content", value=content, key=f"{key}.content")
+        is_fig = False
+        st.form_submit_button(
+            "Update",
+            on_click=_update_model_card,
+            args=(model_card, key, section_name, content, is_fig),
+        )
+
+
+def _add_fig_form(
+    model_card: card.Card, key: str, section_name: str, old_title: str, content: str
+) -> None:
+    with st.form(key, clear_on_submit=False):
+        st.header(section_name)
+        # setting the 'key' argument below to update the session_state
+        st.text_input("Section name", value=old_title, key=f"{key}.title")
+        st.file_uploader("Upload image", key=f"{key}.content")
+        is_fig = True
+        st.form_submit_button(
+            "Update",
+            on_click=_update_model_card,
+            args=(model_card, key, section_name, content, is_fig),
+        )
+
+
+def create_form_from_section(
+    model_card: card.Card, key: str, section_name: str, content: str, is_fig: bool = False
+) -> None:
+    split_sections = split_subsection_names(section_name)
+    old_title = split_sections[-1]
+    if is_fig:
+        _add_fig_form(
+            model_card=model_card,
+            key=key,
+            section_name=section_name,
+            old_title=old_title,
+            content=content,
+        )
+    else:
+        _add_section_form(
+            model_card=model_card,
+            key=key,
+            section_name=section_name,
+            old_title=old_title,
+            content=content,
+        )
+
+    col_0, col_1, col_2 = st.columns([4, 2, 2])
+    with col_0:
+        st.button(
+            f"delete '{arepr.repr(old_title)}'",
+            on_click=_delete_section,
+            args=(model_card, key),
+            key=f"{key}.delete",
+        )
+    with col_1:
+        st.button(
+            "add section below",
+            on_click=_add_section,
+            args=(model_card, key),
+            key=f"{key}.add",
+        )
+    with col_2:
+        st.button(
+            "add figure below",
+            on_click=_add_figure,
+            args=(model_card, key),
+            key=f"{key}.fig",
+        )
+
+
+def display_sections(model_card: card.Card) -> None:
+    for key, section_name, content, is_fig in iterate_key_section_content(model_card._data):
+        create_form_from_section(model_card, key, section_name, content, is_fig)
+
+
+def display_model_card(model_card: card.Card) -> None:
+    rendered = model_card.render()
+    metadata, rendered = process_card_for_rendering(rendered)
+
+    # strip metadata
+    with st.expander("show metadata"):
+        st.text(metadata)
+    st.markdown(rendered, unsafe_allow_html=True)
+
+
+def reset_model_card() -> None:
+    if "task_state" not in st.session_state:
+        return
+    if "model_card" not in st.session_state:
+        del st.session_state["model_card"]
+
+    while st.session_state.task_state.done_list:
+        st.session_state.task_state.undo()
+
+
+def delete_model_card() -> None:
+    if "model_card" in st.session_state:
+        del st.session_state["model_card"]
+    if "task_state" in st.session_state:
+        st.session_state.task_state.reset()
+
+
+def undo_last():
+    st.session_state.task_state.undo()
+    display_model_card(st.session_state.model_card)
+
+
+def redo_last():
+    st.session_state.task_state.redo()
+    display_model_card(st.session_state.model_card)
+
+
+def add_download_model_card_button():
+    model_card = st.session_state.get("model_card")
+    download_disabled = not bool(model_card)
+    data = model_card.render()
+    st.download_button(
+        "Save (md)", data=data, disabled=download_disabled
+    )
+
+
+def edit_input_form():
+    if "task_state" not in st.session_state:
+        st.session_state.task_state = TaskState()
+
+    with st.sidebar:
+        col_0, col_1, col_2, col_3, col_4 = st.columns([1.6, 1.5, 1.2, 2, 1.5])
+        undo_disabled = not bool(st.session_state.task_state.done_list)
+        redo_disabled = not bool(st.session_state.task_state.undone_list)
+        with col_0:
+            name = f"UNDO ({len(st.session_state.task_state.done_list)})"
+            st.button(name, on_click=undo_last, disabled=undo_disabled)
+        with col_1:
+            name = f"REDO ({len(st.session_state.task_state.undone_list)})"
+            st.button(name, on_click=redo_last, disabled=redo_disabled)
+        with col_2:
+            st.button("Reset", on_click=reset_model_card)
+        with col_3:
+            add_download_model_card_button()
+        with col_4:
+            st.button("Delete", on_click=delete_model_card)
+
+        if "model_card" in st.session_state:
+            display_sections(st.session_state.model_card)
+
+    if "model_card" in st.session_state:
+        display_model_card(st.session_state.model_card)

make-data.py

@@ -0,0 +1,26 @@
+# companion script to st-space-creator.py
+
+import pickle
+
+import pandas as pd
+from sklearn.datasets import make_classification
+from sklearn.linear_model import LogisticRegression
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import StandardScaler
+
+X, y = make_classification()
+df = pd.DataFrame(X)
+
+clf = Pipeline(
+    [
+        ("scale", StandardScaler()),
+        ("clf", LogisticRegression(random_state=0)),
+    ]
+)
+clf.fit(X, y)
+
+with open("logreg.pkl", "wb") as f:
+    pickle.dump(clf, f)
+
+
+df.to_csv("data.csv", index=False)

packages.txt

@@ -0,0 +1 @@
+pandoc

requirements.txt

@@ -0,0 +1,7 @@
+catboost
+huggingface_hub
+lightgbm
+pandas
+scikit-learn
+xgboost
+git+https://github.com/skops-dev/skops.git

start.py

@@ -0,0 +1,184 @@
+import glob
+import io
+import os
+import pickle
+import shutil
+from pathlib import Path
+from tempfile import mkdtemp
+
+import pandas as pd
+import sklearn
+import streamlit as st
+from huggingface_hub import hf_hub_download
+from sklearn.base import BaseEstimator
+from sklearn.dummy import DummyClassifier
+
+import skops.io as sio
+from skops import card, hub_utils
+
+
+hf_path = Path(mkdtemp(prefix="skops-"))   # hf repo
+tmp_path = Path(mkdtemp(prefix="skops-"))  # temporary files
+description = """Create an sklearn model card
+
+This Hugging Face Space that aims to provide a simple interface to use the `skops` model card creation utilities.
+
+"""
+
+
+
+def load_model() -> None:
+    if st.session_state.get("model_file") is None:
+        st.session_state.model = DummyClassifier()
+        return
+
+    bytes_data = st.session_state.model_file.getvalue()
+    model = pickle.loads(bytes_data)
+    assert isinstance(model, BaseEstimator), "model must be an sklearn model"
+
+    st.session_state.model = model
+
+
+def load_data() -> None:
+    if st.session_state.get("data_file"):
+        bytes_data = io.BytesIO(st.session_state.data_file.getvalue())
+        df = pd.read_csv(bytes_data)
+    else:
+        df = pd.DataFrame([])
+
+    st.session_state.data = df
+
+
+def _clear_repo(path: str) -> None:
+    for file_path in glob.glob(str(Path(path) / "*")):
+        if os.path.isfile(file_path) or os.path.islink(file_path):
+            os.unlink(file_path)
+        elif os.path.isdir(file_path):
+            shutil.rmtree(file_path)
+
+
+def init_repo(path: str) -> None:
+    _clear_repo(path)
+    requirements = []
+    task = "tabular-classification"
+    data = pd.DataFrame([])
+
+    if "requirements" in st.session_state:
+        requirements = st.session_state.requirements.splitlines()
+    if "task" in st.session_state:
+        task = st.session_state.task
+    if "data_file" in st.session_state:
+        load_data()
+        data = st.session_state.data
+
+    if task.startswith("text") and isinstance(data, pd.DataFrame):
+        data = data.values.tolist()
+
+    try:
+        file_name = tmp_path / "model.skops"
+        sio.dump(st.session_state.model, file_name)
+
+        hub_utils.init(
+            model=file_name,
+            dst=path,
+            task=task,
+            data=data,
+            requirements=requirements,
+        )
+        1
+    except Exception as exc:
+        print("Uh oh, something went wrong when initializing the repo:", exc)
+
+
+def create_skops_model_card() -> None:
+    init_repo(hf_path)
+    metadata = card.metadata_from_config(hf_path)
+    model_card = card.Card(model=st.session_state.model, metadata=metadata)
+    st.session_state.model_card = model_card
+
+
+def create_empty_model_card() -> None:
+    init_repo(hf_path)
+    metadata = card.metadata_from_config(hf_path)
+    model_card = card.Card(model=st.session_state.model, metadata=metadata, template=None)
+    model_card.add(**{"Untitled": "[More Information Needed]"})
+    st.session_state.model_card = model_card
+
+
+def create_hf_model_card() -> None:
+    repo_id = st.session_state.get("hf_repo_id", "").strip("'").strip('"')
+    if not repo_id:
+        return
+
+    print("downloading model card")
+    path = hf_hub_download(repo_id, "README.md")
+    model_card = card.parse_modelcard(path)
+    st.session_state.model_card = model_card
+
+
+def start_input_form():
+    if "model" not in st.session_state:
+        st.session_state.model = DummyClassifier()
+
+    if "data" not in st.session_state:
+        st.session_state.data = pd.DataFrame([])
+
+    if "model_card" not in st.session_state:
+        st.session_state.model_card = None
+
+    st.markdown(description)
+    st.markdown("---")
+
+    st.text(
+        "Upload an sklearn model (strongly recommended)\n"
+        "The model can be used to automatically populate fields in the model card."
+    )
+    st.file_uploader("Upload a model*", on_change=load_model, key="model_file")
+    st.markdown("---")
+
+    st.text(
+        "Upload samples from your data (in csv format)\n"
+        "This sample data can be attached to the metadata of the model card"
+    )
+    st.file_uploader(
+        "Upload X data (csv)*", type=["csv"], on_change=load_data, key="data_file"
+    )
+    st.markdown("---")
+
+    st.selectbox(
+        label="Choose the task type*",
+        options=[
+            "tabular-classification",
+            "tabular-regression",
+            "text-classification",
+            "text-regression",
+        ],
+        key="task",
+        on_change=init_repo,
+        args=(hf_path,)
+    )
+    st.markdown("---")
+
+    st.text_area(
+        label="Requirements*",
+        value=f"scikit-learn=={sklearn.__version__}\n",
+        key="requirements",
+        on_change=init_repo,
+        args=(hf_path,)
+    )
+    st.markdown("---")
+
+    col_0, col_1, col_2 = st.columns([2, 2, 2])
+    with col_0:
+        st.button("Create a new skops model card", on_click=create_skops_model_card)
+
+    with col_1:
+        st.button("Create a new empty model card", on_click=create_empty_model_card)
+
+    with col_2:
+        with st.form("Load existing model card from HF Hub", clear_on_submit=False):
+            st.text_input("Repo name (e.g. 'gpt2')", key="hf_repo_id")
+            st.form_submit_button("Load", on_click=create_hf_model_card)
+
+
+start_input_form()

tasks.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from pathlib import Path
+from uuid import uuid4
+
+from skops import card
+from skops.card._model_card import PlotSection, split_subsection_names
+from streamlit.runtime.uploaded_file_manager import UploadedFile
+
+
+class Task:
+    def __init__(self, model_card: card.Card) -> None:
+        self.model_card = model_card
+
+    def do(self) -> None:
+        raise NotImplementedError
+
+    def undo(self) -> None:
+        raise NotImplementedError
+
+
+class TaskState:
+    def __init__(self) -> None:
+        self.done_list: list[Task] = []
+        self.undone_list: list[Task] = []
+
+    def undo(self) -> None:
+        if not self.done_list:
+            return
+
+        task = self.done_list.pop(-1)
+        task.undo()
+        self.undone_list.append(task)
+
+    def redo(self) -> None:
+        if not self.undone_list:
+            return
+
+        task = self.undone_list.pop(-1)
+        task.do()
+        self.done_list.append(task)
+
+    def add(self, task: Task) -> None:
+        task.do()
+        self.done_list.append(task)
+        self.undone_list.clear()
+
+    def reset(self) -> None:
+        self.done_list.clear()
+        self.undone_list.clear()
+
+
+class AddSectionTask(Task):
+    def __init__(
+        self,
+        model_card: card.Card,
+        title: str,
+        content: str,
+    ) -> None:
+        self.model_card = model_card
+        self.title = title
+        self.key = title + " " + str(uuid4())[:6]
+        self.content = content
+
+    def do(self) -> None:
+        self.model_card.add(**{self.key: self.content})
+        section = self.model_card.select(self.key)
+        section.title = split_subsection_names(self.title)[-1]
+
+    def undo(self) -> None:
+        self.model_card.delete(self.key)
+
+
+class AddFigureTask(Task):
+    def __init__(
+        self,
+        model_card: card.Card,
+        title: str,
+        content: str,
+    ) -> None:
+        self.model_card = model_card
+        self.title = title
+        self.key = title + " " + str(uuid4())[:6]
+        self.content = content
+
+    def do(self) -> None:
+        self.model_card.add_plot(**{self.key: self.content})
+        section = self.model_card.select(self.key)
+        section.title = split_subsection_names(self.title)[-1]
+        section.is_fig = True  # type: ignore
+
+    def undo(self) -> None:
+        self.model_card.delete(self.key)
+
+
+class DeleteSectionTask(Task):
+    def __init__(
+        self,
+        model_card: card.Card,
+        key: str,
+    ) -> None:
+        self.model_card = model_card
+        self.key = key
+
+    def do(self) -> None:
+        self.model_card.select(self.key).visible = False
+
+    def undo(self) -> None:
+        self.model_card.select(self.key).visible = True
+
+
+class UpdateSectionTask(Task):
+    def __init__(
+        self,
+        model_card: card.Card,
+        key: str,
+        old_name: str,
+        new_name: str,
+        old_content: str,
+        new_content: str,
+    ) -> None:
+        self.model_card = model_card
+        self.key = key
+        self.old_name = old_name
+        self.new_name = new_name
+        self.old_content = old_content
+        self.new_content = new_content
+
+    def do(self) -> None:
+        section = self.model_card.select(self.key)
+        new_title = split_subsection_names(self.new_name)[-1]
+        section.title = new_title
+        section.content = self.new_content
+
+    def undo(self) -> None:
+        section = self.model_card.select(self.key)
+        old_title = split_subsection_names(self.old_name)[-1]
+        section.title = old_title
+        section.content = self.old_content
+
+
+class UpdateFigureTask(Task):
+    def __init__(
+        self,
+        model_card: card.Card,
+        key: str,
+        old_name: str,
+        new_name: str,
+        data: UploadedFile | None,
+        path: Path | None,
+    ) -> None:
+        self.model_card = model_card
+        self.key = key
+        self.old_name = old_name
+        self.new_name = new_name
+        self.old_data = self.model_card.select(self.key).content
+        self.path = path
+
+        if not data:
+            self.new_data = self.old_data
+        else:
+            self.new_data = data
+
+    def do(self) -> None:
+        section = self.model_card.select(self.key)
+        new_title = split_subsection_names(self.new_name)[-1]
+        section.title = self.title = new_title
+        if self.new_data == self.old_data:  # image is same
+            return
+
+        # write figure
+        # note: this can still be the same image if the image is a file, there
+        # is no test to check, e.g., the hash of the image
+        with open(self.path, "wb") as f:
+            f.write(self.new_data.getvalue())
+        section.content = PlotSection(
+            alt_text=self.new_data.name,
+            path=self.path,
+        ).format()
+
+    def undo(self) -> None:
+        section = self.model_card.select(self.key)
+        old_title = split_subsection_names(self.old_name)[-1]
+        section.title = old_title
+        if self.new_data == self.old_data:  # image is same
+            return
+
+        self.path.unlink(missing_ok=True)
+        section.content = self.old_data

utils.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import base64
+import re
+from pathlib import Path
+from typing import Iterator
+
+from skops.card._model_card import Section
+
+
+def process_card_for_rendering(rendered: str) -> tuple[str, str]:
+    idx = rendered[1:].index("\n---") + 1
+    metadata = rendered[3:idx]
+    rendered = rendered[idx + 4 :]  # noqa: E203
+
+    # below is a hack to display the images in streamlit
+    # https://discuss.streamlit.io/t/image-in-markdown/13274/10 The problem is
+
+    # that streamlit does not display images in markdown, so we need to replace
+    # them with html. However, we only want that in the rendered markdown, not
+    # in the card that is produced for the hub
+    def markdown_images(markdown):
+        # example image markdown:
+        # ![Test image](images/test.png "Alternate text")
+        images = re.findall(
+            r'(!\[(?P<image_title>[^\]]+)\]\((?P<image_path>[^\)"\s]+)\s*([^\)]*)\))',
+            markdown,
+        )
+        return images
+
+    def img_to_bytes(img_path):
+        img_bytes = Path(img_path).read_bytes()
+        encoded = base64.b64encode(img_bytes).decode()
+        return encoded
+
+    def img_to_html(img_path, img_alt):
+        img_format = img_path.split(".")[-1]
+        img_html = (
+            f'<img src="data:image/{img_format.lower()};'
+            f'base64,{img_to_bytes(img_path)}" '
+            f'alt="{img_alt}" '
+            'style="max-width: 100%;">'
+        )
+        return img_html
+
+    def markdown_insert_images(markdown):
+        images = markdown_images(markdown)
+
+        for image in images:
+            image_markdown = image[0]
+            image_alt = image[1]
+            image_path = image[2]
+            markdown = markdown.replace(
+                image_markdown, img_to_html(image_path, image_alt)
+            )
+        return markdown
+
+    rendered_with_img = markdown_insert_images(rendered)
+    return metadata, rendered_with_img
+
+
+def iterate_key_section_content(
+    data: dict[str, Section],
+    parent_section: str = "",
+    parent_keys: list[str] | None = None,
+) -> Iterator[tuple[str, str, str, bool]]:
+    parent_keys = parent_keys or []
+
+    for key, val in data.items():
+        if parent_section:
+            title = "/".join((parent_section, val.title))
+        else:
+            title = val.title
+
+        if not val.visible:
+            continue
+
+        return_key = key if not parent_keys else "/".join(parent_keys + [key])
+        is_fig = getattr(val, "is_fig", False)
+        yield return_key, title, val.content, is_fig
+
+        if val.subsections:
+            yield from iterate_key_section_content(
+                val.subsections,
+                parent_section=title,
+                parent_keys=parent_keys + [key],
+            )