@getollie/cli 0.0.5 → 0.2.1

package/library/data_science-machine_learning/eyebrow-controlled-phone-app-with-ui.json

@@ -1,68 +0,0 @@
-{
-  "index": 1326,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Take care to ensure the generated code is executable for demonstration. I also need a UI interface with 2 buttons: one for \"Start\" and one for \"Exit.\" After clicking Start, the app should run in the background, allowing users to control their phone through eyebrow movements.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the eyebrow movement detection system fully implemented?",
-      "description": "Review whether the code accurately implements facial landmark detection through computer vision libraries (like MediaPipe/OpenCV), specifically targeting eyebrow region tracking. Check if it includes proper calibration for different users, noise filtering, and gesture recognition accuracy. Score 0 if core detection logic is missing, 5 if only basic face detection is implemented, and 10 if precise eyebrow movement patterns are accurately captured with >90% recognition rate.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the phone control mapping functionality implemented?",
-      "description": "Check whether the eyebrow movements are properly mapped to phone control actions (swipe, tap, scroll, etc.). Evaluate if the system includes customizable gesture-to-action mapping, sensitivity adjustment, and multi-directional control support. Deduct 5 points if only basic directional mapping exists, and 3 points if no sensitivity calibration is provided. The full score requires comprehensive control coverage including navigation, app switching, and text input assistance.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the background service architecture properly designed with camera access management?",
-      "description": "Evaluate whether the background service properly handles camera resource management, permission requests, and system-level integration without blocking other apps. Check for proper service lifecycle management, memory optimization, and battery usage consideration. Deduct 5 points if camera resource conflicts occur, and 5 points if the service doesn't properly handle system interruptions (calls, notifications). Requires seamless background operation.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the complete accessibility and calibration system constructed?",
-      "description": "Check whether the code includes comprehensive user calibration flow, accessibility settings for different physical abilities, and adaptive learning for individual eyebrow movement patterns. Evaluate if it provides feedback mechanisms, adjustment tutorials, and personalization options. Deduct 5 points if no calibration process exists, and 3 points if accessibility considerations are minimal. Give 10 points if fully adaptive system with learning capabilities is implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as poor lighting conditions, camera obstruction, multiple faces in frame, system resource constraints, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should gracefully handle edge cases like face detection failures, camera permission denials, and hardware limitations, giving 10 points. If robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance accessibility and user experience (e.g., 1. Voice feedback for movement confirmation 2. Gesture recording and playback for complex actions 3. Integration with system accessibility services 4. Multi-user profile support 5. Gesture macro creation). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar detection algorithms (e.g., multiple face detection libraries running simultaneously) 2. Function modules unrelated to eyebrow control (e.g., built-in games or entertainment features) 3. Resource-intensive effects that impact detection performance (e.g., heavy UI animations during detection). Deduct 3 points for each redundancy found, and directly deduct 10 points if core detection functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating detection engine/control mapping/UI layers), proper error handling, and performance optimization. Deduct 5 points if memory leaks in camera handling are found or poor separation of concerns; deduct 5 points if the detection loop blocks the main thread; deduct 5 points if no proper resource cleanup mechanisms exist. The full score requires clean architecture with proper threading and resource management.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet accessibility design standards?",
-      "description": "Evaluate whether the UI design follows accessibility principles: 1) High contrast design suitable for users with visual impairments 2) Large, easily identifiable buttons (minimum 44px touch targets) 3) Clear visual feedback for all interactions 4) Simple, uncluttered layout focusing on essential controls. Deduct 3 points for each accessibility guideline violation, 5 points for poor color contrast ratios (<4.5:1), and 5 points for confusing button layouts. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the real-time performance smooth and responsive?",
-      "description": "Judge whether the detection and control response meets real-time requirements: 1) Detection frame rate ≥ 15fps for smooth tracking 2) Gesture-to-action delay ≤ 200ms 3) Consistent performance across different lighting conditions 4) No noticeable lag in background operation. Deduct 5 points for each stuttering interaction, 3 points for inconsistent detection rates, and 5 points for performance degradation during extended use. The full score requires consistently smooth real-time operation.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "hard"
-}

