SNIPPETS

[oneaiguru]

1. Objective: Develop an automated tool that updates your codebase using outputs generated by LLMs (e.g., ChatGPT with Code Interpreter, Claude.ai) with minimal manual intervention.

2. Current Workflow Challenges:

   • Varied Output Formats: LLM outputs can be complete files, incomplete updates with placeholders (e.g., "rest of methods are not changed"), or multiple files within a single code block separated by comments indicating filenames.
   • Inconsistent File Paths: Filenames or file paths in comments may not always be precise, though filenames are usually correct.
   • Manual Adjustments: Some LLM outputs require cleaning or manual review before they can be applied to the codebase.

3. Constraints and Considerations:

   • Minimal Manual Effort: The primary goal is to automate as much of the update process as possible.
   • Focus on Functionality: Initial versions should prioritize functionality over complex features like change approvals or rollbacks.
   • Modularization: Due to prompt size limitations with some models, tasks should be broken down into manageable modules.
   • Leveraging Tools: Utilize the strengths of tools like ChatGPT's Code Interpreter and Claude 3.5, especially their capabilities in Test-Driven Development (TDD).

4. Resources Provided:

   • Project Code Structure: Detailed directory and file structure of your project.
   • Sample LLM Outputs: Numbered .py files (e.g., 0.py, 1.py, ..., 9.py) containing code updates from past LLM interactions.

5. Desired Outcome:

   • Automated Code Updates: A tool that can process LLM-generated outputs and apply them to your codebase reliably.
   • Test-Driven Development: Ensure that each module of the tool is developed using TDD to guarantee reliability.
   • Ease of Use: Provide clear instructions and code snippets that can be easily input into ChatGPT (with Code Interpreter) and later adapted to run locally.

---

Detailed Implementation Plan

To achieve your objective efficiently and reliably, we'll break down the development process into detailed, manageable steps. Each step includes specific modules, code snippets, test cases, and instructions to ensure seamless integration with ChatGPT's Code Interpreter and future local deployment.

Overview of the Tool's Workflow

1. Input Handling:
   • Accept LLM-generated outputs, preferably in a standardized format (e.g., zip files containing numbered .py files).
2. Parsing and Extraction:
   • Parse the uploaded files to extract individual code blocks and associate them with their respective filenames.
3. Mapping and Validation:
   • Map extracted code blocks to the correct files in your codebase, handling incomplete updates and placeholders.
4. Backup Original Files:
   • Create backups of the original files before applying any updates.
5. Apply Updates:
   • Update the existing codebase with the new code blocks.
6. Validation and Testing:
   • Validate the updates by running automated tests and ensuring no functionality is broken.
7. Task Tracking:
   • Track the status of each update task using a SQLite database.
8. Reporting:
   • Generate reports summarizing the updates applied and any issues encountered.

---

Step-by-Step Development Plan

Step 1: Define the Workflow and Requirements

Goal: Clearly outline each component of the tool and the overall workflow.

Actions:

• Input: LLM-generated code updates (numbered .py files within a zip archive).
• Processing:
  1. Unzip and organize the uploaded files.
  2. Parse the code blocks and associate them with filenames.
  3. Backup original files.
  4. Apply updates to the codebase.
  5. Validate the updates through tests.
  6. Track and report task statuses.
• Output: Updated codebase with applied changes and a summary report.

Deliverables:

• A detailed description of each module/function the tool needs.

• Define data structures (e.g., SQLite database schema) to keep track of tasks and file mappings.

• • *

Step 2: Break Down the Task into Modules

Goal: Identify and define the individual modules/functions needed.

Modules:

1. File Input Module
2. Parsing Module
3. Mapping Module
4. Backup Module
5. Update Module
6. Validation Module
7. Task Tracking Module
8. Reporting Module

---

Step 3: Develop Each Module with Code Snippets and Test Cases

For each module, we'll define its purpose, requirements, provide code snippets, and include test cases following TDD principles.

Note: To facilitate uploading multiple files at once, we'll provide all code snippets in a single code block with clear separators indicating the filename for each module.

---

Module 1: File Input Module

Purpose: Read LLM outputs from uploaded zip files containing numbered .py files.

Requirements:

• Accept a zip file containing up to 10 numbered .py files (e.g., 0.py, 1.py, ..., 9.py).
• Extract the zip file to a working directory.
• Ignore hidden files (those starting with a dot).
• Preserve folder structures when moving files.
• Record moved file paths in a SQLite database.

Code Snippet:

# file: file_input_module.py
import zipfile
import os
import shutil
import sqlite3
from contextlib import closing

