scriptmonkey 0.1.0__tar.gz

scriptmonkey-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: scriptmonkey
+Version: 0.1.0
+Summary: A Python package that automatically fixes errors in your code using OpenAI's GPT API
+Home-page: https://github.com/lukerbs/CodeMonkey
+Author: Luke Kerbs
+Author-email: LDK.kerbs@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: openai
+Requires-Dist: pydantic
+Requires-Dist: tqdm
+
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
+
+## Features
+- **Automatic error detection**: Captures errors during runtime.
+- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code auto-correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+### Example
+
+```python
+import scriptmonkey
+
+# Enable Codemonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the correct code.
+
+## How It Works
+
+ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
+- Collects the traceback and the Python file that caused the error.
+- Sends the error message and code to OpenAI.
+- Receives the solution as structured JSON.
+- Applies the fix directly to the source file.
+
+## Requirements
+- Python 3.6 or later
+- OpenAI API key
+
+## Setup
+
+To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
+
+```bash
+export OPENAI_API_KEY='your-api-key'
+```
+
+Let ScriptMonkey take care of your Python errors so you can focus on building!

scriptmonkey-0.1.0/README.md

@@ -0,0 +1,66 @@
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
+
+## Features
+- **Automatic error detection**: Captures errors during runtime.
+- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code auto-correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+### Example
+
+```python
+import scriptmonkey
+
+# Enable Codemonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the correct code.
+
+## How It Works
+
+ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
+- Collects the traceback and the Python file that caused the error.
+- Sends the error message and code to OpenAI.
+- Receives the solution as structured JSON.
+- Applies the fix directly to the source file.
+
+## Requirements
+- Python 3.6 or later
+- OpenAI API key
+
+## Setup
+
+To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
+
+```bash
+export OPENAI_API_KEY='your-api-key'
+```
+
+Let ScriptMonkey take care of your Python errors so you can focus on building!

scriptmonkey-0.1.0/scriptmonkey/__init__.py

@@ -0,0 +1 @@
+from .core import run

scriptmonkey-0.1.0/scriptmonkey/core.py

@@ -0,0 +1,72 @@
+import sys
+import traceback
+from .openai_client import chatgpt_json, ScriptMonkeyResponse, default_prompts
+from .file_handler import read_file, write_file
+import platform
+import threading
+import itertools
+import time
+
+
+def get_platform():
+    os_name = platform.system()
+    os_version = platform.release()
+    return f"# Operating System: {os_name}, Version: {os_version}\n\n"
+
+
+class Spinner:
+    def __init__(self, message="Processing"):
+        self.spinner = itertools.cycle(["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"])
+        self.stop_running = threading.Event()
+        self.spin_thread = None
+        self.message = message
+
+    def spin(self):
+        while not self.stop_running.is_set():
+            sys.stdout.write(f"\r{self.message} {next(self.spinner)}")
+            sys.stdout.flush()
+            time.sleep(0.1)
+        sys.stdout.write("\r" + " " * (len(self.message) + 2) + "\r")
+        sys.stdout.flush()
+
+    def __enter__(self):
+        self.spin_thread = threading.Thread(target=self.spin)
+        self.spin_thread.start()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop_running.set()
+        self.spin_thread.join()
+
+
+def codemonkey_exception_handler(exc_type, exc_value, exc_traceback):
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+        return
+
+    error_message = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+
+    print(f"\n🐒 ScriptMonkey Detected an Error:")
+    print(error_message, "\n")
+
+    frame = traceback.extract_tb(exc_traceback)[-1]
+    file_path = frame.filename
+
+    original_code = read_file(file_path)
+    content = f"{get_platform()}# Original Code:\n```\n{original_code}\n```\n\n# Error Message:\n{error_message}"
+
+    solution = None
+    with Spinner("🐒 ScriptMonkey is working on a solution"):
+        solution = chatgpt_json(
+            instructions=default_prompts.fix_error, content=content, response_format=ScriptMonkeyResponse
+        )
+
+    print(f"\n🐒 ScriptMonkey Fixed It:\nProblem:\n{solution['problem']}\n")
+    print(f"Suggested Solution:\n{solution['solution']}\n")
+
+    corrected_code = solution["corrected_code"].replace("```python", "").replace("```", "")
+    write_file(file_path, corrected_code)
+    print(f"🐒 ScriptMonkey automatically fixed your code at: '{file_path}'.")
+
+
+def run():
+    sys.excepthook = codemonkey_exception_handler