package/library/data_science-machine_learning/facial-expression-recognition-webcam-project.json

@@ -1,68 +0,0 @@
-{
-  "index": 1473,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you generate is executable and can be demonstrated. I want to create a facial expression recognition project that can recognize my expressions through my webcam. Please provide me with the complete project code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the facial expression detection functionality completely implemented?",
-      "description": "Evaluate whether the code correctly implements real-time facial detection, facial landmark extraction, and expression classification (at least 6 basic emotions: happy, sad, angry, surprised, fearful, disgusted). Score 0 if facial detection is missing, 5 if only basic detection without expression classification is implemented, and 10 if both detection and accurate multi-expression classification are fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the webcam integration properly implemented?",
-      "description": "Check whether the code includes proper webcam access (with browser permissions handling), video streaming setup, frame capture at appropriate intervals (15-30 fps), and fallback mechanisms for devices without cameras. Deduct 5 points if there's no error handling for camera permission denial, 3 points if the frame rate isn't optimized, and 2 points if there's no camera availability check. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the machine learning model implementation appropriate?",
-      "description": "Assess whether the code uses a suitable pre-trained model (like TensorFlow.js with MobileNet, face-api.js, or custom CNN) with proper model loading, inference optimization, and model versioning. Evaluate if model size balances accuracy vs. performance (under 10MB for browser usage). Deduct 5 points if the model accuracy is below industry standards, 3 points if inference time exceeds 100ms per frame. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the expression visualization and feedback system well-designed?",
-      "description": "Review how expression results are visualized (e.g., emotion labels, confidence percentages, facial landmark overlays, emotion history graphs). Check for real-time feedback with low latency (<200ms), smooth transitions between detected expressions, and clear confidence indicators. Deduct 5 points if visualization is minimal or unclear, 3 points if there's significant lag in the feedback loop. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as poor lighting conditions, multiple faces in frame, profile views, occlusions, webcam disconnection, etc.) and provide graceful degradation or recovery. Code with strong robustness should log errors, provide user feedback for issues, and implement appropriate fallbacks, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Expression-triggered animations or effects 2. Expression history tracking with statistics 3. Expression-based avatar mirroring 4. Multi-user comparison mode). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementations of similar detection algorithms 2. Unnecessary processing steps that impact performance 3. Excessive UI elements unrelated to expression recognition. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/model/controller components), error handling, performance optimization techniques (like requestAnimationFrame usage, canvas vs. DOM manipulation), and code commenting. Deduct 5 points if global state pollution is found; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no performance optimization for continuous video processing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Clear visual hierarchy highlighting expression results 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Appropriate use of color to indicate different emotions 4) Professional typography for results display. Deduct 3 points for each crowded visual element, 5 points for poor visual distinction between emotions, and 5 points for chaotic camera feed and result positioning. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Expression detection latency ≤ 200ms 2) Smooth transitions when expression changes 3) Responsive UI even during intensive processing. Deduct 5 points for noticeable frame drops during detection, 3 points for jerky visualization transitions, and 5 points for UI freezes during model processing. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "easy"
-}

package/library/data_science-machine_learning/model-training-page.json