def unzip_and_move(zip_path: str, extraction_path: str, target_path: str, db_path: str) -> dict:
    """
    Unzips the provided zip file, moves files to the target directory, and records file paths in the database.

    Args:
        zip_path (str): Path to the zip file.
        extraction_path (str): Path where the zip file will be extracted.
        target_path (str): Path where files will be moved, preserving folder structure.
        db_path (str): Path to the SQLite database.

    Returns:
        dict: Counts of files moved and database entries.
    """
    # Step 1: Unzip the file
    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
        zip_ref.extractall(extraction_path)

    # Step 2: Move files while ignoring hidden files
    files_moved = 0
    for root, dirs, files in os.walk(extraction_path):
        for file in files:
            if not file.startswith('.'):  # Ignore hidden files
                source_file = os.path.join(root, file)
                relative_path = os.path.relpath(source_file, extraction_path)
                destination_file = os.path.join(target_path, relative_path)
                os.makedirs(os.path.dirname(destination_file), exist_ok=True)
                shutil.move(source_file, destination_file)
                files_moved += 1

    # Step 3: Record moved file paths in the database
    with closing(sqlite3.connect(db_path)) as conn:
        with closing(conn.cursor()) as cursor:
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS file_updates (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    file_path TEXT NOT NULL,
                    status TEXT DEFAULT 'pending'
                )
            ''')
            for root, dirs, files in os.walk(target_path):
                for file in files:
                    file_path = os.path.join(root, file)
                    relative_file_path = os.path.relpath(file_path, target_path)
                    cursor.execute('''
                        INSERT INTO file_updates (file_path)
                        VALUES (?)
                    ''', (relative_file_path,))
            conn.commit()
            cursor.execute("SELECT COUNT(*) FROM file_updates")
            db_count = cursor.fetchone()[0]

    return {
        'files_moved': files_moved,
        'db_entries': db_count
    }

# Test cases for File Input Module
# file: test_file_input_module.py
import unittest
import os
import shutil
import sqlite3
from file_input_module import unzip_and_move

class TestFileInputModule(unittest.TestCase):
    def setUp(self):
        # Setup test directories
        self.zip_path = 'test_data.zip'
        self.extraction_path = 'test_extracted'
        self.target_path = 'test_data'
        self.db_path = 'test_database.db'

        # Create a sample zip file
        with zipfile.ZipFile(self.zip_path, 'w') as zipf:
            zipf.writestr('0.py', '# Sample code block 0')
            zipf.writestr('1.py', '# Sample code block 1')
            zipf.writestr('.hidden.py', '# Hidden file')

    def tearDown(self):
        # Remove test directories and files
        for path in [self.zip_path, self.extraction_path, self.target_path, self.db_path]:
            if os.path.exists(path):
                if os.path.isdir(path):
                    shutil.rmtree(path)
                else:
                    os.remove(path)

    def test_unzip_and_move(self):
        result = unzip_and_move(
            zip_path=self.zip_path,
            extraction_path=self.extraction_path,
            target_path=self.target_path,
            db_path=self.db_path
        )
        self.assertEqual(result['files_moved'], 2)  # Hidden file ignored
        self.assertEqual(result['db_entries'], 2)
        # Check files exist in target
        self.assertTrue(os.path.isfile(os.path.join(self.target_path, '0.py')))
        self.assertTrue(os.path.isfile(os.path.join(self.target_path, '1.py')))
        # Check hidden file does not exist
        self.assertFalse(os.path.isfile(os.path.join(self.target_path, '.hidden.py')))
        # Check database entries
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute("SELECT COUNT(*) FROM file_updates")
            count = cursor.fetchone()[0]
            self.assertEqual(count, 2)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the file_input_module.py and test_file_input_module.py as separate files.
   • Ensure that the filenames are clear and correspond to the prompts you will use.

3. Running Tests:

   • Execute test_file_input_module.py to ensure the file_input_module.py functions correctly.
   • The test verifies that hidden files are ignored and that file paths are correctly recorded in the database.

---

Module 2: Parsing Module

Purpose: Parse the extracted code blocks to identify filenames and associate them with their respective code segments.

Requirements:

• Identify file separators within the code blocks (comments indicating filenames).
• Handle incomplete code blocks with placeholders like "rest of methods are not changed."
• Normalize filenames to match actual file paths in the codebase.
• Manage multiple files within a single code block.

Code Snippet:

# file: parsing_module.py
import re
from typing import List, Tuple

def parse_code_blocks(file_content: str) -> List[Tuple[str, str]]:
    """
    Parses the content of a .py file to extract code blocks associated with filenames.

    Args:
        file_content (str): The content of the .py file.

    Returns:
        List[Tuple[str, str]]: A list of tuples containing filenames and their corresponding code blocks.
    """
    # Regex to identify filename comments (e.g., # utils/redis_manager.py)
    pattern = re.compile(r'^#\s*(.+\.py)$', re.MULTILINE)

    matches = list(pattern.finditer(file_content))
    code_blocks = []

    for i, match in enumerate(matches):
        filename = match.group(1).strip()
        start = match.end()
        end = matches[i + 1].start() if i + 1 < len(matches) else len(file_content)
        code_block = file_content[start:end].strip()
        if code_block:
            code_blocks.append((filename, code_block))

    return code_blocks

# Test cases for Parsing Module
# file: test_parsing_module.py
import unittest
from parsing_module import parse_code_blocks

class TestParsingModule(unittest.TestCase):
    def test_parse_single_file(self):
        content = """
# utils/redis_manager.py
import redis.asyncio as redis

class RedisManager:
    pass
"""
        result = parse_code_blocks(content)
        self.assertEqual(len(result), 1)
        self.assertEqual(result[0][0], 'utils/redis_manager.py')
        self.assertIn('import redis.asyncio as redis', result[0][1])

    def test_parse_multiple_files(self):
        content = """
# utils/redis_manager.py
import redis.asyncio as redis

class RedisManager:
    pass

# utils/logger.py
import logging

class LoggerManager:
    pass
"""
        result = parse_code_blocks(content)
        self.assertEqual(len(result), 2)
        self.assertEqual(result[0][0], 'utils/redis_manager.py')
        self.assertIn('import redis.asyncio as redis', result[0][1])
        self.assertEqual(result[1][0], 'utils/logger.py')
        self.assertIn('import logging', result[1][1])

    def test_parse_with_placeholders(self):
        content = """
# utils/redis_manager.py
import redis.asyncio as redis

class RedisManager:
    # rest of methods are not changed
    pass
"""
        result = parse_code_blocks(content)
        self.assertEqual(len(result), 1)
        self.assertEqual(result[0][0], 'utils/redis_manager.py')
        self.assertIn('# rest of methods are not changed', result[0][1])

    def test_parse_no_filenames(self):
        content = """
import redis.asyncio as redis

class RedisManager:
    pass
"""
        result = parse_code_blocks(content)
        self.assertEqual(len(result), 0)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the parsing_module.py and test_parsing_module.py as separate files.

3. Running Tests:

   • Execute test_parsing_module.py to ensure the parse_code_blocks function works correctly.
   • The tests cover scenarios with single and multiple files, placeholders, and cases with no filenames.

---

Module 3: Mapping Module

Purpose: Map extracted code blocks to the correct files in your codebase, resolving any discrepancies in filenames.

Requirements:

• Resolve filenames from parsed code blocks to actual file paths in the project directory.
• Handle cases where filenames in comments might not precisely match the actual file paths.
• Ensure that only existing files in the codebase are targeted for updates.

Code Snippet:

# file: mapping_module.py
import os
from typing import List, Tuple

def map_code_blocks_to_paths(parsed_blocks: List[Tuple[str, str]], project_root: str) -> List[Tuple[str, str]]:
    """
    Maps parsed code blocks to actual file paths in the project directory.

    Args:
        parsed_blocks (List[Tuple[str, str]]): List of tuples with filenames and code blocks.
        project_root (str): Root directory of the project.

    Returns:
        List[Tuple[str, str]]: List of tuples with absolute file paths and code blocks.
    """
    mapped_updates = []
    for filename, code in parsed_blocks:
        potential_path = os.path.join(project_root, filename)
        if os.path.isfile(potential_path):
            mapped_updates.append((potential_path, code))
        else:
            # Attempt to resolve discrepancies, e.g., case sensitivity or misplaced files
            for root, dirs, files in os.walk(project_root):
                for file in files:
                    if file.lower() == os.path.basename(filename).lower():
                        resolved_path = os.path.join(root, file)
                        mapped_updates.append((resolved_path, code))
                        break
        # If still not found, skip or log
    return mapped_updates

# Test cases for Mapping Module
# file: test_mapping_module.py
import unittest
import os
import tempfile
from mapping_module import map_code_blocks_to_paths

class TestMappingModule(unittest.TestCase):
    def setUp(self):
        # Create a temporary project directory
        self.project_root = tempfile.mkdtemp()
        # Create some sample files
        os.makedirs(os.path.join(self.project_root, 'utils'), exist_ok=True)
        with open(os.path.join(self.project_root, 'utils', 'redis_manager.py'), 'w') as f:
            f.write('# Original RedisManager code')
        with open(os.path.join(self.project_root, 'utils', 'logger.py'), 'w') as f:
            f.write('# Original LoggerManager code')

    def tearDown(self):
        # Remove the temporary directory
        shutil.rmtree(self.project_root)

    def test_map_existing_files(self):
        parsed_blocks = [
            ('utils/redis_manager.py', '# Updated RedisManager code'),
            ('utils/logger.py', '# Updated LoggerManager code')
        ]
        result = map_code_blocks_to_paths(parsed_blocks, self.project_root)
        self.assertEqual(len(result), 2)
        self.assertTrue(os.path.isfile(result[0][0]))
        self.assertEqual(result[0][1], '# Updated RedisManager code')
        self.assertTrue(os.path.isfile(result[1][0]))
        self.assertEqual(result[1][1], '# Updated LoggerManager code')

    def test_map_non_existing_file_with_resolution(self):
        parsed_blocks = [
            ('utils/Redis_Manager.py', '# Updated RedisManager code')  # Different case and underscore
        ]
        result = map_code_blocks_to_paths(parsed_blocks, self.project_root)
        self.assertEqual(len(result), 1)
        self.assertTrue(os.path.isfile(result[0][0]))
        self.assertEqual(result[0][1], '# Updated RedisManager code')

    def test_map_non_existing_file_no_resolution(self):
        parsed_blocks = [
            ('utils/non_existing.py', '# Some code')
        ]
        result = map_code_blocks_to_paths(parsed_blocks, self.project_root)
        self.assertEqual(len(result), 0)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the mapping_module.py and test_mapping_module.py as separate files.

3. Running Tests:

   • Execute test_mapping_module.py to ensure the map_code_blocks_to_paths function works correctly.
   • The tests cover scenarios with exact matches, case discrepancies, and non-existing files.

---

Module 4: Backup Module

Purpose: Create backups of original files before applying updates to ensure that you can restore them if needed.

Requirements:

• Accept a list of file paths to back up.
• Copy each file to a backup directory, preserving the directory structure.
• Include a timestamp in the backup filenames to prevent overwriting previous backups.

Code Snippet:

# file: backup_module.py
import shutil
import os
from datetime import datetime
from typing import List

def backup_files(file_paths: List[str], project_root: str, backup_root: str) -> int:
    """
    Creates backups of the specified files.

    Args:
        file_paths (List[str]): List of absolute file paths to back up.
        project_root (str): Root directory of the project.
        backup_root (str): Root directory where backups will be stored.

    Returns:
        int: Number of files successfully backed up.
    """
    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
    files_backed_up = 0
    for file_path in file_paths:
        relative_path = os.path.relpath(file_path, project_root)
        backup_path = os.path.join(backup_root, timestamp, relative_path)
        os.makedirs(os.path.dirname(backup_path), exist_ok=True)
        shutil.copy2(file_path, backup_path)
        files_backed_up += 1
    return files_backed_up

# Test cases for Backup Module
# file: test_backup_module.py
import unittest
import tempfile
import os
from backup_module import backup_files

class TestBackupModule(unittest.TestCase):
    def setUp(self):
        # Create temporary directories
        self.project_root = tempfile.mkdtemp()
        self.backup_root = tempfile.mkdtemp()
        # Create sample files
        os.makedirs(os.path.join(self.project_root, 'utils'), exist_ok=True)
        with open(os.path.join(self.project_root, 'utils', 'redis_manager.py'), 'w') as f:
            f.write('# Original RedisManager code')
        with open(os.path.join(self.project_root, 'bot', 'telegram_bot.py'), 'w') as f:
            f.write('# Original TelegramBot code')
        self.file_paths = [
            os.path.join(self.project_root, 'utils', 'redis_manager.py'),
            os.path.join(self.project_root, 'bot', 'telegram_bot.py')
        ]

    def tearDown(self):
        # Remove temporary directories
        shutil.rmtree(self.project_root)
        shutil.rmtree(self.backup_root)

    def test_backup_files(self):
        count = backup_files(self.file_paths, self.project_root, self.backup_root)
        self.assertEqual(count, 2)
        # Check if backup files exist with timestamp
        backup_dirs = os.listdir(self.backup_root)
        self.assertEqual(len(backup_dirs), 1)
        backup_timestamp = backup_dirs[0]
        for original_file in self.file_paths:
            relative_path = os.path.relpath(original_file, self.project_root)
            backup_file = os.path.join(self.backup_root, backup_timestamp, relative_path)
            self.assertTrue(os.path.isfile(backup_file))
            with open(backup_file, 'r') as f:
                content = f.read()
                self.assertIn('# Original', content)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the backup_module.py and test_backup_module.py as separate files.

3. Running Tests:

   • Execute test_backup_module.py to ensure the backup_files function works correctly.
   • The test verifies that backups are created with the correct directory structure and timestamp.

---

Module 5: Update Module

Purpose: Apply the new code blocks to the existing codebase by overwriting or modifying files as necessary.

Requirements:

• Accept a list of tuples containing file paths and new code blocks.
• Overwrite existing files with new code blocks.
• Handle partial updates intelligently (e.g., only replace certain sections if code is incomplete).
• Skip updates marked for manual review and log warnings.

Code Snippet:

# file: update_module.py
import os
from typing import List, Tuple

def update_files(mapped_updates: List[Tuple[str, str]]) -> dict:
    """
    Updates the specified files with new code blocks.

    Args:
        mapped_updates (List[Tuple[str, str]]): List of tuples with absolute file paths and new code blocks.

    Returns:
        dict: Counts of files updated and files skipped.
    """
    files_updated = 0
    files_skipped = 0
    for file_path, code_block in mapped_updates:
        if 'rest of' in code_block.lower() or 'do not change' in code_block.lower():
            # Placeholder detected, skip update
            files_skipped += 1
            continue
        with open(file_path, 'w', encoding='utf-8') as f:
            f.write(code_block)
        files_updated += 1
    return {
        'files_updated': files_updated,
        'files_skipped': files_skipped
    }

# Test cases for Update Module
# file: test_update_module.py
import unittest
import tempfile
import os
from update_module import update_files

class TestUpdateModule(unittest.TestCase):
    def setUp(self):
        # Create a temporary project directory
        self.project_root = tempfile.mkdtemp()
        # Create sample files
        os.makedirs(os.path.join(self.project_root, 'utils'), exist_ok=True)
        with open(os.path.join(self.project_root, 'utils', 'redis_manager.py'), 'w') as f:
            f.write('# Original RedisManager code')
        with open(os.path.join(self.project_root, 'utils', 'logger.py'), 'w') as f:
            f.write('# Original LoggerManager code')
        self.mapped_updates = [
            (os.path.join(self.project_root, 'utils', 'redis_manager.py'), '# Updated RedisManager code'),
            (os.path.join(self.project_root, 'utils', 'logger.py'), '# rest of methods are not changed')
        ]

    def tearDown(self):
        # Remove the temporary directory
        shutil.rmtree(self.project_root)

    def test_update_files(self):
        result = update_files(self.mapped_updates)
        self.assertEqual(result['files_updated'], 1)
        self.assertEqual(result['files_skipped'], 1)
        # Check updated file
        with open(os.path.join(self.project_root, 'utils', 'redis_manager.py'), 'r') as f:
            content = f.read()
            self.assertEqual(content, '# Updated RedisManager code')
        # Check skipped file remains unchanged
        with open(os.path.join(self.project_root, 'utils', 'logger.py'), 'r') as f:
            content = f.read()
            self.assertEqual(content, '# Original LoggerManager code')

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the update_module.py and test_update_module.py as separate files.

3. Running Tests:

   • Execute test_update_module.py to ensure the update_files function works correctly.
   • The test verifies that files with placeholders are skipped and others are updated appropriately.

---

Module 6: Validation Module

Purpose: Validate that the updates have been applied correctly by comparing updated files with their backups and running automated tests.

Requirements:

• Compare updated files with their original backups to ensure changes were applied.
• Optionally run existing unit tests to verify that no functionality is broken.
• Report any discrepancies or confirm the correctness of actions.

Code Snippet:

# file: validation_module.py
import filecmp
import os
from typing import List, Tuple
import subprocess

def compare_files(original_dir: str, updated_dir: str) -> List[str]:
    """
    Compares files in the original and updated directories.

    Args:
        original_dir (str): Directory containing original backup files.
        updated_dir (str): Directory containing updated files.

    Returns:
        List[str]: List of file paths that differ.
    """
    mismatches = []
    for root, dirs, files in os.walk(original_dir):
        for file in files:
            original_file = os.path.join(root, file)
            relative_path = os.path.relpath(original_file, original_dir)
            updated_file = os.path.join(updated_dir, relative_path)
            if os.path.isfile(updated_file):
                if not filecmp.cmp(original_file, updated_file, shallow=False):
                    mismatches.append(relative_path)
            else:
                mismatches.append(relative_path)
    return mismatches

def run_unit_tests(test_directory: str) -> Tuple[bool, str]:
    """
    Runs unit tests using unittest framework.

    Args:
        test_directory (str): Directory containing test files.

    Returns:
        Tuple[bool, str]: (Success status, Test output)
    """
    try:
        result = subprocess.run(
            ['python', '-m', 'unittest', 'discover', '-s', test_directory],
            capture_output=True,
            text=True,
            check=True
        )
        return (True, result.stdout)
    except subprocess.CalledProcessError as e:
        return (False, e.stdout + e.stderr)

def validate_updates(original_backup_dir: str, updated_dir: str, test_directory: str) -> dict:
    """
    Validates the updates by comparing files and running tests.

    Args:
        original_backup_dir (str): Directory containing original backup files.
        updated_dir (str): Directory containing updated files.
        test_directory (str): Directory containing test files.

    Returns:
        dict: Validation results including mismatched files and test status.
    """
    mismatches = compare_files(original_backup_dir, updated_dir)
    tests_passed, test_output = run_unit_tests(test_directory)

    return {
        'mismatched_files': mismatches,
        'tests_passed': tests_passed,
        'test_output': test_output
    }

# Test cases for Validation Module
# file: test_validation_module.py
import unittest
import tempfile
import os
from validation_module import compare_files, run_unit_tests, validate_updates

class TestValidationModule(unittest.TestCase):
    def setUp(self):
        # Create temporary directories for original and updated files
        self.original_dir = tempfile.mkdtemp()
        self.updated_dir = tempfile.mkdtemp()
        self.test_directory = tempfile.mkdtemp()

        # Create sample files in original_dir
        os.makedirs(os.path.join(self.original_dir, 'utils'), exist_ok=True)
        with open(os.path.join(self.original_dir, 'utils', 'redis_manager.py'), 'w') as f:
            f.write('# Original RedisManager code')
        with open(os.path.join(self.original_dir, 'utils', 'logger.py'), 'w') as f:
            f.write('# Original LoggerManager code')

        # Create updated files in updated_dir
        os.makedirs(os.path.join(self.updated_dir, 'utils'), exist_ok=True)
        with open(os.path.join(self.updated_dir, 'utils', 'redis_manager.py'), 'w') as f:
            f.write('# Updated RedisManager code')
        with open(os.path.join(self.updated_dir, 'utils', 'logger.py'), 'w') as f:
            f.write('# Original LoggerManager code')  # No change

        # Create a sample test file in test_directory
        with open(os.path.join(self.test_directory, 'test_sample.py'), 'w') as f:
            f.write("""
import unittest

class SampleTest(unittest.TestCase):
    def test_true(self):
        self.assertTrue(True)

if __name__ == '__main__':
    unittest.main()
""")

    def tearDown(self):
        # Remove temporary directories
        shutil.rmtree(self.original_dir)
        shutil.rmtree(self.updated_dir)
        shutil.rmtree(self.test_directory)

    def test_compare_files(self):
        mismatches = compare_files(self.original_dir, self.updated_dir)
        self.assertEqual(len(mismatches), 1)
        self.assertIn('utils/redis_manager.py', mismatches)

    def test_run_unit_tests_success(self):
        passed, output = run_unit_tests(self.test_directory)
        self.assertTrue(passed)
        self.assertIn('OK', output)

    def test_run_unit_tests_failure(self):
        # Introduce a failing test
        with open(os.path.join(self.test_directory, 'test_sample.py'), 'w') as f:
            f.write("""
import unittest

class SampleTest(unittest.TestCase):
    def test_false(self):
        self.assertTrue(False)

if __name__ == '__main__':
    unittest.main()
""")
        passed, output = run_unit_tests(self.test_directory)
        self.assertFalse(passed)
        self.assertIn('FAIL', output)

    def test_validate_updates(self):
        result = validate_updates(self.original_dir, self.updated_dir, self.test_directory)
        self.assertEqual(result['mismatched_files'], ['utils/redis_manager.py'])
        self.assertTrue(result['tests_passed'])
        self.assertIn('OK', result['test_output'])

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the validation_module.py and test_validation_module.py as separate files.

3. Running Tests:

   • Execute test_validation_module.py to ensure the validate_updates function works correctly.
   • The test verifies file comparisons and the execution of unit tests, including handling both passing and failing scenarios.

---

Module 7: Task Tracking Module

Purpose: Track the status of each update task to monitor progress and handle any issues.

Requirements:

• Use a SQLite database to record tasks with fields like file name, status, and error messages.
• Update task statuses as each file is processed (e.g., 'pending', 'updated', 'skipped', 'error').
• Provide functions to add tasks, update statuses, and retrieve task summaries.

Code Snippet:

# file: task_tracking_module.py
import sqlite3
from typing import List, Tuple, Optional

class TaskTracker:
    def __init__(self, db_path: str):
        self.db_path = db_path
        self.initialize_db()

    def initialize_db(self):
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tasks (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    file_path TEXT NOT NULL,
                    status TEXT DEFAULT 'pending',
                    error_message TEXT
                )
            ''')
            conn.commit()

    def add_tasks(self, file_paths: List[str]):
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.executemany('''
                INSERT INTO tasks (file_path)
                VALUES (?)
            ''', [(path,) for path in file_paths])
            conn.commit()

    def update_task_status(self, file_path: str, status: str, error_message: Optional[str] = None):
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                UPDATE tasks
                SET status = ?, error_message = ?
                WHERE file_path = ?
            ''', (status, error_message, file_path))
            conn.commit()

    def get_pending_tasks(self) -> List[str]:
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT file_path FROM tasks WHERE status = 'pending'
            ''')
            return [row[0] for row in cursor.fetchall()]

    def get_task_summary(self) -> dict:
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT status, COUNT(*) FROM tasks GROUP BY status
            ''')
            summary = {row[0]: row[1] for row in cursor.fetchall()}
        return summary

# Test cases for Task Tracking Module
# file: test_task_tracking_module.py
import unittest
import tempfile
import os
from task_tracking_module import TaskTracker

class TestTaskTrackingModule(unittest.TestCase):
    def setUp(self):
        # Create a temporary database
        self.db_path = tempfile.mkstemp()[1]
        self.tracker = TaskTracker(self.db_path)
        self.file_paths = [
            '/path/to/file1.py',
            '/path/to/file2.py',
            '/path/to/file3.py'
        ]

    def tearDown(self):
        # Remove the temporary database
        os.remove(self.db_path)

    def test_add_and_get_pending_tasks(self):
        self.tracker.add_tasks(self.file_paths)
        pending = self.tracker.get_pending_tasks()
        self.assertEqual(set(pending), set(self.file_paths))

    def test_update_task_status(self):
        self.tracker.add_tasks([self.file_paths[0]])
        self.tracker.update_task_status(self.file_paths[0], 'updated')
        pending = self.tracker.get_pending_tasks()
        self.assertNotIn(self.file_paths[0], pending)
        summary = self.tracker.get_task_summary()
        self.assertEqual(summary.get('updated'), 1)

    def test_update_task_with_error(self):
        self.tracker.add_tasks([self.file_paths[1]])
        self.tracker.update_task_status(self.file_paths[1], 'error', 'Syntax error')
        summary = self.tracker.get_task_summary()
        self.assertEqual(summary.get('error'), 1)
        # Check error message
        with sqlite3.connect(self.db_path) as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT error_message FROM tasks WHERE file_path = ?
            ''', (self.file_paths[1],))
            error_message = cursor.fetchone()[0]
            self.assertEqual(error_message, 'Syntax error')

    def test_get_task_summary(self):
        self.tracker.add_tasks(self.file_paths)
        self.tracker.update_task_status(self.file_paths[0], 'updated')
        self.tracker.update_task_status(self.file_paths[1], 'error', 'Failed to update')
        summary = self.tracker.get_task_summary()
        self.assertEqual(summary.get('updated'), 1)
        self.assertEqual(summary.get('error'), 1)
        self.assertEqual(summary.get('pending'), 1)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the task_tracking_module.py and test_task_tracking_module.py as separate files.

