Updates including full validation report

app.py

@@ -2,36 +2,50 @@ import gradio as gr
 import json
 import time
 import traceback
-from validation import validate_json, validate_croissant, validate_records
+from validation import validate_json, validate_croissant, validate_records, generate_validation_report
 import requests
 
 def process_file(file):
     results = []
+    json_data = None
+
+    # Use just the filename instead of full path
+    filename = file.name.split("/")[-1]
     
     # Check 1: JSON validation
     json_valid, json_message, json_data = validate_json(file.name)
+    # Remove empty checkmarks from messages
+    json_message = json_message.replace("\n✓\n", "\n")
     results.append(("JSON Format Validation", json_valid, json_message))
     
     if not json_valid:
-        return results
+        return results, None
     
     # Check 2: Croissant validation
-    croissant_valid, croissant_message = validate_croissant(json_data)
+    croissant_valid, croissant_message = validate_croissant(json_data)    
+    # Remove empty checkmarks from messages
+    croissant_message = croissant_message.replace("\n✓\n", "\n")
     results.append(("Croissant Schema Validation", croissant_valid, croissant_message))
     
     if not croissant_valid:
-        return results
+        return results, None
     
     # Check 3: Records validation
-    records_valid, records_message = validate_records(json_data)
+    records_valid, records_message = validate_records(json_data)    
+    # Remove empty checkmarks from messages
+    records_message = records_message.replace("\n✓\n", "\n")
     results.append(("Records Generation Test", records_valid, records_message))
     