@@ -1,68 +0,0 @@
-{
-  "index": 1387,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Try to ensure that the generated code is executable and demonstrable.\n\n+---------------------------------------------------------------+\n| Model Training Page                                           |\n+-------------------+-------------------+-----------------------+\n| Model Selection   | Dataset Selection | Training Configuration|\n| - Model List      | - Dataset List    | - Learning Rate       |\n| - Model Description| - Dataset Preview | - Batch Size         |\n| - Model Parameters| - Data Preprocessing| - Iterations        |\n+-------------------+-------------------+-----------------------+\n| Training Process Visualization                                |\n| - Real-time Training Curves | - Progress Bar | - Log Output   |\n+---------------------------------------------------------------+\n| Model Evaluation                                              |\n| - Evaluation Metrics | - Confusion Matrix | - ROC Curve       |\n+---------------------------------------------------------------+\n| Model Saving and Export                                       |\n| - Save Model        | - Export Results   |                    |\n+---------------------------------------------------------------+\n| History                                                       |\n| - Training History  | - Retrain          |                    |\n+---------------------------------------------------------------+\n| Help and Documentation                                        |\n| - Operation Guide   | - Model Documentation |                 |\n+---------------------------------------------------------------+\nPlease help me generate a page based on this layout",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the entire model training interface layout accurately implemented?",
-      "description": "Evaluate if the HTML/CSS code precisely implements the specified layout with all six main sections (Model Selection, Dataset Selection, Training Configuration, Training Process Visualization, Model Evaluation, Model Saving and Export, History, Help and Documentation). Verify that each section contains the correct subsections as specified in the diagram. Score 0 if major sections are missing, 5 if all sections exist but with layout inaccuracies, and 10 if the layout perfectly matches the specification.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the model and dataset selection components fully functional?",
-      "description": "Check if the implementation includes interactive model and dataset selection components with proper lists, descriptions, and parameter configurations. Verify if model descriptions update dynamically when a model is selected, and if dataset preview functionality is implemented. Score 3 for basic selection dropdowns, 7 for selection with dynamic information display, and 10 for comprehensive components with parameter configuration and dataset preview capabilities.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the training configuration section properly implemented with validation?",
-      "description": "Assess if the training configuration section includes proper input fields for learning rate, batch size, and iterations with appropriate validation (numeric constraints, reasonable ranges). Check if there are tooltips or guidance for optimal parameter selection. Deduct 3 points for missing validation, 2 points for lacking tooltips/guidance, and 2 points if parameter interdependencies are not handled. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "How comprehensive is the training process visualization implementation?",
-      "description": "Evaluate the quality of the training visualization components: real-time curves (should update dynamically, show multiple metrics), progress bar (should show accurate percentage and estimated time), and log output (should auto-scroll, allow filtering). Deduct 3 points for static/non-updating visualizations, 3 points for missing any of the three required components, and 2 points for poor real-time performance. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid parameter inputs, API failures, incompatible model-dataset combinations, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Interactive model architecture visualization 2. Transfer learning capabilities 3. A/B testing of different configurations 4. Auto-parameter suggestions). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar functions (e.g., multiple chart libraries for the same visualization) 2. Function modules unrelated to model training (e.g., a built-in chat system) 3. Fancy effects that affect performance (e.g., unnecessary animations in training visualizations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI components/data processing/visualization logic), state management approach, and code maintainability. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there's no clear separation between UI and business logic. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance. Deduct 5 points for each operation without feedback, 3 points for visual after-images during fast sliding, and 5 points for hard-to-find key function buttons. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "easy"
-}

package/library/data_science-machine_learning/opencvjs-image-polygon-text-extraction.json

@@ -1,68 +0,0 @@
-{
-  "index": 1450,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the generated code is executable whenever possible. Implement, using HTML with Opencv.js, a method to set polygon coordinates on an image and extract text from within the selected polygon area.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the polygon coordinate selection system properly implemented?",
-      "description": "Check if the HTML interface allows users to create and modify polygon vertices on the image. The implementation should include point creation on click, vertex dragging, and completion of the polygon. Score 0 if no polygon creation exists, 5 if only basic point placement is implemented, and 10 if a complete, interactive polygon drawing system with editing capabilities is present.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the image loading and display functionality robust?",
-      "description": "Evaluate whether the code properly handles image loading, including error handling for invalid images, support for different image formats (JPEG, PNG, etc.), and responsive sizing that maintains aspect ratio. The image should be properly displayed as a canvas element for OpenCV.js processing. Deduct 5 points if there's no image validation, 3 points if responsive sizing is missing, and 2 points if the canvas setup is incorrect. Full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the OpenCV.js integration correctly implemented?",
-      "description": "Assess the initialization of OpenCV.js, proper usage of cv.Mat objects, and memory management with .delete() calls to prevent leaks. Check for proper module loading detection and fallback mechanisms if OpenCV fails to load. Deduct 5 points for missing memory management, 5 points for no OpenCV loading verification, and 3 points for inefficient usage of OpenCV objects. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the text extraction from the polygon region correctly implemented?",
-      "description": "Verify that the code correctly masks the image using the defined polygon, applies appropriate preprocessing (like grayscale conversion, thresholding, noise removal) before OCR, and extracts text from only within the polygon. Check for OCR library integration (like Tesseract.js). Deduct 5 points if the masking is incorrect, 5 points if no preprocessing is applied, and 5 points if OCR integration is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as invalid polygon shapes, extremely small polygons, images that fail to load, or browser compatibility issues) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Auto-adjustment of polygon for better text recognition 2. Multiple polygon support with labeling 3. Text extraction result highlighting on the original image). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar image processing functions 2. Unnecessary UI elements unrelated to the polygon creation and text extraction task 3. Heavy computational methods that slow down browser performance. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating UI/image processing/OCR logic), error handling, and code comments. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no meaningful comments explaining complex OpenCV operations. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Clean and intuitive UI for polygon creation 2) Proper layout spacing between controls and the image canvas 3) Professional visual feedback when selecting points and creating polygons. Deduct 3 points for each crowded visual element, 5 points for poorly contrasting colors making polygon points hard to see, and 5 points for chaotic button/control layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Immediate visual feedback when placing polygon points 2) Smooth polygon dragging and reshaping 3) Clear indication when the polygon is complete and ready for text extraction. Deduct 5 points for each operation without feedback, 3 points for laggy polygon manipulation, and 5 points for confusing interaction patterns that don't follow standard conventions. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "hard"
-}

