Upload 5 files

.gitattributes

@@ -58,3 +58,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+code_debugging_events_fixed.csv filter=lfs diff=lfs merge=lfs -text
+code_debugging_sessions_fixed.csv filter=lfs diff=lfs merge=lfs -text

DATA_DICTIONARY_updated.md

@@ -0,0 +1,106 @@
+
+# Code Debugging Trajectory Dataset - Data Dictionary
+# ===================================================
+# Generated: 2026-06-26
+# Sessions: 50,000 | Events: 665,364 | Avg events/session: 13.3
+
+## SESSION-LEVEL DATA (code_debugging_sessions.csv)
+# 38 columns describing the overall debugging session
+
+| Column | Type | Description |
+|--------|------|-------------|
+| session_id | string | Unique identifier (DBG_0000000 format) |
+| timestamp_start | datetime | Session start time (2025 calendar year) |
+| timestamp_end | datetime | Session end time |
+| day_of_week | categorical | Monday-Sunday |
+| hour_of_day | int (0-23) | Start hour with realistic work-hour bias |
+| is_weekend | bool | True if Saturday or Sunday |
+| years_experience | float | Developer years of experience (0-25) |
+| experience_level | categorical | Junior/Mid-level/Senior/Staff-Principal |
+| editor_used | categorical | IDE/editor (VS Code dominant at 35%) |
+| operating_system | categorical | macOS/Linux/Windows |
+| company_size | categorical | Startup to Enterprise |
+| team_context | categorical | Solo, pair, sprint, on-call, review, learning |
+| programming_language | categorical | 8 languages with realistic market share |
+| project_type | categorical | Web, mobile, ML, CLI, microservice, etc. |
+| codebase_size_loc | int | Lines of code (log-normal, median ~22k) |
+| files_modified | int | Number of files touched |
+| primary_file_extension | categorical | File extension of primary language |
+| error_type | categorical | 71 language-specific error types |
+| error_severity | int (1-5) | Severity rating based on error taxonomy |
+| error_message_length | int | Character count of error message |
+| stack_trace_depth | int | Number of frames in stack trace |
+| similar_bug_before | bool | Whether developer encountered similar bug |
+| resolution_time_seconds | int | Total debugging time (15s - 2hr cap) |
+| resolution_time_minutes | float | Same as above in minutes |
+| compile_attempts | int | Number of compile/build attempts |
+| num_web_searches | int | Web searches performed |
+| external_resources_used | string | Pipe-separated list of resources |
+| ai_assistant_used | bool | Whether ChatGPT/Copilot/etc was used |
+| asked_colleague | bool | Whether help was requested |
+| num_file_navigations | int | File/cursor navigation events |
+| lines_changed | int | Lines of code modified |
+| keystrokes_per_minute | int | Typing intensity proxy |
+| took_break | bool | Break taken during session |
+| fix_strategy | categorical | What approach ultimately worked |
+| outcome | categorical | fixed / workaround_applied / escalated / abandoned |
+| fix_quality | categorical | poor / acceptable / good / excellent / refactored / N/A (N/A when outcome is not 'fixed') |
+| regression_introduced | bool | Whether fix caused new bugs |
+| test_added | bool | Whether test was added with fix |
+
+## EVENT-LEVEL DATA (code_debugging_events.csv)
+# 665,364 individual events across all sessions
+
+| Column | Type | Description |
+|--------|------|-------------|
+| session_id | string | Foreign key to sessions table |
+| event_sequence | int | Order of event within session (0-indexed) |
+| event_type | categorical | 15 event types (compile, edit, search, etc.) |
+| event_detail | string | Context-specific detail for the event. 'general' where no specific detail applies. |
+| event_timestamp | datetime | When event occurred |
+| event_duration_seconds | int | How long the event lasted |
+| elapsed_seconds | int | Cumulative time since session start |
+| session_stage | categorical | early / middle / late |
+| is_final_event | bool | Whether this is the last event in session |
+
+## KEY DESIGN DECISIONS
+
+1. **Realistic distributions**: Language shares match StackOverflow survey data.
+   Python (30%), JavaScript (22%), Java (15%), TypeScript (12%), C++ (8%), Go (5%), C# (4%), Rust (4%).
+
+2. **Experience-dependent behavior**: Juniors search more, use AI more, 
+   take longer to resolve. Seniors navigate files more efficiently.
+
+3. **Severity-driven complexity**: Severity 1 (SyntaxError) ~2min avg.
+   Severity 5 (SegFault) ~15min avg. Correlates with compile attempts,
+   stack trace depth, and fix strategy complexity.
+
+4. **Context modifiers**: On-call incidents resolve faster (pressure).
+   Learning/tutorials take longest. Weekends slightly slower.
+
+5. **Language difficulty**: Rust/C++ sessions take 1.4-1.6x longer.
+   Python/JavaScript are fastest to debug.
+
+6. **Outcome realism**: 88.6% fixed, 7.7% workaround, 2.8% escalated,
+   0.9% abandoned. Quality correlates with experience.
+
+7. **Event trajectories**: Each session generates a realistic sequence
+   of 3-200 events. Early = more errors/searches. Late = more tests/commits.
+
+## SUGGESTED DL TASKS
+
+1. **Time-to-fix regression**: Predict resolution_time_seconds from
+   first N events + session metadata.
+
+2. **Outcome classification**: Predict fixed/escalated/abandoned from
+   early trajectory patterns.
+
+3. **Next-event prediction**: Given event history, predict next event_type.
+
+4. **Fix quality prediction**: Predict fix_quality from debugging behavior.
+
+5. **Anomaly detection**: Identify sessions that will regress or abandon
+   before they do.
+
+6. **Sequence-to-sequence**: Generate full event trajectory from session
+   metadata (generative modeling).

