Update app.py

app.py

@@ -9,7 +9,6 @@ from requests.exceptions import HTTPError
 def parse_roboflow_url(url):
     """
     Extract workspace/project and version from a Roboflow Universe URL.
-    Example: https://universe.roboflow.com/.../dataset/6
     Returns (workspace, project, version)
     """
     pattern = r"roboflow\.com/([^/]+)/([^/]+)/dataset/(\d+)"
@@ -21,18 +20,17 @@ def parse_roboflow_url(url):
 
 def fetch_metadata(api_key, workspace, project, version):
     """
-    Fetch metadata for a given project version from Roboflow API.
-    Raises ValueError on HTTP errors.
+    Fetch metadata from Roboflow. Raises ValueError on HTTP errors.
     """
     endpoint = f"https://api.roboflow.com/{workspace}/{project}/{version}"
+    resp = requests.get(endpoint, params={"api_key": api_key})
     try:
-        resp = requests.get(endpoint, params={"api_key": api_key})
         resp.raise_for_status()
     except HTTPError:
         if resp.status_code == 401:
             raise ValueError("Unauthorized: check your API key.")
         else:
-            raise ValueError(f"Error fetching {workspace}/{project}/{version}: {resp.status_code}")
+            raise ValueError(f"Error {resp.status_code} for {workspace}/{project}/{version}")
     data = resp.json()
     total = data.get("version", {}).get("images") or data.get("project", {}).get("images", 0)
     classes = data.get("project", {}).get("classes", {})
@@ -41,15 +39,19 @@ def fetch_metadata(api_key, workspace, project, version):
 
 def aggregate_datasets(api_key, entries):
     """
-    Given API key and list of (url, file, line) tuples,
-    returns total_images, aggregated lowercase class counts,
-    and per-class source URLs.
+    Given list of (url, file, line), returns:
+      - total_images
+      - dict[class_name_lowercase] = aggregated count
+      - dict[class_name_lowercase] = set(source URLs)
     """
     total_images = 0
     class_counts = {}
     class_sources = {}
     for url, fname, lineno in entries:
-        ws, proj, ver = parse_roboflow_url(url)
+        try:
+            ws, proj, ver = parse_roboflow_url(url)
+        except ValueError:
+            raise ValueError(f"Invalid URL '{url}' in file '{fname}', line {lineno}")
         imgs, cls_map = fetch_metadata(api_key, ws, proj, ver)
         total_images += imgs
         for cls, cnt in cls_map.items():
@@ -61,14 +63,14 @@ def aggregate_datasets(api_key, entries):
 
 def make_bar_chart(counts):
     """
-    Return a matplotlib figure showing a bar chart of counts dict.
+    Build a bar chart from a {label: value} dict.
     """
     fig, ax = plt.subplots()
-    keys = list(counts.keys())
-    vals = list(counts.values())
-    ax.bar(range(len(keys)), vals)
-    ax.set_xticks(range(len(keys)))
-    ax.set_xticklabels(keys, rotation=45, ha="right")
+    labels = list(counts.keys())
+    values = list(counts.values())
+    ax.bar(range(len(labels)), values)
+    ax.set_xticks(range(len(labels)))
+    ax.set_xticklabels(labels, rotation=45, ha="right")
     ax.set_ylabel("Image Count")
     ax.set_title("Class Distribution")
     fig.tight_layout()
@@ -77,14 +79,19 @@ def make_bar_chart(counts):
 
 def load_datasets(api_key, file_objs):
     """
-    Read uploaded .txt files, dedupe URLs, fetch metadata,
-    and return all outputs for the UI.
+    1) Ensure API key present
+    2) Read & dedupe URLs from each uploaded .txt
+    3) Fetch & aggregate metadata
+    Returns: total, table_data, figure, json_counts, markdown_sources
     """
+    if not api_key or not api_key.strip():
+        raise ValueError("Please enter your Roboflow API Key before loading datasets.")
+
     entries = []
     seen = set()
     for fobj in file_objs:
         fname = getattr(fobj, "name", None) or fobj.get("name", "unknown")
