Initial version

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sigbjørn Skjæret
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,5 +1,5 @@
 ---
-title: Gguf Editor
+title: GGUF Editor
 emoji: 🏢
 colorFrom: blue
 colorTo: purple
@@ -8,6 +8,6 @@ sdk_version: 4.42.0
 app_file: app.py
 pinned: false
 license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+hf_oauth: true
+hf_oauth_scopes:
+  - read-repos

_hf_explorer.py

@@ -0,0 +1,200 @@
+import fnmatch
+import gradio as gr
+import posixpath
+from gradio.components import Timer
+from gradio.components.base import Component, server
+from gradio.data_classes import GradioRootModel
+from gradio_client.documentation import document
+from huggingface_hub import HfFileSystem
+from typing import Any, Callable, List, Literal, Sequence
+
+
+class FileExplorerData(GradioRootModel):
+    # The outer list is the list of files selected, and the inner list
+    # is the path to the file as a list, split by the posixpath.sep.
+    root: List[List[str]]
+
+
+# Hijack Gradio FileExplorer class for file browser functionality
+@document()
+class FileExplorer(Component):
+    """
+    Creates a file explorer component that allows users to browse files on Huggingface. As an input component,
+    it also allows users to select files to be used as input to a function, while as an output component, it displays selected files.
+    """
+
+    EVENTS = ["change"]
+    data_model = FileExplorerData
+
+    def __init__(
+        self,
+        glob: str = "**/*",
+        *,
+        value: str | list[str] | Callable | None = None,
+        file_count: Literal["single", "multiple"] = "multiple",
+        root_dir: str = None,
+        branch: str = "main",
+        token: gr.OAuthToken | None = None,
+        ignore_glob: str | None = None,
+        label: str | None = None,
+        every: Timer | float | None = None,
+        inputs: Component | Sequence[Component] | set[Component] | None = None,
+        show_label: bool | None = None,
+        container: bool = True,
+        scale: int | None = None,
+        min_width: int = 160,
+        height: int | float | str | None = None,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        elem_classes: list[str] | str | None = None,
+        render: bool = True,
+        key: int | str | None = None,
+    ):
+        """
+        Parameters:
+            glob: The glob-style pattern used to select which files to display, e.g. "*" to match all files, "*.png" to match all .png files, "**/*.txt" to match any .txt file in any subdirectory, etc. The default value matches all files and folders recursively. See the Python glob documentation at https://docs.python.org/3/library/glob.html for more information.
+            value: The file (or list of files, depending on the `file_count` parameter) to show as "selected" when the component is first loaded. If a callable is provided, it will be called when the app loads to set the initial value of the component. If not provided, no files are shown as selected.
+            file_count: Whether to allow single or multiple files to be selected. If "single", the component will return a single absolute file path as a string. If "multiple", the component will return a list of absolute file paths as a list of strings.
+            root_dir: Path to root directory to select files from. If not provided, defaults to current working directory.
+            branch: Branch name to browse.
+            token: Huggingface token.
+            ignore_glob: The glob-style, case-sensitive pattern that will be used to exclude files from the list. For example, "*.py" will exclude all .py files from the list. See the Python glob documentation at https://docs.python.org/3/library/glob.html for more information.
+            label: The label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
+            every: Continously calls `value` to recalculate it if `value` is a function (has no effect otherwise). Can provide a Timer whose tick resets `value`, or a float that provides the regular interval for the reset Timer.
+            inputs: Components that are used as inputs to calculate `value` if `value` is a function (has no effect otherwise). `value` is recalculated any time the inputs change.
+            show_label: if True, will display label.
+            container: If True, will place the component in a container - providing some extra padding around the border.
+            scale: relative size compared to adjacent Components. For example if Components A and B are in a Row, and A has scale=2, and B has scale=1, A will be twice as wide as B. Should be an integer. scale applies in Rows, and to top-level Components in Blocks where fill_height=True.
+            min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
+            height: The maximum height of the file component, specified in pixels if a number is passed, or in CSS units if a string is passed. If more files are uploaded than can fit in the height, a scrollbar will appear.
+            interactive: if True, will allow users to select file(s); if False, will only display files. If not provided, this is inferred based on whether the component is used as an input or output.
+            visible: If False, component will be hidden.
+            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
+            elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
+            render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
+            key: if assigned, will be used to assume identity across a re-render. Components that have the same key across a re-render will have their value preserved.
+        """
+        self.root_dir = root_dir
+        self.branch = branch
+        self.fs = HfFileSystem(token = token)
+        self.glob = glob
+        self.ignore_glob = ignore_glob
+        valid_file_count = ["single", "multiple"]
+        if file_count not in valid_file_count:
+            raise ValueError(
+                f"Invalid value for parameter `file_count`: {file_count}. Please choose from one of: {valid_file_count}"
+            )
+        self.file_count = file_count
+        self.height = height
+
+        super().__init__(
+            label=label,
+            every=every,
+            inputs=inputs,
+            show_label=show_label,
+            container=container,
+            scale=scale,
+            min_width=min_width,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            elem_classes=elem_classes,
+            render=render,
+            key=key,
+            value=value,
+        )
+
+    def example_payload(self) -> Any:
+        return [["gradio", "app.py"]]
+
+    def example_value(self) -> Any:
+        return posixpath.join(["gradio", "app.py"])
+
+    def preprocess(self, payload: FileExplorerData | None) -> list[str] | str | None:
+        """
+        Parameters:
+            payload: List of selected files as a FileExplorerData object.
+        Returns:
+            Passes the selected file or directory as a `str` path (relative to `root`) or `list[str}` depending on `file_count`
+        """
+        if payload is None:
+            return None
+
+        if self.file_count == "single":
+            if len(payload.root) > 1:
+                raise ValueError(
+                    f"Expected only one file, but {len(payload.root)} were selected."
+                )
+            elif len(payload.root) == 0:
+                return None
+            else:
+                return posixpath.normpath(posixpath.join(self.root_dir, *payload.root[0]))
+        files = []
+        for file in payload.root:
+            file_ = posixpath.normpath(posixpath.join(self.root_dir, *file))
+            files.append(file_)
+        return files
+
+    def _strip_root(self, path: str) -> str:
+        if path.startswith(self.root_dir):
+            return path[len(self.root_dir) + 1 :]
+        return path
+
+    def postprocess(self, value: str | list[str] | None) -> FileExplorerData | None:
+        """
+        Parameters:
+            value: Expects function to return a `str` path to a file, or `list[str]` consisting of paths to files.
+        Returns:
+            A FileExplorerData object containing the selected files as a list of strings.
+        """
+        if value is None:
+            return None
+
+        files = [value] if isinstance(value, str) else value
+        root = []
+        for file in files:
+            root.append(self._strip_root(file).split(posixpath.sep))
+
+        return FileExplorerData(root=root)
+
+    @server
+    def ls(self, subdirectory: list[str] | None = None) -> list[dict[str, str]] | None:
+        """
+        Returns:
+            a list of dictionaries, where each dictionary represents a file or subdirectory in the given subdirectory
+        """
+        if not self.root_dir:
+            return []
+
+        full_subdir_path = self._safe_join(subdirectory or [])
+
+        try:
+            # subdir_items = sorted(fs.ls(full_subdir_path, detail=True), key=lambda x: x.get('name'))
+            subdir_items = self.fs.ls(full_subdir_path, revision=self.branch, detail=True)
+        except Exception as e:
+            raise gr.Error(e)
+
+        files, folders = [], []
+        for item in subdir_items:
+            full_path = item.get('name')
+            item_name = posixpath.basename(full_path)
+            is_file = item.get('type') != 'directory'
+            valid_by_glob = fnmatch.fnmatch(full_path, self.glob)
+            if is_file and not valid_by_glob:
+                continue
+            if self.ignore_glob and fnmatch.fnmatch(full_path, self.ignore_glob):
+                continue
+            target = files if is_file else folders
+            target.append(
+                {
+                    "name": item_name,
+                    "type": "file" if is_file else "folder",
+                    "valid": valid_by_glob,
+                }
+            )
+
+        return folders + files
+
+    def _safe_join(self, folders: list[str]) -> str:
+        return posixpath.join(self.root_dir, *folders) if folders else self.root_dir