3. Running Tests:

   • Execute test_task_tracking_module.py to ensure the TaskTracker class functions correctly.
   • The test verifies task addition, status updates, error handling, and summary generation.

---

Module 8: Reporting Module

Purpose: Generate reports summarizing the updates applied and any issues encountered during the update process.

Requirements:

• Summarize the number of files updated, skipped, and any errors.
• Optionally, generate markdown files summarizing the changes.
• Provide a summary that can be reviewed to ensure all updates were applied correctly.

Code Snippet:

# file: reporting_module.py
from typing import List, Tuple, Dict
import os

def generate_report(validation_results: dict, backup_timestamp: str, target_path: str, report_path: str):
    """
    Generates a markdown report summarizing the update process.

    Args:
        validation_results (dict): Results from the validation module.
        backup_timestamp (str): Timestamp of the backup.
        target_path (str): Path to the updated files.
        report_path (str): Path where the report will be saved.
    """
    with open(report_path, 'w', encoding='utf-8') as f:
        f.write(f"# Code Update Report\n\n")
        f.write(f"**Backup Timestamp**: {backup_timestamp}\n\n")

        # Summary of file updates
        f.write(f"## File Updates\n")
        f.write(f"- **Files Updated**: {validation_results.get('files_updated', 0)}\n")
        f.write(f"- **Files Skipped**: {validation_results.get('files_skipped', 0)}\n")
        f.write(f"- **Mismatched Files**: {len(validation_results.get('mismatched_files', []))}\n")
        if validation_results.get('mismatched_files'):
            f.write(f"  - {', '.join(validation_results['mismatched_files'])}\n")
        f.write("\n")

        # Test results
        f.write(f"## Test Results\n")
        f.write(f"- **Tests Passed**: {validation_results.get('tests_passed', False)}\n")
        f.write(f"- **Test Output**:\n```\n{validation_results.get('test_output', '')}\n```\n")
        f.write("\n")

        # Overall Status
        overall_status = "✅ Success" if validation_results.get('tests_passed', False) and not validation_results.get('mismatched_files') else "❌ Failed"
        f.write(f"## Overall Status\n- {overall_status}\n")

    return report_path