package/library/data_science-machine_learning/pyqt-interface-brain-tumor-yolov8-detection.json

@@ -1,68 +0,0 @@
-{
-  "index": 892,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Ensure that any code you generate is executable for demonstration purposes. Please help me design a PyQt interface for a brain tumor system based on YOLOv8 deep learning detection.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "YOLOv8 integration completeness",
-      "description": "Evaluate how completely the YOLOv8 detection model is integrated into the PyQt application. Check if the code properly loads pretrained models, handles image preprocessing, and implements proper inference pipelines for brain tumor detection.Score 0 if YOLOv8 is not integrated at all, 5 if basic integration exists but lacks optimization, and 10 if the implementation includes proper model loading, inference pipeline, confidence thresholds, and NMS settings specific to medical imaging contexts.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Medical image handling capabilities",
-      "description": "Assess whether the application correctly handles medical imaging formats (DICOM, NIfTI) with proper metadata preservation. Check if it includes necessary preprocessing specific to brain MRI/CT scans (normalization, windowing) and supports different cross-sectional views.Deduct 3 points if standard medical formats aren't supported, 3 points if metadata isn't preserved, and 4 points if brain-specific preprocessing is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Visualization of detection results",
-      "description": "Evaluate how tumor detection results are visualized. Check if the interface includes proper bounding box overlays, segmentation masks, confidence scores, and multi-slice viewing capabilities for 3D data.Score 0 if visualization is absent, 5 if basic bounding boxes are implemented, and 10 if the system provides comprehensive visualization with color-coded overlays, adjustable transparency, and measurement tools for clinical assessment.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Clinical workflow integration",
-      "description": "Assess whether the PyQt interface supports a complete clinical workflow including patient data management, scan history, reporting capabilities, and integration points with hospital systems.Deduct 3 points if patient management is missing, 3 points if reporting functionality is absent, and 4 points if the system lacks interoperability features (DICOM networking, HL7). The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Code robustness",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as corrupted images, model loading failures, memory limitations with large datasets) and provide friendly error prompts or recovery mechanisms.Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Innovative features that are eye-catching",
-      "description": "Check whether the code includes surprise features that enhance the clinical experience (e.g., 1. Real-time volumetric measurements 2. Automatic report generation with findings 3. Comparative analysis between scans 4. Growth trajectory prediction).Add 2.5 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Redundant features",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementations of similar functions (e.g., multiple image loading pipelines) 2. Function modules unrelated to tumor detection (e.g., generic image editing tools) 3. Fancy effects that affect performance or clinical accuracy.Deduct 3 points for each redundancy found, and directly deduct 10 points if the core medical functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Engineering quality",
-      "description": "Review modular design (such as separating medical processing/UI/model inference layers), unit test coverage (especially for critical detection algorithms), and build process automation.Deduct 3 points if global state pollution is found; deduct 3 points if the code duplication rate is too high (over 30%); deduct 4 points if there are no validations for medical data integrity. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Interface vision meets clinical standards",
-      "description": "Evaluate whether the interface follows clinical software design principles: 1) High contrast for tumor visualization 2) Consistent layout optimized for radiology workflows 3) Clear distinction between diagnostic and administrative features 4) Accessibility considerations for hospital environments.Deduct 3 points for poor tumor visibility, 3 points for workflow inefficiencies requiring excessive clicks, and 4 points for interfaces that don't follow medical software conventions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Dynamic interaction smoothness",
-      "description": "Judge whether the PyQt interface provides smooth interactions essential for clinical use: 1) Responsive zooming/panning of medical images ≤ 100ms 2) Background processing for heavy computations 3) Progress indicators for long-running operations 4) Responsive UI during model inference.Deduct 3 points for each laggy operation when handling medical images, 3 points for UI freezing during detection, and 4 points if the interface becomes unresponsive with larger datasets. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "hard"
-}