_hf_gguf.py

@@ -0,0 +1,338 @@
+import struct
+from enum import IntEnum
+from fsspec.spec import AbstractBufferedFile
+from typing import Any, Iterator, NamedTuple
+
+
+class GGUFValueType(IntEnum):
+    UINT8   = 0
+    INT8    = 1
+    UINT16  = 2
+    INT16   = 3
+    UINT32  = 4
+    INT32   = 5
+    FLOAT32 = 6
+    BOOL    = 7
+    STRING  = 8
+    ARRAY   = 9
+    UINT64  = 10
+    INT64   = 11
+    FLOAT64 = 12
+
+
+standard_metadata = {
+    "general.type": (GGUFValueType.STRING, "model"),
+    "general.architecture": (GGUFValueType.STRING, "llama"),
+    "general.quantization_version": (GGUFValueType.UINT32, 2),
+    "general.alignment": (GGUFValueType.UINT32, 32),
+    "general.file_type": (GGUFValueType.UINT32, 0),
+    "general.name": (GGUFValueType.STRING, ""),
+    "general.author": (GGUFValueType.STRING, ""),
+    "general.version": (GGUFValueType.STRING, ""),
+    "general.organization": (GGUFValueType.STRING, ""),
+    "general.finetune": (GGUFValueType.STRING, ""),
+    "general.basename": (GGUFValueType.STRING, ""),
+    "general.description": (GGUFValueType.STRING, ""),
+    "general.quantized_by": (GGUFValueType.STRING, ""),
+    "general.size_label": (GGUFValueType.STRING, ""),
+    "general.license": (GGUFValueType.STRING, ""),
+    "general.license.name": (GGUFValueType.STRING, ""),
+    "general.license.link": (GGUFValueType.STRING, ""),
+    "general.url": (GGUFValueType.STRING, ""),
+    "general.doi": (GGUFValueType.STRING, ""),
+    "general.uuid": (GGUFValueType.STRING, ""),
+    "general.repo_url": (GGUFValueType.STRING, ""),
+    "general.source.url": (GGUFValueType.STRING, ""),
+    "general.source.doi": (GGUFValueType.STRING, ""),
+    "general.source.uuid": (GGUFValueType.STRING, ""),
+    "general.source.repo_url": (GGUFValueType.STRING, ""),
+    "general.tags": (GGUFValueType.STRING, []),
+    "general.languages": (GGUFValueType.STRING, []),
+    "general.datasets": (GGUFValueType.STRING, []),
+    "split.no": (GGUFValueType.UINT16, 0),
+    "split.count": (GGUFValueType.UINT16, 0),
+    "split.tensors.count": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.model": (GGUFValueType.STRING, "gpt2"),
+    "tokenizer.ggml.pre": (GGUFValueType.STRING, "llama-bpe"),
+    "tokenizer.ggml.tokens": (GGUFValueType.STRING, []),
+    "tokenizer.ggml.token_type": (GGUFValueType.INT32, []),
+    "tokenizer.ggml.scores": (GGUFValueType.FLOAT32, []),
+    "tokenizer.ggml.merges": (GGUFValueType.STRING, []),
+    "tokenizer.ggml.bos_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.eos_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.unknown_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.seperator_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.padding_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.cls_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.mask_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.add_bos_token": (GGUFValueType.BOOL, False),
+    "tokenizer.ggml.add_eos_token": (GGUFValueType.BOOL, False),
+    "tokenizer.ggml.add_space_prefix": (GGUFValueType.BOOL, False),
+    "tokenizer.ggml.remove_extra_whitespaces": (GGUFValueType.BOOL, False),
+    "tokenizer.chat_template": (GGUFValueType.STRING, ""),
+    "tokenizer.chat_template.rag": (GGUFValueType.STRING, ""),
+    "tokenizer.chat_template.tool_use": (GGUFValueType.STRING, ""),
+    "tokenizer.chat_templates": (GGUFValueType.STRING, []),
+    "tokenizer.ggml.prefix_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.suffix_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.middle_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.eot_token_id": (GGUFValueType.UINT32, 0),
+    "tokenizer.ggml.eom_token_id": (GGUFValueType.UINT32, 0),
+    "quantize.imatrix.file": (GGUFValueType.STRING, ""),
+    "quantize.imatrix.dataset": (GGUFValueType.STRING, ""),
+    "quantize.imatrix.entries_count": (GGUFValueType.INT32, 0),
+    "quantize.imatrix.chunks_count": (GGUFValueType.INT32, 0),
+}
+
+
+gguf_scalar_size: dict[GGUFValueType, int] = {
+    GGUFValueType.UINT8:   1,
+    GGUFValueType.INT8:    1,
+    GGUFValueType.UINT16:  2,
+    GGUFValueType.INT16:   2,
+    GGUFValueType.UINT32:  4,
+    GGUFValueType.INT32:   4,
+    GGUFValueType.FLOAT32: 4,
+    GGUFValueType.BOOL:    1,
+    GGUFValueType.UINT64:  8,
+    GGUFValueType.INT64:   8,
+    GGUFValueType.FLOAT64: 8,
+}
+
+
+gguf_scalar_pack: dict[GGUFValueType, str] = {
+    GGUFValueType.UINT8:   "B",
+    GGUFValueType.INT8:    "b",
+    GGUFValueType.UINT16:  "H",
+    GGUFValueType.INT16:   "h",
+    GGUFValueType.UINT32:  "I",
+    GGUFValueType.INT32:   "i",
+    GGUFValueType.FLOAT32: "f",
+    GGUFValueType.BOOL:    "?",
+    GGUFValueType.UINT64:  "Q",
+    GGUFValueType.INT64:   "q",
+    GGUFValueType.FLOAT64: "d",
+}
+
+
+class GGUFData(NamedTuple):
+    type: GGUFValueType | None
+    value: Any
+    data: bytes
+
+
+class HuggingGGUFstream:
+    fp: AbstractBufferedFile
+    header: dict[str, GGUFData]
+    metadata: dict[str, GGUFData]
+    endian: str
+    metaend: int
+    filesize: int
+
+    def __init__(
+        self,
+        fp: AbstractBufferedFile,
+    ) -> None:
+        self.fp = fp
+        self.header = {}
+        self.metadata = {}
+        self.endian = '<'
+        self.metaend = 0
+        self.filesize = fp.details.get('size')
+
+        if (data := self.fp.read(4)) != b'GGUF':
+            raise TypeError('File is not a GGUF')
+
+        self.header['magic'] = GGUFData(
+            type = None,
+            value = None,
+            data = data,
+        )
+
+        data = self._read_field(GGUFValueType.UINT32)
+        if data.value != 3:
+            if data.value == 3 << 24:
+                data.value = 3
+                self.endian = '>'
+            else:
+                raise TypeError('Unsupported GGUF version')
+        self.header['version'] = data
+
+        data = self._read_field(GGUFValueType.UINT64)
+        self.header['tensors'] = data
+
+        data = self._read_field(GGUFValueType.UINT64)
+        self.header['metadata'] = data
+
+    def _unpack_field(
+        self,
+        buffer: bytes,
+        field_type: GGUFValueType,
+        repeat: int = 1,
+    ) -> Any:
+        value = struct.unpack(f'{self.endian}{repeat}{gguf_scalar_pack.get(field_type)}', buffer)
+        return value[0] if repeat == 1 else value
+
+    def _pack_field(
+        self,
+        field_type: GGUFValueType,
+        *values,
+    ) -> bytes:
+        return struct.pack(f'{self.endian}{len(values)}{gguf_scalar_pack.get(field_type)}', *values)
+
+    def _pack_value(
+        self,
+        val_type: GGUFValueType,
+        value: Any,
+    ) -> bytes:
+        if isinstance(value, list):
+            data = self._pack_field(GGUFValueType.UINT32, val_type)
+            data += self._pack_field(GGUFValueType.UINT64, len(value))
+
+        if val_type == GGUFValueType.ARRAY:
+            raise TypeError('Array of arrays currently unsupported')
+        elif val_type == GGUFValueType.STRING:
+            if isinstance(value, list):
+                for v in value:
+                    buf = str(v).encode('utf-8')
+                    data += self._pack_field(GGUFValueType.UINT64, len(buf))
+                    data += buf
+            else:
+                buf = str(value).encode('utf-8')
+                data = self._pack_field(GGUFValueType.UINT64, len(buf))
+                data += buf
+        elif val_type in gguf_scalar_pack:
+            if isinstance(value, list):
+                data += self._pack_field(val_type, *value)
+            else:
+                data = self._pack_field(val_type, value)
+        else:
+            raise TypeError('Unknown metadata type')
+
+        return data
+
+    def _read_field(
+        self,
+        field_type: GGUFValueType,
+        repeat: int = 1,
+    ) -> GGUFData:
+        data = self.fp.read(gguf_scalar_size.get(field_type) * repeat)
+        value = self._unpack_field(data, field_type, repeat = repeat)
+
+        return GGUFData(
+            type = field_type,
+            value = value,
+            data = data,
+        )
+
+    def _read_value(
+        self,
+        val_type: GGUFValueType,
+    ) -> GGUFData:
+        if val_type == GGUFValueType.ARRAY:
+            data = self._read_field(GGUFValueType.UINT32)
+            val_len = self._read_field(GGUFValueType.UINT64)
+
+            if data.value in gguf_scalar_pack:
+                val = self._read_field(data.value, repeat = val_len.value)
+                data = GGUFData(
+                    type = val.type,
+                    value = list(val.value),
+                    data = data.data + val_len.data + val.data,
+                )
+            else:
+                v = []
+                d = [data.data, val_len.data]
+
+                for _ in range(val_len.value):
+                    val = self._read_value(data.value)
+                    d.append(val.data)
+                    v.append(val.value)
+
+                data = GGUFData(
+                    type = data.value,
+                    value = v,
+                    data = b''.join(d),
+                )
+        elif val_type == GGUFValueType.STRING:
+            data = self._read_field(GGUFValueType.UINT64)
+            val = self.fp.read(data.value)
+            data = GGUFData(
+                type = val_type,
+                value = val.decode('utf-8'),
+                data = data.data + val,
+            )
+        elif val_type in gguf_scalar_pack:
+            data = self._read_field(val_type)
+        else:
+            raise TypeError('Unknown metadata type')
+
+        return data
+
+    def _update_metacount(
+        self,
+    ) -> None:
+        old_count = self.header['metadata']
+        new_count = len(self.metadata)
+        self.header['metadata'] = GGUFData(
+            type = old_count.type,
+            value = new_count,
+            data = self._pack_field(old_count.type, new_count),
+        )
+
+    def read_metadata(
+        self,
+    ) -> Iterator[tuple[str, GGUFData]]:
+        if self.metadata:
+            for k, v in self.metadata.items():
+                yield k, v
+        else:
+            num_metadata = self.header['metadata'].value
+
+            for _ in range(num_metadata):
+                key = self._read_value(GGUFValueType.STRING)
+                val_type = self._read_field(GGUFValueType.UINT32)
+                val = self._read_value(val_type.value)
+
+                self.metadata[key.value] = val = GGUFData(
+                    type = val.type,
+                    value = val.value,
+                    data = key.data + val_type.data + val.data,
+                )
+
+                yield key.value, val
+
+            self.metaend = self.fp.loc
+
+    def add_metadata(
+        self,
+        key: str,
+        type: GGUFValueType,
+        value: Any,
+    ) -> None:
+        data = self._pack_value(GGUFValueType.STRING, key)
+        data += self._pack_field(GGUFValueType.UINT32, GGUFValueType.ARRAY if isinstance(value, list) else type)
+        data += self._pack_value(type, value)
+
+        if (meta := self.metadata.get(key)):
+            self.filesize -= len(meta.data)
+
+        self.filesize += len(data)
+        self.metadata[key] = GGUFData(
+            type = type,
+            value = value,
+            data = data,
+        )
+
+        if not meta:
+            self._update_metacount()
+
+    def remove_metadata(
+        self,
+        key: str,
+    ) -> None:
+        if (meta := self.metadata.get(key)):
+            del self.metadata[key]
+
+            self.filesize -= len(meta.data)
+            self._update_metacount()

