Synced repo using 'sync_with_huggingface' Github Action

app.py

@@ -1,212 +1,48 @@
-import io
-import base64
 import gradio as gr
-import iscc_core as ic
-import iscc_sdk as idk
-from PIL import Image
-
-idk.sdk_opts.image_thumbnail_size = 265
-idk.sdk_opts.image_thumbnail_quality = 80
-idk.sdk_opts.granular = True
-
+from demos.generate import demo as demo_generate
+from demos.compare import demo as demo_compare
+from demos.inspect_ import demo as demo_inspect
+from demos.chunker import demo as demo_chunker
 
 custom_css = """
-.fixed-height img {
-    height: 265px;  /* Fixed height */
+.fixed-height {
+    height: 240px;  /* Fixed height */
     object-fit: contain;  /* Scale the image to fit within the element */
 }
 #chunked-text span.label {
     text-transform: none !important;
 }
-"""
-
-newline_symbols = {
-    "\u000a": "⏎",  # Line Feed - Represented by the 'Return' symbol
-    "\u000b": "↨",  # Vertical Tab - Represented by the 'Up Down Arrow' symbol
-    "\u000c": "␌",  # Form Feed - Unicode Control Pictures representation
-    "\u000d": "↵",  # Carriage Return - 'Downwards Arrow with Corner Leftwards' symbol
-    "\u0085": "⤓",  # Next Line - 'Downwards Arrow with Double Stroke' symbol
-    "\u2028": "↲",  # Line Separator - 'Downwards Arrow with Tip Leftwards' symbol
-    "\u2029": "¶",  # Paragraph Separator - Represented by the 'Pilcrow' symbol
+.json-holder {
+    word-wrap: break-word;
+    white-space: pre-wrap;
 }
 
+#examples-a, #examples-b {
+    height: 140px;  /* Fixed height */
+    object-fit: contain;  /* Scale the image to fit within the element */
+}
 