package/library/data_science-machine_learning/text-to-image-generation-tool-development.json

@@ -1,68 +0,0 @@
-{
-  "index": 1433,
-  "question": "You are a code expert. Please use your professional expertise to generate accurate, professional responses. Be sure to provide executable code when possible. I want to develop my own text-to-image generation tool. What do I need to prepare? Please describe in detail, and ideally help me write some code.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the text-to-image generation model selection and integration properly implemented?",
-      "description": "Check whether the code includes proper selection and integration of text-to-image models (such as Stable Diffusion, DALL-E, or Midjourney-like architectures). Assess if the code provides clear instructions for model download/installation, API integration, or local deployment. Score 0 if no specific model implementation is provided, 5 if only basic API calls are implemented, and 10 if there's comprehensive model integration with parameter tuning options.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Are the necessary dependencies and environment setup clearly specified?",
-      "description": "Evaluate whether the code includes complete environment setup instructions (Python version, GPU requirements, CUDA compatibility, memory needs) and dependency management (requirements.txt, Docker configuration, or virtual environment setup). Deduct 5 points if hardware requirements are not specified, 3 points if dependency versions are ambiguous. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the prompt engineering functionality implemented with appropriate controls?",
-      "description": "Assess whether the code implements prompt engineering capabilities, including prompt templates, modifier keywords, negative prompting, and weight/emphasis controls. Check if the system allows users to save, edit, and reuse successful prompts. Score 0 if basic text input only, 5 if simple prompt mechanisms exist, and 10 if advanced prompt engineering with guidance is fully implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a comprehensive user interface for image generation and management?",
-      "description": "Verify that the code implements a functional UI (web-based, desktop application, or CLI) with proper image generation controls, preview functionality, batch processing capability, and history/gallery management. Deduct 5 points if the UI lacks image manipulation features, 3 points if generation parameters cannot be adjusted intuitively, and 5 points if the gallery/history management is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code handles common failure scenarios (GPU memory errors, API rate limits, network interruptions, invalid prompts) and provides appropriate error handling with user-friendly messages. Code should include timeout handling, retry logic, and graceful degradation. Give 10 points for comprehensive error handling, 5 points for basic error catching, and 0 points if exceptions are unhandled.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. Image interpolation between prompts 2. Automatic prompt improvement suggestions 3. Style transfer capabilities 4. Integration with external content APIs). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant model implementations that serve the same purpose 2. Unnecessary preprocessing steps that don't improve output quality 3. Over-complicated UI elements that obscure core functionality. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (separating model interaction, UI, prompt processing, and image handling), configuration management, and scalability considerations. Deduct 5 points for global state pollution or monolithic architecture; deduct 5 points if the code lacks abstraction layers or has high coupling; deduct 5 points if configuration requires code changes rather than external files. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the UI design follows modern principles: 1) Clean layout with logical grouping of controls 2) Proper visual hierarchy highlighting important features 3) Consistent styling throughout the application 4) Responsive design accommodating different screen sizes. Deduct 3 points for cluttered interfaces, 5 points for inconsistent styling, and 5 points for poor accessibility features. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the performance optimization adequately addressed?",
-      "description": "Judge whether the code implements performance optimizations: 1) Efficient model loading and caching 2) Batch processing capabilities 3) Resource management (memory usage, concurrent generations) 4) Progress indicators for long-running operations. Deduct 5 points for each missing optimization strategy, 3 points for not handling large image generations efficiently, and 5 points for lack of resource monitoring. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "hard"
-}