# Test cases for Reporting Module
# file: test_reporting_module.py
import unittest
import tempfile
from reporting_module import generate_report

class TestReportingModule(unittest.TestCase):
    def setUp(self):
        self.validation_results = {
            'files_updated': 5,
            'files_skipped': 2,
            'mismatched_files': ['utils/redis_manager.py', 'bot/telegram_bot.py'],
            'tests_passed': True,
            'test_output': 'Ran 10 tests in 0.002s\n\nOK'
        }
        self.backup_timestamp = '20231024120000'
        self.target_path = '/path/to/updated_files'
        self.report_path = 'report.md'

    def tearDown(self):
        if os.path.exists(self.report_path):
            os.remove(self.report_path)

    def test_generate_report_success(self):
        report = generate_report(self.validation_results, self.backup_timestamp, self.target_path, self.report_path)
        self.assertTrue(os.path.isfile(report))
        with open(report, 'r') as f:
            content = f.read()
            self.assertIn("# Code Update Report", content)
            self.assertIn("**Backup Timestamp**: 20231024120000", content)
            self.assertIn("- **Files Updated**: 5", content)
            self.assertIn("- **Files Skipped**: 2", content)
            self.assertIn("- **Mismatched Files**: 2", content)
            self.assertIn("utils/redis_manager.py, bot/telegram_bot.py", content)
            self.assertIn("- **Tests Passed**: True", content)
            self.assertIn("✅ Success", content)

    def test_generate_report_failure(self):
        self.validation_results['tests_passed'] = False
        self.validation_results['mismatched_files'] = ['utils/redis_manager.py']
        report = generate_report(self.validation_results, self.backup_timestamp, self.target_path, self.report_path)
        self.assertTrue(os.path.isfile(report))
        with open(report, 'r') as f:
            content = f.read()
            self.assertIn("❌ Failed", content)