-def no_nl(text):
-    for char, symbol in newline_symbols.items():
-        text = text.replace(char, symbol)
-    return text
-
-
-def generate_iscc(file):
-    imeta = idk.code_iscc(file.name)
-    thumbnail = None
-    if imeta.thumbnail:
-        header, encoded = imeta.thumbnail.split(",", 1)
-        data = base64.b64decode(encoded)
-        thumbnail = Image.open(io.BytesIO(data))
-    metadata = imeta.dict(exclude_unset=False, by_alias=True)
-    if metadata.get("thumbnail"):
-        del metadata["thumbnail"]
-    return imeta.iscc, thumbnail, metadata
-
-
-def explain_iscc(code):
-    canonical = ic.iscc_normalize(code)
-    human = " - ".join(ic.iscc_explain(code).split("-"))
-    code_obj = ic.Code(canonical)
-    decomposed = " - ".join(ic.iscc_decompose(canonical))
-    multiformat = code_obj.mf_base58btc
-    return canonical, human, decomposed, multiformat
-
-
-def generate_text_code(text, chunk_size):
-    original_chunk_size = idk.sdk_opts.text_avg_chunk_size
-    idk.sdk_opts.text_avg_chunk_size = chunk_size
-    cleaned = ic.text_clean(text)
-    processed = idk.text_features(cleaned)
-    features = processed["features"]
-    sizes = processed["sizes"]
-    start = 0
-    chunks = []
-    for size in sizes:
-        end = start + size
-        chunks.append(no_nl(cleaned[start:end]))
-        start = end
-    result = [
-        (chunk, f"{size}:{feat}") for chunk, size, feat in zip(chunks, sizes, features)
-    ]
-    idk.sdk_opts.text_avg_chunk_size = original_chunk_size
-    return result
-
-
-####################################################################################################
-# TAB ISCC-CODE                                                                                    #
-####################################################################################################
-
-with gr.Blocks() as demo_generate:
-    gr.Markdown(
-        """
-    ## 🌟 ISCC-CODE Generator - The DNA of digital content
-    """
-    )
-    with gr.Row():
-        with gr.Column(scale=2):
-            in_file = gr.File(label="Media File")
-        with gr.Column(scale=1):
-            out_thumbnail = gr.Image(
-                label="Extracted Thumbnail", elem_classes=["fixed-height"]
-            )
-    with gr.Row():
-        out_iscc = gr.Text(label="ISCC-CODE", show_copy_button=True)
-    with gr.Row():
-        out_meta = gr.Json(label="Metadata")
-    in_file.change(
-        generate_iscc, inputs=[in_file], outputs=[out_iscc, out_thumbnail, out_meta]
-    )
-
-####################################################################################################
-# TAB ENCODING                                                                                     #
-####################################################################################################
-
-with gr.Blocks() as demo_decode:
-    gr.Markdown(
-        """
-    ## 🌟 A Codec for Self-Describing Compact Binary Codes
-    """
-    )
-    with gr.Row():
-        with gr.Column():
-            in_iscc = gr.Text(
-                label="ISCC",
-                info="INPUT ANY VALID ISCC-CODE OR ISCC-UNIT",
-                autofocus=True,
-            )
-            examples = [
-                "ISCC:AAAWN77F727NXSUS",  # Meta-Code
-                "bzqaqaal5rvp72lx2thvq",  # Multiformat
-                "ISCC:EAASKDNZNYGUUF5A",  # Text-Code
-                "ISCC:GABW5LUBVP23N3DOD7PPINHT5JKBI",  # Data-Code 128 bits
-                "ISCC:KUAG5LUBVP23N3DOHCHWIYGXVN7ZS",  # ISCC-SUM
-                "ISCC:KAA2Y5NUST7BFD5NN2XIDK7VW3WG4OEPMRQNPK37TE",  # ISCC-CDI
-                "z36hVxiqoF8AAmDpZV958hn3tsv2i7v1NfCrSzpq",  # ISCC-CDI multiformats
-                "ISCC:KACT4EBWK27737D2AYCJRAL5Z36G76RFRMO4554RU26HZ4ORJGIVHDI",
-            ]
-            gr.Examples(label="Example ISCCs", examples=examples, inputs=[in_iscc])
-
-    gr.Markdown("## Different Encodings:")
-    with gr.Row():
-        with gr.Column():
-            out_canonical = gr.Text(
-                label="Canonical",
-                info="NORMALIZED STANDARD REPRESENTATION",
-                show_copy_button=True,
-            )
-            out_human = gr.Text(
-                label="Human Readable",
-                info="MAINTYPE - SUBTYPE - VERSION - LENGTH - BODY",
-                show_copy_button=True,
-            )
-            out_decomposed = gr.Text(
-                label="Decomposed",
-                info="ISCC-UNITS",
-                show_copy_button=True,
-            )
-            out_multiformat = gr.Text(
-                label="Multiformat",
-                info="BASE58-BTC",
-                show_copy_button=True,
-            )
-    in_iscc.change(
-        explain_iscc,
-        inputs=[in_iscc],
-        outputs=[
-            out_canonical,
-            out_human,
-            out_decomposed,
-            out_multiformat,
-        ],
-    )
+textarea {
+    font-family: JetBrains Mono;
+}
+"""
 
-####################################################################################################
-# CHUNKING                                                                                         #
-####################################################################################################
 
-with gr.Blocks() as demo_chunking:
-    gr.Markdown(
-        """
-    ## 🌟 Content Defined Chunking for Shift-Resistant Text and Data Segmentation
-    """
-    )
-    with gr.Row():
-        with gr.Column():
-            in_text = gr.Textbox(label="Text Input", lines=8, autofocus=True)
-            in_chunksize = gr.Slider(
-                label="Chunk Size",
-                info="AVERAGE NUMBER OF CHARACTERS PER CHUNK",
-                minimum=32,
-                maximum=2048,
-                step=32,
-                value=64,
-            )
+iscc_theme = gr.themes.Default(
+    font=gr.themes.GoogleFont("Readex Pro"),
+    font_mono=gr.themes.GoogleFont("JetBrains Mono"),
+    radius_size=gr.themes.sizes.radius_none,
+)
 
-        out_text = gr.HighlightedText(
-            label="Chunked Text Output",
-            interactive=False,
-            elem_id="chunked-text",
-        )
-    in_text.change(
-        generate_text_code, inputs=[in_text, in_chunksize], outputs=[out_text]
-    )
-    in_chunksize.change(
-        generate_text_code, inputs=[in_text, in_chunksize], outputs=[out_text]
-    )
 
 demo = gr.TabbedInterface(
-    title="▶️ ISCC Playground",
-    interface_list=[demo_generate, demo_decode, demo_chunking],
-    tab_names=["ISCC-CODE", "ENCODING", "CHUNKING"],
+    title="▶️ ISCC Playground - The DNA of your digital content",
+    interface_list=[demo_generate, demo_compare, demo_inspect, demo_chunker],
+    tab_names=["GENERATE", "COMPARE", "INSPECT", "CHUNKER"],
     css=custom_css,
+    theme=iscc_theme,
 )
 
+
 if __name__ == "__main__":
     demo.launch()

demos/chunker.py

@@ -0,0 +1,144 @@
+import gradio as gr
+import iscc_core as ic
+import iscc_sdk as idk
+import pathlib
+
+
+HERE = pathlib.Path(__file__).parent.absolute()
+SAMPLE_FILEPATH = HERE / "samples/sample.txt"
+sample_text = open(SAMPLE_FILEPATH, "rt", encoding="utf-8").read()
+
+newline_symbols = {
+    "\u000a": "⏎",  # Line Feed - Represented by the 'Return' symbol
+    "\u000b": "↨",  # Vertical Tab - Represented by the 'Up Down Arrow' symbol
+    "\u000c": "␌",  # Form Feed - Unicode Control Pictures representation
+    "\u000d": "↵",  # Carriage Return - 'Downwards Arrow with Corner Leftwards' symbol
+    "\u0085": "⤓",  # Next Line - 'Downwards Arrow with Double Stroke' symbol
+    "\u2028": "↲",  # Line Separator - 'Downwards Arrow with Tip Leftwards' symbol
+    "\u2029": "¶",  # Paragraph Separator - Represented by the 'Pilcrow' symbol
+}
+
+custom_css = """
+#chunked-text span.label {
+    text-transform: none !important;
+}
+"""
+
+
+def no_nl(text):
+    """Replace non-printable newline characters with printable symbols"""
+    for char, symbol in newline_symbols.items():
+        text = text.replace(char, symbol)
+    return text
+
+
+def chunk_text(text, chunk_size):
+    original_chunk_size = idk.sdk_opts.text_avg_chunk_size
+    idk.sdk_opts.text_avg_chunk_size = chunk_size
+    cleaned = ic.text_clean(text)
+    processed = idk.text_features(cleaned)
+    features = processed["features"]
+    sizes = processed["sizes"]
+    start = 0
+    chunks = []
+    for size in sizes:
+        end = start + size
+        chunks.append(no_nl(cleaned[start:end]))
+        start = end
+    result = [
+        (chunk, f"{size}:{feat}") for chunk, size, feat in zip(chunks, sizes, features)
+    ]
+    idk.sdk_opts.text_avg_chunk_size = original_chunk_size
+    return result
+
+
+with gr.Blocks(css=custom_css) as demo:
+    with gr.Row(variant="panel"):
+        gr.Markdown(
+            """
+        ## ✂️ ISCC Chunker
+        Demo of Content-Defined Variable-Length Chunking for Shift-Resistant Text and Data Segmentation
+        """,
+        )
+    with gr.Row(variant="panel"):
+        with gr.Column(variant="panel"):
+            in_text = gr.TextArea(
+                label="Text Chunker",
+                placeholder="Paste your text here",
+                lines=12,
+                max_lines=12,
+            )
+            in_chunksize = gr.Slider(
+                label="Chunk Size",
+                info="AVERAGE NUMBER OF CHARACTERS PER CHUNK",
+                minimum=64,
+                maximum=2048,
+                step=32,
+                value=64,
+            )
+            gr.Examples(label="Sample Text", examples=[sample_text], inputs=[in_text])
+
+        out_text = gr.HighlightedText(
+            label="Chunked Text Output",
+            interactive=False,
+            elem_id="chunked-text",
+        )
+    with gr.Row():
+        gr.ClearButton(components=[in_text, in_chunksize, out_text])
+    with gr.Row(variant="panel"):
+        gr.Markdown(
+            """
+        ## 📖 Help & Instructions
+
+        This Demo showcases ISCC's shift-resistant chunking algorithm. Here's how to use it:
+
+        A) **Paste your text** into the "Text Chunker" field or select the sample below.
+
+        The **"Chunked Text Output"** will display the results, highlighting each chunk and its
+        number of characters and associated similarity hash.
+
+        B) Edit the text** in the "Text Chunker" field
+
+        Observe how most chunks stay the same (same length and same hash) even if you make edits
+        in the beginning of the text.
+
+        C) **Adjust the "Chunk Size"** slider to control the average number of characters per chunk.
+
+        Observe how the chunks get smaller/larger on average. Smaller sizes result in more,
+        more fine grained chunks, while larger sizes produce fewer, larger chunks on average.
+
+        D) Use the **Clear Button** to start over.
+
+        For more information about ISCC chunking, please visit: https://core.iscc.codes/algorithms/cdc/
+        """,
+        )
+
+        gr.Markdown(
+            """
+        ## What is Content-Defined Chunking?
+
+        This method segments text (or data) into chunks using a content-defined approach, which is
+        resilient to shifts in the text. It ensures that changes in the beginning of the text have
+        minimal impact on the chunk boundaries further in the text, making it ideal for version
+        control, data deduplication, and similar applications where detecting content changes
+        efficiently is crucial.
+
+        ## How does ISCC use Content-Defined Chunking?
+
+        The [Data-Code](https://github.com/iscc/iscc-core/blob/main/iscc_core/code_data.py) is
+        generated by chunking the raw file bitstream with an average chunk size of 1024 bytes.
+        The chunks are hashed with `xxhash` and processed with a `minhash` algorithm.
+
+        It is also used by the [iscc-sdk](https://github.com/iscc/iscc-sdk) to generate granular
+        syntactic similarity hashes for textual content with an average chunk size of 1024
+        characters. When activated the granular chunk hashes are attached to the generated ISCC
+        Metadata.
+        """
+        )
+
+    in_text.change(chunk_text, inputs=[in_text, in_chunksize], outputs=[out_text])
+    in_chunksize.change(chunk_text, inputs=[in_text, in_chunksize], outputs=[out_text])
+
+
+if __name__ == "__main__":
+    demo.launch()

demos/compare.py

@@ -0,0 +1,287 @@
+import base64
+import io
+from loguru import logger as log
+from pathlib import Path
+import gradio as gr
+from PIL import Image
+import iscc_core as ic
+import iscc_sdk as idk
+import iscc_sci as sci
+import plotly.graph_objects as go
+import pandas as pd
+
+
+idk.sdk_opts.image_thumbnail_size = 265
+idk.sdk_opts.image_thumbnail_quality = 80
+
+
+HERE = Path(__file__).parent.absolute()
+IMAGES1 = HERE / "images1"
+IMAGES2 = HERE / "images2"
+
+
+custom_css = """
+.fixed-height {
+    height: 240px;  /* Fixed height */
+    object-fit: contain;  /* Scale the image to fit within the element */
+}
+
+#examples-a, #examples-b {
+    height: 140px;  /* Fixed height */
+    object-fit: contain;  /* Scale the image to fit within the element */
+}
+"""
+
+
+def iscc_semantic(filepath: str) -> idk.IsccMeta:
+    """Generate ISCC-CODE extended with Semantic-Code for supported modalities (Image)"""
+    imeta = idk.code_iscc(filepath)
+    if imeta.mode == "image":
+        # Inject Semantic-Code
+        sci_code = sci.code_image_semantic(filepath, bits=64)["iscc"]
+        units = ic.iscc_decompose(imeta.iscc)
+        units.append(sci_code)
+        iscc_code_s = ic.gen_iscc_code(units)["iscc"]
+        imeta.iscc = iscc_code_s
+    return imeta
+
+
+def dist_to_sim(data, dim=64):
+    result = {}
+    for k, v in data.items():
+        if k == "instance_match":
+            result[k.split("_")[0].title()] = 1.0 if v is True else -1.0
+        else:
+            result[k.split("_")[0].title()] = hamming_to_cosine(v, dim)
+    return result
+
+
+def hamming_to_cosine(hamming_distance: int, dim: int) -> float:
+    """Aproximate the cosine similarity for a given hamming distance and dimension"""
+    result = 1 - (2 * hamming_distance) / dim
+    log.debug(f"Hamming distance: {hamming_distance} - Dim: {dim} - Result: {result}")
+    return result
+
+
+def similarity_plot(sim_data):
+    # type: (dict) -> go.Figure
+    # Convert input dictionary to DataFrame, sort by value for visual consistency
+    data_df = pd.DataFrame(reversed(sim_data.items()), columns=["Category", "Value"])
+    data_df["Percentage"] = data_df["Value"] * 100  # Convert to percentage
+
+    # Define color for bars based on value
+    # data_df["Color"] = ["red" if x < 0 else "green" for x in data_df["Value"]]
+    data_df["Color"] = [
+        f"rgba(224,122,95,{abs(x)})" if x < 0 else f"rgba(118,185,71,{x})"
+        for x in data_df["Value"]
+    ]
+
+    # Create Plotly Figure
+    fig = go.Figure()
+    fig.add_trace(
+        go.Bar(
+            x=data_df["Value"],
+            y=data_df["Category"],
+            orientation="h",
+            marker_color=data_df["Color"],
+            text=data_df["Percentage"].apply(lambda x: f"{x:.2f}%"),
+            textposition="inside",
+        )
+    )  # Change made here
+
+    # Update layout for aesthetics
+    fig.update_layout(
+        title={"text": "Approximate ISCC-UNIT Similarities", "x": 0.5},
+        xaxis=dict(title="Similarity", tickformat=",.0%"),
+        yaxis=dict(title=""),
+        plot_bgcolor="rgba(0,0,0,0)",
+        height=len(sim_data) * 70,
+        showlegend=False,
+        autosize=True,
+        margin=dict(l=50, r=50, t=50, b=50),
+    )
+
+    # Adjust the x-axis to accommodate percentage labels
+    fig.update_xaxes(range=[-1.1, 1.1])
+
+    return fig
+
+
+with gr.Blocks(css=custom_css) as demo:
+    gr.Markdown("## 🖼️ ISCC Similarity Comparison")
+
+    with gr.Row(variant="default", equal_height=True):
+        with gr.Column(variant="compact"):
+            in_file_a = gr.File(
+                label="Media File A", type="filepath", elem_classes=["fixed-height"]
+            )
+            out_thumb_a = gr.Image(
+                label="Extracted Thumbnail",
+                visible=False,
+                height=240,
+                elem_classes=["fixed-height"],
+                interactive=True,
+                show_download_button=False,
+                sources=["upload"],
+            )
+
+            # Proxy component to patch image example selection -> gr.File
+            dumy_image_a = gr.Image(visible=False, type="filepath", height=240)
+
+            gr.Examples(
+                examples=IMAGES1.as_posix(),
+                cache_examples=False,
+                inputs=[dumy_image_a],
+                elem_id="examples-a",
+            )
+
+            out_iscc_a = gr.Text(label="ISCC")
+            with gr.Accordion(label="ISCC Metadata", open=False):
+                out_meta_a = gr.Code(language="json", label="JSON-LD")
+
+        with gr.Column(variant="compact"):
+            in_file_b = gr.File(
+                label="Media File B", type="filepath", elem_classes=["fixed-height"]
+            )
+
+            out_thumb_b = gr.Image(
+                label="Extracted Thumbnail",
+                visible=False,
+                height=240,
+                elem_classes=["fixed-height"],
+                interactive=True,
+                show_download_button=False,
+                sources=["upload"],
+            )
+
+            # Proxy component to patch image example selection -> gr.File
+            dumy_image_b = gr.Image(visible=False, type="filepath", height=240)
+
+            gr.Examples(
+                examples=IMAGES2.as_posix(),
+                cache_examples=False,
+                inputs=[dumy_image_b],
+                elem_id="examples-b",
+            )
+
+            out_iscc_b = gr.Text(label="ISCC")
+            with gr.Accordion(label="ISCC Metadata", open=False):
+                out_meta_b = gr.Code(language="json", label="JSON-LD")
+
+    with gr.Row(variant="panel"):
+        out_compare = gr.Plot(
+            label="Approximate ISCC-UNIT Similarities", container=False
+        )
+
+    def rewrite_uri(filepath, sample_set):
+        # type: (str, str) -> str
+        """Rewrites temporary image URI to original sample URI"""
+        if filepath:
+            inpath = Path(filepath)
+            outpath = HERE / f"{sample_set}/{inpath.name.replace('jpeg', 'jpg')}"
+
+            log.info(filepath)
+            return outpath.as_posix()
+
+    def process_upload(filepath, suffix):
+        # type: (str, str) -> dict
+        """Generate extended ISCC with experimental Semantic Code (for images)"""
+
+        # Map to active component group
+        in_file_func = globals().get(f"in_file_{suffix}")
+        out_thumb_func = globals().get(f"out_thumb_{suffix}")
+        out_iscc_func = globals().get(f"out_iscc_{suffix}")
+        out_meta_func = globals().get(f"out_meta_{suffix}")
+
+        # Handle emtpy filepath
+        if not filepath:
+            return {
+                in_file_func: None,
+            }
+
+        imeta = iscc_semantic(filepath)
+
+        # Pop Thumbnail for Preview
+        thumbnail = None
+        if imeta.thumbnail:
+            header, encoded = imeta.thumbnail.split(",", 1)
+            data = base64.b64decode(encoded)
+            thumbnail = Image.open(io.BytesIO(data))
+            imeta.thumbnail = None
+
+        result = {
+            in_file_func: gr.File(visible=False, value=None),
+            out_thumb_func: gr.Image(visible=True, value=thumbnail),
+            out_iscc_func: imeta.iscc,
+            out_meta_func: imeta.json(exclude_unset=False, by_alias=True, indent=2),
+        }
+
+        return result
+
+    def iscc_compare(iscc_a, iscc_b):
+        # type: (str, str) -> dict | None
+        """Compare two ISCCs"""
+        if not all([iscc_a, iscc_b]):
+            return None
+        dist_data = ic.iscc_compare(iscc_a, iscc_b)
+        sim_data = dist_to_sim(dist_data, dim=64)
+        sim_plot = similarity_plot(sim_data)
+        return sim_plot
+
+    # Events
+    in_file_a.change(
+        lambda file: process_upload(file, "a"),
+        inputs=[in_file_a],
+        outputs=[in_file_a, out_thumb_a, out_iscc_a, out_meta_a],
+        show_progress="full",
+    )
+    in_file_b.change(
+        lambda file: process_upload(file, "b"),
+        inputs=[in_file_b],
+        outputs=[in_file_b, out_thumb_b, out_iscc_b, out_meta_b],
+        show_progress="full",
+    )
+    out_thumb_a.clear(
+        lambda: (gr.File(visible=True), gr.Image(visible=False), "", ""),
+        inputs=[],
+        outputs=[in_file_a, out_thumb_a, out_iscc_a, out_meta_a],
+        show_progress="hidden",
+    )
+
+    out_thumb_b.clear(
+        lambda: (gr.File(visible=True), gr.Image(visible=False), "", ""),
+        inputs=[],
+        outputs=[in_file_b, out_thumb_b, out_iscc_b, out_meta_b],
+        show_progress="hidden",
+    )
+
+    out_iscc_a.change(
+        iscc_compare,
+        inputs=[out_iscc_a, out_iscc_b],
+        outputs=[out_compare],
+        show_progress="hidden",
+    )
+
+    out_iscc_b.change(
+        iscc_compare,
+        inputs=[out_iscc_a, out_iscc_b],
+        outputs=[out_compare],
+        show_progress="hidden",
+    )
+
+    dumy_image_a.change(
+        lambda file: rewrite_uri(file, "images1"),
+        inputs=[dumy_image_a],
+        outputs=[in_file_a],
+        show_progress="hidden",
+    )
+    dumy_image_b.change(
+        lambda file: rewrite_uri(file, "images2"),
+        inputs=[dumy_image_b],
+        outputs=[in_file_b],
+        show_progress="hidden",
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(debug=True)

demos/generate.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+import base64
+import io
+import gradio as gr
+import iscc_core as ic
+import iscc_sdk as idk
+import iscc_sci as sci
+import iscc_schema as iss
+from PIL import Image
+import json
+
+idk.sdk_opts.image_thumbnail_size = 240
+idk.sdk_opts.image_thumbnail_quality = 80
+
+custom_css = """
+.fixed-height img {
+    height: 240px;  /* Fixed height */
+    object-fit: contain;  /* Scale the image to fit within the element */
+}
+"""
+
+
+def generate_iscc(file):
+    imeta = idk.code_iscc(file.name)
+    thumbnail = None
+    if imeta.thumbnail:
+        header, encoded = imeta.thumbnail.split(",", 1)
+        data = base64.b64decode(encoded)
+        thumbnail = Image.open(io.BytesIO(data))
+    metadata = imeta.dict(exclude_unset=False, by_alias=True)
+    if metadata.get("thumbnail"):
+        del metadata["thumbnail"]
+    return (
+        imeta.iscc,
+        thumbnail,
+        imeta.name,
+        imeta.description,
+        json.dumps(metadata, indent=2),
+        None,
+    )
+
+
+with gr.Blocks(title="ISCC Generator", css=custom_css) as demo:
+    gr.Markdown("## ⚙️ ISCC Generator")
+    with gr.Row():
+        in_file = gr.File(label="Media File")
+    with gr.Row():
+        out_iscc = gr.Text(
+            label="ISCC",
+            info="GENERATED FROM MEDIA FILE",
+            show_copy_button=True,
+            show_label=True,
+        )
+    with gr.Row(variant="panel", equal_height=False):
+        with gr.Column():
+            out_thumbnail = gr.Image(
+                label="Extracted Thumbnail",
+                elem_classes=["fixed-height"],
+                height=240,
+            )
+        with gr.Column(scale=3):
+            with gr.Group():
+                out_name = gr.Text(label="Name", show_copy_button=True)
+                out_description = gr.Textbox(
+                    label="Description", lines=4, max_lines=4, show_copy_button=True
+                )
+
+    with gr.Row():
+        with gr.Accordion(label="ISCC Metadata", open=False):
+            out_meta = gr.Code(language="json", label="JSON-LD")
+    in_file.upload(
+        generate_iscc,
+        inputs=[in_file],
+        outputs=[out_iscc, out_thumbnail, out_name, out_description, out_meta, in_file],
+    )
+
+    # Custom footer
+    footer = (
+        "https://github.com/iscc"
+        f" | iscc-core v{ic.__version__}"
+        f" | iscc-sdk v{idk.__version__}"
+        f" | iscc-sci v{sci.__version__}"
+        f" | iscc-schema v{iss.__version__}"
+    )
+    gr.Markdown(
+        footer,
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()

demos/inspect_.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+from loguru import logger as log
+import gradio as gr
+import iscc_core as ic
+
+
+def explain_iscc(code):
+    result = [gr.Column(visible=False), None, None, None, None]
+    if not code:
+        return tuple(result)
+    try:
+        canonical = ic.iscc_normalize(code)
+        # TODO Update iscc-core validation for MSCDI
+        # ic.iscc_validate(canonical, strict=True)
+        human = " - ".join(ic.iscc_explain(code).split("-"))
+        code_obj = ic.Code(canonical)
+        decomposed = " - ".join(ic.iscc_decompose(canonical))
+        multiformat = code_obj.mf_base58btc
+    except Exception as e:
+        log.error(e)
+        result[1] = str(e)
+        return tuple(result)
+    return gr.Column(visible=True), canonical, human, decomposed, multiformat
+
+
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+    ## 🕵️‍♂️ ISCC Inspector
+    """
+    )
+    with gr.Row():
+        with gr.Column():
+            in_iscc = gr.Text(
+                label="ISCC Inspector",
+                info="DECODE & EXPLAIN ISCC STRUCTURE",
+                placeholder="Paste an ISCC here to break it down",
+                autofocus=True,
+            )
+            examples = [
+                "ISCC:AAAWN77F727NXSUS",  # Meta-Code
+                "bzqaqaal5rvp72lx2thvq",  # Multiformat
+                "ISCC:EAASKDNZNYGUUF5A",  # Text-Code
+                "ISCC:GABW5LUBVP23N3DOD7PPINHT5JKBI",  # Data-Code 128 bits
+                "ISCC:KUAG5LUBVP23N3DOHCHWIYGXVN7ZS",  # ISCC-SUM
+                "ISCC:KAA2Y5NUST7BFD5NN2XIDK7VW3WG4OEPMRQNPK37TE",  # ISCC-CDI
+                "z36hVxiqoF8AAmDpZV958hn3tsv2i7v1NfCrSzpq",  # ISCC-CDI multiformats
+                "ISCC:KACT4EBWK27737D2AYCJRAL5Z36G76RFRMO4554RU26HZ4ORJGIVHDI",
+            ]
+            gr.Examples(label="Example ISCCs", examples=examples, inputs=[in_iscc])
+
+    with gr.Row():
+        with gr.Column(visible=False) as out_column:
+            out_canonical = gr.Text(
+                label="Canonical",
+                info="NORMALIZED STANDARD REPRESENTATION",
+                show_copy_button=True,
+                value=None,
+            )
+            out_human = gr.Text(
+                label="Human Readable",
+                info="MAINTYPE - SUBTYPE - VERSION - LENGTH - BODY",
+                show_copy_button=True,
+            )
+            out_decomposed = gr.Text(
+                label="Decomposed",
+                info="ISCC-UNITS",
+                show_copy_button=True,
+            )
+            out_multiformat = gr.Text(
+                label="Multiformat",
+                info="BASE58-BTC",
+                show_copy_button=True,
+            )
+    in_iscc.change(
+        explain_iscc,
+        inputs=[in_iscc],
+        outputs=[
+            out_column,
+            out_canonical,
+            out_human,
+            out_decomposed,
+            out_multiformat,
+        ],
+        show_progress="hidden",
+    )
+
+if __name__ == "__main__":
+    demo.launch()