package/library/data_science-machine_learning/web-program-import-tables-convert-to-ai-language.json

@@ -1,68 +0,0 @@
-{
-  "index": 1631,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Pay attention to ensuring the code you generate is executable. Help me create a web program that imports tables and can convert them into a language that AI can analyze.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the table import functionality fully implemented?",
-      "description": "Review whether the code implements multiple table import methods (e.g., CSV, Excel, JSON, direct input) and properly handles different file encodings and formats. Score 0 if import functionality is missing, 5 if only basic format support is available, and 10 if comprehensive import options with error handling are implemented.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the table parsing and data extraction logic robust?",
-      "description": "Check whether the code correctly parses various table structures, handles headers, detects data types, and manages special characters. Examine if it deals with merged cells, empty values, and inconsistent formats. Deduct 5 points if basic CSV parsing only, 3 points if no data type inference exists. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is the AI-compatible format conversion implemented correctly?",
-      "description": "Evaluate whether the code transforms tabular data into AI-readable formats (e.g., structured JSON, CSV with metadata, labeled datasets). Check for proper schema definition, adherence to common AI input conventions, and inclusion of relevant metadata. Deduct 5 points if the output lacks structure, 3 points if metadata is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is there a preview and validation system for the conversion?",
-      "description": "Assess if the code includes features to preview data before conversion, validate the transformed output, and provide feedback on potential issues (e.g., missing values, inconsistencies). Examine whether users can adjust settings and see real-time results. Deduct 5 points if preview functionality is absent, 3 points if validation is missing. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as malformed tables, excessively large files, network interruptions during upload, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-assisted data cleaning 2. Automatic column type detection and annotation 3. Historical conversion tracking and comparison). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar parsing functions 2. Function modules unrelated to table conversion (e.g., unnecessary animations or widgets) 3. Complex features that affect core performance (e.g., overly sophisticated visualizations). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating import/parsing/conversion/UI layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional design standards?",
-      "description": "Evaluate whether the overall design follows modern design principles: 1) Harmonious color matching (no more than 3 primary colors) 2) Proper layout spacing (element spacing follows the 8px multiple principle) 3) Professional font system (body font size ≥ 14px, line height over 1.5 times). Deduct 3 points for each crowded visual element, 5 points for a glaring color combination, and 5 points for chaotic text-image layout. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and seamless?",
-      "description": "Judge whether the dynamic effects conform to human perception characteristics: 1) Feedback on file upload/processing ≤ 100ms 2) Progress indicators for lengthy operations 3) Clear visual guidance through the conversion workflow. Deduct 5 points for each operation without feedback, 3 points for lack of progress indication during processing, and 5 points for confusing navigation between import and conversion steps. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Machine Learning",
-  "difficulty": "easy"
-}

package/library/data_science-predictive_modeling/grain-oil-futures-analysis-software.json

