Upload 3 files

app.py

@@ -14,15 +14,20 @@ with gr.Blocks(theme="NoCrypt/miku", fill_width=True, css=CSS) as demo:
     gr.Markdown("# Search Hugging Face🤗", elem_classes="title")
     with gr.Column():
         search_result = gr.State(value=HFSearchResult())
+        ui_mode = gr.Radio(label="Mode", choices=["PC", "Phone"], value="Phone")
         with gr.Tab("Normal Search"):
             with gr.Group():
                 with gr.Row(equal_height=True):
                     repo_types = gr.CheckboxGroup(label="Repo type", choices=["model", "dataset", "space", "collection"], value=["model", "dataset", "space"])
                     filter_str = gr.Textbox(label="Filter", info="String(s) to filter repos", value="")
+                    sort = gr.Radio(label="Sort", choices=["last_modified", "likes", "downloads", "trending_score"], value="likes")
+                    
                 with gr.Accordion("Advanced", open=False):
                     with gr.Row(equal_height=True):
                         search_str = gr.Textbox(label="Search", info="A string that will be contained in the returned repo ids", placeholder="bert", value="", lines=1)
-                        author = gr.Textbox(label="Author", info="The author (user or organization)", value="", lines=1)
+                        #author = gr.Textbox(label="Author", info="The author (user or organization)", value="", lines=1)
+                        author = HuggingfaceHubSearch(label="Author", placeholder="The author (user or organization)", search_type="user", sumbit_on_select=False)
+                        followed = HuggingfaceHubSearch(label="Followed by", placeholder="Extract repos followed by this user", search_type="user", sumbit_on_select=False)
                     with gr.Column():
                         tags = gr.Textbox(label="Tags", info="Tag(s) to filter repos", value="")
                         with gr.Accordion("Tag input assistance", open=False):
@@ -33,9 +38,11 @@ with gr.Blocks(theme="NoCrypt/miku", fill_width=True, css=CSS) as demo:
                                 subtag_cat = gr.Dropdown(label="Category", choices=get_subtag_categories(), value=get_subtag_categories()[0], scale=2)
                                 subtag_item = gr.Dropdown(label="Item", choices=[""], value="", allow_custom_value=True, scale=2)
                                 subtug_btn = gr.Button("Add", scale=1)
-                    with gr.Column():
-                        gated_status = gr.Radio(label="Gated status", choices=["gated", "non-gated", "all"], value="all")
-                        appr_status = gr.CheckboxGroup(label="Approval method", choices=["auto", "manual"], value=["auto", "manual"])
+                    with gr.Row(equal_height=True):
+                        with gr.Column():
+                            gated_status = gr.Radio(label="Gated status", choices=["gated", "non-gated", "all"], value="all")
+                            appr_status = gr.CheckboxGroup(label="Approval method", choices=["auto", "manual"], value=["auto", "manual"])
+                        limit = gr.Number(label="Limit", info="If 0, fetches all models", value=1000, step=1, minimum=0, maximum=10000000)
                     with gr.Tab("for Models"):
                         with gr.Column():
                             infer_status = gr.Radio(label="Inference status", choices=["warm", "cold", "frozen", "all"], value="all")
@@ -54,13 +61,12 @@ with gr.Blocks(theme="NoCrypt/miku", fill_width=True, css=CSS) as demo:
                         with gr.Row(equal_height=True):
                             hardware = gr.CheckboxGroup(label="Specify hardware", choices=SPACE_HARDWARES, value=[])
                             stage = gr.CheckboxGroup(label="Specify stage", choices=SPACE_STAGES, value=[])