demos/samples/sample.txt

@@ -0,0 +1,7 @@
+# What is the ISCC
+
+The ISCC is a similarity preserving fingerprint and identifier for digital media assets.
+
+ISCCs are generated algorithmically from digital content, just like cryptographic hashes. However, instead of using a single cryptographic hash function to identify data only, the ISCC uses various algorithms to create a composite identifier that exhibits similarity-preserving properties (soft hash).
+
+The component-based structure of the ISCC identifies content at multiple levels of abstraction. Each component is self-describing, modular, and can be used separately or with others to aid in various content identification tasks. The algorithmic design supports content deduplication, database synchronization, indexing, integrity verification, timestamping, versioning, data provenance, similarity clustering, anomaly detection, usage tracking, allocation of royalties, fact-checking and general digital asset management use-cases.

pyproject.toml

@@ -8,8 +8,10 @@ readme = "README.md"
 
 [tool.poetry.dependencies]
 python = "^3.9"
-gradio = "^4.12.0"
-iscc-sdk = "^0.6.0"
+gradio = "*"
+iscc-sdk = "^0.6.1"
+iscc-sci = "^0.1.0"
+plotly = "^5.18.0"
 
 [tool.poetry.group.dev.dependencies]
 black = "^23.12.1"

requirements.txt

@@ -1 +1,4 @@
-iscc-sdk==0.6.0
+gradio==4.19.1
+iscc-sdk==0.6.1
+iscc-sci==0.1.0
+plotly==5.19.0