@@ -1,68 +0,0 @@
-{
-  "index": 1608,
-  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure the generated code is executable and demonstrable. Help me write a software for analyzing grain and oil futures on a six-month cycle that can obtain real-time trading information and policies for domestic grain and oil products. The data should be sourced from the National Grain Trade Center and GrainOil Duoduo. Ideally, it should integrate with AI large models. Please write all the code for the entire project.",
-  "checklist": [
-    {
-      "id": 0,
-      "title": "Is the data acquisition system fully implemented?",
-      "description": "Review whether the code accurately implements web scraping or API integration with the National Grain Trade Center and GrainOil Duoduo. Check for proper authentication handling, rate limiting, error handling during data fetching, and data storage mechanisms. Score 0 if no data acquisition is implemented, 5 if only basic scraping without error handling is present, and 10 if robust data acquisition with fallback mechanisms and comprehensive error handling is included.",
-      "maxScore": 10
-    },
-    {
-      "id": 1,
-      "title": "Is the six-month cycle futures analysis functionality properly implemented?",
-      "description": "Evaluate whether the code includes time series analysis algorithms appropriate for six-month cycle futures analysis (e.g., seasonal decomposition, cyclical pattern detection, trend analysis). Check for implementation of statistical methods like moving averages, ARIMA models, or other forecasting techniques. Deduct 5 points if only basic charting without actual cycle analysis is implemented, and 3 points if the analysis lacks statistical validation. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 2,
-      "title": "Is real-time trading information processing implemented?",
-      "description": "Check whether the code includes functionality to process and update real-time trading data, including websocket connections or frequent API polling, data transformation pipelines, and real-time visualization updates. Verify if price alerts, threshold notifications, or other real-time features are included. Deduct 5 points if data refresh rate is inadequate for trading decisions (>1 minute delay), and 5 points if there's no mechanism to handle network interruptions. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 3,
-      "title": "Is the policy analysis integration with AI large models implemented?",
-      "description": "Assess whether the code effectively integrates with AI large models (e.g., GPT, BERT) for policy analysis, including proper API usage, prompt engineering for financial analysis, and context handling. Check if results from AI models are properly integrated into the analysis workflow. Deduct 5 points if AI integration is superficial with no domain-specific tuning, and 5 points if there's no evaluation mechanism for AI-generated insights. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 4,
-      "title": "Is the code robust?",
-      "description": "Evaluate whether the code can handle common abnormal situations (such as network failures, API changes, malformed data, missing values in time series) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle these edge cases, giving 10 points. If the robustness is average, give 5 points, and if no exceptions are handled, give 0 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 5,
-      "title": "Are there any innovative features that are eye-catching?",
-      "description": "Check whether the code includes surprise features that enhance the experience (e.g., 1. AI-driven anomaly detection for market movements 2. Natural language query interface for market data 3. Custom alert system with multiple notification channels). Add 3 points for each practical innovative feature implemented (maximum 10 points).",
-      "maxScore": 10
-    },
-    {
-      "id": 6,
-      "title": "Are there any redundant features?",
-      "description": "Strictly check three types of redundancy: 1. Redundant implementation of similar analysis functions (e.g., multiple trend detection algorithms without clear purpose) 2. Function modules unrelated to futures analysis (e.g., general financial calculators not specific to grain/oil) 3. Fancy visualizations that affect performance without adding analytical value. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core functions are interfered with by redundant code.",
-      "maxScore": 10
-    },
-    {
-      "id": 7,
-      "title": "Does the code have engineering quality?",
-      "description": "Review modular design (such as separating data acquisition/analysis/visualization layers), unit test coverage, and build process automation. Deduct 5 points if global state pollution is found or design patterns are not used; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 8,
-      "title": "Does the interface vision meet professional financial software standards?",
-      "description": "Evaluate whether the overall design follows professional financial software design principles: 1) Color scheme appropriate for financial data (clear differentiation between positive/negative trends, alerts) 2) Proper layout of multiple data panels without overwhelming the user 3) Professional typography for financial data presentation (clear hierarchy, readable numbers). Deduct 3 points for each crowded dashboard panel, 5 points for confusing trend visualization color schemes, and 5 points for poor information hierarchy. The full score is 10 points.",
-      "maxScore": 10
-    },
-    {
-      "id": 9,
-      "title": "Is the dynamic interaction smooth and responsive for trading analysis?",
-      "description": "Judge whether the dynamic effects support effective financial analysis: 1) Chart interaction response ≤ 200ms 2) Smooth transitions between different timeframes and analysis views 3) Intuitive filtering and comparison tools. Deduct 5 points if data filtering causes significant lag, 3 points for jumpy transitions between analysis views, and 5 points for hidden or complex access to critical trading information. The full score is 10 points.",
-      "maxScore": 10
-    }
-  ],
-  "class": "Data Science-Predictive Modeling",
-  "difficulty": "hard"
-}