munchboka-edutools 0.1.13__py3-none-any.whl

munchboka_edutools/static/js/interactiveCode/interactiveCodeSetup.js

@@ -0,0 +1,348 @@
+class InteractiveCodeSetup {
+    constructor(containerId, initialCode, preloadPackages = null) {
+        this.containerId = containerId;
+        this.initialCode = initialCode;
+        this.preloadPackages = preloadPackages;
+        console.log("InteractiveCodeSetup - Preload packages:", this.preloadPackages);
+        this.uniqueId = this.generateUUID();
+        console.log("Unique ID:", this.uniqueId);
+
+        // HTML element IDs
+        this.editorId = `code-editor-${this.uniqueId}`;
+        this.runButtonId = `run-button-${this.uniqueId}`;
+        this.resetButtonId = `reset-button-${this.uniqueId}`;
+        this.cancelButtonId = `cancel-button-${this.uniqueId}`;
+        this.outputId = `output-${this.uniqueId}`;
+        this.errorBoxId = `error-box-${this.uniqueId}`;
+
+        // Store instances of CodeEditor and PythonRunner
+        this.editorInstance = null;
+        this.runnerInstance = null;
+
+
+        // Initialize the editor setup
+        this.createEditorHTML();
+        this.setupInteractiveEditor();
+    }
+
+    generateUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+            const r = Math.random() * 16 | 0, v = c === 'x' ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        });
+    }
+
+    createEditorHTML() {
+        const container = document.getElementById(this.containerId);
+        if (!container) {
+            console.error(`Container with ID ${this.containerId} not found.`);
+            return;
+        }
+
+        const runIcon = `
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6">
+  <path stroke-linecap="round" stroke-linejoin="round" d="M5.25 5.653c0-.856.917-1.398 1.667-.986l11.54 6.347a1.125 1.125 0 0 1 0 1.972l-11.54 6.347a1.125 1.125 0 0 1-1.667-.986V5.653Z" />
+</svg>
+`;
+        const resetIcon = `
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" class="size-6">
+  <path fill-rule="evenodd" d="M9.53 2.47a.75.75 0 0 1 0 1.06L4.81 8.25H15a6.75 6.75 0 0 1 0 13.5h-3a.75.75 0 0 1 0-1.5h3a5.25 5.25 0 1 0 0-10.5H4.81l4.72 4.72a.75.75 0 1 1-1.06 1.06l-6-6a.75.75 0 0 1 0-1.06l6-6a.75.75 0 0 1 1.06 0Z" clip-rule="evenodd" />
+</svg>
+`;
+
+        const cancelIcon = `
+<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="size-6">
+  <path stroke-linecap="round" stroke-linejoin="round" d="M5.25 7.5A2.25 2.25 0 0 1 7.5 5.25h9a2.25 2.25 0 0 1 2.25 2.25v9a2.25 2.25 0 0 1-2.25 2.25h-9a2.25 2.25 0 0 1-2.25-2.25v-9Z" />
+</svg>
+`;
+
+        const html = `
+            <div>
+                <textarea id="${this.editorId}" name="code-${this.uniqueId}">${this.initialCode}</textarea>
+                
+                <button id="${this.runButtonId}" class="button button-run">Kjør kode ${runIcon}</button>
+                <button id="${this.resetButtonId}" class="button button-reset">Reset kode ${resetIcon}</button>
+                <button id="${this.cancelButtonId}" class="button button-cancel">Avbryt kjøring ${cancelIcon}</button>
+            </div>
+            <div id="${this.errorBoxId}"></div>
+            <pre id="${this.outputId}" class="pythonoutput"></pre>
+        `;
+
+        container.innerHTML = html;
+    }
+
+    setupInteractiveEditor() {
+        this.editorInstance = new CodeEditor(this.editorId); // Initialize the CodeEditor
+        this.runnerInstance = new PythonRunner(this.outputId, this.errorBoxId, this.preloadPackages); // Initialize the PythonRunner
+
+        // Add event listeners for buttons
+        document.getElementById(this.runButtonId).addEventListener("click", () => this.runCode());
+        document.getElementById(this.resetButtonId).addEventListener("click", () => this.resetCode());
+        document.getElementById(this.cancelButtonId).addEventListener("click", () => this.cancelCodeExecution());
+    }
+
+    
+
+    runCode() {
+        this.clearOutput();
+        this.runnerInstance.run(this.editorInstance); // Pass the editor instance to PythonRunner for execution
+    }
+
+    resetCode() {
+        this.clearOutput();
+        this.editorInstance.resetEditor(this.initialCode); // Reset the editor content to the initial code
+    }
+
+    cancelCodeExecution() {
+        if (this.runnerInstance.workerManager) {
+            this.runnerInstance.workerManager.restartWorker(); // Restart the worker to cancel code execution
+        }
+    }
+
+    clearOutput() {
+        document.getElementById(this.outputId).textContent = "";
+        document.getElementById(this.errorBoxId).textContent = "";
+    }
+}
+
+
+function makeInteractiveCode(containerId, initialCode, preloadPackages = null) {
+    return new InteractiveCodeSetup(containerId, initialCode, preloadPackages);
+}
+
+
+// predictionInteractiveCodeSetup.js
+
+class PredictionInteractiveCodeSetup extends InteractiveCodeSetup {
+    constructor(containerId, initialCode) {
+        super(containerId, initialCode);
+
+        // Additional IDs for the prediction feature
+        this.predictionInputId = `prediction-input-${this.uniqueId}`;
+        this.lockPredictionButtonId = `lock-prediction-button-${this.uniqueId}`;
+        this.predictionDisplayId = `prediction-display-${this.uniqueId}`;
+        this.predictionOutputId = `prediction-output-${this.uniqueId}`;
+        this.predictionOutputContainerId = `prediction-output-container-${this.uniqueId}`;
+        this.predictionContainerId = `prediction-container-${this.uniqueId}`;
+        // this.initialCode = initialCode;
+
+        // Flag to track whether the prediction has been displayed
+        this.predictionDisplayed = false;
+
+        // Modify the HTML to include prediction elements
+        this.addPredictionHTML();
+
+        // Set up the prediction feature
+        this.setupPredictionFeature();
+    }
+
+    addPredictionHTML() {
+        const container = document.getElementById(this.containerId);
+        if (!container) {
+            console.error(`Container with ID ${this.containerId} not found.`);
+            return;
+        }
+
+        // Build the prediction input HTML
+        const predictionHtml = `
+            <div id="${this.predictionContainerId}" class="prediction-container">
+            <textarea id="${this.predictionInputId}" rows="3" placeholder="Skriv inn svaret ditt her! \n \nTrykk på Enter (&#9166;) for en ny linje."></textarea>
+            <button id="${this.lockPredictionButtonId}" class="button button-run">Sjekk svaret!</button>
+            </div>
+        `;
+
+        // Insert the prediction input after the existing editor HTML
+        container.insertAdjacentHTML('beforeend', predictionHtml);
+
+        // Create the prediction-output container
+        const predictionOutputContainer = document.createElement('div');
+        predictionOutputContainer.id = this.predictionOutputContainerId;
+        predictionOutputContainer.className = 'prediction-output-container';
+        predictionOutputContainer.style.display = 'none';
+
+        // Create the prediction display
+        const predictionDisplay = document.createElement('div');
+        predictionDisplay.className = 'prediction-display';
+        predictionDisplay.innerHTML = `
+            <h3>Ditt svar:</h3>
+            <pre id="${this.predictionDisplayId}"></pre>
+        `;
+
+        // Create the output display for prediction phase
+        const outputDisplay = document.createElement('div');
+        outputDisplay.className = 'output-display';
+        outputDisplay.innerHTML = `
+            <h3>Faktisk utskrift:</h3>
+            <pre id="${this.predictionOutputId}" class="pythonoutput"></pre>
+        `;
+
+        // Append the displays to the prediction-output container
+        predictionOutputContainer.appendChild(predictionDisplay);
+        predictionOutputContainer.appendChild(outputDisplay);
+
+        // Append the prediction-output container after the error box
+        const errorBoxElement = document.getElementById(this.errorBoxId);
+        if (errorBoxElement) {
+            errorBoxElement.insertAdjacentElement('afterend', predictionOutputContainer);
+        } else {
+            console.error(`Error box element with ID ${this.errorBoxId} not found.`);
+            container.appendChild(predictionOutputContainer);
+        }
+
+        // Save a reference to the original output element
+        this.originalOutputElement = document.getElementById(this.outputId);
+    }
+
+    
+
+    setupPredictionFeature() {
+        // Make the code editor read-only initially
+        // Use setTimeout to ensure the editor is fully initialized
+        const setupReadOnly = () => {
+            // Check if editor instance exists and has been properly initialized
+            if (this.editorInstance && this.editorInstance.editor) {
+                console.log("Setting editor to read-only");
+                this.editorInstance.editor.setOption('readOnly', true);
+                
+                // Hide the buttons now that we know the editor is ready
+                document.getElementById(this.runButtonId).style.display = 'none';
+                document.getElementById(this.resetButtonId).style.display = 'none';
+                document.getElementById(this.cancelButtonId).style.display = 'none';
+            } else {
+                console.log("Editor not ready yet, retrying in 100ms...");
+                // Retry after a short delay
+                setTimeout(setupReadOnly, 100);
+            }
+        };
+    
+        // Start the setup process
+        setupReadOnly();
+
+
+        // this.editorInstance.editor.setOption('readOnly', true);
+
+        // // Hide the run/reset/cancel buttons until the prediction is made
+        // document.getElementById(this.runButtonId).style.display = 'none';
+        // document.getElementById(this.resetButtonId).style.display = 'none';
+        // document.getElementById(this.cancelButtonId).style.display = 'none';
+
+        // Add event listener for the lock prediction button
+        document.getElementById(this.lockPredictionButtonId).addEventListener("click", () => this.lockPrediction());
+    }
+
+    lockPrediction() {
+        const prediction = document.getElementById(this.predictionInputId).value;
+
+        // Store the prediction
+        this.prediction = prediction;
+
+        // Hide the prediction input area
+        const predictionContainer = document.getElementById(this.predictionContainerId);
+        if (predictionContainer) {
+            predictionContainer.style.display = 'none';
+        }
+
+        // Make the code editor editable
+        this.editorInstance.editor.setOption('readOnly', false);
+
+        // Show the run/reset/cancel buttons
+        document.getElementById(this.runButtonId).style.display = 'inline-block';
+        document.getElementById(this.resetButtonId).style.display = 'inline-block';
+        document.getElementById(this.cancelButtonId).style.display = 'inline-block';
+
+        // Automatically run the code
+        this.runCode();
+    }
+
+    runCode() {
+        if (this.predictionDisplayed) {
+            // Replace with a new InteractiveCodeSetup instance
+            this.initialCode = this.editorInstance.getValue();
+            this.replaceWithInteractiveCodeSetup();
+
+        } else {
+            // First run after prediction is locked in
+            this.clearOutput();
+            this.runnerInstance.run(this.editorInstance, this.predictionOutputId); // Pass the new output ID
+
+            // Display the prediction and output side by side
+            this.displayPredictionAndOutput();
+
+            // Set flag to indicate prediction has been displayed
+            this.predictionDisplayed = true;
+        }
+    }
+
+    resetCode() {
+        if (this.predictionDisplayed) {
+            // Replace with a new InteractiveCodeSetup instance
+            this.replaceWithInteractiveCodeSetup();
+        } else {
+            // First reset (unlikely, but handle just in case)
+            this.clearOutput();
+            this.editorInstance.resetEditor(this.initialCode);
+        }
+    }
+
+    cancelCodeExecution() {
+        if (this.predictionDisplayed) {
+            // Replace with a new InteractiveCodeSetup instance
+            this.replaceWithInteractiveCodeSetup();
+        } else {
+            // First cancel after prediction is locked in
+            if (this.runnerInstance.workerManager) {
+                this.runnerInstance.workerManager.restartWorker();
+            }
+        }
+    }
+
+    replaceWithInteractiveCodeSetup() {
+        // Get the container element
+        const container = document.getElementById(this.containerId);
+        if (container) {
+            // Clear the container's content
+            container.innerHTML = '';
+
+            // Create a new instance of InteractiveCodeSetup
+            new InteractiveCodeSetup(this.containerId, this.initialCode);
+        } else {
+            console.error(`Container with ID ${this.containerId} not found.`);
+        }
+    }
+
+    displayPredictionAndOutput() {
+        // Display the user's prediction
+        document.getElementById(this.predictionDisplayId).textContent = this.prediction;
+
+        // Hide the original output element
+        if (this.originalOutputElement) {
+            this.originalOutputElement.style.display = 'none';
+        }
+
+        // Show the prediction-output container
+        document.getElementById(this.predictionOutputContainerId).style.display = 'flex';
+    }
+
+    clearOutput() {
+        if (this.predictionDisplayed) {
+            const outputElement = document.getElementById(this.predictionOutputId);
+            if (outputElement) {
+                outputElement.textContent = "";
+            }
+        } else {
+            const outputElement = document.getElementById(this.outputId);
+            if (outputElement) {
+                outputElement.textContent = "";
+            }
+        }
+        const errorBoxElement = document.getElementById(this.errorBoxId);
+        if (errorBoxElement) {
+            errorBoxElement.textContent = "";
+        }
+    }
+}
+
+// Function to initialize the prediction code editor
+function makePredictionInteractiveCode(containerId, initialCode) {
+    return new PredictionInteractiveCodeSetup(containerId, initialCode);
+}