if __name__ == '__main__':
    unittest.main()

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the reporting_module.py and test_reporting_module.py as separate files.

3. Running Tests:

   • Execute test_reporting_module.py to ensure the generate_report function works correctly.
   • The test verifies that the report is generated with correct content based on validation results.

---

Step 4: Integrate the Modules

Goal: Combine the individual modules into a cohesive tool that orchestrates the entire update process.

Components:

1. Main Update Script: Coordinates the workflow by invoking each module in sequence.
2. Configuration: Define paths and settings required by the tool.

Code Snippet:

# file: main_update_tool.py
import os
import shutil
import sqlite3
from file_input_module import unzip_and_move
from parsing_module import parse_code_blocks
from mapping_module import map_code_blocks_to_paths
from backup_module import backup_files
from update_module import update_files
from validation_module import validate_updates
from task_tracking_module import TaskTracker
from reporting_module import generate_report
from datetime import datetime

def main(zip_file_path: str, project_root: str, backup_root: str, report_directory: str, db_path: str):
    """
    Main function to orchestrate the code update process.

    Args:
        zip_file_path (str): Path to the uploaded zip file containing LLM outputs.
        project_root (str): Root directory of the project codebase.
        backup_root (str): Root directory where backups will be stored.
        report_directory (str): Directory where reports will be saved.
        db_path (str): Path to the SQLite database for task tracking.
    """
    extraction_path = 'temp_extracted'
    target_path = project_root
    os.makedirs(extraction_path, exist_ok=True)
    os.makedirs(backup_root, exist_ok=True)
    os.makedirs(report_directory, exist_ok=True)

    # Step 1: Unzip and move files
    move_result = unzip_and_move(zip_file_path, extraction_path, target_path, db_path)
    print(f"Files moved: {move_result['files_moved']}")
    print(f"Database entries: {move_result['db_entries']}")

    # Initialize Task Tracker
    tracker = TaskTracker(db_path)
    tracker.add_tasks([os.path.join(target_path, f) for f in os.listdir(target_path)])

    # Step 2: Parse code blocks
    parsed_blocks = []
    for root, dirs, files in os.walk(target_path):
        for file in files:
            if file.endswith('.py'):
                file_path = os.path.join(root, file)
                with open(file_path, 'r', encoding='utf-8') as f:
                    content = f.read()
                    parsed = parse_code_blocks(content)
                    parsed_blocks.extend(parsed)

    # Step 3: Map code blocks to file paths
    mapped_updates = map_code_blocks_to_paths(parsed_blocks, project_root)

    # Step 4: Backup original files
    files_to_backup = [path for path, code in mapped_updates]
    backup_count = backup_files(files_to_backup, project_root, backup_root)
    print(f"Files backed up: {backup_count}")

    # Step 5: Apply updates
    update_result = update_files(mapped_updates)
    print(f"Files updated: {update_result['files_updated']}")
    print(f"Files skipped: {update_result['files_skipped']}")

    # Step 6: Validate updates
    # Assume backup timestamp is the latest backup
    backup_timestamp = sorted(os.listdir(backup_root))[-1]
    original_backup_dir = os.path.join(backup_root, backup_timestamp)
    validation_results = validate_updates(original_backup_dir, project_root, 'test_directory')  # Replace 'test_directory' with actual test path
    print(f"Validation Results: {validation_results}")

    # Step 7: Generate report
    report_path = os.path.join(report_directory, f"update_report_{backup_timestamp}.md")
    generate_report(validation_results, backup_timestamp, project_root, report_path)
    print(f"Report generated at: {report_path}")

    # Step 8: Update task statuses
    for file_path in files_to_backup:
        if file_path in validation_results['mismatched_files']:
            tracker.update_task_status(file_path, 'error', 'Mismatch after update')
        elif file_path in [path for path, _ in mapped_updates]:
            tracker.update_task_status(file_path, 'updated')
        else:
            tracker.update_task_status(file_path, 'skipped')