-                    with gr.Row(equal_height=True):
-                        sort = gr.Radio(label="Sort", choices=["last_modified", "likes", "downloads", "trending_score"], value="likes")
-                        sort_method = gr.Radio(label="Sort method", choices=["ascending order", "descending order"], value="ascending order")
-                        limit = gr.Number(label="Limit", info="If 0, fetches all models", value=1000, step=1, minimum=0, maximum=10000000)
-                        fetch_detail = gr.CheckboxGroup(label="Fetch detail", choices=["Space Runtime"], value=["Space Runtime"])
-                    with gr.Row(equal_height=True):
-                        show_labels = gr.CheckboxGroup(label="Show items", choices=get_labels(), value=get_valid_labels())
+                    with gr.Accordion("More Advanced", open=False):
+                        with gr.Row(equal_height=True):
+                            sort_method = gr.Radio(label="Sort method", choices=["ascending order", "descending order"], value="ascending order")
+                            fetch_detail = gr.CheckboxGroup(label="Fetch detail", choices=["Space Runtime"], value=["Space Runtime"])
+                        with gr.Row(equal_height=True):
+                            show_labels = gr.CheckboxGroup(label="Show items", choices=get_labels(), value=get_valid_labels())
                 run_button = gr.Button("Search", variant="primary")
         with gr.Tab("Find Serverless Inference API enabled models"):
             with gr.Group():
