basic checker

app.py

@@ -0,0 +1,178 @@
+import gradio as gr
+import json
+import time
+import traceback
+from validation import validate_json, validate_croissant, validate_records
+
+def process_file(file):
+    results = []
+    
+    # Check 1: JSON validation
+    json_valid, json_message, json_data = validate_json(file.name)
+    results.append(("JSON Format Validation", json_valid, json_message))
+    
+    if not json_valid:
+        return results
+    
+    # Check 2: Croissant validation
+    croissant_valid, croissant_message = validate_croissant(json_data)
+    results.append(("Croissant Schema Validation", croissant_valid, croissant_message))
+    
+    if not croissant_valid:
+        return results
+    
+    # Check 3: Records validation
+    records_valid, records_message = validate_records(json_data)
+    results.append(("Records Generation Test", records_valid, records_message))
+    
+    return results
+
+def create_ui():
+    with gr.Blocks(theme=gr.themes.Soft()) as app:
+        gr.Markdown("# Croissant JSON-LD Validator for NeurIPS")
+        gr.Markdown("""
+        Upload your Croissant JSON-LD file to validate if it meets the requirements for NeurIPS submission.
+        The validator will check:
+        1. If the file is valid JSON
+        2. If it passes Croissant schema validation
+        3. If records can be generated within a reasonable time
+        """)
+        
+        with gr.Row():
+            file_input = gr.File(label="Upload Croissant JSON-LD File", file_types=[".json", ".jsonld"])
+        
+        upload_progress = gr.HTML(
+            """<div class="progress-container">
+                 <div class="progress-status">Ready for upload</div>
+               </div>""", visible=True)
+        
+        validate_btn = gr.Button("Validate", variant="primary")
+        
+        # Create containers for each validation step
+        validation_results = gr.HTML(visible=False)
+        
+        # Define CSS for the validation UI
+        gr.HTML("""
+        <style>
+        .validation-step {
+            margin-bottom: 15px;
+            border: 1px solid #e0e0e0;
+            border-radius: 8px;
+            overflow: hidden;
+        }
+        .step-header {
+            padding: 10px 15px;
+            background-color: #f5f5f5;
+            display: flex;
+            align-items: center;
+            cursor: pointer;
+        }
+        .step-status {
+            margin-right: 10px;
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-weight: bold;
+            color: white;
+        }
+        .status-waiting {
+            background-color: #9e9e9e;
+        }
+        .status-success {
+            background-color: #4caf50;
+        }
+        .status-error {
+            background-color: #f44336;
+        }
+        .step-title {
+            font-weight: 500;
+        }
+        .step-details {
+            padding: 15px;
+            background-color: #fafafa;
+            border-top: 1px solid #e0e0e0;
+            white-space: pre-wrap;
+            font-family: monospace;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+        .progress-container {
+            margin: 10px 0;
+            font-weight: 500;
+            text-align: center;
+        }
+        </style>
+        """)
+        
+        def on_file_upload(file):
+            if file is None:
+                return """<div class="progress-container">
+                         <div class="progress-status">Ready for upload</div>
+                       </div>"""
+            
+            return """<div class="progress-container">
+                     <div class="progress-status">✅ File uploaded successfully</div>
+                   </div>"""
+        
+        def on_validate(file):
+            if file is None:
+                return gr.update(visible=False)
+            
+            # Process the file and get results
+            results = process_file(file)
+            
+            # Build the HTML for validation results
+            html = '<div class="validation-results">'
+            
+            for i, (test_name, passed, message) in enumerate(results):
+                # Determine status class
+                status_class = "status-success" if passed else "status-error"
+                status_icon = "✓" if passed else "✗"
+                
+                html += f'''
+                <div class="validation-step" id="step-{i}">
+                    <div class="step-header" onclick="toggleDetails({i})">
+                        <div class="step-status {status_class}">{status_icon}</div>
+                        <div class="step-title">{test_name}</div>
+                    </div>
+                    <div class="step-details" id="details-{i}" style="display: none;">
+                        {message}
+                    </div>
+                </div>
+                '''
+            
+            html += '</div>'
+            
+            # Add JavaScript to handle toggling details
+            html += '''
+            <script>
+                function toggleDetails(id) {
+                    const details = document.getElementById('details-' + id);
+                    if (details.style.display === 'none') {
+                        details.style.display = 'block';
+                    } else {
+                        details.style.display = 'none';
+                    }
+                }
+            </script>
+            '''
+            
+            return gr.update(value=html, visible=True)
+        
+        file_input.change(on_file_upload, inputs=file_input, outputs=upload_progress)
+        validate_btn.click(on_validate, inputs=file_input, outputs=validation_results)
+        
+        gr.HTML("""
+        <div style="text-align: center; margin-top: 20px;">
+            <p>Based on the <a href="https://github.com/mlcommons/croissant" target="_blank">Croissant standard</a> from MLCommons.</p>
+        </div>
+        """)
+        
+    return app
+
+if __name__ == "__main__":
+    app = create_ui()
+    app.launch() 

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=3.50.2
+mlcroissant
+func_timeout 

validation.py

@@ -0,0 +1,63 @@
+import json
+import traceback
+import mlcroissant as mlc
+import func_timeout
+
+ONE_MINUTE = 60  # seconds
+
+def validate_json(file_path):
+    """Validate that the file is proper JSON."""
+    try:
+        with open(file_path, 'r') as f:
+            json_data = json.load(f)
+        return True, "✅ The file is valid JSON.", json_data
+    except json.JSONDecodeError as 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)}"
+        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."
+    except mlc.ValidationError as e:
+        error_details = traceback.format_exc()
+        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}"
+        return False, error_message
+
+def validate_records(json_data):
+    """Validate that records can be generated within the time limit."""
+    try:
+        dataset = mlc.Dataset(jsonld=json_data)
+        record_sets = dataset.metadata.record_sets
+        
+        if not record_sets:
+            return True, "✅ No record sets found to validate."
+        
+        results = []
+        
+        for record_set in record_sets:
+            try:
+                records = dataset.records(record_set=record_set.name)
+                _ = func_timeout.func_timeout(ONE_MINUTE, lambda: next(iter(records)))
+                results.append(f"✅ Record set '{record_set.name}' passed validation.")
+            except func_timeout.exceptions.FunctionTimedOut:
+                error_message = f"❌ Record set '{record_set.name}' 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.name}' 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