working for MIDTERM2a and b

app.py

@@ -2,6 +2,7 @@ from app_utils import (load_problems, export_submissions,
             get_all_students, get_student_submissions, check_password, 
             refresh_submissions)
 from student_tab import create_student_tab
+from dump_all import create_markdown_zip
 import gradio as gr
 
 
@@ -25,9 +26,15 @@ def create_app():
                         refresh_button = gr.Button("🔄 Refresh")
                     
                     submissions = gr.JSON(label="Submissions")
-                    download_btn = gr.Button("Download All Submissions")
                     
-                    # Move this inside admin_panel to ensure it's only accessible after login
+                    with gr.Row():
+                        download_btn = gr.Button("Download All Submissions (JSON)")
+                        download_markdown_btn = gr.Button("Download All Submissions (Markdown)")
+                    
+                    with gr.Row():
+                        download_output = gr.File(label="Download JSON")
+                        download_markdown_output = gr.File(label="Download Markdown")
+                    
                     def refresh_data():
                         return {
                             students: gr.update(choices=get_all_students()),
@@ -38,8 +45,6 @@ def create_app():
                         fn=refresh_data,
                         outputs=[students, submissions]
                     )
-                    
-                    download_output = gr.File(label="Download")
                 
                 def login(pwd):
                     if check_password(pwd):
@@ -48,7 +53,7 @@ def create_app():
                             admin_panel: gr.update(visible=True),
                             students: gr.update(choices=student_list),
                             login_status: "✅ Logged in successfully!",