munchboka_edutools/static/js/interactiveCode/pythonRunner.js

@@ -0,0 +1,336 @@
+// pythonRunner.js
+
+class PythonRunner {
+    constructor(outputId, errorBoxId, preloadPackages = ['casify']) {
+        this.outputId = outputId;            // ID of the HTML element where output will be displayed
+        this.errorBoxId = errorBoxId;        // ID of the HTML element for displaying errors
+        this.workerManager = WorkerManager.getInstance(preloadPackages);
+        this.preloadPackages = preloadPackages;
+    }
+
+    /**
+     * Prepares and runs the code provided in the editor.
+     * @param {Object} editor - The CodeMirror editor instance containing the code.
+     */
+    async run(editor, outputId = null) {
+        // Wait until worker is ready and preload packages are loaded
+        try {
+            await this.workerManager.workerReadyPromise;
+        } catch (error) {
+            console.error("Worker failed to initialize:", error);
+            this.handleErrorMessage("Failed to initialize Python environment.");
+            return;
+        }
+
+        this.editorInstance = editor;
+        this.editorInstance.clearLineHighlights();
+        let code = editor.getValue();
+        this.currentCode = code;
+
+        if (outputId) {
+            this.outputId = outputId;
+        }
+
+        // Handle input statements and modify the code accordingly
+        const inputStatements = this.findInputStatements(this.currentCode);
+        if (inputStatements.length > 0) {
+            const userValues = await this.getUserInputs(inputStatements);
+            this.currentCode = this.replaceInputStatements(this.currentCode, userValues);
+            console.log("Modified code:", this.currentCode);
+        }
+
+        // Extract and load necessary packages
+        const packages = this.extractPackageNames(this.currentCode);
+
+        if (!packages.includes('matplotlib')) {
+            packages.push('matplotlib');
+        }
+
+        console.log("Packages to load:", packages);
+        if (packages.length > 0) {
+            try {
+                await this.workerManager.loadPackages(packages);
+            } catch (error) {
+                // Handle package load error
+                console.error("Failed to load packages:", error);
+                this.handleErrorMessage(error.message);
+                return;
+            }
+        }
+
+
+        const callback = (data) => {
+            if (data.type === 'stdout') {
+                this.handleWorkerMessage(data);
+            } else if (data.type === 'stderr') {
+                this.handleErrorMessage(data.msg);  // Displays the error
+            } else if (data.type === 'plot') {
+                const outputElement = document.getElementById(this.outputId);
+                if (!outputElement) {
+                    console.error("Output element not found:", this.outputId);
+                    return;
+                }
+    
+                const img = document.createElement('img');
+                img.src = 'data:image/png;base64,' + data.data;
+                img.style.width = '100%'; // Or any other appropriate styling
+                img.style.height = 'auto'; // Or any other appropriate styling
+                img.style.maxHeight = '500px';  // Example: set a max width
+    
+                outputElement.appendChild(img);
+                this.scrollToBottom(outputElement); // Scroll to show new plot
+            } else if (data.type === 'executionComplete') {
+                console.log("Code execution complete for messageId:", data.messageId);
+            }
+        };
+        
+
+        this.workerManager.runCode(this.currentCode, callback);
+    }
+
+
+    /**
+     * Handles incoming messages from the WorkerManager.
+     * @param {Object} data - The parsed message data from the worker.
+     */
+    handleWorkerMessage(data) {
+        const { type, msg } = data;
+        console.log("Message from worker:", data);
+        const outputElement = document.getElementById(this.outputId);
+
+        if (!outputElement) {
+            console.error("Output element not found:", this.outputId);
+            return;
+        }
+
+        if (type === 'stdout') {
+            // Replace "&" with "∧", "oo" with "∞", and "|" with "∨"
+            let formattedMsg = msg
+            .replace(/And\(([^)]+)\)/g, (match, p1) => {
+                // Split conditions by comma, trim spaces, and wrap each in parentheses
+                const conditions = p1.split(',').map(cond => cond.trim());
+                return conditions.map(cond => `(${cond})`).join(' ∧ ');
+            })
+            // .replace(/&/g, '∧')
+            .replace(/oo/g, '∞')
+            .replace(/\|/g, '∨');
+            outputElement.innerHTML += this.formatErrorMessage(formattedMsg);
+            this.highlightLine(this.editorInstance, data.msg);
+            this.scrollToBottom(outputElement);
+
+        } else if (type === 'stderr') {
+            console.log("Error message:", msg);
+            this.handleErrorMessage(msg);
+        }
+    }
+
+    scrollToBottom(element) {
+        element.scrollTop = element.scrollHeight;
+    }
+
+    /**
+     * Handles error messages from the worker.
+     * @param {string} msg - The error message.
+     */
+    handleErrorMessage(msg) {
+        const errorElement = document.getElementById(this.errorBoxId);
+        if (errorElement) {
+            errorElement.innerHTML = this.formatErrorMessage(msg);
+        }
+        this.highlightLine(this.editorInstance, msg);
+
+    }
+
+    /**
+     * Formats output messages for display.
+     * @param {string} msg - The message to be formatted.
+     * @returns {string} - The formatted message.
+     */
+    formatOutput(msg) {
+        return msg;
+    }
+
+
+    highlightLine(editor, msg) {
+        const linePattern = /File "<exec>", line (\d+)/;
+        const match = linePattern.exec(msg);
+        if (match) {
+            const lineNumber = parseInt(match[1]) - 1;
+            console.log("Highlighting line:", lineNumber);
+            editor.highlightLine(lineNumber);
+            console.log("Highlighting error at line:", lineNumber);
+        }
+    }
+
+    formatErrorMessage(errorMsg) {
+        let formattedMessage = errorMsg;
+        let content = '';
+        let title = '';
+        let knownError = false;
+
+    
+        // Highlight the line number in the pattern 'File "<exec>", line <number>'
+        const fileLinePattern = /File "<exec>", line (\d+)/g;
+        formattedMessage = formattedMessage.replace(fileLinePattern, (match, p1) => {
+            return match.replace(`line ${p1}`, `<span class="error-line">line ${p1}</span>`);
+        });
+
+
+        // Highlight the error type
+        const errorTypeMatch = errorMsg.match(/(\w+Error):/);
+        if (errorTypeMatch) {
+            console.log("Error type match:", errorTypeMatch[1]);
+            formattedMessage = formattedMessage.replace(errorTypeMatch[1], `<span class="error-type">${errorTypeMatch[1]}</span>`);
+
+        }
+
+
+        return formattedMessage;
+    }
+
+
+
+    /**
+     * Extracts package names from the code based on import statements.
+     * @param {string} code - The Python code to be analyzed.
+     * @returns {Array<string>} - An array of package names.
+     */
+    extractPackageNames(code) {
+        // Matches "import <package> as <alias>" and "import <package>"
+        const importRegex = /^\s*import\s+([^;\s]+)\s*/gm;
+    
+        // Matches "from <package> import <something>"
+        const fromImportRegex = /^\s*from\s+([^;\s]+)\s+import/gm;
+    
+        const packages = new Set();
+        const standardLibs = new Set([
+            'abc', 'aifc', 'argparse', 'array', 'ast', 'asynchat', 'asyncio', 'asyncore', 'atexit', 'audioop', 'base64', 
+            'bdb', 'binascii', 'binhex', 'bisect', 'builtins', 'bz2', 'cProfile', 'calendar', 'cgi', 'cgitb', 'chunk', 
+            'cmath', 'cmd', 'code', 'codecs', 'codeop', 'collections', 'colorsys', 'compileall', 'concurrent', 'configparser', 
+            'contextlib', 'copy', 'copyreg', 'crypt', 'csv', 'ctypes', 'curses', 'dataclasses', 'datetime', 'dbm', 'decimal', 
+            'difflib', 'dis', 'distutils', 'doctest', 'email', 'encodings', 'ensurepip', 'enum', 'errno', 'faulthandler', 
+            'fcntl', 'filecmp', 'fileinput', 'fnmatch', 'formatter', 'fractions', 'ftplib', 'functools', 'gc', 'getopt', 
+            'getpass', 'gettext', 'glob', 'grp', 'gzip', 'hashlib', 'heapq', 'hmac', 'html', 'http', 'imaplib', 'imghdr', 
+            'imp', 'importlib', 'inspect', 'io', 'ipaddress', 'itertools', 'json', 'keyword', 'lib2to3', 'linecache', 'locale', 
+            'logging', 'lzma', 'mailbox', 'mailcap', 'marshal', 'math', 'mimetypes', 'mmap', 'modulefinder', 'msilib', 'msvcrt', 
+            'multiprocessing', 'netrc', 'nntplib', 'numbers', 'operator', 'optparse', 'os', 'ossaudiodev', 'parser', 'pathlib', 
+            'pdb', 'pickle', 'pickletools', 'pipes', 'pkgutil', 'platform', 'plistlib', 'poplib', 'posix', 'pprint', 'profile', 
+            'pstats', 'pty', 'pwd', 'py_compile', 'pyclbr', 'pydoc', 'queue', 'quopri', 'random', 're', 'readline', 'reprlib', 
+            'resource', 'rlcompleter', 'runpy', 'sched', 'secrets', 'select', 'selectors', 'shelve', 'shlex', 'shutil', 'signal', 
+            'site', 'smtpd', 'smtplib', 'sndhdr', 'socket', 'socketserver', 'spwd', 'sqlite3', 'ssl', 'stat', 'statistics', 
+            'string', 'stringprep', 'struct', 'subprocess', 'sunau', 'symbol', 'symtable', 'sys', 'sysconfig', 'tabnanny', 
+            'tarfile', 'telnetlib', 'tempfile', 'termios', 'test', 'textwrap', 'threading', 'time', 'timeit', 'tkinter', 'token', 
+            'tokenize', 'trace', 'traceback', 'tracemalloc', 'tty', 'turtle', 'turtledemo', 'types', 'typing', 'unicodedata', 
+            'unittest', 'urllib', 'uu', 'uuid', 'venv', 'warnings', 'wave', 'weakref', 'webbrowser', 'winreg', 'winsound', 
+            'wsgiref', 'xdrlib', 'xml', 'xmlrpc', 'zipapp', 'zipfile', 'zipimport', 'zlib'
+        ]);
+    
+        let match;
+    
+        // Process "import" statements
+        while ((match = importRegex.exec(code)) !== null) {
+            const packageName = match[1].split('.')[0];
+            if (!standardLibs.has(packageName)) {
+                packages.add(packageName);
+            }
+        }
+    
+        // Process "from ... import" statements
+        while ((match = fromImportRegex.exec(code)) !== null) {
+            const packageName = match[1].split('.')[0];
+            if (!standardLibs.has(packageName)) {
+                packages.add(packageName);
+            }
+        }
+    
+        console.log("Packages to load:", Array.from(packages));
+    
+        return Array.from(packages);
+    }
+
+    /**
+     * Finds input statements in the code.
+     * @param {string} code - The Python code to be analyzed.
+     * @returns {Array<Object>} - An array of input statements found.
+     */
+    findInputStatements(code) {
+        const inputRegex = /(\w+)\s*=\s*(int|float|eval)?\(?input\(["'](.*?)["']\)\)?/g;
+        let match;
+        let inputs = [];
+
+        while ((match = inputRegex.exec(code)) !== null) {
+            inputs.push({
+                variable: match[1],
+                promptText: match[3]
+            });
+        }
+
+        return inputs;
+    }
+
+    /**
+     * Prompts the user for input when input statements are found in the code.
+     * @param {Array<Object>} inputs - An array of input statements.
+     * @returns {Object} - A dictionary of user inputs mapped to variable names.
+     */
+    async getUserInputs(inputs) {
+        let userValues = {};
+
+        for (let input of inputs) {
+            let promptText = input.promptText.replace(/['"]+/g, '');
+            let userValue = await this.promptUser(promptText);
+            userValues[input.variable] = userValue;
+        }
+
+        return userValues;
+    }
+
+    /**
+     * Prompts the user for input.
+     * @param {string} promptText - The text to display in the prompt.
+     * @returns {Promise<string>} - A promise that resolves with the user input.
+     */
+    promptUser(promptText) {
+        return new Promise((resolve) => {
+            let userInput = prompt(promptText);
+            resolve(userInput);
+        });
+    }
+
+    /**
+     * Replaces input statements in the code with user-provided values. 
+     * @param {string} code - The Python code.
+     * @param {Object} userValues - A dictionary of user-provided values.
+     * @returns {string} - The modified code with input statements replaced.
+     */
+
+    replaceInputStatements(code, userValues) {
+        let codeLines = code.split('\n');
+    
+        codeLines = codeLines.map(line => {
+            for (let variable in userValues) {
+                console.log("Variable: ", variable);
+                // Adjust the regex to handle Unicode characters in variable names
+                const inputRegex = new RegExp(`\\b${variable}\\b\\s*=\\s*(float|int|eval)?\\(?input\\(.*?\\)\\)?`, 'gu');
+    
+                if (inputRegex.test(line)) {
+                    let userValue = userValues[variable];
+    
+                    // Detect the type of the user input
+                    if (!isNaN(userValue)) {
+                        // Check if the input is a number (int or float)
+                        //userValue = Number(userValue); // Convert the string to a number
+                    } else if (typeof userValue === 'string') {
+                        // Check if the input is a string and doesn't contain only numbers
+                        userValue = `"${userValue}"`; // Add quotes around string inputs
+                    }
+                    
+                    line = line.replace(inputRegex, `${variable} = ${userValue}`);
+                }
+            }
+            return line;
+        });
+    
+        return codeLines.join('\n');
+    }
+}