# Example usage
if __name__ == "__main__":
    main(
        zip_file_path='llm_outputs.zip',
        project_root='/Users/m/git/lubot',
        backup_root='/Users/m/git/lubot_backups',
        report_directory='/Users/m/git/lubot_reports',
        db_path='/Users/m/git/lubot/update_tasks.db'
    )

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the main_update_tool.py as a separate file.
   • Ensure that all the previously developed modules (file_input_module.py, parsing_module.py, etc.) are also uploaded in the session.

3. Configuration:

   • Update the main function's parameters with the correct paths specific to your environment.
   • Replace 'test_directory' with the actual directory where your unit tests are located.

4. Running the Tool:

   • Execute main_update_tool.py to perform the entire update process.
   • Ensure that all dependencies and paths are correctly set up in your environment.

---

Step 5: Adapt the Tool to Run Locally

Goal: Transfer the tool from the Code Interpreter environment to your local machine.

Actions:

1. Export Code:

   • Download all the generated scripts from the Code Interpreter session.
   • Ensure that each module (file_input_module.py, parsing_module.py, etc.) is saved in the appropriate directory structure.

2. Set Up Local Environment:

   • Python Environment:

     • Ensure you have Python 3.8+ installed.

     • Create a virtual environment:

       python3 -m venv venv
       source venv/bin/activate

   • Dependencies:

     • Create a requirements.txt file with necessary dependencies:

       sqlalchemy
       asyncpg
       redis
       telegram

     • Install dependencies:

       pip install -r requirements.txt