scriptmonkey-0.1.0/scriptmonkey/file_handler.py

@@ -0,0 +1,22 @@
+def read_file(path: str) -> str:
+    """Loads a file and returns the content.
+
+    Args:
+        path (str): Path to the file
+
+    Returns:
+        str: The content of the file
+    """
+    with open(path, "r") as file:
+        return file.read()
+
+
+def write_file(path: str, content: str) -> None:
+    """Writes string content to a file.
+
+    Args:
+        path (str): Path to the file.
+        content (str): Content to write to file.
+    """
+    with open(path, "w") as file:
+        file.write(content)

scriptmonkey-0.1.0/scriptmonkey/openai_client/__init__.py

@@ -0,0 +1,12 @@
+from .prompting import DefaultPrompts
+from .client import chatgpt_json
+from pydantic import BaseModel
+
+
+class ScriptMonkeyResponse(BaseModel):
+    problem: str  # A description of the error/problem
+    solution: str  # The solution to the problem
+    corrected_code: str  # The corrected version of the Python code
+
+
+default_prompts = DefaultPrompts()

scriptmonkey-0.1.0/scriptmonkey/openai_client/basemodels.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class CodemonkeyResponse(BaseModel):
+    problem: str  # A description of the error/problem
+    solution: str  # The solution to the problem
+    corrected_code: str  # The corrected version of the Python code

scriptmonkey-0.1.0/scriptmonkey/openai_client/client.py

@@ -0,0 +1,59 @@
+import os
+
+from dotenv import load_dotenv
+from pydantic import BaseModel
+import openai
+
+# Load the OpenAI API key from .env file
+load_dotenv()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if OPENAI_API_KEY:
+    # Initialize openai API client
+    client = openai.OpenAI(api_key=OPENAI_API_KEY)
+else:
+    raise ValueError("Missing OpenAI API Key. Please check your environment variables.")
+
+
+def chatgpt_json(instructions: str, content: str, response_format: BaseModel) -> dict:
+    """This function is used to return content from OpenAI Chat Completions API as a structured dictionary response.
+
+    Args:
+        instructions (str): Instructions for the LLM (how the LLM should process the input content).
+        content (str): Information that the LLM is supposed to process.
+        response_format (BaseModel): The output format defined by a Pydantic Basemodel.
+
+    Returns:
+        dict: The structured output response from the LLM.
+    """
+    completion = client.beta.chat.completions.parse(
+        model="gpt-4o-2024-08-06",
+        messages=[
+            {"role": "system", "content": instructions},
+            {"role": "user", "content": content},
+        ],
+        response_format=response_format,
+    )
+
+    structured_response = completion.choices[0].message.parsed
+    return structured_response.model_dump()
+
+
+def chatgpt(prompt: str, model="gpt-4o", max_tokens=None):
+    """Function for generating responses to text prompts with OpenAI's ChatGPT API
+
+    Args:
+        prompt (str): The instructions for ChatGPT to respond to
+        model (str, optional): ChatGPT model to use. Defaults to "gpt-4o".
+            - List of Available Models: https://platform.openai.com/docs/models/continuous-model-upgrades
+        max_tokens (int, optional): Optional, the max tokens to be returned by response. Defaults to no limit (i.e. None).
+
+    Returns:
+        str: Returns the response to the prompt as a string value
+    """
+    completion = client.chat.completions.create(
+        model=model,
+        max_tokens=max_tokens,
+        messages=[{"role": "user", "content": prompt}],
+    )
+    response = completion.choices[0].message.content
+    return response

scriptmonkey-0.1.0/scriptmonkey/openai_client/prompting.py

@@ -0,0 +1,12 @@
+import os
+
+
+def load_prompt(path: str) -> str:
+    path = os.path.join(os.path.dirname(__file__), path)
+    with open(path, "r") as file:
+        return file.read()
+
+
+class DefaultPrompts:
+    def __init__(self):
+        self.fix_error = load_prompt(path="./prompts/fix_error.txt")

scriptmonkey-0.1.0/scriptmonkey/openai_client/prompts/fix_error.txt

@@ -0,0 +1,10 @@
+You are a Python programming expert that helps solve Python code errors. 
+When you fix Python code, your improvements should be well designed and follow Python best practices.
+While you are at it, also make improvements like:
+    - Improving the code structure, formatting, and readability.
+    - Adding type hints to functions and classes.
+    - Organizing import statements.
+    - Leave short comments in the code describing the fix, and always start your explanations of fixes with: "SCRIPTMONKEY: "
+NEVER remove any code related to scriptmonkey imports or statements.
+    - scriptmonkey.run() should always be the first statement in the file after the imports
+Return the solution in a structured JSON format.