-    return results
+
+    # Generate detailed report with just filename
+    report = generate_validation_report(filename, json_data, results)
+
+    return results, report
 
 def create_ui():
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         gr.HTML("<p align='center'><img src='https://upload.wikimedia.org/wikipedia/en/0/08/Logo_for_Conference_on_Neural_Information_Processing_Systems.svg' alt='NeurIPS Logo' width='400'/></p>")
-        gr.Markdown("# 🥐 Croissant JSON-LD Validator for NeurIPS")
+        gr.Markdown("# 🥐 Croissant Validator for NeurIPS")
         gr.Markdown("""
         Upload your Croissant JSON-LD file or enter a URL to validate if it meets the requirements for NeurIPS submission. <a href="https://blog.neurips.cc/2025/03/10/neurips-datasets-benchmarks-raising-the-bar-for-dataset-submissions/">Read more about why this is required.</a>.
         
@@ -70,7 +84,23 @@ def create_ui():
         # Now create the validation results section in a separate group
         with gr.Group():
             # Validation results
-            validation_results = gr.HTML(visible=False)
+            validation_results = gr.HTML(visible=False)            
+            validation_progress = gr.HTML(visible=False)
+
+            # Collapsible report section
+            with gr.Accordion("Download full validation report", visible=False, open=False) as report_group:
+                with gr.Column():
+                    report_md = gr.File(
+                        label="Download Report",
+                        visible=True,
+                        file_types=[".md"]
+                    )
+                    report_text = gr.Textbox(
+                        label="Report Content", 
+                        visible=True,
+                        show_copy_button=True,
+                        lines=10
+                    )
         
         # Define CSS for the validation UI
         gr.HTML("""
@@ -165,8 +195,84 @@ def create_ui():
         .arrow-indicator {
             font-size: 14px;
             transition: transform 0.3s ease;
+            transform: rotate(0deg);  /* Point right by default */
         }
         .arrow-down {
+            transform: rotate(90deg);  /* Point down when expanded */
+        }
+        
+        /* Loading animation */
+        .loading-spinner {
+            display: inline-block;
+            width: 20px;
+            height: 20px;
+            border: 3px solid rgba(0, 0, 0, 0.1);
+            border-radius: 50%;
+            border-top-color: var(--primary-500);
+            animation: spin 1s ease-in-out infinite;
+            margin-right: 10px;
+        }
+        @keyframes spin {
+            to { transform: rotate(360deg); }
+        }
+        .validation-progress {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 10px;
+            margin: 10px 0;
+            background-color: var(--background-fill-secondary);
+            border-radius: 8px;
+        }
+        /* Override Gradio's default accordion arrow */
+        .gr-accordion {
+            position: relative;
+        }
+        .gr-accordion > .label-wrap {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding-right: 32px;  /* Make room for the arrow */
+        }
+        .gr-accordion > .label-wrap::after {
+            content: "▶";
+            position: absolute;
+            right: 16px;
+            top: 50%;
+            transform: translateY(-50%);
+            transition: transform 0.3s ease;
+            font-size: 0.8em;
+        }
+        .gr-accordion[data-open=true] > .label-wrap::after {
+            transform: translateY(-50%) rotate(90deg);
+        }
+        /* Consistent arrow styling for both validation steps and accordion */
+        .validation-step .step-header,
+        .gr-accordion > .label-wrap {
+            position: relative;
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        .validation-step .arrow-indicator,
+        .gr-accordion > .label-wrap::after {
+            content: "▶";
+            font-size: 0.8em;
+            margin-left: 8px;
+            transition: transform 0.3s ease;
+        }
+        /* Remove absolute positioning and right alignment for accordion arrow */
+        .gr-accordion > .label-wrap {
+            padding-right: 0;  /* Remove extra padding */
+        }
+        .gr-accordion > .label-wrap::after {
+            position: static;  /* Remove absolute positioning */
+            right: auto;
+            transform: none;
+        }
+        /* Consistent rotation for expanded state */
+        .validation-step .arrow-down,
+        .gr-accordion[data-open=true] > .label-wrap::after {
             transform: rotate(90deg);
         }
         </style>
@@ -176,61 +282,145 @@ def create_ui():
         def on_tab_change(evt: gr.SelectData):
             tab_id = evt.value
             if tab_id == "Upload File":
-                return "upload", """<div class="progress-status">Ready for upload</div>""", gr.update(visible=False)
+                return [
+                    "upload",
+                    """<div class="progress-status">Ready for upload</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),  # Hide report group
+                    None,  # Clear report text
+                    None,  # Clear report file
+                    None,  # Clear file input
+                    gr.update(value="")  # Clear URL input
+                ]
             else:
-                return "url", """<div class="progress-status">Enter a URL to fetch</div>""", gr.update(visible=False)
+                return [
+                    "url",
+                    """<div class="progress-status">Enter a URL to fetch</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),  # Hide report group
+                    None,  # Clear report text
+                    None,  # Clear report file
+                    None,  # Clear file input
+                    gr.update(value="")  # Clear URL input
+                ]
+
+        def on_copy_click(report):
+            return report
+
+        def on_download_click(report, file_name):
+            report_file = f"report_{file_name}.md"
+            with open(report_file, "w") as f:
+                f.write(report)
+            return report_file
         
         def on_file_upload(file):
             if file is None:
-                return """<div class="progress-status">Ready for upload</div>""", gr.update(visible=False)
-            
-            return """<div class="progress-status">✅ File uploaded successfully</div>""", gr.update(visible=False)
-        
+                return [
+                    """<div class="progress-status">Ready for upload</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),  # Hide report group
+                    None,  # Clear report text
+                    None   # Clear report file
+                ]
+
+            return [
+                """<div class="progress-status">✅ File uploaded successfully</div>""",
+                gr.update(visible=False),
+                gr.update(visible=False),  # Hide report group
+                None,  # Clear report text
+                None   # Clear report file
+            ]
+                
         def fetch_from_url(url):
             if not url:
-                return """<div class="progress-status">Please enter a URL</div>""", gr.update(visible=False)
-            
+                return [
+                    """<div class="progress-status">Please enter a URL</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    None,
+                    None
+                ]
             try:
                 # Fetch JSON from URL
                 response = requests.get(url, timeout=10)
                 response.raise_for_status()
                 json_data = response.json()
                 
-                # Show success message
+                # Process validation
                 progress_html = """<div class="progress-status">✅ JSON fetched successfully from URL</div>"""
                 
                 # Validate the fetched JSON
                 results = []
-                results.append(("JSON Format Validation", True, "✅ The URL returned valid JSON."))
+                results.append(("JSON Format Validation", True, "The URL returned valid JSON."))
                 
                 croissant_valid, croissant_message = validate_croissant(json_data)
                 results.append(("Croissant Schema Validation", croissant_valid, croissant_message))
                 
                 if not croissant_valid:
-                    return progress_html, build_results_html(results)
+                    return [
+                        """<div class="progress-status">✅ JSON fetched successfully from URL</div>""",
+                        build_results_html(results),
+                        gr.update(visible=False),
+                        None,
+                        None
+                    ]
                 
                 records_valid, records_message = validate_records(json_data)
                 results.append(("Records Generation Test", records_valid, records_message))
                 
-                return progress_html, build_results_html(results)
-                
+                # Generate report
+                report = generate_validation_report(url.split("/")[-1], json_data, results)
+                report_filename = f"report_croissant-validation_{json_data.get('name', 'unnamed')}.md"
+
+                if report:
+                    with open(report_filename, "w") as f:
+                        f.write(report)
+
+                return [
+                    """<div class="progress-status">✅ JSON fetched successfully from URL</div>""",
+                    build_results_html(results),
+                    gr.update(visible=True),
+                    report,
+                    report_filename
+                ]
+                            
             except requests.exceptions.RequestException as e:
-                error_message = f"❌ Error fetching URL: {str(e)}"
-                return f"""<div class="progress-status">{error_message}</div>""", gr.update(visible=False)
+                error_message = f"Error fetching URL: {str(e)}"
+                return [
+                    f"""<div class="progress-status">{error_message}</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    None,
+                    None
+                ]                
             except json.JSONDecodeError as e:
-                error_message = f"❌ URL did not return valid JSON: {str(e)}"
-                return f"""<div class="progress-status">{error_message}</div>""", gr.update(visible=False)
+                error_message = f"URL did not return valid JSON: {str(e)}"
+                return [
+                    f"""<div class="progress-status">{error_message}</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    None,
+                    None
+                ]
             except Exception as e:
-                error_message = f"❌ Unexpected error: {str(e)}"
-                return f"""<div class="progress-status">{error_message}</div>""", gr.update(visible=False)
-        
+                error_message = f"Unexpected error: {str(e)}"
+                return [
+                    f"""<div class="progress-status">{error_message}</div>""",
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    None,
+                    None
+                ]
+            
         def build_results_html(results):
             # Build validation results HTML
             html = '<div class="validation-results">'
             
             for i, (test_name, passed, message) in enumerate(results):
                 status_class = "status-success" if passed else "status-error"
-                status_icon = "✓" if passed else "✗"
+                status_icon = "✓" if passed else "✗"                
+                # Add emoji to message
+                message_with_emoji = ("✅ " if passed else "❌ ") + message
                 
                 html += f'''
                 <div class="validation-step" id="step-{i}">
@@ -246,12 +436,12 @@ def create_ui():
                         }}">
                         <div class="step-left">
                             <div class="step-status {status_class}">{status_icon}</div>
-                            <div class="step-title">{test_name}</div>
-                            <div class="arrow-indicator" id="arrow-{i}">▶</div>
+                            <span class="step-title">{test_name}</span>
+                            <span class="arrow-indicator" id="arrow-{i}">▶</span>
                         </div>
                     </div>
                     <div class="step-details" id="details-{i}" style="display: none;">
-                        {message}
+                        {message_with_emoji}
                     </div>
                 </div>
                 '''
@@ -261,18 +451,85 @@ def create_ui():
         
         def on_validate(file):
             if file is None:
-                return gr.update(visible=False)
-            
+                return [
+                    gr.update(visible=False),  # validation_results
+                    gr.update(visible=False),  # validation_progress
+                    gr.update(visible=False),  # report_group
+                    None,  # report_text
+                    None   # report_md
+                ]
+
             # Process the file and get results
-            results = process_file(file)
-            return build_results_html(results)
-        
-        # Connect UI events to functions
-        tabs.select(on_tab_change, None, [active_tab, upload_progress, validation_results])
-        file_input.change(on_file_upload, inputs=file_input, outputs=[upload_progress, validation_results])
-        validate_btn.click(on_validate, inputs=file_input, outputs=validation_results)
-        fetch_btn.click(fetch_from_url, inputs=url_input, outputs=[upload_progress, validation_results])
-        
+            results, report = process_file(file)
+
+            # Extract dataset name from the JSON for the report filename
+            try:
+                with open(file.name, 'r') as f:
+                    json_data = json.load(f)
+                dataset_name = json_data.get('name', 'unnamed')
+            except:
+                dataset_name = 'unnamed'
+
+            # Save report to file with new naming convention
+            report_filename = f"report_croissant-validation_{dataset_name}.md"
+            if report:
+                with open(report_filename, "w") as f:
+                    f.write(report)
+
+            # Return final state
+            return [
+                build_results_html(results),  # validation_results
+                gr.update(visible=False),  # validation_progress
+                gr.update(visible=True) if report else gr.update(visible=False),  # report_group
+                report if report else None,  # report_text
+                report_filename if report else None  # report_md
+            ]
+
+        # Connect UI events to functions with updated outputs
+        tabs.select(
+            on_tab_change,
+            None,
+            [active_tab, upload_progress, validation_results, report_group, report_text, report_md, file_input, url_input]
+        )
+        file_input.change(
+            on_file_upload,
+            inputs=file_input,
+            outputs=[upload_progress, validation_results, report_group, report_text, report_md]
+        )
+
+        # Add progress state handling
+        def show_progress():
+            progress_html = """
+            <div class="validation-progress">
+                <div class="loading-spinner"></div>
+                <span>Validating file...</span>
+            </div>
+            """
+            return [
+                gr.update(visible=False),  # validation_results
+                gr.update(visible=True, value=progress_html),  # validation_progress
+                gr.update(visible=False),  # report_group
+                None,  # report_text
+                None   # report_md
+            ]
+
+        validate_btn.click(
+            fn=show_progress,
+            inputs=None,
+            outputs=[validation_results, validation_progress, report_group, report_text, report_md],
+            queue=False
+        ).then(
+            fn=on_validate,
+            inputs=file_input,
+            outputs=[validation_results, validation_progress, report_group, report_text, report_md]
+        )
+
+        fetch_btn.click(
+            fetch_from_url,
+            inputs=url_input,
+            outputs=[upload_progress, validation_results, report_group, report_text, report_md]
+        )
+
         # Footer
         gr.HTML("""
         <div style="text-align: center; margin-top: 20px;">
@@ -284,4 +541,4 @@ def create_ui():
 
 if __name__ == "__main__":
     app = create_ui()
-    app.launch() 
+    app.launch()

requirements.txt

@@ -1,4 +1,12 @@
+mlcroissant>=1.0.16
+pydantic==2.10.6
 gradio>=3.50.2
-mlcroissant
 func_timeout
-requests 
+requests
+huggingface-hub==0.30.1
+fsspec==2023.10.0
+aiohttp==3.11.15
+aiohappyeyeballs==2.6.1
+pandas==2.2.2
+pyarrow==18.1.0
+GitPython>=3.1.0

validation.py

@@ -10,26 +10,26 @@ def validate_json(file_path):
     try:
         with open(file_path, 'r') as f:
             json_data = json.load(f)
-        return True, "✅ The file is valid JSON.", json_data
+        return True, "The file is valid JSON.", json_data
     except json.JSONDecodeError as e:
-        error_message = f"❌ Invalid JSON format: {str(e)}"
+        error_message = f"Invalid JSON format: {str(e)}"
         return False, error_message, None
     except Exception as e:
-        error_message = f"❌ Error reading file: {str(e)}"
+        error_message = f"Error reading file: {str(e)}"
         return False, error_message, None
 
 def validate_croissant(json_data):
     """Validate that the JSON follows Croissant schema."""
     try:
         dataset = mlc.Dataset(jsonld=json_data)
-        return True, "✅ The dataset passes Croissant validation."
+        return True, "The dataset passes Croissant validation."
     except mlc.ValidationError as e:
         error_details = traceback.format_exc()
-        error_message = f"❌ Validation failed: {str(e)}\n\n{error_details}"
+        error_message = f"Validation failed: {str(e)}\n\n{error_details}"
         return False, error_message
     except Exception as e:
         error_details = traceback.format_exc()
-        error_message = f"❌ Unexpected error during validation: {str(e)}\n\n{error_details}"
+        error_message = f"Unexpected error during validation: {str(e)}\n\n{error_details}"
         return False, error_message
 
 def validate_records(json_data):
@@ -39,7 +39,7 @@ def validate_records(json_data):
         record_sets = dataset.metadata.record_sets
         
         if not record_sets:
-            return True, "✅ No record sets found to validate."
+            return True, "No record sets found to validate."
         
         results = []
         
@@ -47,17 +47,41 @@ def validate_records(json_data):
             try:
                 records = dataset.records(record_set=record_set.uuid)
                 _ = func_timeout.func_timeout(WAIT_TIME, lambda: next(iter(records)))
-                results.append(f"✅ Record set '{record_set.uuid}' passed validation.")
+                results.append(f"Record set '{record_set.uuid}' passed validation.")
             except func_timeout.exceptions.FunctionTimedOut:
-                error_message = f"❌ Record set '{record_set.uuid}' generation took too long (>60s)"
+                error_message = f"Record set '{record_set.uuid}' generation took too long (>60s)"
                 return False, error_message
             except Exception as e:
                 error_details = traceback.format_exc()
-                error_message = f"❌ Record set '{record_set.uuid}' failed: {str(e)}\n\n{error_details}"
+                error_message = f"Record set '{record_set.uuid}' failed: {str(e)}\n\n{error_details}"
                 return False, error_message
         
         return True, "\n".join(results)
     except Exception as e:
         error_details = traceback.format_exc()
-        error_message = f"❌ Unexpected error during records validation: {str(e)}\n\n{error_details}"
-        return False, error_message 
+        error_message = f"Unexpected error during records validation: {str(e)}\n\n{error_details}"
+        return False, error_message 
+    
+def generate_validation_report(filename, json_data, results):
+    """Generate a detailed validation report in markdown format."""
+    report = []
+    report.append("# CROISSANT VALIDATION REPORT")
+    report.append("=" * 80)
+    report.append("## VALIDATION RESULTS")
+    report.append("-" * 80)
+    report.append(f"Starting validation for file: {filename}")
+
+    # Add validation results
+    for test_name, passed, message in results:
+        report.append(f"### {test_name}")
+        report.append("✓" if passed else "✗")
+        report.append(message.strip())  # Remove any trailing newlines
+
+    # Add JSON-LD reference
+    report.append("## JSON-LD REFERENCE")
+    report.append("=" * 80)
+    report.append("```json")
+    report.append(json.dumps(json_data, indent=2))
+    report.append("```")
+
+    return "\n".join(report)