-                            submissions: refresh_submissions()  # Load initial submissions
+                            submissions: refresh_submissions()
                         }
                     return {
                         admin_panel: gr.update(visible=False),
@@ -68,6 +73,12 @@ def create_app():
                         return file_path
                     return None
                 
+                def download_markdown():
+                    file_path = create_markdown_zip()
+                    if file_path:
+                        return file_path
+                    return None
+                
                 # Update event handlers
                 login_button.click(
                     fn=login,
@@ -84,7 +95,13 @@ def create_app():
                 download_btn.click(
                     fn=download_all,
                     outputs=[download_output]
-                )    
+                )
+                
+                download_markdown_btn.click(
+                    fn=download_markdown,
+                    outputs=[download_markdown_output]
+                )
+    
     return app
 
 if __name__ == "__main__":

app_utils.py

@@ -1,6 +1,9 @@
 import json
 import os
 import datetime
+import logging
+import traceback
+import sqlite3
 from pathlib import Path
 from dotenv import load_dotenv
 from tinydb import TinyDB, Query
@@ -8,108 +11,154 @@ from tinydb_serialization import SerializationMiddleware
 from tinydb_sqlite import SQLiteStorage
 import tempfile
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('app.log'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
 load_dotenv()
 SESSION_ID = os.getenv('SESSION_ID', 'default_session')
-print(f"Session ID: {SESSION_ID}")
+SESSION_TITLE = os.getenv('SESSION_TITLE', 'Default Session')
+logger.info(f"Session ID: {SESSION_ID}")
 ADMIN_PASSWD = os.getenv('ADMIN_PASSWD', 'default_password')
 SUBMISSIONS_DIR = 'submissions'
 
-print("Using TinyDB with SQLiteStorage for data storage")
-
-def get_db():
-    """Initialize and return a TinyDB instance with SQLiteStorage."""
-    serialization = SerializationMiddleware()
-    storage = SQLiteStorage(
-        'submissions.db',
-        serialization=serialization,
-        connection_kwargs={'check_same_thread': False}
-    )
-    db = TinyDB(storage=storage)
-    submissions_table = db.table('submissions')
-    return db, submissions_table
+def get_storage():
+    """Create and return SQLite storage instance."""
+    try:
+        db_path = 'submissions.db'
+        serialization = SerializationMiddleware()
+        connection = sqlite3.connect(db_path, check_same_thread=False)
+        return SQLiteStorage(
+            connection=connection,
+            serializer=serialization
+        )
+    except Exception as e:
+        logger.error(f"Error creating storage: {str(e)}\n{traceback.format_exc()}")
+        raise
 
+# Initialize TinyDB with the storage factory
+try:
+    _db = TinyDB(storage=get_storage)
+    _submissions_table = _db.table('submissions')
+    logger.info("Database initialized successfully")
+except Exception as e:
+    logger.error(f"Database initialization failed: {str(e)}\n{traceback.format_exc()}")
+    raise
 
-print("Using TinyDB for data storage")
+def get_db():
+    """Get the database and submissions table instances."""
+    return _db, _submissions_table
 
 def load_problems():
     problems = []
-    db_path = Path(SESSION_ID)
-    for json_file in db_path.glob('*.json'):
-        with open(json_file) as f:
-            problem = json.load(f)
-            problem['id'] = json_file.stem
-            problems.append(problem)
-        print(f"Loaded problem: {json_file.stem}")
+    try:
+        db_path = Path(SESSION_ID)
+        for json_file in db_path.glob('*.json'):
+            try:
+                with open(json_file) as f:
+                    problem = json.load(f)
+                    problem['id'] = json_file.stem
+                    problems.append(problem)
+                logger.info(f"Loaded problem: {json_file.stem}")
+            except Exception as e:
+                logger.error(f"Error loading problem {json_file}: {str(e)}\n{traceback.format_exc()}")
+    except Exception as e:
+        logger.error(f"Error in load_problems: {str(e)}\n{traceback.format_exc()}")
     return problems
 
-
 def save_submission(session, name, email, problem_id, code, hint_requested):
-    db, submissions_table = get_db()
-    timestamp = datetime.datetime.now().isoformat()
-    submission = {
-        'session': session,
-        'name': name,
-        'email': email,
-        'problem_id': problem_id,
-        'student_code': code,
-        'hint_requested': hint_requested,
-        'timestamp': timestamp
-    }
-    query = Query()
-    submissions_table.upsert(submission, (query.session == session) & (query.name == name) & (query.email == email) & (query.problem_id == problem_id))
-    db.close()
-
+    try:
+        _, submissions_table = get_db()
+        timestamp = datetime.datetime.now().isoformat()
+        submission = {
+            'session': session,
+            'name': name,
+            'email': email,
+            'problem_id': problem_id,
+            'student_code': code,
+            'hint_requested': hint_requested,
+            'timestamp': timestamp
+        }
+        query = Query()
+        submissions_table.upsert(
+            submission,
+            (query.session == session) & 
+            (query.name == name) & 
+            (query.email == email) & 
+            (query.problem_id == problem_id)
+        )
+        logger.info(f"Saved submission for {name} - Problem: {problem_id}")
+    except Exception as e:
+        logger.error(f"Error in save_submission: {str(e)}\n{traceback.format_exc()}")
+        raise
 
 def save_all_submissions(name, email, codes_dict, hints_dict):
-    db, submissions_table = get_db()
     try:
         for problem_id, code in codes_dict.items():
             hint_requested = hints_dict.get(problem_id, False)
             save_submission(SESSION_ID, name, email, problem_id, code, hint_requested)
-        db.close()
+        logger.info(f"Successfully saved all submissions for {name}")
         return "✅ All submissions saved successfully!"
     except Exception as e:
-        db.close()
-        return f"❌ Error saving submissions: {str(e)}"
+        error_msg = f"Error saving submissions: {str(e)}"
+        logger.error(f"{error_msg}\n{traceback.format_exc()}")
+        return f"❌ {error_msg}"
 
 def check_password(password):
     return password == ADMIN_PASSWD
 
 def get_all_students():
-    db, submissions_table = get_db()
-    result = list(set([submission['name'] for submission in submissions_table.all()]))
-    db.close()
-    return result
+    try:
+        _, submissions_table = get_db()
+        result = list(set([submission['name'] for submission in submissions_table.all()]))
+        logger.info(f"Retrieved {len(result)} students")
+        return result
+    except Exception as e:
+        logger.error(f"Error in get_all_students: {str(e)}\n{traceback.format_exc()}")
+        return []
 
 def get_student_submissions(name):
-    db, submissions_table = get_db()
-    query = Query()
-    submissions = submissions_table.search(query.name == name)
-    submissions.sort(key=lambda x: datetime.datetime.fromisoformat(x['timestamp']), reverse=True)
-    db.close()
-    return submissions
+    try:
+        _, submissions_table = get_db()
+        query = Query()
+        submissions = submissions_table.search(query.name == name)
+        submissions.sort(key=lambda x: datetime.datetime.fromisoformat(x['timestamp']), reverse=True)
+        logger.info(f"Retrieved {len(submissions)} submissions for student: {name}")
+        return submissions
+    except Exception as e:
+        logger.error(f"Error in get_student_submissions: {str(e)}\n{traceback.format_exc()}")
+        return []
 
 def export_submissions():
-    db, submissions_table = get_db()
     try:
+        _, submissions_table = get_db()
         submissions = submissions_table.all()
         submissions.sort(key=lambda x: datetime.datetime.fromisoformat(x['timestamp']), reverse=True)
         data = json.dumps(submissions, indent=2)
         
-        # Create a temporary file and write the data to it
         temp_file = tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.json')
         temp_file.write(data)
         temp_file.close()
-        db.close()
+        logger.info(f"Exported {len(submissions)} submissions to {temp_file.name}")
         return temp_file.name
     except Exception as e:
-        print(f"Error in export_submissions: {str(e)}")
-        db.close()
+        logger.error(f"Error in export_submissions: {str(e)}\n{traceback.format_exc()}")
         return None
 
 def refresh_submissions():
-    db, submissions_table = get_db()
-    all_submissions = submissions_table.all()
-    all_submissions.sort(key=lambda x: datetime.datetime.fromisoformat(x['timestamp']), reverse=True)
-    db.close()
-    return all_submissions
+    try:
+        _, submissions_table = get_db()
+        all_submissions = submissions_table.all()
+        all_submissions.sort(key=lambda x: datetime.datetime.fromisoformat(x['timestamp']), reverse=True)
+        logger.info(f"Refreshed {len(all_submissions)} submissions")
+        return all_submissions
+    except Exception as e:
+        logger.error(f"Error in refresh_submissions: {str(e)}\n{traceback.format_exc()}")
+        return []

df2sqlite.py

@@ -0,0 +1,61 @@
+# df2sqlite.py
+
+import sqlite3
+import pandas as pd
+import logging
+from create_course_dataframe import create_course_dataframe, process_xlsx
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    handlers=[logging.StreamHandler()]
+)
+
+def save_to_sqlite(df, database_name='courses.db', table_name='courses'):
+    """
+    Save DataFrame to SQLite Database
+    """
+    try:
+        logging.info(f"Connecting to database: {database_name}")
+        conn = sqlite3.connect(database_name)
+        
+        logging.info(f"Saving DataFrame to table: {table_name}")
+        df.to_sql(table_name, conn, if_exists='replace', index=False)
+        
+        logging.info("Data successfully saved to SQLite database")
+        
+        # Verify the data
+        row_count = pd.read_sql(f"SELECT COUNT(*) FROM {table_name}", conn).iloc[0,0]
+        logging.info(f"Verified {row_count} rows in table {table_name}")
+        
+        conn.close()
+        return True
+        
+    except Exception as e:
+        logging.error(f"Error saving to database: {str(e)}")
+        return False
+
+if __name__ == "__main__":
+    # Load and process XLSX file
+    file_path = "FTCM_Course List_Spring2025.xlsx"
+    result = process_xlsx(file_path)
+    
+    if result:
+        column_names, department_program_courses = result
+        
+        cleaned_column_names = ['Course Code', 'Course Title', 'Cr', 'Prereq(s)', 
+                              'Instructor', 'Major/ GE/ \nElective', 'Format', 
+                              'Mon', 'MonTo', 'Tue', 'TueTo', 'Wed', 'WedTo', 
+                              'Thu', 'ThuTo', 'Fri', 'FriTo', 'Sat', 'SatTo', 
+                              'Platform', 'New/ Repeat', 'Room']
+        
+        # Create DataFrame
+        df = create_course_dataframe(cleaned_column_names, column_names, department_program_courses)
+        
+        # Save to SQLite
+        if save_to_sqlite(df):
+            logging.info("Process completed successfully")
+        else:
+            logging.error("Failed to save data to SQLite")
+    else:
+        logging.error("Failed to process XLSX file")

dump_all.py

@@ -1,9 +1,12 @@
 import os
+import logging
+import zipfile
+import tempfile
 from datetime import datetime
 from pathlib import Path
-from tinydb import TinyDB, Query
-from tinydb.storages import JSONStorage
-from tinydb.middlewares import CachingMiddleware
+from app_utils import get_db
+
+logger = logging.getLogger(__name__)
 
 def create_markdown_content(submissions):
     """Generate markdown content from a list of submissions"""
@@ -41,61 +44,91 @@ def create_markdown_content(submissions):
     
     return content
 
-def main():
-    # Configuration
-    DB_PATH = 'submissions.json'
-    OUTPUT_DIR = Path("db_dump")
+def group_submissions_by_student(submissions):
+    """Group submissions by student name"""
+    student_submissions = {}
+    for submission in submissions:
+        name = submission['name']
+        if name not in student_submissions:
+            student_submissions[name] = []
+        student_submissions[name].append(submission)
+    return student_submissions
+
+def create_markdown_files(student_submissions, output_dir):
+    """Create markdown files for each student in the specified directory"""
+    output_dir = Path(output_dir)
+    output_dir.mkdir(exist_ok=True)
+    created_files = []
     
-    # Create output directory if it doesn't exist
-    OUTPUT_DIR.mkdir(exist_ok=True)
+    for name, submissions in student_submissions.items():
+        # Create safe filename from student name
+        safe_filename = "".join(x for x in name if x.isalnum() or x in "- ").strip()
+        safe_filename = safe_filename.replace(" ", "_") + ".md"
+        
+        # Generate markdown content
+        content = create_markdown_content(submissions)
+        
+        # Write to file
+        file_path = output_dir / safe_filename
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        created_files.append(file_path)
+        logger.info(f"Created markdown file for {name}: {file_path}")
     
+    return created_files
+
+def create_markdown_zip():
+    """Create a zip file containing markdown files for all submissions"""
     try:
-        # Connect to TinyDB
-        db = TinyDB(DB_PATH, storage=CachingMiddleware(JSONStorage))
-        submissions_table = db.table('submissions')
-        print(f"Connected to TinyDB at {DB_PATH}")
-        
-        # Get all submissions
+        # Get submissions from database
+        _, submissions_table = get_db()
         all_submissions = submissions_table.all()
         
         if not all_submissions:
-            print("No submissions found in database")
-            return
-        
-        # Group submissions by student name
-        student_submissions = {}
-        for submission in all_submissions:
-            name = submission['name']
-            if name not in student_submissions:
-                student_submissions[name] = []
-            student_submissions[name].append(submission)
+            logger.warning("No submissions found in database")
+            return None
         
-        # Create markdown file for each student
-        for name, submissions in student_submissions.items():
-            # Create safe filename from student name
-            safe_filename = "".join(x for x in name if x.isalnum() or x in "- ").strip()
-            safe_filename = safe_filename.replace(" ", "_") + ".md"
+        # Create temporary directory for markdown files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Group submissions and create markdown files
+            student_submissions = group_submissions_by_student(all_submissions)
+            markdown_files = create_markdown_files(student_submissions, temp_dir)
             
-            # Generate markdown content
-            content = create_markdown_content(submissions)
+            # Create zip file
+            zip_path = tempfile.mktemp(suffix='.zip')
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for file_path in markdown_files:
+                    zipf.write(file_path, file_path.name)
             
-            # Write to file
-            file_path = OUTPUT_DIR / safe_filename
-            with open(file_path, 'w', encoding='utf-8') as f:
-                f.write(content)
+            logger.info(f"Created zip file with {len(markdown_files)} markdown files")
+            return zip_path
             
-            print(f"Created markdown file for {name}: {file_path}")
-            print(f"Number of submissions: {len(submissions)}")
+    except Exception as e:
+        logger.error(f"Error creating markdown zip: {str(e)}")
+        return None
+
+def main():
+    """Main function for command-line usage"""
+    output_dir = Path("db_dump")
+    try:
+        # Get submissions from database
+        _, submissions_table = get_db()
+        all_submissions = submissions_table.all()
         
-        print(f"\nSuccessfully created markdown files in {OUTPUT_DIR}")
-        print(f"Total number of students: {len(student_submissions)}")
+        if not all_submissions:
+            logger.warning("No submissions found in database")
+            return
+        
+        # Group submissions and create markdown files
+        student_submissions = group_submissions_by_student(all_submissions)
+        create_markdown_files(student_submissions, output_dir)
+        
+        logger.info(f"Successfully created markdown files in {output_dir}")
+        logger.info(f"Total number of students: {len(student_submissions)}")
         
     except Exception as e:
-        print(f"Error occurred: {str(e)}")
-    
-    finally:
-        # Close database connection
-        db.close()
+        logger.error(f"Error occurred: {str(e)}")
 
 if __name__ == "__main__":
     main()

grading.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 """
-Create a grading script based on midterm2a-submissions.json which will be filename on the command line. The script should:
+Create a grading script based on midterm2a-submissions.json or from db which will be filename on the command line. The script should:
 1. input the json file for student submissions
 2. get student student_code and problem_id, if there are multiple entry for the same student_code and problem_id, only the last entry will be graded
 3. for each student_code , problem_id tuple, get the correct answer and problem_description for the problem_id with function get_correct_answer(problem_id)
@@ -34,18 +34,20 @@ from collections import defaultdict
 from datetime import datetime
 import sys, os
 from grading_utils import grade_submission, Grading_rubric
-from app_utils import load_problems
+from app_utils import (load_problems, SESSION_ID, SESSION_TITLE, logger)
+from utils import get_full_traceback
 
 problemsDB = {problem['id']: problem for problem in load_problems()} 
-Grading_rubric_path = "grading_rubric.json"
+Grading_rubric_path = os.path.join(SESSION_ID, "grading_rubric.json")
+output_dir = os.path.join("grading_reports",SESSION_ID)
 if os.path.exists(Grading_rubric_path):
     with open(Grading_rubric_path, 'r') as f:
         Grading_rubric.update(json.load(f))
     print("Grading rubric loaded successfully.")
 
 def get_correct_answer(problem_id: str) -> Tuple[str, str]:
-    """Mock function to get correct answer and problem description.""" 
-    return problemsDB[problem_id]['Solution_Code'], problemsDB[problem_id]['Problem_markdown']    
+    """To get correct answer and problem description.""" 
+    return problemsDB[problem_id]['Solution_Code'], problemsDB[problem_id]['Problem_markdown']
 
 def process_submissions(submissions: List[dict]) -> Dict[str, Dict[str, dict]]:
     """Process submissions and keep only the latest submission for each student-problem pair."""
@@ -53,13 +55,14 @@ def process_submissions(submissions: List[dict]) -> Dict[str, Dict[str, dict]]:
     
     for submission in submissions:
         name = submission['name']  # Using name as student identifier
+
         problem_id = submission['problem_id']
-        
         # Check if this is a newer submission
-        if (problem_id not in student_submissions[name] or
-            submission['timestamp']['$date'] > student_submissions[name][problem_id]['timestamp']['$date']):
+        if ((problem_id not in student_submissions[name]) or
+            (submission['timestamp']['$date'] > 
+             student_submissions[name][problem_id]['timestamp']['$date'])):    
             student_submissions[name][problem_id] = submission
-    
+
     return student_submissions
 
 def generate_markdown_report(student_submissions: Dict[str, Dict[str, dict]], output_dir: str = "grading_reports"):
@@ -74,10 +77,9 @@ def generate_markdown_report(student_submissions: Dict[str, Dict[str, dict]], ou
             filepath = os.path.join(output_dir, filename)
             
             header = f"""---
-title: "Midterm 2a"
+title: "{SESSION_TITLE}"
 subtitle: {student_name} 
-output: 
-  pdf_document 
+format: pdf
 ---
 """
             
@@ -87,8 +89,11 @@ output:
                 problem_count = 0
                 f.write(f"{header}\n\n")
                 for problem_id, submission in problems.items():
+                    if submission['session'] != SESSION_ID:
+                        continue
+                    correct_answer, problem_description = get_correct_answer(  problem_id) 
+                    logger.info(f"Grading {student_name} for problem: {problem_id}")
                     problem_count += 1
-                    correct_answer, problem_description = get_correct_answer(problem_id)
                     score, feedback, rubric = grade_submission(
                         student_name,
                         problem_id,
@@ -102,7 +107,7 @@ output:
                     
                     f.write(f"## Problem: {problem_id}\n\n")
                     f.write(f"**Description:** {problem_description}\n\n")
-                    f.write("**Student Solution:**\n```python\n{}\n```\n\n".format(submission['student_code']))
+                    f.write("**Your Answer:**\n```python\n{}\n```\n\n".format(submission['student_code']))
                     f.write("**Correct Solution:**\n```python\n{}\n```\n\n".format(correct_answer))
                     f.write(f"**Rubric:**\n{Grading_rubric[problem_id]}\n\n")
                     f.write(f"**Score:** {score:.2f}\n\n")
@@ -121,7 +126,7 @@ output:
         print(f"Reports generated successfully in directory: {output_dir}")
                 
     except Exception as e:
-        print(f"Error generating reports: {e}")
+        logger.error(f"Error generating reports: {e}\n{get_full_traceback(e)}")
         sys.exit(1)
 
 def main():
@@ -138,7 +143,7 @@ def main():
     
     # Process submissions and generate reports
     student_submissions = process_submissions(submissions)
-    generate_markdown_report(student_submissions)
+    generate_markdown_report(student_submissions, output_dir=output_dir)
     
 
 if __name__ == "__main__":

grading_utils.py

@@ -113,9 +113,9 @@ def grade_submission(student_code: str, problem_id: str,
 
     prompt = f"""You are a programming assignment grader.
 
-    Evaluate the student's answer based on the Problem description, Grading rubric and correct answer and provide a score and brief feedback. 
+    Evaluate the student's answer based on the Problem description, Grading rubric and correct answer and provide a score and brief feedback. Note if a problem asks an essay question or short answer question, student's answer may be in comments like "# answer" or in tripple quotes.
 
-    If Grading rubric is not provided, you should develop your own rubric based on the problem description and correct answer. In rubric do not include readability and structure. Please be tolerant for minor syntax errors (up to 1 point deduction for less than 2 minor syntax errors). Please focus on the logic of the code.
+    If Grading rubric is not provided, you should develop your own rubric based on the problem description and correct answer. In rubric do not include readability and structure criteria. Please be tolerant for minor syntax errors (up to 1 point deduction for less than 2 minor syntax errors). Please focus on the logic of the code.
     
     ##Problem ID: {problem_id}
 
@@ -144,6 +144,7 @@ def grade_submission(student_code: str, problem_id: str,
     </output>
     """
     logger.info(f"Problem ID: {problem_id}")
+
     if DEBUG:
         logger.debug("Prompt sent to LLM:")
         logger.debug(prompt)

student_tab.py

@@ -1,6 +1,7 @@
 # tab1.py
 import gradio as gr
-from app_utils import (save_submission, save_all_submissions, SESSION_ID)
+from app_utils import (save_submission, save_all_submissions, 
+            logger, SESSION_ID)
 
 def create_student_tab(problems):
 
@@ -17,6 +18,7 @@ def create_student_tab(problems):
         for problem in problems:
             with gr.Group():
                 gr.Markdown("---")
+                logger.info(f"Creating problem {problem['id']}")
                 gr.Markdown(problem["Problem_markdown"])
                 
                 hint_state = gr.State(value=False)

utils.py

@@ -0,0 +1,28 @@
+import traceback
+
+def get_full_traceback(e: Exception) -> str:
+    """
+    Returns full formatted traceback information from an exception object.
+    
+    Args:
+        e (Exception): The exception object
+        
+    Returns:
+        str: Formatted traceback string
+    """
+    # Get exception info as a list of strings
+    tb_lines = traceback.format_exception(type(e), e, e.__traceback__)
+    
+    # Join lines into single string
+    full_traceback = ''.join(tb_lines)
+    
+    return full_traceback
+
+if __name__ == "__main__":
+    # Usage example:
+    try:
+        # Some code that may raise exception
+        raise ValueError("Example error")
+    except Exception as e:
+        error_trace = get_full_traceback(e)
+        print(error_trace)