@getollie/cli 0.0.1

package/library/data_science-data_visualization_dashboards/provinces-job-levels-column-chart.json

@@ -0,0 +1,68 @@
+{
+  "index": 1362,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable for display purposes. Present clustered column chart code that shows provinces and job levels.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the clustered column chart properly implemented with clear province and job level data?",
+      "description": "Review whether the code accurately implements a clustered column chart that distinctly represents provinces along one axis and job levels as grouped columns. Check if the data structure logically organizes provinces and their corresponding job level values. Score 0 if the chart is not implemented, 5 if basic implementation lacks proper clustering, and 10 if provinces and job levels are clearly visualized with appropriate clustering.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the chart include necessary components (axes, legends, labels, title)?",
+      "description": "Evaluate if the chart includes properly labeled axes (x-axis for provinces, y-axis for values), a clear legend identifying different job levels, appropriate data labels, and a descriptive title. Deduct 2 points for each missing component, 1 point for poorly implemented components. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data visualization coded with appropriate technologies?",
+      "description": "Check whether the implementation uses suitable front-end visualization libraries (like D3.js, Chart.js, Highcharts) or native HTML5 canvas/SVG. Assess if the chosen technology is appropriate for clustered column charts. Deduct 5 points if using outdated or inappropriate technology, 3 points if modern libraries are used but not optimally. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is the chart responsive and adaptable to different screen sizes?",
+      "description": "Test whether the chart adjusts appropriately to different viewport sizes, maintains readability on mobile devices, and implements responsive design principles. Check if the clustering remains clear on smaller screens. Deduct 5 points if the chart is fixed size only, 3 points if responsive but with layout issues on certain devices. 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 missing data, unexpected data types, browser compatibility issues, etc.) and provides appropriate fallbacks or error handling. 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 tooltips with detailed information 2. Animation when loading/filtering data 3. Ability to toggle or highlight specific job levels 4. Export functionality). 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 visualization functions 2. Function modules unrelated to the clustered column chart 3. Fancy effects that affect performance (e.g., excessive animations or 3D effects that don't add 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 processing/visualization/interaction logic), code organization, and 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 the code lacks comments or documentation. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the chart follows data visualization best practices: 1) Appropriate color scheme that differentiates job levels clearly 2) Proper spacing between columns and groups 3) Balanced visual hierarchy with emphasis on the data. Deduct 3 points for poor color choices that hinder data interpretation, 5 points for cluttered layout with overlapping elements, and 5 points for inappropriate chart dimensions. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the chart provides effective interactive elements: 1) Responsive hover effects (≤ 100ms delay) 2) Smooth transitions when filtering or updating data (300-500ms duration) 3) Intuitive interaction patterns. Deduct 5 points for missing interaction feedback, 3 points for laggy transitions, and 5 points for confusing or non-standard interaction patterns. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}

package/library/data_science-data_visualization_dashboards/python-amazon-sock-product-dashboard-visualization.json

@@ -0,0 +1,68 @@
+{
+  "index": 833,
+  "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 for demonstration. Create a dashboard visualization using Python showing search volume, new product percentage, and review count percentage for sock products on Amazon US site based on real data.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the data acquisition and processing pipeline properly implemented?",
+      "description": "Review whether the code includes proper methods for acquiring Amazon product data (web scraping, API usage, or sample dataset loading), preprocessing steps (cleaning, normalization), and data validation. Score 0 if there is no data acquisition logic, 5 if basic data loading is implemented but with minimal preprocessing, and 10 if there is a complete ETL pipeline with error handling and data validation steps.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the dashboard visualization comprehensive and well-structured?",
+      "description": "Evaluate if the dashboard includes all three required metrics (search volume, new product percentage, review count percentage) with appropriate visualization types for each (e.g., line charts for trends, bar charts for comparisons, pie charts for percentages). Check if the visualizations have proper titles, labels, and legends. Deduct 3 points for each missing metric, 2 points for inappropriate chart selection, and 2 points for missing critical elements like legends or axes labels. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Does the visualization provide interactive features?",
+      "description": "Check whether the dashboard includes interactive elements such as filters, tooltips, hover effects, drill-down capabilities, or time range selectors. Evaluate the effectiveness of these interactions for exploring the sock product data. Award 0 points for static visualizations with no interactivity, 5 points for basic hover tooltips or simple filters, and 10 points for comprehensive interactive features with smooth transitions that enhance data exploration.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is data insight extraction and presentation implemented?",
+      "description": "Assess if the code includes analytical capabilities to extract meaningful insights from the sock product data, such as trend identification, outlier detection, correlation analysis, or seasonal patterns. Check if insights are presented alongside visualizations through annotations, highlights, or summary text. Award 10 points for sophisticated analysis with clear insight presentation, 5 points for basic trend identification, and 0 points if no analytical components are included.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data, outliers, connection issues, invalid inputs, 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. Real-time data updates 2. Predictive analytics for sock trends 3. Competitive analysis across different sock categories). 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 visualization of similar metrics (e.g., multiple charts showing the same data) 2. Function modules unrelated to sock product analysis (e.g., irrelevant product categories) 3. Fancy effects that affect performance (e.g., unnecessary animations or 3D effects). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core visualization 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 processing/visualization/interaction layers), function documentation, and code maintainability. Deduct 5 points if global variables are overused or design patterns are not applied; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if there are no comments or documentation. 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 dashboard design principles: 1) Harmonious color palette suitable for data visualization (contrasting but not jarring) 2) Proper layout with information hierarchy (most important metrics prominent) 3) Professional typography (readable fonts, consistent styling). Deduct 3 points for each cluttered chart area, 5 points for poor color choices that hinder data interpretation, and 5 points for inconsistent styling across visualizations. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dashboard performance optimized?",
+      "description": "Judge whether the visualization is optimized for performance: 1) Data loading and chart rendering time ≤ 3 seconds 2) Smooth transitions for interactive elements 3) Efficient data handling for large datasets. Deduct 5 points for slow loading times (>5 seconds), 3 points for laggy interactions, and 5 points for memory leaks or browser freezing with larger datasets. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}

package/library/data_science-data_visualization_dashboards/python-financial-data-reports-frontend-display.json

@@ -0,0 +1,68 @@
+{
+  "index": 1390,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration. Implement frontend display of financial data reports in Python.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Does the code implement effective financial data visualization?",
+      "description": "Review whether the code effectively uses visualization libraries (like Matplotlib, Plotly, Bokeh, or Dash) to display financial data through appropriate chart types (line charts for time series, bar charts for comparisons, pie charts for distributions). Score 0 if no visualizations are implemented, 5 if basic charts are created without customization, and 10 if comprehensive visualizations with proper financial indicators are created.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is there proper data handling and preprocessing for financial reports?",
+      "description": "Evaluate whether the code includes proper financial data handling (using Pandas, NumPy), including cleaning missing values, handling outliers, normalizing data, and calculating financial metrics (e.g., moving averages, volatility, returns). Deduct 3 points if data validation is missing, 3 points if no financial calculations are performed, and 4 points if the preprocessing pipeline is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is there an interactive dashboard or report interface?",
+      "description": "Check whether the code implements an interactive frontend (using Dash, Streamlit, Flask with JavaScript, or similar) that allows users to filter data, select time periods, drill down into details, and customize the financial report view. Deduct 5 points if no interactivity is implemented, 3 points if only basic filters exist, and 2 points if the interface lacks responsiveness. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are appropriate financial metrics and KPIs displayed?",
+      "description": "Assess whether the code calculates and displays relevant financial metrics (ROI, P/E ratio, EBITDA, cash flow analysis, risk metrics like Beta or Sharpe ratio). Deduct 3 points for each missing essential financial metric category, and award full 10 points only if comprehensive metrics with explanations are provided for financial decision-making.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as missing data, API failures, invalid user inputs, 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-powered trend predictions 2. PDF export with customizable templates 3. Alert system for threshold violations). 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 chart types or calculations 2. Function modules unrelated to financial reporting 3. Excessive animations or visual elements that distract from financial insights. 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 processing/visualization/interface layers), unit test coverage, and build process automation. Deduct 5 points if global variables are overused or design patterns are not applied; deduct 5 points if the code duplication rate is too high (over 30%); deduct 5 points if the build process is not automated or documented. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the financial dashboard follows professional design principles: 1) Financial industry color scheme (conservative palette with highlight colors for alerts) 2) Proper layout spacing with clear hierarchy of information 3) Consistent typography that prioritizes readability (especially for numbers and tables). Deduct 3 points for each cluttered data visualization, 5 points for inappropriate color schemes in financial contexts, and 5 points for poor information hierarchy. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the dynamic effects enhance financial data understanding: 1) Chart transitions that maintain context 2) Fast data filtering response (≤ 500ms) 3) Clear visual cues for data comparisons and trends. Deduct 5 points for lagging data updates, 3 points for confusing transitions between different views, and 5 points for difficult navigation between different financial metrics or time periods. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "medium"
+}

package/library/data_science-data_visualization_dashboards/react-echarts-china-map-geojson-api.json

@@ -0,0 +1,68 @@
+{
+  "index": 1658,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Make sure the code you provide is executable for demonstration purposes. Use React, TypeScript, and ECharts to implement a China map with provincial and city granularity, obtaining the GeoJSON through an API.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the GeoJSON data fetching and error handling implemented correctly?",
+      "description": "Verify that the code properly fetches the GeoJSON data from an API using standard fetch/axios methods with proper error handling. Check if there's a loading state, error state management, and retry mechanism. The implementation should include proper TypeScript interfaces for the GeoJSON structure. Deduct 5 points if error handling is missing, 3 points if no loading state is shown, 2 points if TypeScript types are incorrect or missing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Is the ECharts map visualization properly configured and rendered?",
+      "description": "Examine whether the ECharts instance is correctly initialized with the GeoJSON data and if proper event listeners are set up for component unmounting. Check if the map rendering includes essential features like zoom controls, tooltips, and proper area highlighting. Verify if the map visualization adjusts to container size changes. Score 0 if the map doesn't render, 5 if basic rendering works but lacks responsiveness, and 10 if fully implemented with all essential features.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the provincial and city granularity switching mechanism implemented?",
+      "description": "Evaluate whether the code provides a clear mechanism to switch between provincial and city-level views with appropriate drill-down functionality. Check if the transition between different granularity levels is smooth and if the code handles the relationships between provinces and their cities correctly. Deduct 5 points if only one granularity level is implemented, 3 points if switching exists but with bugs, and 2 points if the city data is incomplete. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there appropriate data visualization (e.g., choropleth coloring, markers) on the map?",
+      "description": "Check if the map includes data visualization elements like choropleth coloring based on data values, markers for points of interest, or other visual indicators. Verify that the visualization includes a legend, proper color scales, and options to toggle different data layers. Deduct 5 points if there's no data visualization beyond the base map, 3 points if the visualization lacks legends, and 2 points if the color scheme is problematic. 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 API failures, malformed GeoJSON data, browser compatibility issues, 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. Custom map themes 2. Advanced filtering capabilities 3. Interactive data comparison between regions). 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 map rendering approaches coexisting) 2. Function modules unrelated to map visualization (e.g., unnecessary animations) 3. Fancy effects that affect performance (e.g., excessive rerendering). 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 React component structure, proper use of TypeScript, code splitting, custom hooks, and performance optimizations (like memoization). Deduct 5 points if there are prop drilling issues instead of using context or proper state management; deduct 5 points if TypeScript is used poorly with many 'any' types; deduct 5 points if the component architecture doesn't follow single-responsibility principle. 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 for the map (distinguishable regions without being garish) 2) Proper layout spacing for controls and legends 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 control placement. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and seamless?",
+      "description": "Judge whether the map interactions conform to human perception characteristics: 1) Hover/click feedback delay ≤ 100ms 2) Zoom/pan animation smoothness 3) Clear visual indication of selected areas. Deduct 5 points for each operation without feedback, 3 points for laggy zoom/pan operations, and 5 points for unclear selection states. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}

package/library/data_science-data_visualization_dashboards/realtime-stock-pattern-alert-monitor.json

@@ -0,0 +1,68 @@
+{
+  "index": 934,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate, professional responses. Make sure that the code you generate is executable and can be demonstrated. In an independent alert monitoring interface window, display which stock belongs to which pattern alert (Wave or MACD) and show which timeframe condition the stock meets (15-minute, 30-minute, 60-minute, or daily chart), along with real-time stock prices and alert timestamps.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the alert monitoring system properly structured?",
+      "description": "Evaluate if the code implements a clear separation between data fetching, pattern recognition (Wave and MACD), and UI display components. Check for appropriate usage of event handling for real-time updates and proper initialization sequence. Score 0 if the core monitoring system is not implemented, 5 if basic structure exists but lacks proper separation of concerns, and 10 if the architecture follows best practices with clean component boundaries.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are the stock pattern recognition algorithms correctly implemented?",
+      "description": "Examine the implementation of both Wave pattern and MACD pattern detection algorithms. The Wave pattern should include proper trend line calculations with support/resistance levels, while the MACD should correctly implement signal line crossovers, histogram analysis, and divergence detection. Deduct 3 points if either pattern algorithm is missing, 5 points if the algorithms lack proper validation thresholds, and 2 points if they don't handle edge cases (like data gaps). The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the multi-timeframe analysis functionality complete?",
+      "description": "Review whether the code properly handles and displays analysis across all required timeframes (15-min, 30-min, 60-min, daily). Check for appropriate data aggregation, resampling techniques, and consistent calculation across timeframes. Deduct 2 points for each missing timeframe implementation, 3 points if timeframe switching affects calculation consistency, and 4 points if there's no correlation analysis between timeframes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are real-time stock prices and alert timestamps properly integrated?",
+      "description": "Assess whether the interface includes accurate real-time stock price updates with appropriate refresh rates (≤5 seconds for active stocks), properly formatted timestamps with timezone handling, and visual indicators for price changes (e.g., color coding for up/down movements). Deduct 3 points if timestamps lack proper formatting, 4 points if price updates aren't real-time or lack change indicators, and 3 points if there's no historical price context provided. 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 API failures, data feed interruptions, malformed data responses, etc.) and provide friendly error prompts or recovery mechanisms. Code with strong robustness should be able to effectively handle network latency, server disconnections, and include graceful degradation. Give 10 points for comprehensive error handling, 5 points for average robustness, and 0 points if no exception handling exists.",
+      "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. Pattern strength indicators 2. Alert notification system with sound/vibration 3. Historical alert performance statistics 4. Custom pattern threshold adjustment). 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 alert mechanisms (e.g., multiple overlapping event listeners) 2. Function modules unrelated to stock monitoring (e.g., unnecessary social sharing options) 3. Fancy effects that affect performance (e.g., excessive animations that slow down critical updates). Deduct 3 points for each redundancy found, and directly deduct 10 points if the core alert 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 fetching/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 dashboard standards?",
+      "description": "Evaluate whether the design follows professional financial dashboard principles: 1) Appropriate color scheme for financial data (using red/green conventions correctly) 2) Information density optimization (key metrics visible without scrolling) 3) Professional typography (monospace for numbers, clear hierarchy for alerts vs. details). Deduct 3 points for cluttered layouts, 5 points for poor visual prioritization of critical alerts, and 5 points for inconsistent data visualization techniques. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the alert interaction efficient and trader-friendly?",
+      "description": "Judge whether the alert system meets trader needs: 1) Alert response time ≤ 500ms from pattern detection 2) One-click access to detailed chart view from alerts 3) Filtering/sorting capabilities for high alert volume scenarios. Deduct 5 points for alerts that require multiple clicks to access details, 3 points for lack of alert prioritization system, and 5 points for missing alert history/persistence. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "hard"
+}

package/library/data_science-data_visualization_dashboards/retail-consumer-credit-data-dashboard-visualization.json

@@ -0,0 +1,68 @@
+{
+  "index": 968,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be sure to ensure that the generated code is executable. Create a comprehensive data dashboard for the retail consumer credit industry that includes visualization design and data presentation. Output in HTML format and ensure the file is executable.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the retail credit data visualization dashboard complete with basic components?",
+      "description": "Check whether the HTML includes the essential dashboard components (header, sidebar/navigation, main visualization area, filters section). Assess the inclusion of relevant retail credit metrics (e.g., credit scores, loan approval rates, delinquency rates, debt-to-income ratios). Score 0 if critical components are missing, 5 if basic structure exists but lacks key metrics, and 10 if comprehensively designed with all essential retail credit KPIs.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are appropriate visualization charts implemented for retail credit data?",
+      "description": "Evaluate the types of charts used (line charts for trends over time, bar charts for comparisons, pie/donut charts for distributions, heatmaps for correlations, etc.). Check for retail credit-specific visualizations such as risk matrices, loan performance waterfalls, or vintage analysis charts. Deduct 3 points for each inappropriate chart type, 5 points if chart selection doesn't match the data nature. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the data filtering and interactivity system well-designed?",
+      "description": "Evaluate whether the dashboard includes interactive features like time period selectors, demographic filters, loan type filters, and risk category selectors. Check if interactions between filters and visualizations work properly with immediate visual feedback. Deduct 5 points if filters don't affect displayed data, 3 points if interactivity has noticeable delays. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is there a well-implemented data drill-down mechanism?",
+      "description": "Assess whether users can click on dashboard elements to reveal deeper insights (e.g., clicking on a delinquent segment shows individual loan details, clicking on a geographic region reveals branch-level performance). Check for breadcrumb navigation when drilling down. Deduct 5 points if drill-down functionality is missing, 3 points if navigation between levels is confusing. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code handles common abnormal situations (such as empty datasets, loading errors, invalid filter combinations, etc.) and provides friendly error messages or fallbacks. Check for data validation, null checking, and exception handling. Code with strong robustness should effectively handle edge cases, 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 dashboard includes surprise features that enhance the experience (e.g., 1. AI-driven risk predictions 2. Customizable dashboard layouts 3. Anomaly detection with alerts 4. Benchmark comparisons with industry standards). 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. Duplicate visualizations showing the same data in different ways 2. Unnecessary metrics unrelated to retail credit (e.g., manufacturing KPIs) 3. Excessive animations or visual effects that distract from data comprehension. Deduct 3 points for each redundancy found, and directly deduct 10 points if core functions are interfered with by redundant code.",
+      "maxScore": 10
+    },
+    {
+      "id": 7,
+      "title": "Does the code have engineering quality?",
+      "description": "Review modular design (separation of data fetching, processing, and visualization), proper use of libraries (D3.js, Chart.js, etc.), code organization, and responsive design implementation. Deduct 5 points if global variables are overused; deduct 5 points if the code is not modular; deduct 5 points if the dashboard doesn't adapt to different screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 8,
+      "title": "Does the interface vision meet professional design standards?",
+      "description": "Evaluate whether the dashboard follows financial/retail industry visual standards: 1) Professional color scheme appropriate for financial data (avoid excessive bright colors) 2) Clean layout with logical grouping of related metrics 3) Consistent typography with proper hierarchy (headers vs. detail text). Deduct 3 points for cluttered layouts, 5 points for unprofessional color schemes, and 5 points for inconsistent design patterns. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dashboard performance optimized for large datasets?",
+      "description": "Judge whether the dashboard can handle retail credit datasets efficiently: 1) Initial load time under 3 seconds 2) Smooth interactions when filtering large datasets 3) Efficient data processing with pagination or virtualization for large tables. Deduct 5 points if visualizations freeze when changing filters, 3 points for noticeable rendering delays, and 5 points if memory usage grows excessively with larger datasets. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "medium"
+}

package/library/data_science-data_visualization_dashboards/selinux-policy-visualization.json

@@ -0,0 +1,68 @@
+{
+  "index": 1549,
+  "question": "You are a code expert. Please use your professional knowledge to generate accurate and professional responses. Be careful to ensure that the generated code is executable for demonstration. How can we implement a visualization of SELinux policies? Requirements: Develop a graphical or web interface tool that allows system administrators and security engineers to intuitively manage SELinux policies.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the SELinux policy visualization core functionality implemented?",
+      "description": "Review whether the code effectively visualizes SELinux policies through a graphical interface, including correct representation of subjects (processes), objects (files, sockets, etc.), and their relationships (permissions). Score 0 if visualization is missing, 5 if only basic policy elements are shown, and 10 if the visualization includes comprehensive policy mapping with context relationships.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Are SELinux policy editing capabilities implemented?",
+      "description": "Check whether the interface allows for creating, modifying, and deleting SELinux policies. Verify if it handles policy syntax validation, provides instant feedback on policy changes, and includes a mechanism to test policies before applying them. Score 0 if editing functionality is absent, 5 if basic editing without validation is present, and 10 if complete editing with validation and testing capabilities are implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the policy analysis and impact assessment feature implemented?",
+      "description": "Evaluate whether the tool can analyze existing policies, detect conflicts, identify potential security gaps, and simulate the impact of policy changes before deployment. Check if visualizations show policy interdependencies and highlight potential issues. Score 0 if no analysis exists, 5 if basic conflict detection is implemented, and 10 if comprehensive analysis with impact simulation is provided.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Is integration with the SELinux system properly implemented?",
+      "description": "Assess whether the tool correctly interfaces with the underlying SELinux subsystem, properly reads and writes policy files, executes SELinux commands with appropriate privileges, and handles SELinux alerts/logs. Score 0 if there's no system integration, 5 if basic read-only capabilities exist, and 10 if full bidirectional integration with proper privilege handling is implemented.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle common abnormal situations (such as permission denied, malformed policy files, system command failures, 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. Real-time policy violation monitoring, 2. Machine learning-based policy recommendations, 3. Interactive policy exploration through graph navigation). 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 ways to perform the same policy operation) 2. Function modules unrelated to SELinux policy management (e.g., general system configuration tools) 3. Fancy effects that affect performance (e.g., unnecessary animations in a security tool). 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 SELinux interaction/visualization/editing 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) Click feedback delay ≤ 100ms 2) Transition animation duration controlled between 300-500ms 3) Clear visual focus guidance for security-critical operations. Deduct 5 points for each operation without feedback, 3 points for visual after-images during graph navigation, and 5 points for hard-to-find key policy management functions. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "hard"
+}

package/library/data_science-data_visualization_dashboards/sentence-structure-complexity-visualization-experts-ai.json

@@ -0,0 +1,68 @@
+{
+  "index": 1331,
+  "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 for demonstration purposes. I now want to create code that visualizes the complexity of sentence structures between experts and AI, please generate this for me.",
+  "checklist": [
+    {
+      "id": 0,
+      "title": "Is the sentence structure complexity visualization fully implemented?",
+      "description": "Review whether the code accurately implements a visualization system for sentence complexity through HTML/JavaScript, including metrics like sentence length, nesting levels, and syntactic structure. Score 0 if there's no visualization, 5 if only basic metrics are visualized, and 10 if the system comprehensively analyzes and displays multiple complexity factors with comparative capabilities.",
+      "maxScore": 10
+    },
+    {
+      "id": 1,
+      "title": "Does the implementation distinguish between expert and AI-generated text?",
+      "description": "Check whether the visualization clearly differentiates between expert and AI text patterns. The system should identify and highlight characteristic differences in sentence structure, complexity patterns, and linguistic features. Deduct 5 points if there's no comparative analysis, and 3 points if the differentiation lacks clear visual indicators. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 2,
+      "title": "Is the natural language processing component properly designed?",
+      "description": "Evaluate whether the code includes proper NLP processing for text analysis, such as tokenization, parsing, and syntactic tree generation. The implementation should handle various linguistic phenomena correctly. Deduct 5 points if only superficial text metrics are used without proper parsing, and 3 points if the parsing capabilities are limited to simple structures. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 3,
+      "title": "Are interactive exploration features provided in the visualization?",
+      "description": "Assess whether the visualization offers interactive elements for users to explore different aspects of sentence complexity (e.g., filtering by complexity level, comparing multiple texts, zooming into specific structures). Deduct 3 points for each missing core interactive capability. The visualization should respond to user interactions with appropriate feedback. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 4,
+      "title": "Is the code robust?",
+      "description": "Evaluate whether the code can handle various edge cases such as extremely long sentences, malformed input, mixed languages, or unusual syntactic structures. Code with strong robustness should handle these cases gracefully with appropriate error messages or fallback visualizations, 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. Real-time analysis as text is typed 2. Exportable visualization reports with annotations 3. Historical comparison of analyzed texts). 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 text analysis functions 2. Function modules unrelated to sentence complexity visualization 3. Fancy effects that affect performance without adding analytical value. Deduct 3 points for each redundancy found, and directly deduct 10 points if the core visualization 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 text processing/visualization/data 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 data visualization standards?",
+      "description": "Evaluate whether the visualization follows modern data visualization principles: 1) Appropriate color encoding (consistent meaning, colorblind-friendly) 2) Proper use of visual hierarchy and white space 3) Clear labeling and legends. Deduct 3 points for each confusing visual element, 5 points for misleading visual encoding, and 5 points for visualizations that obscure rather than clarify the underlying data. The full score is 10 points.",
+      "maxScore": 10
+    },
+    {
+      "id": 9,
+      "title": "Is the dynamic interaction smooth and responsive?",
+      "description": "Judge whether the interactive elements respond efficiently to user actions: 1) Analysis feedback delay ≤ 500ms for typical texts 2) Smooth transitions when switching between visualization modes 3) Responsive design that works across device sizes. Deduct 5 points for each operation without feedback, 3 points for noticeable lag when processing longer texts, and 5 points for visualizations that break on common screen sizes. The full score is 10 points.",
+      "maxScore": 10
+    }
+  ],
+  "class": "Data Science-Data Visualization Dashboards",
+  "difficulty": "easy"
+}