drafts ideas

Author: pcrespov

scripts/user-message-reviewer/message_extraction.py

@@ -0,0 +1,59 @@
+import ast
+import json
+from pathlib import Path
+
+"""
+def mark_for_review(message):
+    return message
+
+# Example error messages
+error_message = mark_for_review("Invalid input: '{input_value}'")
+not_found_message = mark_for_review("File '{filename}' was not found")
+"""
+
+
+def extract_unreviewed_messages(code_file, output_file, condition=None):
+    """
+    Extracts messages from mark_for_review calls that match a condition on the version tag.
+
+    Parameters:
+        code_file (str): Path to the Python source code file.
+        output_file (str): Path to save the extracted messages as a JSON file.
+        condition (callable, optional): A function to evaluate the version tag. If None, extracts messages with no version tag.
+    """
+    with Path.open(code_file) as f:
+        tree = ast.parse(f.read())
+
+    messages = {}
+
+    # Walk through the AST to find calls to `mark_for_review`
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.Call)
+            and getattr(node.func, "id", None) == "mark_for_review"
+        ):
+            if len(node.args) >= 1 and isinstance(node.args[0], ast.Constant):
+                original_message = node.args[0].value
+                version = None
+
+                # Check if a second argument (version) exists
+                if len(node.args) > 1 and isinstance(node.args[1], ast.Constant):
+                    version = node.args[1].value
+
+                # Apply the filter condition
+                if condition is None or condition(version):
+                    key = f"{node.lineno}_{node.col_offset}"  # Unique key based on location
+                    messages[key] = {"message": original_message, "version": version}
+
+    # Save extracted messages to a JSON file
+    with Path.open(output_file, "w") as f:
+        json.dump(messages, f, indent=4)
+
+
+# Example usage
+# Condition: Extract messages with no version or explicitly unreviewed (e.g., version is None or "unreviewed")
+def is_unreviewed(version):
+    return version is None or version == "unreviewed"
+
+
+# extract_unreviewed_messages("your_script.py", "unreviewed_messages.json", condition=is_unreviewed)

scripts/user-message-reviewer/message_refinement.py

@@ -0,0 +1,90 @@
+import json
+import os
+from pathlib import Path
+
+import openai
+
+# Set your OpenAI API key
+openai.api_key = os.environ["OPENAPI_API_KEY"]
+
+
+def load_rules(rules_file):
+    """Load rules for message refinement from a JSON file."""
+    with Path.open(rules_file) as f:
+        return json.load(f)
+
+
+def load_messages(messages_file):
+    """Load messages from the messages.json file."""
+    with Path.open(messages_file) as f:
+        return json.load(f)
+
+
+def send_to_chatgpt(messages, rules):
+    """Send messages and rules to ChatGPT and request alternatives."""
+    refined_messages = {}
+    for key, details in messages.items():
+        message = details["message"]
+        version = details.get("version", "unknown")
+
+        # Prepare the prompt
+        prompt = f"""
+You are a language expert. Apply the following rules to suggest alternatives for the given message:
+
+Rules:
+- Tone: {rules['tone']}
+- Style: {rules['style']}
+- Length: {rules['length']}
+- Placeholders: {rules['placeholders']}
+
+Original Message: "{message}"
+
+Provide three alternatives based on the above rules. Ensure placeholders remain intact.
+"""
+
+        # Send the request to ChatGPT
+        response = openai.Completion.create(
+            engine="text-davinci-003", prompt=prompt, max_tokens=150, temperature=0.7
+        )
+
+        # Parse the response
+        alternatives = response.choices[0].text.strip()
+        refined_messages[key] = {
+            "original": message,
+            "version": version,
+            "alternatives": alternatives.split(
+                "\n"
+            ),  # Split into list if alternatives are on separate lines
+        }
+
+    return refined_messages
+
+
+def save_refined_messages(output_file, refined_messages):
+    """Save the refined messages to a JSON file."""
+    with Path.open(output_file, "w") as f:
+        json.dump(refined_messages, f, indent=4)
+
+
+# Example usage
+# update_messages_in_code("your_script.py", "messages.json")
+
+
+# Main script
+if __name__ == "__main__":
+    # File paths
+    messages_file = "messages.json"
+    rules_file = "rules.json"
+    output_file = "refined_messages.json"
+
+    # Load inputs
+    rules = load_rules(rules_file)
+    messages = load_messages(messages_file)
+
+    # Process messages with ChatGPT
+    refined_messages = send_to_chatgpt(messages, rules)
+
+    # Save the refined messages
+    save_refined_messages(output_file, refined_messages)
+
+    print(f"Refined messages saved to {output_file}.")

scripts/user-message-reviewer/message_reintegration.py

@@ -0,0 +1,43 @@
+import ast
+import json
+from pathlib import Path
+
+import astor
+
+
+def update_messages_in_code(code_file, messages_file):
+    # Load corrected messages from the JSON file
+    with Path.open(messages_file) as f:
+        corrected_messages = json.load(f)
+
+    # Parse the Python code
+    with Path.open(code_file) as f:
+        tree = ast.parse(f.read())
+
+    # Walk through the AST to find calls to `mark_for_review`
+    for node in ast.walk(tree):
+        if (
+            isinstance(node, ast.Call)
+            and getattr(node.func, "id", None) == "mark_for_review"
+        ):
+            # Get the original message
+            if isinstance(node.args[0], ast.Constant):
+                original_message = node.args[0].value
+
+                # Match it with corrected messages
+                for key, corrected_message in corrected_messages.items():
+                    if original_message == corrected_message["original"]:
+                        # Replace the message with the corrected version
+                        node.args[0].value = corrected_message["current"]
+
+                        # Add the version as the second argument
+                        version_node = ast.Constant(value=corrected_message["version"])
+                        if len(node.args) == 1:
+                            node.args.append(version_node)
+                        else:
+                            node.args[1] = version_node
+
+    # Write the updated code back to the file
+    updated_code = astor.to_source(tree)
+    with Path.open(code_file, "w") as f:
+        f.write(updated_code)