scriptmonkey-0.1.0/scriptmonkey.egg-info/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: scriptmonkey
+Version: 0.1.0
+Summary: A Python package that automatically fixes errors in your code using OpenAI's GPT API
+Home-page: https://github.com/lukerbs/CodeMonkey
+Author: Luke Kerbs
+Author-email: LDK.kerbs@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: openai
+Requires-Dist: pydantic
+Requires-Dist: tqdm
+
+
+# ScriptMonkey 🐒
+
+ScriptMonkey is a Python package that automatically detects and fixes errors in your code using OpenAI's GPT API. It works with any IDE or code editor, analyzing your code at runtime, providing solutions to errors, and even updating the file with the corrected code.
+
+## Features
+- **Automatic error detection**: Captures errors during runtime.
+- **AI-powered fixes**: Uses OpenAI's GPT API to understand and resolve errors.
+- **Code auto-correction**: Automatically updates your Python files with the fixes.
+- **Cross-IDE compatibility**: Works with any IDE or code editor.
+
+## Installation
+
+To install ScriptMonkey, simply run:
+
+```bash
+pip install scriptmonkey
+```
+
+## Usage
+
+1. Import `scriptmonkey` in your Python script.
+2. Call `scriptmonkey.run()` to activate the error handler.
+3. Run your code, and let ScriptMonkey handle any errors that occur.
+
+### Example
+
+```python
+import scriptmonkey
+
+# Enable Codemonkey's error handler
+scriptmonkey.run()
+
+# Intentional error for testing
+def add(a, b):
+    return a + b  # This will fail if b is a string
+
+print(add(2, "3"))  # Codemonkey will automatically fix this error and update the file
+```
+
+Once an error occurs, ScriptMonkey will:
+1. Detect the error.
+2. Send the error and code to OpenAI for analysis.
+3. Provide a solution and automatically update the file with the correct code.
+
+## How It Works
+
+ScriptMonkey replaces Python's default exception handling with a custom handler. When an error is caught, it:
+- Collects the traceback and the Python file that caused the error.
+- Sends the error message and code to OpenAI.
+- Receives the solution as structured JSON.
+- Applies the fix directly to the source file.
+
+## Requirements
+- Python 3.6 or later
+- OpenAI API key
+
+## Setup
+
+To use ScriptMonkey, you'll need an OpenAI API key. Set it up as follows:
+
+```bash
+export OPENAI_API_KEY='your-api-key'
+```
+
+Let ScriptMonkey take care of your Python errors so you can focus on building!

scriptmonkey-0.1.0/scriptmonkey.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+setup.py
+scriptmonkey/__init__.py
+scriptmonkey/core.py
+scriptmonkey/file_handler.py
+scriptmonkey.egg-info/PKG-INFO
+scriptmonkey.egg-info/SOURCES.txt
+scriptmonkey.egg-info/dependency_links.txt
+scriptmonkey.egg-info/requires.txt
+scriptmonkey.egg-info/top_level.txt
+scriptmonkey/openai_client/__init__.py
+scriptmonkey/openai_client/basemodels.py
+scriptmonkey/openai_client/client.py
+scriptmonkey/openai_client/prompting.py
+scriptmonkey/openai_client/prompts/fix_error.txt

scriptmonkey-0.1.0/scriptmonkey.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

scriptmonkey-0.1.0/scriptmonkey.egg-info/requires.txt

@@ -0,0 +1,3 @@
+openai
+pydantic
+tqdm

scriptmonkey-0.1.0/scriptmonkey.egg-info/top_level.txt

@@ -0,0 +1 @@
+scriptmonkey

scriptmonkey-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

scriptmonkey-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="scriptmonkey",
+    version="0.1.0",
+    description="A Python package that automatically fixes errors in your code using OpenAI's GPT API",
+    long_description=open("README.md", "r").read(),
+    long_description_content_type="text/markdown",
+    url="https://github.com/lukerbs/CodeMonkey",
+    author="Luke Kerbs",
+    author_email="LDK.kerbs@gmail.com",
+    license="MIT",
+    packages=find_packages(),
+    install_requires=["openai", "pydantic", "tqdm"],
+    python_requires=">=3.6",  # Minimum Python version
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    package_data={"scriptmonkey.openai_client": ["prompts/*.txt"]},
+    include_package_data=True,
+)