app.py

@@ -0,0 +1,724 @@
+import gradio as gr
+import json
+import posixpath
+from fastapi import HTTPException, Path, Query, Request
+from fastapi.responses import StreamingResponse
+from gradio_huggingfacehub_search import HuggingfaceHubSearch
+from huggingface_hub import HfApi, HfFileSystem
+from typing import Annotated, Any, NamedTuple
+from urllib.parse import urlencode
+
+from _hf_explorer import FileExplorer
+from _hf_gguf import standard_metadata, GGUFValueType, HuggingGGUFstream
+
+
+hfapi = HfApi()
+
+
+class MetadataState(NamedTuple):
+    var: dict[str, Any]
+    key: dict[str, tuple[int, Any]]
+    add: dict[str, Any]
+    rem: set
+
+
+def init_state(
+):
+    return MetadataState(
+        var = {},
+        key = {},
+        add = {},
+        rem = set(),
+    )
+
+
+def human_readable_metadata(
+    typ: int,
+    val: Any,
+) -> tuple[str, Any]:
+    typ = GGUFValueType(typ).name
+
+    if typ == 'ARRAY':
+        val = '[[...], ...]'
+    elif isinstance(val, list):
+        typ = f'[{typ}][{len(val)}]'
+
+        if len(val) > 8:
+            val = str(val[:8])[:-1] + ', ...]'
+        else:
+            val = str(val)
+
+    return typ, val
+
+
+with gr.Blocks(
+) as blocks:
+    with gr.Row():
+        hf_search = HuggingfaceHubSearch(
+            label = "Search Huggingface Hub",
+            placeholder = "Search for models on Huggingface",
+            search_type = "model",
+            sumbit_on_select = True,
+            scale = 2,
+        )
+
+        hf_branch = gr.Dropdown(
+            None,
+            label = "Branch",
+            scale = 1,
+        )
+
+        gr.LoginButton(
+            "Sign in to access gated/private repos",
+            scale = 1,
+        )
+
+    hf_file = FileExplorer(
+        visible=False,
+    )
+
+    with gr.Row():
+        with gr.Column():
+            meta_keys = gr.Dropdown(
+                None,
+                label = "Modify Metadata",
+                allow_custom_value = True,
+                visible = False,
+            )
+
+        with gr.Column():
+            meta_types = gr.Dropdown(
+                [e.name for e in GGUFValueType],
+                label = "Metadata Type",
+                type = "index",
+                visible = False,
+            )
+
+        with gr.Column():
+            btn_delete = gr.Button(
+                "Remove Key",
+                variant = 'stop',
+                visible = False,
+            )
+
+    meta_boolean = gr.Checkbox(
+        visible = False,
+    )
+
+    with gr.Row():
+        # Too slow unfortunately, needs a proper search box
+        # meta_lookup = gr.Dropdown(
+        #     label = 'Lookup token',
+        #     type = 'index',
+        #     visible = False,
+        # )
+
+        meta_number = gr.Number(
+            visible = False,
+        )
+
+    meta_string = gr.Textbox(
+        visible = False,
+    )
+
+    meta_array = gr.Matrix(
+        None,
+        label = "Unsupported",
+        row_count = (1, 'fixed'),
+        height = "1rem",
+        interactive = False,
+        visible = False,
+    )
+
+    meta_changes = gr.HighlightedText(
+        None,
+        label = "Metadata Changes",
+        color_map = {'add': 'green', 'rem': 'red'},
+        interactive = False,
+        visible = False,
+    )
+
+    btn_download = gr.Button(
+        "Download GGUF",
+        variant = "primary",
+        visible = False,
+    )
+
+    file_meta = gr.Matrix(
+        None,
+        col_count = (3, "fixed"),
+        headers = [
+            "Metadata Name",
+            "Type",
+            "Value",
+        ],
+        datatype = ["str", "str", "str"],
+        column_widths = ["35%", "15%", "50%"],
+        wrap = True,
+        interactive = False,
+        visible = False,
+    )
+
+    meta_state = gr.State() # init_state
+    # BUG: For some reason using gr.State initial value turns tuple to list?
+    meta_state.value = init_state()
+
+    file_change_components = [
+        meta_changes,
+        file_meta,
+        meta_keys,
+        btn_download,
+    ]
+    state_change_components = [
+        meta_state,
+    ] + file_change_components
+
+
+    @gr.on(
+        triggers = [
+            hf_search.submit,
+        ],
+        inputs = [
+            hf_search,
+        ],
+        outputs = [
+            hf_branch,
+        ],
+    )
+    def get_branches(
+        repo: str,
+        oauth_token: gr.OAuthToken | None = None,
+    ):
+        branches = []
+
+        try:
+            refs = hfapi.list_repo_refs(
+                repo,
+                token = oauth_token.token if oauth_token else False,
+            )
+            branches = [b.name for b in refs.branches]
+        except Exception as e:
+            raise gr.Error(e)
+
+        return {
+            hf_branch: gr.Dropdown(
+                branches or None,
+                value = "main" if "main" in branches else None,
+            ),
+        }
+
+
+    @gr.on(
+        triggers = [
+            hf_search.submit,
+            hf_branch.input,
+        ],
+        inputs = [
+            hf_search,
+            hf_branch,
+        ],
+        outputs = [
+            hf_file,
+        ] + file_change_components,
+    )
+    def get_files(
+        repo: str,
+        branch: str | None,
+        oauth_token: gr.OAuthToken | None = None,
+    ):
+        return {
+            hf_file: FileExplorer(
+                "**/*.gguf",
+                file_count = "single",
+                root_dir = repo,
+                branch = branch,
+                token = oauth_token.token if oauth_token else None,
+                visible = True,
+            ),
+            meta_changes: gr.HighlightedText(
+                None,
+                visible = False,
+            ),
+            file_meta: gr.Matrix(
+                # None, # FIXME (see Dataframe bug below)
+                visible = False,
+            ),
+            meta_keys: gr.Dropdown(
+                None,
+                visible = False,
+            ),
+            btn_download: gr.Button(
+                visible = False,
+            ),
+        }
+
+
+    @gr.on(
+        triggers = [
+            hf_file.change,
+        ],
+        inputs = [
+            hf_file,
+            hf_branch,
+        ],
+        outputs = [
+            meta_state,
+        ] + file_change_components,
+        show_progress = 'minimal',
+    )
+    def load_metadata(
+        repo_file: str | None,
+        branch: str | None,
+        progress: gr.Progress = gr.Progress(),
+        oauth_token: gr.OAuthToken | None = None,
+    ):
+        m = []
+        meta = init_state()
+
+        yield {
+            meta_state: meta,
+            file_meta: gr.Matrix(
+                [['', '', '']] * 100, # FIXME: Workaround for Dataframe bug when user has selected data
+                visible = True,
+            ),
+            meta_changes: gr.HighlightedText(
+                None,
+                visible = False,
+            ),
+            meta_keys: gr.Dropdown(
+                None,
+                visible = False,
+            ),
+            btn_download: gr.Button(
+                visible = False,
+            ),
+        }
+
+        if not repo_file:
+            return
+
+        fs = HfFileSystem(
+            token = oauth_token.token if oauth_token else None,
+        )
+
+        try:
+            progress(0, desc = 'Loading file...')
+            with fs.open(
+                repo_file,
+                "rb",
+                revision = branch,
+                block_size = 8 * 1024 * 1024,
+                cache_type = "readahead",
+            ) as fp:
+                progress(0, desc = 'Reading header...')
+                gguf = HuggingGGUFstream(fp)
+                num_metadata = gguf.header['metadata'].value
+                metadata = gguf.read_metadata()
+
+                meta.var['repo_file'] = repo_file
+                meta.var['branch'] = branch
+
+                for k, v in progress.tqdm(metadata, desc = 'Reading metadata...', total = num_metadata, unit = f' of {num_metadata} metadata keys...'):
+                    m.append([k, *human_readable_metadata(v.type, v.value)])
+                    meta.key[k] = (v.type, v.value)
+
+                    # FIXME
+                    # yield {
+                    #     file_meta: gr.Matrix(
+                    #         m,
+                    #     ),
+                    # }
+        except Exception as e:
+            raise gr.Error(e)
+
+        yield {
+            meta_state: meta,
+            file_meta: gr.Matrix(
+                m,
+            ),
+            meta_keys: gr.Dropdown(
+                sorted(meta.key.keys() | standard_metadata.keys()),
+                value = '',
+                visible = True,
+            ),
+        }
+
+
+    @gr.on(
+        triggers = [
+            meta_keys.change,
+        ],
+        inputs = [
+            meta_state,
+            meta_keys,
+        ],
+        outputs = [
+            meta_types,
+            btn_delete,
+        ],
+    )
+    def update_metakey(
+        meta: MetadataState,
+        key: str | None,
+    ):
+        typ = None
+        if (val := meta.key.get(key, standard_metadata.get(key))) is not None:
+            typ = GGUFValueType(val[0]).name
+        elif key and key.startswith('tokenizer.chat_template.'):
+            typ = GGUFValueType.STRING.name
+
+        return {
+            meta_types: gr.Dropdown(
+                value = typ,
+                interactive = False if key in meta.key else True,
+                visible = True if key else False,
+            ),
+            btn_delete: gr.Button(
+                visible = True if key in meta.key else False,
+            ),
+        }
+
+
+    @gr.on(
+        triggers = [
+            meta_keys.change,
+            meta_types.input,
+        ],
+        inputs = [
+            meta_state,
+            meta_keys,
+            meta_types,
+        ],
+        outputs = [
+            meta_boolean,
+            meta_number,
+            meta_string,
+            meta_array,
+        ],
+    )
+    def update_metatype(
+        meta: MetadataState,
+        key: str,
+        typ: int,
+    ):
+        val = None
+        if (data := meta.key.get(key, standard_metadata.get(key))) is not None:
+            typ = data[0]
+            val = data[1]
+        elif not key:
+            typ = None
+
+        if isinstance(val, list):
+            # TODO: Support arrays?
+            typ = GGUFValueType.ARRAY
+
+        match typ:
+            case GGUFValueType.INT8 | GGUFValueType.INT16 | GGUFValueType.INT32 | GGUFValueType.INT64 | GGUFValueType.UINT8 | GGUFValueType.UINT16 | GGUFValueType.UINT32 | GGUFValueType.UINT64 | GGUFValueType.FLOAT32 | GGUFValueType.FLOAT64:
+                is_number = True
+            case _:
+                is_number = False
+
+        return {
+            meta_boolean: gr.Checkbox(
+                value = val if typ == GGUFValueType.BOOL and data is not None else False,
+                visible = True if typ == GGUFValueType.BOOL else False,
+            ),
+            meta_number: gr.Number(
+                value = val if is_number and data is not None else 0,
+                precision = 10 if typ == GGUFValueType.FLOAT32 or typ == GGUFValueType.FLOAT64 else 0,
+                visible = True if is_number else False,
+            ),
+            meta_string: gr.Textbox(
+                value = val if typ == GGUFValueType.STRING else '',
+                visible = True if typ == GGUFValueType.STRING else False,
+            ),
+            meta_array: gr.Matrix(
+                visible = True if typ == GGUFValueType.ARRAY else False,
+            ),
+        }
+
+
+    # FIXME: Disabled for now due to Dataframe bug when user has selected data
+    # @gr.on(
+    #     triggers = [
+    #         file_meta.select,
+    #     ],
+    #     inputs = [
+    #     ],
+    #     outputs = [
+    #         meta_keys,
+    #     ],
+    # )
+    # def select_metakey(
+    #     evt: gr.SelectData,
+    # ):
+    #     return {
+    #         meta_keys: gr.Dropdown(
+    #             value = evt.row_value[0] if evt.selected else '',
+    #         ),
+    #     }
+
+
+    def notify_state_change(
+        meta: MetadataState,
+        request: gr.Request,
+    ):
+        changes = [(k, 'rem') for k in meta.rem]
+
+        for k, v in meta.add.items():
+            changes.append((k, 'add'))
+            changes.append((str(v[1]), None))
+
+        m = []
+        for k, v in meta.key.items():
+            m.append([k, *human_readable_metadata(v[0], v[1])])
+
+        link = str(request.request.url_for('download', repo_file = meta.var['repo_file']).include_query_params(branch = meta.var['branch']))
+        if meta.rem or meta.add:
+            link += '&' + urlencode(
+                {
+                    'rem': meta.rem,
+                    'add': [json.dumps([k, *v], ensure_ascii = False) for k, v in meta.add.items()],
+                },
+                doseq = True,
+                safe = '[]{}:"\',',
+            )
+
+        return {
+            meta_state: meta,
+            meta_changes: gr.HighlightedText(
+                changes,
+                visible = True if changes else False,
+            ),
+            file_meta: gr.Matrix(
+                m,
+            ),
+            meta_keys: gr.Dropdown(
+                sorted(meta.key.keys() | standard_metadata.keys()),
+                value = '',
+            ),
+            btn_download: gr.Button(
+                link = link,
+                visible = True if changes else False,
+            ),
+        }
+
+
+    @gr.on(
+        triggers = [
+            btn_delete.click,
+        ],
+        inputs = [
+            meta_state,
+            meta_keys,
+        ],
+        outputs = [
+        ] + state_change_components,
+    )
+    def rem_metadata(
+        meta: MetadataState,
+        key: str,
+        request: gr.Request,
+    ):
+        if key in meta.add:
+            del meta.add[key]
+
+        if key in meta.key:
+            del meta.key[key]
+
+        meta.rem.add(key)
+
+        return notify_state_change(
+            meta,
+            request,
+        )
+
+
+    def add_metadata(
+        meta: MetadataState,
+        key: str,
+        typ: int | None,
+        val: Any,
+        request: gr.Request,
+    ):
+        if not key or typ is None:
+            if key:
+                gr.Warning('Missing required value type')
+
+            return {
+                meta_changes: gr.HighlightedText(
+                )
+            }
+
+        if key in meta.rem:
+            meta.rem.remove(key)
+
+        meta.key[key] = meta.add[key] = (typ, val)
+
+        if key.startswith('tokenizer.chat_template.'):
+            template = key[24:]
+            if template not in meta.key.get('tokenizer.chat_templates', []):
+                templates = [x[24:] for x in meta.key.keys() if x.startswith('tokenizer.chat_template.')]
+                meta.key['tokenizer.chat_templates'] = meta.add['tokenizer.chat_templates'] = (GGUFValueType.STRING, templates)
+
+        return notify_state_change(
+            meta,
+            request,
+        )
+
+
+    meta_boolean.input(
+        add_metadata,
+        inputs = [
+            meta_state,
+            meta_keys,
+            meta_types,
+            meta_boolean,
+        ],
+        outputs = [
+        ] + state_change_components,
+    )
+
+    # meta_lookup.input(
+    #     lambda token: gr.Number(value = token),
+    #     inputs = meta_lookup,
+    #     outputs = meta_number,
+    # )
+
+    meta_number.submit(
+        add_metadata,
+        inputs = [
+            meta_state,
+            meta_keys,
+            meta_types,
+            meta_number,
+        ],
+        outputs = [
+        ] + state_change_components,
+    )
+
+    meta_string.submit(
+        add_metadata,
+        inputs = [
+            meta_state,
+            meta_keys,
+            meta_types,
+            meta_string,
+        ],
+        outputs = [
+        ] + state_change_components,
+    )
+
+    meta_array.input(
+        add_metadata,
+        inputs = [
+            meta_state,
+            meta_keys,
+            meta_types,
+            meta_array,
+        ],
+        outputs = [
+        ] + state_change_components,
+    )
+
+
+def stream_repo_file(
+    repo_file: str,
+    branch: str,
+    add_meta: list[str] | None,
+    rem_meta: list[str] | None,
+    token: str | None = None,
+):
+    fs = HfFileSystem(
+        token = token,
+    )
+
+    with fs.open(
+        repo_file,
+        "rb",
+        revision = branch,
+        block_size = 8 * 1024 * 1024,
+        cache_type = "readahead",
+    ) as fp:
+        if not rem_meta:
+            rem_meta = []
+
+        if not add_meta:
+            add_meta = []
+
+        gguf = HuggingGGUFstream(fp)
+        for _ in gguf.read_metadata():
+            pass
+
+        for k in rem_meta:
+            gguf.remove_metadata(k)
+
+        for k in add_meta:
+            k = json.loads(k)
+            if isinstance(k, list) and len(k) == 3:
+                gguf.add_metadata(*k)
+
+        yield gguf.filesize
+
+        yield b''.join((v.data for k, v in gguf.header.items()))
+
+        for k, v in gguf.metadata.items():
+            yield v.data
+
+        while True:
+            if not (data := fp.read(65536)):
+                break
+
+            yield data
+
+
+if __name__ == "__main__":
+    blocks.queue(
+        max_size = 10,
+        default_concurrency_limit = 10,
+    )
+    app, local_url, share_url = blocks.launch(
+        show_api = False,
+        prevent_thread_lock = True,
+    )
+
+    async def download(
+        request: Request,
+        repo_file: Annotated[str, Path()],
+        branch: Annotated[str, Query()] = "main",
+        add: Annotated[list[str] | None, Query()] = None,
+        rem: Annotated[list[str] | None, Query()] = None,
+    ):
+        token = request.session.get('oauth_info', {}).get('access_token')
+
+        if posixpath.normpath(repo_file) != repo_file or '\\' in repo_file or repo_file.startswith('../') or repo_file.startswith('/') or repo_file.count('/') < 2:
+            raise HTTPException(
+                status_code = 404,
+                detail = 'Invalid repository',
+            )
+
+        stream = stream_repo_file(
+            repo_file,
+            branch,
+            add,
+            rem,
+            token = token,
+        )
+        size = next(stream)
+
+        return StreamingResponse(
+            stream,
+            headers = {
+                'Content-Length': str(size),
+            },
+            media_type = 'application/octet-stream',
+        )
+
+    app.add_api_route(
+        "/download/{repo_file:path}",
+        download,
+        methods = ["GET"],
+    )
+    # app.openapi_schema = None
+    # app.setup()
+    blocks.block_thread()

requirements.txt

@@ -0,0 +1,2 @@
+# gradio[oauth]==4.42.0
+gradio_huggingfacehub_search==0.0.7