3. Configuration:

   • Update any hardcoded paths in main_update_tool.py to relative paths or environment variables.
   • Ensure database paths and backup directories are correctly set.

4. Testing:

   • Run all unit tests to ensure that each module functions as expected.
   • Execute main_update_tool.py with a sample zip file to verify end-to-end functionality.

---

Step 6: Implement Error Handling and Logging

Goal: Enhance the tool's robustness by adding comprehensive error handling and logging mechanisms.

Actions:

1. Error Handling:

   • Ensure all modules catch and handle exceptions gracefully.
   • Log meaningful error messages to aid in troubleshooting.

2. Logging:

   • Utilize Python's logging module to log operations and errors.
   • Configure log levels (INFO, WARNING, ERROR) appropriately.
   • Optionally, implement log rotation to manage log file sizes.

Code Snippet:

# file: logger_module.py
import logging
from logging.handlers import RotatingFileHandler
import os

def setup_logger(name: str, log_file: str, level=logging.INFO) -> logging.Logger:
    """
    Sets up a logger with the specified name and log file.

    Args:
        name (str): Name of the logger.
        log_file (str): Path to the log file.
        level (int): Logging level.

    Returns:
        logging.Logger: Configured logger.
    """
    logger = logging.getLogger(name)
    logger.setLevel(level)

    # Create handlers
    c_handler = logging.StreamHandler()
    f_handler = RotatingFileHandler(log_file, maxBytes=5*1024*1024, backupCount=2)
    c_handler.setLevel(level)
    f_handler.setLevel(level)

    # Create formatters and add to handlers
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    c_handler.setFormatter(formatter)
    f_handler.setFormatter(formatter)

    # Add handlers to the logger
    if not logger.handlers:
        logger.addHandler(c_handler)
        logger.addHandler(f_handler)

    return logger

# Example usage in main_update_tool.py
# Add at the top of main_update_tool.py
from logger_module import setup_logger

# Inside main function
def main(...):
    # Setup logging
    log_file = os.path.join(report_directory, 'update_tool.log')
    logger = setup_logger('update_tool', log_file)

    try:
        ...
    except Exception as e:
        logger.error(f"An unexpected error occurred: {str(e)}")
    finally:
        logger.info("Update process completed.")

Instructions:

1. Save the Code: Save the above code in a single code block when interacting with ChatGPT. Use clear separators to denote each file.

2. Uploading Files: When uploading to ChatGPT's Code Interpreter:

   • Upload the logger_module.py as a separate file.
   • Ensure that all modules importing setup_logger are updated accordingly.

3. Configuration:

   • Define the log file path relative to your project or as per your directory structure.
   • Ensure that log directories exist or are created by the tool.

4. Enhance Existing Modules:

   • Import and utilize the setup_logger function in each module to create and use loggers.

   • Example in file_input_module.py:

     from logger_module import setup_logger
     logger = setup_logger('file_input_module', 'file_input.log')

   • Replace print statements with appropriate logging calls:

     logger.info(f"Files moved: {move_result['files_moved']}")
     logger.error(f"Error processing file: {file_path}")

---

Step 7: Final Validation and Documentation

Goal: Ensure the tool meets all requirements and is properly documented for ease of use and maintenance.

Actions:

1. Final Testing:

   • Run the tool with real LLM outputs to ensure it functions as expected.
   • Verify that backups are correctly created, files are updated, validations pass, and reports are generated.

2. Documentation:

   • Create a README.md file detailing:
     • Purpose of the tool.
     • Installation instructions.
     • Usage guide with examples.
     • Troubleshooting tips.
     • Contribution guidelines (if applicable).

3. Code Comments:

   • Ensure all code is well-commented to explain the functionality and logic.
   • Maintain consistency in coding style and formatting.

Code Snippet:

# Code Update Automation Tool

## Overview

This tool automates the process of updating your codebase using outputs generated by Large Language Models (LLMs) like ChatGPT with Code Interpreter or Claude.ai. It minimizes manual intervention by parsing, backing up, applying updates, validating changes, and generating comprehensive reports.

## Features

- **Automated File Processing**: Handles zip archives containing multiple code updates.
- **Parsing and Mapping**: Extracts and associates code blocks with their respective files.
- **Backup Mechanism**: Creates backups of original files before applying updates.
- **Update Application**: Applies new code blocks to the existing codebase.
- **Validation**: Compares updated files with backups and runs automated tests to ensure integrity.
- **Task Tracking**: Monitors the status of each update task using a SQLite database.
- **Reporting**: Generates markdown reports summarizing the update process and results.
- **Comprehensive Logging**: Logs all operations and errors for easy troubleshooting.

## Installation