@@ -97,11 +103,11 @@ with gr.Blocks(theme="NoCrypt/miku", fill_width=True, css=CSS) as demo:
             result_df = gr.DataFrame(label="Results", type="pandas", value=None, interactive=False)
 
     run_button.click(search, [repo_types, sort, sort_method, filter_str, search_str, author, tags, infer_status, gated_status, appr_status,
-                              size_categories, limit, hardware, stage, fetch_detail, show_labels, search_result],
+                              size_categories, limit, hardware, stage, followed, fetch_detail, show_labels, ui_mode, search_result],
                      [result_df, hide_labels, search_result])\
     .success(update_filter, [filter_item1, search_result], [filter_item1, filter1, filter_btn, search_result], queue=False)
     infer_run_button.click(search, [infer_repo_types, sort, sort_method, filter_str, search_str, author, tags, infer_infer_status, infer_gated_status, infer_appr_status,
-                                    size_categories, limit, hardware, stage, fetch_detail, show_labels, search_result],
+                                    size_categories, limit, hardware, stage, followed, fetch_detail, show_labels, ui_mode, search_result],
                            [result_df, hide_labels, search_result])\
     .success(update_filter, [filter_item1, search_result], [filter_item1, filter1, filter_btn, search_result], queue=False)
     gr.on(triggers=[hide_labels.change, filter_btn.click], fn=update_df, inputs=[hide_labels, filter_item1, filter1, search_result],
@@ -110,7 +116,8 @@ with gr.Blocks(theme="NoCrypt/miku", fill_width=True, css=CSS) as demo:
     subtag_cat.change(update_subtag_items, [subtag_cat], [subtag_item], queue=False, show_api=False)
     subtug_btn.click(update_subtags, [tags, subtag_cat, subtag_item], [tags], queue=False, show_api=False)
     tag_btn.click(update_tags, [tags, tag_item], [tags], queue=False, show_api=False)
-    gr.on(triggers=[rec_run_button.click, rec_repo_id.submit], fn=search_ref_repos, inputs=[rec_repo_id, rec_repo_types, rec_sort, rec_show_labels, rec_limit, search_result],
+    gr.on(triggers=[rec_run_button.click, rec_repo_id.submit], fn=search_ref_repos,
+          inputs=[rec_repo_id, rec_repo_types, rec_sort, rec_show_labels, rec_limit, ui_mode, search_result],
           outputs=[result_df, hide_labels, search_result])
 
 demo.queue().launch()

hfconstants.py

@@ -6,6 +6,11 @@ SPACE_HARDWARES = ["cpu-basic", "zero-a10g", "cpu-upgrade", "t4-small", "l4x1",
 
 SPACE_STAGES = ["RUNNING", "SLEEPING", "RUNTIME_ERROR", "PAUSED", "BUILD_ERROR", "CONFIG_ERROR", "BUILDING", "APP_STARTING", "RUNNING_APP_STARTING"]
 
+SPACE_STAGES_EMOJI = {
+    "SLEEPING": "💤", "RUNTIME_ERROR": "💀", "PAUSED": "⏸️", "BUILD_ERROR": "💀",
+    "CONFIG_ERROR": "💀", "BUILDING": "🚧", "APP_STARTING": "🚧", "RUNNING_APP_STARTING": "🚧"
+}
+
 PIPELINES = ["text-generation", "text-to-image", "image-text-to-text", "fill-mask", "text-classification", "sentence-similarity", "automatic-speech-recognition",
     "feature-extraction", "text-to-speech", "text2text-generation", "image-to-image", "text-to-video", "zero-shot-image-classification",
     "image-classification", "image-to-video", "image-to-text", "token-classification", "translation", "time-series-forecasting", "audio-classification",

hfsearch.py

@@ -8,7 +8,7 @@ import pandas as pd
 import datetime
 import json
 import re
-from hfconstants import DS_SIZE_CATEGORIES, SPACE_HARDWARES, SPACE_STAGES, EMOJIS
+from hfconstants import DS_SIZE_CATEGORIES, SPACE_HARDWARES, SPACE_STAGES, SPACE_STAGES_EMOJI, EMOJIS
 
 @spaces.GPU
 def dummy_gpu():
@@ -288,10 +288,18 @@ class HFSearchResult():
         self.show_labels = []
         self.filter_items = None
         self.filters = None
+        self.phone_mode = True #
         gc.collect()
     
     def reset(self):
         self.__init__()
+    
+    def set_mode(self, mode: str):
+        if mode == "Phone": self.phone_mode = True
+        elif mode == "PC": self.phone_mode = False
+    
+    def get_show_labels(self):
+        return ["Type", "ID"] if self.phone_mode else self.show_labels
 
     def _set(self, data, label: str):
         self.labels.set(label)
@@ -358,9 +366,10 @@ class HFSearchResult():
         self._next()
 
     def search(self, repo_types: list, sort: str, sort_method: str, filter_str: str, search_str: str, author: str, tags: str, infer: str, gated: str, appr: list[str],
-               size_categories: list, limit: int, hardware: list, stage: list, fetch_detail: list, show_labels: list):
+               size_categories: list, limit: int, hardware: list, stage: list, followed: str, fetch_detail: list, show_labels: list, ui_mode="PC"):
         try:
             self.reset()
+            self.set_mode(ui_mode)
             self.show_labels = show_labels.copy()
             api = HfApi()
             kwargs = {}
@@ -422,13 +431,15 @@ class HFSearchResult():
                 cols = api.list_collections(**ckwargs)
                 for col in cols:
                     self.add_item(col)
+            if followed: self.followed_by(followed)
             self.sort(sort)
         except Exception as e:
             raise Exception(f"Search error: {e}") from e
 
-    def search_ref_repos(self, repo_id: str, repo_types: str, sort: str, show_labels: list, limit=10):
+    def search_ref_repos(self, repo_id: str, repo_types: str, sort: str, show_labels: list, limit=10, ui_mode="PC"):
         try:
             self.reset()
+            self.set_mode(ui_mode)
             self.show_labels = show_labels.copy()
             api = HfApi()
             if "model" in repo_types or "dataset" in repo_types or "space" in repo_types or "paper" in repo_types:
@@ -453,8 +464,8 @@ class HFSearchResult():
         self._do_filter()
         dflist = [[item.get(l, self.labels.get_null_value(t)) for l, t in zip(labels, label_types)] for item, is_hide in zip(self.item_list, self.item_hide_flags) if not is_hide]
         df = self._to_pandas(dflist, labels)
-        show_label_types = [t for l, t in zip(labels, label_types) if l not in self.hide_labels and l in self.show_labels]
-        show_labels = [l for l in labels if l not in self.hide_labels and l in self.show_labels]
+        show_label_types = [t for l, t in zip(labels, label_types) if l not in self.hide_labels and l in self.get_show_labels()]
+        show_labels = [l for l in labels if l not in self.hide_labels and l in self.get_show_labels()]
         return df, show_labels, show_label_types
 
     def _to_pandas(self, dflist: list, labels: list):
@@ -478,8 +489,8 @@ class HFSearchResult():
             if "AllDLs" in columns: sdf = rank_df(sdf, df, "AllDLs")
             if "DLs" in columns: sdf = rank_df(sdf, df, "DLs")
             if "Status" in columns:
-                sdf.loc[df["Status"] == "warm", ["Type"]] = 'color: orange'
-                sdf.loc[df["Status"] == "cold", ["Type"]] = 'color: dodgerblue'
+                sdf.loc[df["Status"] == "warm", ["Type", "Status"]] = 'color: orange'
+                sdf.loc[df["Status"] == "cold", ["Type", "Status"]] = 'color: dodgerblue'
             if "Gated" in columns:
                 sdf.loc[df["Gated"] == "auto", ["Gated"]] = 'color: dodgerblue'
                 sdf.loc[df["Gated"] == "manual", ["Gated"]] = 'color: crimson'
@@ -496,12 +507,32 @@ class HFSearchResult():
             sdf = sdf.drop(drop_columns, axis=1)
             return sdf
         
-        def id_to_md(df: pd.DataFrame):
-            if df["Type"] == "collection": return f'[{df["User"]}/{df["Name"]}]({df["URL"]}){df["Emoji"]}'
-            elif df["Type"] == "space": return f'[{df["Name"]} ({df["ID"]})]({df["URL"]}){df["Emoji"]}'
-            elif df["Type"] == "paper": return f'[{df["Name"]} (arxiv:{df["ID"]})]({df["URL"]}){df["Emoji"]}'
-            else: return f'[{df["ID"]}]({df["URL"]}){df["Emoji"]}'
-        
+        def id_to_md(df: pd.DataFrame, verbose=False):
+            columns = list(df.index)
+            if df["Type"] == "collection": id = f'[{df["User"]}/{df["Name"]}]({df["URL"]}){df["Emoji"]}'
+            elif df["Type"] == "space": id = f'[{df["Name"]} ({df["ID"]})]({df["URL"]}){df["Emoji"]}'
+            elif df["Type"] == "paper": id = f'[{df["Name"]} (arxiv:{df["ID"]})]({df["URL"]}){df["Emoji"]}'
+            else: id = f'[{df["ID"]}]({df["URL"]}){df["Emoji"]}'
+            if verbose:
+                l = []
+                if "NFAA" in columns and df["NFAA"] == "True": l.append('🤐')
+                if "Likes" in columns and df["Likes"] > 0: l.append(f'💕:{df["Likes"]}')
+                if df["Type"] in ["model", "space", "dataset"]:
+                    if "Trending" in columns and df["Trending"] > 0: l.append(f'trend:{df["Trending"]}')
+                    if df["Type"] in ["model", "dataset"]:
+                        if "DLs" in columns and df["DLs"] > 0: l.append(f'DL:{df["DLs"]}')
+                        if "Gated" in columns and df["Gated"] in ["manual", "auto"]: l.append(f'🔑:{df["Gated"]}')
+                    if df["Type"] == "model":
+                        if "Status" in columns:
+                            if df["Status"] == "warm": l.append(f'inference:🔥')
+                            elif df["Status"] == "cold": l.append(f'inference:🧊')
+                    if df["Type"] == "space":
+                        if "Hardware" in columns and df["Hardware"] in SPACE_HARDWARES and df["Hardware"] != "cpu-basic": l.append(f'{df["Hardware"]}')
+                        if "SDK" in columns: l.append(f'{df["SDK"]}')
+                        if "Stage" in columns and df["Stage"] in SPACE_STAGES_EMOJI.keys(): l.append(f'{SPACE_STAGES_EMOJI[df["Stage"]]}')
+                if len(l) > 0: id += f" ({' '.join(l)})"
+            return id
+
         def to_emoji(df: pd.DataFrame, label: str, key: str, emoji: str):
             if df[label] == key: return f'{df["Emoji"]}{emoji}' if df["Emoji"] else f' {emoji}'
             else: return df["Emoji"]
@@ -513,12 +544,12 @@ class HFSearchResult():
                     df["Emoji"] = df.apply(to_emoji, axis=1, label=label, key=key, emoji=emoji)
             return df
 
-        def format_md_df(df: pd.DataFrame):
-            df["ID"] = df.apply(id_to_md, axis=1)
+        def format_md_df(df: pd.DataFrame, verbose=False):
+            df["ID"] = df.apply(id_to_md, axis=1, verbose=verbose)
             return df
         
-        hide_labels = [l for l in labels if l in self.hide_labels or l not in self.show_labels]
-        df = format_md_df(apply_emoji_df(pd.DataFrame(dflist, columns=labels)))
+        hide_labels = [l for l in labels if l in self.hide_labels or l not in self.get_show_labels()]
+        df = format_md_df(apply_emoji_df(pd.DataFrame(dflist, columns=labels)), verbose=self.phone_mode)
         ref_df = df.copy()
         df = df.drop(hide_labels, axis=1).style.apply(highlight_df, axis=None, df=ref_df)
         return df
@@ -568,9 +599,18 @@ class HFSearchResult():
         if not key in self.labels.get()[0]: key = "Likes"
         self.item_list, self.item_hide_flags, self.item_info_list = zip(*sorted(zip(self.item_list, self.item_hide_flags, self.item_info_list), key=lambda x: x[0][key], reverse=True))
 
+    def followed_by(self, user: str):
+        if not user: return
+        api = HfApi()
+        usernames = set([x.username for x in api.list_user_following(username=user)])
+        self.item_hide_flags = [True if i["ID"].split("/")[0] not in usernames else is_hide for i, is_hide in zip(self.item_list, self.item_hide_flags)]
+
     def get_gr_df(self):
         df, labels, label_types = self.get()
         widths = self.labels.get_widths()
+        if self.phone_mode:
+            widths["Type"] = "10%"
+            widths["ID"] = "90%"
         column_widths = [widths[l] for l in labels]
         return gr.update(type="pandas", value=df, headers=labels, datatype=label_types, column_widths=column_widths, wrap=True)
 
@@ -595,18 +635,19 @@ class HFSearchResult():
         return gr.update(choices=[""] + [t[0] for t in sorted(d.items(), key=lambda x : x[1])][:100], value="", visible=True)
 
 def search(repo_types: list, sort: str, sort_method: str, filter_str: str, search_str: str, author: str, tags: str, infer: str,
-           gated: str, appr: list[str], size_categories: list, limit: int, hardware: list, stage: list, fetch_detail: list, show_labels: list, r: HFSearchResult):
+           gated: str, appr: list[str], size_categories: list, limit: int, hardware: list, stage: list, followed: str,
+           fetch_detail: list, show_labels: list, ui_mode: str, r: HFSearchResult):
     try:
         r.search(repo_types, sort, sort_method, filter_str, search_str, author, tags, infer, gated, appr, size_categories,
-                 limit, hardware, stage, fetch_detail, show_labels)
+                 limit, hardware, stage, followed, fetch_detail, show_labels, ui_mode)
         return r.get_gr_df(), r.get_gr_hide_labels(), r
     except Exception as e:
         raise gr.Error(e)
 
-def search_ref_repos(repo_id: str, repo_types: list, sort: str, show_labels: list, limit, r: HFSearchResult):
+def search_ref_repos(repo_id: str, repo_types: list, sort: str, show_labels: list, limit, ui_mode: str, r: HFSearchResult):
     try:
         if not repo_id: raise gr.Error("Input Repo ID")
-        r.search_ref_repos(repo_id, repo_types, sort, show_labels, limit)
+        r.search_ref_repos(repo_id, repo_types, sort, show_labels, limit, ui_mode)
         return r.get_gr_df(), r.get_gr_hide_labels(), r
     except Exception as e:
         raise gr.Error(e)