code_debugging_events_fixed.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fff5e5c324252b3e16f074d0f580de1dbcbd8388ab2f20baa96ee47dc238685d
+size 55129409

code_debugging_sessions_fixed.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffbfa5316ca0e0bb23cea878486a419310b657b6fd78b215b20a94a2f63e0153
+size 17125038

daily-coding-companion.ipynb

@@ -0,0 +1,1029 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1eaefe42",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004281,
+     "end_time": "2026-06-27T15:07:13.649704+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:13.645423+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "# DebugTraj-50K — Daily Coding Companion\n",
+    "\n",
+    "**This notebook shows how YOU can use this dataset in your daily coding life.**\n",
+    "\n",
+    "No ML experience needed. Every example is practical and copy-paste ready.\n",
+    "\n",
+    "---\n",
+    "### What you will learn:\n",
+    "1. How long will my bug take to fix?\n",
+    "2. Am I debugging the right way?\n",
+    "3. What should I do next when stuck?\n",
+    "4. Which language is hardest to debug?\n",
+    "5. Build your own personal debugging report\n",
+    "6. Get smarter search suggestions while debugging\n",
+    "7. Know when to ask for help\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "13cdcd5f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:13.658624Z",
+     "iopub.status.busy": "2026-06-27T15:07:13.657698Z",
+     "iopub.status.idle": "2026-06-27T15:07:18.922382Z",
+     "shell.execute_reply": "2026-06-27T15:07:18.921175Z"
+    },
+    "papermill": {
+     "duration": 5.27189,
+     "end_time": "2026-06-27T15:07:18.924934+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:13.653044+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Dataset loaded successfully!\n",
+      "Sessions : 50,000\n",
+      "Events   : 665,364\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Setup — run this first\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "sns.set_theme(style='darkgrid')\n",
+    "\n",
+    "BASE = '/kaggle/input/datasets/abhisheksingh016/debugtraj-50k/'\n",
+    "\n",
+    "sessions = pd.read_csv(BASE + 'code_debugging_sessions_fixed.csv')\n",
+    "events   = pd.read_csv(BASE + 'code_debugging_events_fixed.csv')\n",
+    "\n",
+    "print('Dataset loaded successfully!')\n",
+    "print(f'Sessions : {len(sessions):,}')\n",
+    "print(f'Events   : {len(events):,}')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e1c9d46",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00418,
+     "end_time": "2026-06-27T15:07:18.935375+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:18.931195+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 1: How Long Will My Bug Take to Fix?\n",
+    "\n",
+    "**Scenario:** You just hit a bug. You want to know — realistically — how long it will take.\n",
+    "\n",
+    "Just fill in your details below and run the cell."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "24a7e98d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:18.946716Z",
+     "iopub.status.busy": "2026-06-27T15:07:18.945923Z",
+     "iopub.status.idle": "2026-06-27T15:07:18.982422Z",
+     "shell.execute_reply": "2026-06-27T15:07:18.981293Z"
+    },
+    "papermill": {
+     "duration": 0.044083,
+     "end_time": "2026-06-27T15:07:18.984655+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:18.940572+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Language   : Python\n",
+      "Experience : Mid-level (2-5 years)\n",
+      "Severity   : 3/5\n",
+      "Based on   : 4,127 similar sessions\n",
+      "\n",
+      "Expected fix time : 4 minutes\n",
+      "Fast scenario     : 2 minutes (top 25%)\n",
+      "Slow scenario     : 5 minutes (bottom 25%)\n",
+      "Chance of fixing  : 88.3%\n",
+      "\n",
+      "Verdict: Quick fix — should be done soon.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR DETAILS ---\n",
+    "my_language   = 'Python'          # Python, JavaScript, Java, TypeScript, C++, Go, C#, Rust\n",
+    "my_experience = 'Mid-level (2-5 years)'   # Junior (0-2 years) / Mid-level (2-5 years) / Senior (5-10 years) / Staff/Principal (10+ years)\n",
+    "my_error      = 'AttributeError'  # e.g. TypeError, NullPointerException, SyntaxError\n",
+    "my_severity   = 3                 # 1=minor, 2=low, 3=medium, 4=high, 5=critical\n",
+    "# ----------------------------\n",
+    "\n",
+    "# Filter similar sessions from dataset\n",
+    "similar = sessions[\n",
+    "    (sessions['programming_language'] == my_language) &\n",
+    "    (sessions['experience_level']     == my_experience) &\n",
+    "    (sessions['error_severity']       == my_severity)\n",
+    "]\n",
+    "\n",
+    "if len(similar) == 0:\n",
+    "    # Relax filter if no exact match\n",
+    "    similar = sessions[\n",
+    "        (sessions['programming_language'] == my_language) &\n",
+    "        (sessions['experience_level']     == my_experience)\n",
+    "    ]\n",
+    "\n",
+    "avg_time  = similar['resolution_time_minutes'].mean()\n",
+    "fast_time = similar['resolution_time_minutes'].quantile(0.25)\n",
+    "slow_time = similar['resolution_time_minutes'].quantile(0.75)\n",
+    "success   = (similar['outcome'] == 'fixed').mean() * 100\n",
+    "\n",
+    "print(f'Language   : {my_language}')\n",
+    "print(f'Experience : {my_experience}')\n",
+    "print(f'Severity   : {my_severity}/5')\n",
+    "print(f'Based on   : {len(similar):,} similar sessions')\n",
+    "print()\n",
+    "print(f'Expected fix time : {avg_time:.0f} minutes')\n",
+    "print(f'Fast scenario     : {fast_time:.0f} minutes (top 25%)')\n",
+    "print(f'Slow scenario     : {slow_time:.0f} minutes (bottom 25%)')\n",
+    "print(f'Chance of fixing  : {success:.1f}%')\n",
+    "print()\n",
+    "if avg_time < 10:\n",
+    "    print('Verdict: Quick fix — should be done soon.')\n",
+    "elif avg_time < 30:\n",
+    "    print('Verdict: Moderate bug — take it step by step.')\n",
+    "else:\n",
+    "    print('Verdict: Complex bug — consider asking a colleague.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ee6a4c61",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003499,
+     "end_time": "2026-06-27T15:07:18.991777+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:18.988278+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 2: Am I Debugging the Right Way?\n",
+    "\n",
+    "**Scenario:** You want to compare your debugging habits with developers at your level.\n",
+    "\n",
+    "Fill in what you did during your last debugging session."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d0b292f9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:19.001022Z",
+     "iopub.status.busy": "2026-06-27T15:07:19.000470Z",
+     "iopub.status.idle": "2026-06-27T15:07:19.023224Z",
+     "shell.execute_reply": "2026-06-27T15:07:19.022045Z"
+    },
+    "papermill": {
+     "duration": 0.030099,
+     "end_time": "2026-06-27T15:07:19.025412+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:18.995313+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Comparing you vs other Mid-level (2-5 years) developers:\n",
+      "\n",
+      "Metric                    You   Avg Peer      Verdict\n",
+      "-------------------------------------------------------\n",
+      "Web Searches              5.0        3.2    Above avg\n",
+      "Compile Attempts          8.0        6.0    Above avg\n",
+      "Files Changed             2.0        3.0    Below avg\n",
+      "Lines Changed            15.0       11.4    Above avg\n",
+      "\n",
+      "AI tool usage among peers: 23.2%\n",
+      "You used AI — same as most developers at your level.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR LAST SESSION ---\n",
+    "my_experience    = 'Mid-level (2-5 years)'\n",
+    "my_searches      = 5     # how many times did you Google?\n",
+    "my_compiles      = 8     # how many times did you compile/run?\n",
+    "my_files_changed = 2     # how many files did you modify?\n",
+    "my_lines_changed = 15    # how many lines did you change?\n",
+    "my_used_ai       = True  # did you use ChatGPT/Copilot?\n",
+    "# ---------------------------------\n",
+    "\n",
+    "peers = sessions[sessions['experience_level'] == my_experience]\n",
+    "\n",
+    "metrics = {\n",
+    "    'Web Searches'   : (my_searches,      peers['num_web_searches'].mean()),\n",
+    "    'Compile Attempts': (my_compiles,      peers['compile_attempts'].mean()),\n",
+    "    'Files Changed'  : (my_files_changed,  peers['files_modified'].mean()),\n",
+    "    'Lines Changed'  : (my_lines_changed,  peers['lines_changed'].mean()),\n",
+    "}\n",
+    "\n",
+    "print(f'Comparing you vs other {my_experience} developers:')\n",
+    "print()\n",
+    "print(f'{\"Metric\":<20} {\"You\":>8} {\"Avg Peer\":>10} {\"Verdict\":>12}')\n",
+    "print('-' * 55)\n",
+    "for metric, (mine, avg) in metrics.items():\n",
+    "    diff = ((mine - avg) / avg) * 100\n",
+    "    if abs(diff) < 20:\n",
+    "        verdict = 'Normal'\n",
+    "    elif diff > 0:\n",
+    "        verdict = 'Above avg'\n",
+    "    else:\n",
+    "        verdict = 'Below avg'\n",
+    "    print(f'{metric:<20} {mine:>8.1f} {avg:>10.1f} {verdict:>12}')\n",
+    "\n",
+    "print()\n",
+    "ai_pct = peers['ai_assistant_used'].mean() * 100\n",
+    "print(f'AI tool usage among peers: {ai_pct:.1f}%')\n",
+    "if my_used_ai:\n",
+    "    print('You used AI — same as most developers at your level.')\n",
+    "else:\n",
+    "    print(f'You did not use AI — {ai_pct:.0f}% of your peers do.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba3c4f78",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003546,
+     "end_time": "2026-06-27T15:07:19.032592+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.029046+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 3: What Should I Do Next When Stuck?\n",
+    "\n",
+    "**Scenario:** You have been debugging for a while. What do most developers do in this situation?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6ac980cd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:19.041873Z",
+     "iopub.status.busy": "2026-06-27T15:07:19.041263Z",
+     "iopub.status.idle": "2026-06-27T15:07:19.071498Z",
+     "shell.execute_reply": "2026-06-27T15:07:19.070445Z"
+    },
+    "papermill": {
+     "duration": 0.037487,
+     "end_time": "2026-06-27T15:07:19.073658+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.036171+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "You have been debugging for 20 minutes in Python.\n",
+      "Searches: 4 | Compile attempts: 6\n",
+      "Found 3,384 similar sessions in dataset.\n",
+      "\n",
+      "Top strategies that WORKED in similar situations:\n",
+      "\n",
+      "  1. Index bounds validation (11% of cases)\n",
+      "  2. Exception handling wrapped (10% of cases)\n",
+      "  3. Variable initialization fixed (10% of cases)\n",
+      "  4. Type cast / conversion applied (10% of cases)\n",
+      "  5. Null/undefined check added (10% of cases)\n",
+      "\n",
+      "Tip: Most developers (89%) solved this independently. Keep going!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR CURRENT SITUATION ---\n",
+    "my_language    = 'Python'\n",
+    "my_experience  = 'Junior (0-2 years)'\n",
+    "minutes_so_far = 20   # how many minutes have you been debugging?\n",
+    "searches_done  = 4    # how many searches have you done?\n",
+    "compiles_done  = 6    # how many compile/run attempts?\n",
+    "# ---------------------------------------\n",
+    "\n",
+    "# Find sessions with similar progress\n",
+    "similar = sessions[\n",
+    "    (sessions['programming_language'] == my_language) &\n",
+    "    (sessions['num_web_searches'] >= searches_done - 1) &\n",
+    "    (sessions['num_web_searches'] <= searches_done + 2) &\n",
+    "    (sessions['compile_attempts']  >= compiles_done - 1)\n",
+    "]\n",
+    "\n",
+    "print(f'You have been debugging for {minutes_so_far} minutes in {my_language}.')\n",
+    "print(f'Searches: {searches_done} | Compile attempts: {compiles_done}')\n",
+    "print(f'Found {len(similar):,} similar sessions in dataset.')\n",
+    "print()\n",
+    "\n",
+    "# What strategy worked for similar sessions?\n",
+    "strategies = similar[similar['outcome']=='fixed']['fix_strategy'].value_counts().head(5)\n",
+    "print('Top strategies that WORKED in similar situations:')\n",
+    "print()\n",
+    "for i, (strategy, count) in enumerate(strategies.items(), 1):\n",
+    "    pct = count / len(similar) * 100\n",
+    "    print(f'  {i}. {strategy} ({pct:.0f}% of cases)')\n",
+    "\n",
+    "print()\n",
+    "\n",
+    "# Should they ask for help?\n",
+    "ask_rate = similar['asked_colleague'].mean() * 100\n",
+    "if ask_rate > 40:\n",
+    "    print(f'Tip: {ask_rate:.0f}% of developers in this situation asked a colleague. Consider it!')\n",
+    "else:\n",
+    "    print(f'Tip: Most developers ({100-ask_rate:.0f}%) solved this independently. Keep going!')\n",
+    "\n",
+    "# Break suggestion\n",
+    "break_rate = similar[similar['resolution_time_minutes'] > minutes_so_far]['took_break'].mean() * 100\n",
+    "if break_rate > 35:\n",
+    "    print(f'Tip: {break_rate:.0f}% took a short break and then fixed it. Try stepping away for 5 minutes.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "758febd6",
+   "metadata": {
+    "papermill": {
+     "duration": 0.003925,
+     "end_time": "2026-06-27T15:07:19.081349+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.077424+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 4: Which Language is Hardest to Debug?\n",
+    "\n",
+    "**Scenario:** You are choosing between two languages for your next project. See which one is easier to debug."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f8146e40",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:19.090055Z",
+     "iopub.status.busy": "2026-06-27T15:07:19.089745Z",
+     "iopub.status.idle": "2026-06-27T15:07:19.889332Z",
+     "shell.execute_reply": "2026-06-27T15:07:19.888168Z"
+    },
+    "papermill": {
+     "duration": 0.807192,
+     "end_time": "2026-06-27T15:07:19.892042+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.084850+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Language Debugging Difficulty Ranking (easiest to hardest):\n",
+      "\n",
+      "Rank  Language        Avg Time  Fix Rate  Searches  Compiles\n",
+      "------------------------------------------------------------\n",
+      "1     Python              3.9m     88.4%       2.6       5.2\n",
+      "2     JavaScript          3.9m     88.6%       2.5       5.0\n",
+      "3     TypeScript          4.4m     88.5%       2.6       5.3\n",
+      "4     C#                  5.9m     89.9%       3.7       7.3\n",
+      "5     Java                6.0m     89.2%       3.3       6.8\n",
+      "6     Go                  6.2m     88.1%       3.7       7.4\n",
+      "7     C++                10.3m     88.7%       4.3       8.6\n",
+      "8     Rust               11.4m     88.7%       4.1       8.1\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Language comparison\n",
+    "lang_stats = sessions.groupby('programming_language').agg(\n",
+    "    avg_time    = ('resolution_time_minutes', 'mean'),\n",
+    "    success_rate= ('outcome', lambda x: (x=='fixed').mean() * 100),\n",
+    "    avg_searches= ('num_web_searches', 'mean'),\n",
+    "    avg_compiles= ('compile_attempts', 'mean'),\n",
+    "    total_sessions = ('session_id', 'count')\n",
+    ").round(1).sort_values('avg_time')\n",
+    "\n",
+    "print('Language Debugging Difficulty Ranking (easiest to hardest):')\n",
+    "print()\n",
+    "print(f'{\"Rank\":<5} {\"Language\":<14} {\"Avg Time\":>9} {\"Fix Rate\":>9} {\"Searches\":>9} {\"Compiles\":>9}')\n",
+    "print('-' * 60)\n",
+    "for rank, (lang, row) in enumerate(lang_stats.iterrows(), 1):\n",
+    "    print(f'{rank:<5} {lang:<14} {row[\"avg_time\"]:>8.1f}m {row[\"success_rate\"]:>8.1f}% {row[\"avg_searches\"]:>9.1f} {row[\"avg_compiles\"]:>9.1f}')\n",
+    "\n",
+    "print()\n",
+    "\n",
+    "# Visual chart\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "lang_stats['avg_time'].plot(kind='barh', ax=axes[0],\n",
+    "    color=sns.color_palette('RdYlGn_r', len(lang_stats)))\n",
+    "axes[0].set_title('Avg Debugging Time by Language', fontweight='bold')\n",
+    "axes[0].set_xlabel('Minutes')\n",
+    "\n",
+    "lang_stats['success_rate'].plot(kind='barh', ax=axes[1],\n",
+    "    color=sns.color_palette('RdYlGn', len(lang_stats)))\n",
+    "axes[1].set_title('Fix Success Rate by Language', fontweight='bold')\n",
+    "axes[1].set_xlabel('% Fixed')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('language_difficulty.png', dpi=150, bbox_inches='tight')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0faff775",
+   "metadata": {
+    "papermill": {
+     "duration": 0.005075,
+     "end_time": "2026-06-27T15:07:19.902042+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.896967+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 5: Build Your Personal Debugging Report\n",
+    "\n",
+    "**Scenario:** End of the week. You want to see how your debugging sessions compare to the dataset."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "82e22622",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:19.913144Z",
+     "iopub.status.busy": "2026-06-27T15:07:19.912760Z",
+     "iopub.status.idle": "2026-06-27T15:07:19.946025Z",
+     "shell.execute_reply": "2026-06-27T15:07:19.944719Z"
+    },
+    "papermill": {
+     "duration": 0.042051,
+     "end_time": "2026-06-27T15:07:19.948570+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.906519+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== YOUR WEEKLY DEBUGGING REPORT ===\n",
+      "\n",
+      "Metric                      You    Peers       Status\n",
+      "-------------------------------------------------------\n",
+      "Avg Fix Time (min)         30.0      5.3   Needs work\n",
+      "Fix Rate (%)               80.0     88.6       Normal\n",
+      "Avg Searches                5.0      3.2   Needs work\n",
+      "Avg Compiles                7.0      6.0       Normal\n",
+      "\n",
+      "Your sessions this week : 5\n",
+      "Fixed                   : 4 / 5\n",
+      "\n",
+      "Overall: Strong week! You resolved most bugs efficiently.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR WEEK ---\n",
+    "my_sessions = [\n",
+    "    {'language': 'Python',     'minutes': 15, 'fixed': True,  'searches': 3, 'compiles': 4},\n",
+    "    {'language': 'JavaScript', 'minutes': 45, 'fixed': True,  'searches': 7, 'compiles': 9},\n",
+    "    {'language': 'Python',     'minutes': 8,  'fixed': True,  'searches': 1, 'compiles': 2},\n",
+    "    {'language': 'TypeScript', 'minutes': 60, 'fixed': False, 'searches': 10,'compiles': 15},\n",
+    "    {'language': 'Python',     'minutes': 22, 'fixed': True,  'searches': 4, 'compiles': 5},\n",
+    "]\n",
+    "my_experience = 'Mid-level (2-5 years)'\n",
+    "# -------------------------\n",
+    "\n",
+    "my_df = pd.DataFrame(my_sessions)\n",
+    "\n",
+    "my_avg_time    = my_df['minutes'].mean()\n",
+    "my_fix_rate    = my_df['fixed'].mean() * 100\n",
+    "my_avg_search  = my_df['searches'].mean()\n",
+    "my_avg_compile = my_df['compiles'].mean()\n",
+    "\n",
+    "peers = sessions[sessions['experience_level'] == my_experience]\n",
+    "p_avg_time    = peers['resolution_time_minutes'].mean()\n",
+    "p_fix_rate    = (peers['outcome']=='fixed').mean() * 100\n",
+    "p_avg_search  = peers['num_web_searches'].mean()\n",
+    "p_avg_compile = peers['compile_attempts'].mean()\n",
+    "\n",
+    "print('=== YOUR WEEKLY DEBUGGING REPORT ===')\n",
+    "print()\n",
+    "print(f'{\"Metric\":<22} {\"You\":>8} {\"Peers\":>8} {\"Status\":>12}')\n",
+    "print('-' * 55)\n",
+    "\n",
+    "def status(mine, peer, lower_is_better=True):\n",
+    "    if lower_is_better:\n",
+    "        return 'Great' if mine < peer * 0.9 else 'Normal' if mine < peer * 1.2 else 'Needs work'\n",
+    "    else:\n",
+    "        return 'Great' if mine > peer * 1.1 else 'Normal' if mine > peer * 0.8 else 'Needs work'\n",
+    "\n",
+    "rows = [\n",
+    "    ('Avg Fix Time (min)',  my_avg_time,    p_avg_time,    True),\n",
+    "    ('Fix Rate (%)',        my_fix_rate,    p_fix_rate,    False),\n",
+    "    ('Avg Searches',        my_avg_search,  p_avg_search,  True),\n",
+    "    ('Avg Compiles',        my_avg_compile, p_avg_compile, True),\n",
+    "]\n",
+    "\n",
+    "for label, mine, peer, lib in rows:\n",
+    "    print(f'{label:<22} {mine:>8.1f} {peer:>8.1f} {status(mine, peer, lib):>12}')\n",
+    "\n",
+    "print()\n",
+    "print(f'Your sessions this week : {len(my_df)}')\n",
+    "print(f'Fixed                   : {my_df[\"fixed\"].sum()} / {len(my_df)}')\n",
+    "print()\n",
+    "if my_fix_rate >= 80:\n",
+    "    print('Overall: Strong week! You resolved most bugs efficiently.')\n",
+    "elif my_fix_rate >= 60:\n",
+    "    print('Overall: Decent week. A few tough ones — normal for your level.')\n",
+    "else:\n",
+    "    print('Overall: Tough week. Consider reviewing debugging strategies.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c6d4120b",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004803,
+     "end_time": "2026-06-27T15:07:19.958836+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.954033+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 6: Smarter Search Suggestions While Debugging\n",
+    "\n",
+    "**Scenario:** You are stuck on an error. What do developers actually search for in this situation?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "36893108",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:19.970856Z",
+     "iopub.status.busy": "2026-06-27T15:07:19.969823Z",
+     "iopub.status.idle": "2026-06-27T15:07:20.003890Z",
+     "shell.execute_reply": "2026-06-27T15:07:20.002482Z"
+    },
+    "papermill": {
+     "duration": 0.042597,
+     "end_time": "2026-06-27T15:07:20.006180+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:19.963583+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error: AttributeError in Python\n",
+      "Found 2,655 matching sessions in dataset\n",
+      "\n",
+      "What developers searched/used to fix this error:\n",
+      "\n",
+      "  no external search                  ########## 32%\n",
+      "  exact error message                 #### 14%\n",
+      "  similar code example                #### 14%\n",
+      "  colleague/Slack                     #### 14%\n",
+      "  AI assistant (ChatGPT/Copilot)      #### 14%\n",
+      "  library documentation               #### 14%\n",
+      "  language-specific forum             #### 13%\n",
+      "  GitHub issue search                 #### 13%\n",
+      "\n",
+      "Most common fix strategy : Variable initialization fixed\n",
+      "Average fix time         : 4 minutes\n",
+      "Fix success rate         : 88.4%\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR ERROR ---\n",
+    "my_language = 'Python'\n",
+    "my_error    = 'AttributeError'\n",
+    "# --------------------------\n",
+    "\n",
+    "similar = sessions[\n",
+    "    (sessions['programming_language'] == my_language) &\n",
+    "    (sessions['error_type']           == my_error)\n",
+    "]\n",
+    "\n",
+    "print(f'Error: {my_error} in {my_language}')\n",
+    "print(f'Found {len(similar):,} matching sessions in dataset')\n",
+    "print()\n",
+    "\n",
+    "# What external resources did developers use?\n",
+    "all_resources = []\n",
+    "for r in similar['external_resources_used'].dropna():\n",
+    "    all_resources.extend([x.strip() for x in str(r).split('|')])\n",
+    "\n",
+    "resource_counts = pd.Series(all_resources).value_counts().head(8)\n",
+    "print('What developers searched/used to fix this error:')\n",
+    "print()\n",
+    "for resource, count in resource_counts.items():\n",
+    "    pct = count / len(similar) * 100\n",
+    "    bar = '#' * int(pct / 3)\n",
+    "    print(f'  {resource:<35} {bar} {pct:.0f}%')\n",
+    "\n",
+    "print()\n",
+    "\n",
+    "# Most common fix strategy\n",
+    "top_fix = similar[similar['outcome']=='fixed']['fix_strategy'].value_counts().index[0]\n",
+    "fix_rate = (similar['outcome']=='fixed').mean() * 100\n",
+    "avg_time = similar['resolution_time_minutes'].mean()\n",
+    "\n",
+    "print(f'Most common fix strategy : {top_fix}')\n",
+    "print(f'Average fix time         : {avg_time:.0f} minutes')\n",
+    "print(f'Fix success rate         : {fix_rate:.1f}%')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba2bf48d",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004371,
+     "end_time": "2026-06-27T15:07:20.014887+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:20.010516+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Example 7: Know When to Ask for Help\n",
+    "\n",
+    "**Scenario:** You have been stuck for a while. Should you keep trying or ask a colleague?\n",
+    "\n",
+    "This tool tells you based on real data from 50,000 sessions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "58ac0aaa",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:20.025393Z",
+     "iopub.status.busy": "2026-06-27T15:07:20.024984Z",
+     "iopub.status.idle": "2026-06-27T15:07:20.054795Z",
+     "shell.execute_reply": "2026-06-27T15:07:20.053191Z"
+    },
+    "papermill": {
+     "duration": 0.038093,
+     "end_time": "2026-06-27T15:07:20.057190+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:20.019097+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== SHOULD YOU ASK FOR HELP? ===\n",
+      "\n",
+      "You have spent 35 min on a severity-4 JavaScript bug.\n",
+      "Searches: 8 | Compiles: 12 | AI used: True\n",
+      "\n",
+      "In 0 similar situations from the dataset:\n",
+      "  Fixed it alone        : nan%\n",
+      "  Fixed after asking    : nan%\n",
+      "  Escalated to senior   : nan%\n",
+      "  Abandoned             : nan%\n",
+      "\n",
+      "Avg extra time needed   : nan more minutes\n",
+      "Developers who asked    : nan%\n",
+      "\n",
+      "VERDICT: Keep going. Most developers solve this independently.\n",
+      "Extra tip: You have exhausted common resources. A fresh pair of eyes will help.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# --- FILL IN YOUR SITUATION ---\n",
+    "my_language    = 'JavaScript'\n",
+    "my_experience  = 'Junior (0-2 years)'\n",
+    "my_severity    = 4\n",
+    "minutes_spent  = 35\n",
+    "searches_done  = 8\n",
+    "compiles_done  = 12\n",
+    "tried_ai       = True\n",
+    "# ------------------------------\n",
+    "\n",
+    "similar = sessions[\n",
+    "    (sessions['programming_language'] == my_language) &\n",
+    "    (sessions['experience_level']     == my_experience) &\n",
+    "    (sessions['error_severity']       == my_severity)\n",
+    "]\n",
+    "\n",
+    "if len(similar) < 50:\n",
+    "    similar = sessions[\n",
+    "        (sessions['experience_level'] == my_experience) &\n",
+    "        (sessions['error_severity']   == my_severity)\n",
+    "    ]\n",
+    "\n",
+    "# Sessions that went longer than you and what happened\n",
+    "longer = similar[similar['resolution_time_minutes'] >= minutes_spent]\n",
+    "\n",
+    "fixed_alone    = ((longer['outcome']=='fixed') & (~longer['asked_colleague'])).mean() * 100\n",
+    "fixed_with_help= ((longer['outcome']=='fixed') & (longer['asked_colleague'])).mean() * 100\n",
+    "escalated      = (longer['outcome']=='escalated').mean() * 100\n",
+    "abandoned      = (longer['outcome']=='abandoned').mean() * 100\n",
+    "ask_rate       = longer['asked_colleague'].mean() * 100\n",
+    "avg_extra_time = longer['resolution_time_minutes'].mean() - minutes_spent\n",
+    "\n",
+    "print('=== SHOULD YOU ASK FOR HELP? ===')\n",
+    "print()\n",
+    "print(f'You have spent {minutes_spent} min on a severity-{my_severity} {my_language} bug.')\n",
+    "print(f'Searches: {searches_done} | Compiles: {compiles_done} | AI used: {tried_ai}')\n",
+    "print()\n",
+    "print(f'In {len(longer):,} similar situations from the dataset:')\n",
+    "print(f'  Fixed it alone        : {fixed_alone:.0f}%')\n",
+    "print(f'  Fixed after asking    : {fixed_with_help:.0f}%')\n",
+    "print(f'  Escalated to senior   : {escalated:.0f}%')\n",
+    "print(f'  Abandoned             : {abandoned:.0f}%')\n",
+    "print()\n",
+    "print(f'Avg extra time needed   : {avg_extra_time:.0f} more minutes')\n",
+    "print(f'Developers who asked    : {ask_rate:.0f}%')\n",
+    "print()\n",
+    "\n",
+    "# Decision\n",
+    "if ask_rate > 50 and fixed_alone < 30:\n",
+    "    print('VERDICT: Ask for help NOW. Data shows most people need it at this point.')\n",
+    "elif ask_rate > 30:\n",
+    "    print('VERDICT: Consider asking. About half of developers do at this stage.')\n",
+    "else:\n",
+    "    print('VERDICT: Keep going. Most developers solve this independently.')\n",
+    "\n",
+    "if searches_done >= 8 and tried_ai:\n",
+    "    print('Extra tip: You have exhausted common resources. A fresh pair of eyes will help.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "68b1512c",
+   "metadata": {
+    "papermill": {
+     "duration": 0.00428,
+     "end_time": "2026-06-27T15:07:20.065944+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:20.061664+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Bonus: Your Error Type Lookup Table\n",
+    "\n",
+    "Quick reference — paste any error type and get instant stats."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "44edaa9a",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-06-27T15:07:20.076409Z",
+     "iopub.status.busy": "2026-06-27T15:07:20.076068Z",
+     "iopub.status.idle": "2026-06-27T15:07:20.116251Z",
+     "shell.execute_reply": "2026-06-27T15:07:20.114954Z"
+    },
+    "papermill": {
+     "duration": 0.048336,
+     "end_time": "2026-06-27T15:07:20.118558+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:20.070222+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "=== AttributeError ===\n",
+      "Total sessions     : 2,655\n",
+      "Avg fix time       : 4.2 min\n",
+      "Fix success rate   : 88.4%\n",
+      "Avg severity       : 3.0/5\n",
+      "Most common in     : Python\n",
+      "Top fix strategy   : Variable initialization fixed\n",
+      "\n",
+      "Fix time by experience level:\n",
+      "experience_level\n",
+      "Junior (0-2 years)             5.0\n",
+      "Mid-level (2-5 years)          4.4\n",
+      "Senior (5-10 years)            3.7\n",
+      "Staff/Principal (10+ years)    2.7\n",
+      "\n",
+      "=== TypeError ===\n",
+      "Total sessions     : 4,835\n",
+      "Avg fix time       : 4.4 min\n",
+      "Fix success rate   : 88.9%\n",
+      "Avg severity       : 3.0/5\n",
+      "Most common in     : JavaScript\n",
+      "Top fix strategy   : Variable initialization fixed\n",
+      "\n",
+      "Fix time by experience level:\n",
+      "experience_level\n",
+      "Junior (0-2 years)             5.2\n",
+      "Mid-level (2-5 years)          4.4\n",
+      "Senior (5-10 years)            3.7\n",
+      "Staff/Principal (10+ years)    2.8\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Quick lookup for any error\n",
+    "def error_lookup(error_type):\n",
+    "    data = sessions[sessions['error_type'] == error_type]\n",
+    "    if len(data) == 0:\n",
+    "        print(f'Error type \"{error_type}\" not found in dataset.')\n",
+    "        print('Available errors:', sorted(sessions['error_type'].unique())[:20])\n",
+    "        return\n",
+    "\n",
+    "    print(f'=== {error_type} ===')\n",
+    "    print(f'Total sessions     : {len(data):,}')\n",
+    "    print(f'Avg fix time       : {data[\"resolution_time_minutes\"].mean():.1f} min')\n",
+    "    print(f'Fix success rate   : {(data[\"outcome\"]==\"fixed\").mean()*100:.1f}%')\n",
+    "    print(f'Avg severity       : {data[\"error_severity\"].mean():.1f}/5')\n",
+    "    print(f'Most common in     : {data[\"programming_language\"].value_counts().index[0]}')\n",
+    "    print(f'Top fix strategy   : {data[data[\"outcome\"]==\"fixed\"][\"fix_strategy\"].value_counts().index[0]}')\n",
+    "    print()\n",
+    "    print('Fix time by experience level:')\n",
+    "    print(data.groupby('experience_level')['resolution_time_minutes'].mean().round(1).to_string())\n",
+    "\n",
+    "# --- Change this to any error you want ---\n",
+    "error_lookup('AttributeError')\n",
+    "print()\n",
+    "error_lookup('TypeError')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3148bef8",
+   "metadata": {
+    "papermill": {
+     "duration": 0.004492,
+     "end_time": "2026-06-27T15:07:20.127592+00:00",
+     "exception": false,
+     "start_time": "2026-06-27T15:07:20.123100+00:00",
+     "status": "completed"
+    },
+    "tags": []
+   },
+   "source": [
+    "---\n",
+    "## Summary — Your Daily Debugging Toolkit\n",
+    "\n",
+    "| Example | Daily Use Case |\n",
+    "|---------|---------------|\n",
+    "| 1 | Estimate how long your current bug will take |\n",
+    "| 2 | Compare your habits with peer developers |\n",
+    "| 3 | Get next-step suggestions when stuck |\n",
+    "| 4 | Choose the easiest language for your project |\n",
+    "| 5 | Generate your weekly debugging performance report |\n",
+    "| 6 | Get smarter search suggestions for your error |\n",
+    "| 7 | Decide when it is time to ask for help |\n",
+    "\n",
+    "---\n",
+    "**Dataset:** DebugTraj-50K by Abhishek Singh | BGIEM Jabalpur | 2026\n",
+    "\n",
+    "If this helped you, please upvote the dataset!"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.13"
+  },
+  "papermill": {
+   "default_parameters": {},
+   "duration": 10.322891,
+   "end_time": "2026-06-27T15:07:20.854401+00:00",
+   "environment_variables": {},
+   "exception": null,
+   "input_path": "__notebook__.ipynb",
+   "output_path": "__notebook__.ipynb",
+   "parameters": {},
+   "start_time": "2026-06-27T15:07:10.531510+00:00",
+   "version": "2.7.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}