-        # read raw content
+        # read raw bytes or dict-data or file path
         try:
             raw = fobj.read()
         except:
@@ -93,6 +100,7 @@ def load_datasets(api_key, file_objs):
             with open(fobj, "rb") as fh:
                 raw = fh.read()
         text = raw.decode("utf-8") if isinstance(raw, (bytes, bytearray)) else raw
+
         for i, line in enumerate(text.splitlines(), start=1):
             url = line.strip()
             if url and url not in seen:
@@ -101,30 +109,41 @@ def load_datasets(api_key, file_objs):
 
     total, counts, sources = aggregate_datasets(api_key, entries)
 
-    # build dataframe list
-    df_data = [[cls, counts[cls]] for cls in counts]
+    # build dataframe rows
+    table_data = [[cls, counts[cls]] for cls in counts]
 
-    # build markdown of sources
+    # build clickable markdown per-class
     md_lines = []
     for cls in counts:
-        links = ", ".join(f"[{s.split('/')[-1]}]({s})" for s in sources[cls])
+        links = ", ".join(f"[{url.split('/')[-1]}]({url})" for url in sources[cls])
         md_lines.append(f"- **{cls}** ({counts[cls]} images): {links}")
     md_sources = "\n".join(md_lines)
 
     fig = make_bar_chart(counts)
-    return str(total), df_data, fig, json.dumps(counts, indent=2), md_sources
+    return str(total), table_data, fig, json.dumps(counts, indent=2), md_sources
 
 
 def update_classes(df_data):
     """
-    Take the edited table rows, merge duplicates (lowercase),
-    and return updated total, df, chart, JSON, and markdown.
+    Convert df_data into a list-of-lists (if needed),
+    merge duplicate/lowercased class names, and recalc all outputs.
+    Returns: total, updated_table, figure, json_counts, markdown_summary
     """
+    # convert Pandas DataFrame or NumPy array into list-of-lists
+    if not isinstance(df_data, list):
+        if hasattr(df_data, "to_numpy"):
+            df_data = df_data.to_numpy().tolist()
+        elif hasattr(df_data, "tolist"):
+            df_data = df_data.tolist()
+
     combined = {}
-    for name, cnt in df_data:
+    for row in df_data:
+        if len(row) < 2:
+            continue
+        name, cnt = row[0], row[1]
         if not name:
             continue
-        key = name.strip().lower()
+        key = str(name).strip().lower()
         try:
             val = int(cnt)
         except:
@@ -132,10 +151,11 @@ def update_classes(df_data):
         combined[key] = combined.get(key, 0) + val
 
     total = sum(combined.values())
-    updated_df = [[k, combined[k]] for k in combined]
+    updated_table = [[k, combined[k]] for k in combined]
     fig = make_bar_chart(combined)
     md_summary = "\n".join(f"- **{k}** ({combined[k]} images)" for k in combined)
-    return str(total), updated_df, fig, json.dumps(combined, indent=2), md_summary
+
+    return str(total), updated_table, fig, json.dumps(combined, indent=2), md_summary
 
 
 def build_ui():
@@ -149,7 +169,10 @@ def build_ui():
         load_btn = gr.Button("Load Datasets")
         total_out = gr.Textbox(label="Total Images", interactive=False)
         df = gr.Dataframe(
-            headers=["Class Name", "Count"], row_count=(1, None), col_count=2, interactive=True
+            headers=["Class Name", "Count"],
+            row_count=(1, None),
+            col_count=2,
+            interactive=True
         )
         plot = gr.Plot()
         json_out = gr.Textbox(label="Counts (JSON)", interactive=False)
@@ -160,12 +183,12 @@ def build_ui():
         load_btn.click(
             fn=load_datasets,
             inputs=[api_input, files],
-            outputs=[total_out, df, plot, json_out, md_out],
+            outputs=[total_out, df, plot, json_out, md_out]
         )
         update_btn.click(
             fn=update_classes,
             inputs=[df],
-            outputs=[total_out, df, plot, json_out, md_out],
+            outputs=[total_out, df, plot, json_out, md_out]
         )
 
     return demo