1. **Clone the Repository**:
   ```bash
   git clone https://github.com/yourusername/code-update-tool.git
   cd code-update-tool

2. Set Up Virtual Environment:

   python3 -m venv venv
   source venv/bin/activate

3. Install Dependencies:

   pip install -r requirements.txt

Usage

1. Prepare LLM Outputs:

   • Ensure your LLM-generated outputs are saved as numbered .py files (e.g., 0.py, 1.py, ..., 9.py) within a zip archive.

2. Run the Update Tool:

   python main_update_tool.py

   • Update the main_update_tool.py script with the correct paths as per your environment.

3. Review Reports:

   • After execution, check the update_reports directory for detailed markdown reports and logs.

Testing

• Run All Unit Tests:

  python -m unittest discover -s tests

  • Ensure all tests pass to verify the tool's functionality.

Troubleshooting

• Common Issues:

  • Missing Files: Ensure that all required files are present in the uploaded zip archive.
  • Permission Errors: Verify that the tool has the necessary permissions to read/write in the specified directories.
  • Database Issues: Check the SQLite database for any inconsistencies or errors.

• Logs:

  • Refer to the log files in the logs directory for detailed error messages and operation logs.

Contribution

Contributions are welcome! Please follow these steps:

1. Fork the Repository.

2. Create a Feature Branch:

   git checkout -b feature/YourFeature

3. Commit Your Changes:

   git commit -m "Add YourFeature"

4. Push to the Branch:

   git push origin feature/YourFeature

5. Create a Pull Request.

License

MIT License

**Instructions**:

1. **Save the Code**: Save the above markdown content in a file named `README.md` within your project directory.

2. **Uploading Files**: When uploading to ChatGPT's Code Interpreter:
   - Upload the `README.md` as a separate file.

3. **Finalize Documentation**:
   - Ensure all sections are accurate and reflect your project's specifics.
   - Update links and paths as necessary.

---

### **Custom Instructions for ChatGPT (Code Interpreter)**

To ensure that ChatGPT adheres to Test-Driven Development (TDD) principles and generates reliable, well-tested code, you can set custom instructions. Here's how you can structure these instructions:

**Custom Instruction Template**:

```markdown
**Custom Instructions for Code Development**

1. **Adhere to Test-Driven Development (TDD)**:
   - Write unit tests **before** writing the corresponding code.
   - Ensure that all tests pass after implementing the code.
   - Use Python's `unittest` framework for writing tests.

2. **Code Structure and Standards**:
   - Follow PEP 8 coding standards for Python.
   - Include comprehensive docstrings for all functions and classes.
   - Use meaningful variable and function names for clarity.

3. **Error Handling and Logging**:
   - Implement robust error handling to catch and manage exceptions gracefully.
   - Utilize Python's `logging` module to log important operations and errors.
   - Ensure that logs provide sufficient information for troubleshooting.

4. **Modularization**:
   - Break down tasks into small, manageable modules or functions.
   - Each module should handle a specific aspect of the overall functionality.

5. **Code Review and Refinement**:
   - After generating code, review it for correctness and efficiency.
   - Refine the code as necessary to meet the specified requirements.

6. **Documentation**:
   - Provide clear and concise documentation for each module.
   - Include usage examples where applicable.

7. **Consistency with Existing Codebase**:
   - Ensure that the newly generated code aligns with the existing project structure and coding style.
   - Reference existing modules and utilities where appropriate to maintain consistency.

How to Use:

1. Set Custom Instructions:

   • In ChatGPT's settings, locate the Custom Instructions section.
   • Paste the above template into the appropriate fields to guide the model's behavior.

2. Interact with ChatGPT:

   • When prompting ChatGPT to generate code, reference the custom instructions to ensure adherence to TDD and other standards.

   • Example Prompt:

     Using the custom instructions provided, develop a Python module that parses LLM-generated code blocks and maps them to their respective files. Ensure that you write unit tests first and that all tests pass after implementing the code.

3. Iterative Development:

   • For each module, follow the TDD cycle: Red (write a failing test), Green (write code to pass the test), and Refactor (improve the code while ensuring tests still pass).
   • Provide feedback to ChatGPT to refine the code and tests as needed.

---

Sample Combined Code Block with File Separators

When interacting with ChatGPT's Code Interpreter, you can provide all the necessary modules and their corresponding tests in a single code block, separated by clear comments indicating filenames. This approach allows you to upload multiple files at once efficiently.

Combined Code Block Example:

# file: file_input_module.py
import zipfile
import os
import shutil
import sqlite3
from contextlib import closing

def unzip_and_move(zip_path: str, extraction_path: str, target_path: str, db_path: str) -> dict:
    """
    Unzips the provided zip file, moves files to the target directory, and records file paths in the database.

    Args:
        zip_path (str): Path to the zip file.
        extraction_path (str): Path where the zip file will be extracted.
        target_path (str): Path where files will be moved, preserving folder structure.
        db_path (str): Path to the SQLite database.

    Returns:
        dict: Counts of files moved and database entries.
    """
    # Step 1: Unzip the file
    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
        zip_ref.extractall(extraction_path)

    # Step 2: Move files while ignoring hidden files
    files_moved = 0
    for root, dirs, files in os.walk(extraction_path):
        for file in files:
            if not file.startswith('.'):  # Ignore hidden files
                source_file = os.path.join(root, file)
                relative_path = os.path.relpath(source_file, extraction_path)
                destination_file = os.path.join(target_path, relative_path)
                os.makedirs(os.path.dirname(destination_file), exist_ok=True)
                shutil.move(source_file, destination_file)
                files_moved += 1

    # Step 3: Record moved file paths in the database
    with closing(sqlite3.connect(db_path)) as conn:
        with closing(conn.cursor()) as cursor:
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS file_updates (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    file_path TEXT NOT NULL,
                    status TEXT DEFAULT 'pending'
                )
            ''')
            for root, dirs, files in os.walk(target_path):
                for file in files:
                    file_path = os.path.join(root, file)
                    relative_file_path = os.path.relpath(file_path, target_path)
                    cursor.execute('''
                        INSERT INTO file_updates (file_path)
                        VALUES (?)
                    ''', (relative_file_path,))
            conn.commit()
            cursor.execute("SELECT COUNT(*) FROM file_updates")
            db_count = cursor.fetchone()[0]

    return {
        'files_moved': files_moved,
        'db_entries': db_count
    }

# file: test_file_input_module.py
import unittest
import os
import shutil
import zipfile
from

Error in message stream