tested, debugged, nice

Author: imapersonman

interpreter/core/core.py

@@ -73,8 +73,7 @@ def __init__(
         skills_path=None,
         import_skills=False,
         multi_line=False,
-        contributing_future_conversations=None,
-        contribute_current_conversation=False
+        contribute_conversation=False
     ):
         # State
         self.messages = [] if messages is None else messages
@@ -125,8 +124,7 @@ def __init__(
 
         self.computer.import_skills = import_skills
 
-        self.contributing_future_conversations = contributing_future_conversations
-        self.contribute_current_conversation = contribute_current_conversation
+        self.contribute_conversation = contribute_conversation
 
     def server(self, *args, **kwargs):
         server(self, *args, **kwargs)
@@ -141,6 +139,12 @@ def wait(self):
     def anonymous_telemetry(self) -> bool:
         return not self.disable_telemetry and not self.offline
 
+    @property
+    def will_contribute(self):
+        contribute_session = self.contribute_conversation
+        overrides = self.offline or not self.conversation_history or self.disable_telemetry
+        return contribute_session and not overrides
+
     def chat(self, message=None, display=True, stream=False, blocking=True):
         try:
             self.responding = True

interpreter/core/utils/telemetry.py

@@ -63,27 +63,3 @@ def send_telemetry(event_name, properties=None):
         pass
 
 
-def contribute_conversations(conversations):
-    url = "https://api.openinterpreter.com/v0/conversations/contribute/"
-    version = pkg_resources.get_distribution("open-interpreter").version
-    
-    if conversations and len(conversations) > 1:
-        payload = {
-            "conversations": [conv for sublist in conversations for conv in sublist],
-            "oi_version": version
-        }
-    else:
-        payload = {
-            "conversations": [conversations[0]],
-            "oi_version": version
-        }
-    try:
-        response = requests.post(url, json=payload)
-        if response.status_code != 200:
-            print(f"Failed to contribute conversation: {response.status_code} {response.text}")
-            return None
-        else:
-            print(f"Successfully contributed conversation!")
-    except requests.RequestException as e:
-        print(f"Failed to contribute conversation: {e}")
-        return None

interpreter/terminal_interface/contributing_conversations.py

@@ -1,108 +1,178 @@
 import os
 import json
+import time
+from typing import List, TypedDict
+
+import pkg_resources
+import requests
+
+from interpreter.terminal_interface.profiles.profiles import write_key_to_profile
+from interpreter.terminal_interface.utils.display_markdown_message import display_markdown_message
 
 
 contribute_cache_path = os.path.join(
     os.path.expanduser("~"), ".cache", "open-interpreter", "contribute.json"
 )
 
 
-def ask_user_to_run_contribute():
-    print("---")
-    print("not contributing current")
-    print("Run --contribute_conversation to contribute the current conversation!")
-    print()
+def display_contribution_message():
+    display_markdown_message(
+"""
+---
+> We're training an open-source language model!
+
+You can help us train it with your past, current, or future conversations by:
+1. Closing out of OpenInterpreter,
+2. Running `interpreter --contribute_conversation`.
+"""
+    )
+    time.sleep(1)
+
+
+def display_contributing_current_message():
+    display_markdown_message(
+f"""
+---
+> This conversation will be used to train OpenInterpreter's language model.
+"""
+    )
 
 
 def send_past_conversations(interpreter):
-    print("sending all past conversations!")
+    past_conversations = get_all_conversations(interpreter)
+    if len(past_conversations) > 0:
+        print()
+        print("Sending all previous conversations to OpenInterpreter...")
+        contribute_conversations(past_conversations)
+        print()
 
 
 def set_send_future_conversations(interpreter, should_send_future):
-    if should_send_future:
-        print("sending!")
-    else:
-        print("not sending!")
+    write_key_to_profile("contribute_conversation", should_send_future)
+    display_markdown_message(
+"""
+> OpenInterpreter will contribute all your conversations from now on.
+
+To change this, consult the documentation at [https://unassuminglink.com](https://www.readthefuckingmanual.com).
+"""
+    )
 
 
-def ask_user_to_contribute_past():
-    print("do you want to contribute all past conversations?")
+def user_wants_to_contribute_past():
+    print("Would you like to contribute all past conversations?")
     response = input("(y/n) ")
     return response.lower() == "y"
 
 
-def ask_user_to_contribute_future():
-    print("do you want to contribute all future conversations?")
+def user_wants_to_contribute_future():
+    print("Would you like to contribute all future conversations?")
     response = input("(y/n) ")
     return response.lower() == "y"
 
 
 def contribute_conversation_launch_logic(interpreter):
     contribution_cache = get_contribute_cache_contents()
-    displayed_contribution_message = contribution_cache["asked_to_run_contribute"]
-    contribute_current = interpreter.contribute_conversation
 
-    if displayed_contribution_message:
-        if contribute_current:
-            # second launch, --contribute-conversation.
-            contribute_past_and_future_logic(interpreter, contribution_cache)
-        else:
-            # second launch, no --contribute-conversation.
-            # continue launching as normal!
-            # no need to modify contribution_cache because we're not asking about
-            # past conversations and we've already displayed the contribution message.
-            return
-    else:
-        if contribute_current:
-            # first launch, --contribute-conversation.
-            contribute_past_and_future_logic(interpreter, contribution_cache)
-        else:
-            # first launch, no --contribute-conversation.
-            ask_user_to_run_contribute()
-            contribution_cache["asked_to_run_contribute"] = True
+    if interpreter.will_contribute:
+        contribute_past_and_future_logic(interpreter, contribution_cache)
+    elif not contribution_cache["displayed_contribution_message"]:
+        display_contribution_message()
 
+    # don't show the contribution message again no matter what.
+    contribution_cache["displayed_contribution_message"] = True
     write_to_contribution_cache(contribution_cache)
 
 
+class ContributionCache(TypedDict):
+    displayed_contribution_message: bool
+    asked_to_contribute_past: bool
+    asked_to_contribute_future: bool
+
+
 # modifies the contribution cache!
-def contribute_past_and_future_logic(interpreter, contribution_cache):
+def contribute_past_and_future_logic(
+    interpreter, contribution_cache: ContributionCache
+):
     if not contribution_cache["asked_to_contribute_past"]:
-        contribute_past = ask_user_to_contribute_past()
-        if contribute_past:
+        if user_wants_to_contribute_past():
             send_past_conversations(interpreter)
+        contribution_cache["asked_to_contribute_past"] = True
 
-    # set asked_to_contribute_past to True no matter what!
-    contribution_cache["asked_to_contribute_past"] = True
-
-    contributing_future = interpreter.contributing_future_conversations
-    if not contributing_future:
-        contribute_future = ask_user_to_contribute_future()
-        if contribute_future:
+    if not contribution_cache["asked_to_contribute_future"]:
+        if user_wants_to_contribute_future():
             set_send_future_conversations(interpreter, True)
-        else:
-            set_send_future_conversations(interpreter, False)
+        contribution_cache["asked_to_contribute_future"] = True
 
+    display_contributing_current_message()
 
-# Returns a {"asked_to_run_contribute": bool, "asked_to_contribute_past": bool}.
+
+# Returns a {"asked_to_run_contribute": bool, "asked_to_contribute_past": bool}
+# as the first part of its Tuple, a bool as a second.
 # Writes the contribution cache file if it doesn't already exist.
-def get_contribute_cache_contents():
+# The bool is True if the file does not already exist, False if it does.
+def get_contribute_cache_contents() -> ContributionCache:
     if not os.path.exists(contribute_cache_path):
-        default_dict = {
+        default_dict: ContributionCache = {
             "asked_to_contribute_past": False,
-            "asked_to_run_contribute": False,
+            "displayed_contribution_message": False,
+            "asked_to_contribute_future": False,
         }
         with open(contribute_cache_path, "a") as file:
             file.write(json.dumps(default_dict))
         return default_dict
-
-    with open(contribute_cache_path, "r") as file:
-        contribute_cache = json.load(file)
-        return contribute_cache
+    else:
+        with open(contribute_cache_path, "r") as file:
+            contribute_cache = json.load(file)
+            return contribute_cache
 
 
 # Takes in a {"asked_to_run_contribute": bool, "asked_to_contribute_past": bool}
-def write_to_contribution_cache(contribution_cache):
+def write_to_contribution_cache(contribution_cache: ContributionCache):
     with open(contribute_cache_path, "w") as file:
         json.dump(contribution_cache, file)
 
 
+def get_all_conversations(interpreter) -> List[List]:
+    def is_conversation_path(path: str):
+        _, ext = os.path.splitext(path)
+        return ext == ".json"
+
+    history_path = interpreter.conversation_history_path
+    all_conversations: List[List] = []
+    for mpath in os.listdir(history_path):
+        if not is_conversation_path(mpath):
+            continue
+        full_path = os.path.join(history_path, mpath)
+        with open(full_path, "r") as cfile:
+            conversation = json.load(cfile)
+            all_conversations.append(conversation)
+    return all_conversations
+
+
+def is_list_of_lists(l):
+    return isinstance(l, list) and all([isinstance(e, list) for e in l])
+
+
+def contribute_conversations(conversations: List[List]):
+    if len(conversations) == 0 or len(conversations[0]) == 0:
+        return None
+
+    url = "https://api.openinterpreter.com/v0/conversations/contribute/"
+    version = pkg_resources.get_distribution("open-interpreter").version
+
+    payload = {"conversations": conversations, "oi_version": version}
+
+    assert is_list_of_lists(payload["conversations"]), "the contribution payload is not a list of lists!"
+
+    try:
+        response = requests.post(url, json=payload)
+        if response.status_code != 200:
+            print(
+                f"Failed to contribute conversation: {response.status_code} {response.text}"
+            )
+            return None
+        else:
+            print(f"Successfully contributed conversations!")
+    except requests.RequestException as e:
+        print(f"Failed to contribute conversation: {e}")
+        return None

interpreter/terminal_interface/profiles/profiles.py

@@ -564,7 +564,6 @@ def apply_profile_to_object(obj, profile):
         else:
             setattr(obj, key, value)
 
-
 def open_storage_dir(directory):
     dir = os.path.join(oi_dir, directory)
 
@@ -758,3 +757,29 @@ def migrate_user_app_directory():
     elif user_version == "0.2.0":
         old_dir = platformdirs.user_config_dir("Open Interpreter Terminal")
         migrate_app_directory(old_dir, oi_dir, profile_dir)
+
+
+def write_key_to_profile(key, value):
+    try:
+        with open(user_default_profile_path, 'r') as file:
+            lines = file.readlines()
+        
+        version_line_index = None
+        new_lines = []
+        for index, line in enumerate(lines):
+            if line.strip().startswith("version:"):
+                version_line_index = index
+                break
+            new_lines.append(line)
+        
+        # Insert the new key-value pair before the version line
+        if version_line_index is not None:
+            if f"{key}: {value}\n" not in new_lines:
+                new_lines.append(f"{key}: {value}\n\n")  # Adding a newline for separation
+            # Append the version line and all subsequent lines
+            new_lines.extend(lines[version_line_index:])
+        
+        with open(user_default_profile_path, 'w') as file:
+            file.writelines(new_lines)
+    except Exception:
+        pass # Fail silently

interpreter/terminal_interface/start_terminal_interface.py

@@ -4,7 +4,7 @@
 
 import pkg_resources
 
-from interpreter.terminal_interface.contributing_conversations import contribute_conversation_launch_logic
+from interpreter.terminal_interface.contributing_conversations import contribute_conversation_launch_logic, contribute_conversations
 
 from ..core.core import OpenInterpreter
 from .conversation_navigator import conversation_navigator
@@ -242,7 +242,8 @@ def start_terminal_interface(interpreter):
         {
             "name": "contribute_conversation",
             "help_text": "let Open Interpreter use the current conversation to train an Open-Source LLM",
-            "type": bool
+            "type": bool,
+            "default": False
         }
     ]
 
@@ -427,7 +428,7 @@ def start_terminal_interface(interpreter):
         interpreter.server()
         return
 
-    interpreter.contribute_conversation = args.contribute_conversation
+    interpreter.contribute_conversation = args.contribute_conversation or arguments
 
     validate_llm_settings(interpreter)
 
@@ -463,4 +464,7 @@ def main():
     except KeyboardInterrupt:
         pass
     finally:
+        if interpreter.will_contribute:
+            contribute_conversations([interpreter.messages])
+            print("Thank you for contributing to our training data!")
         interpreter.computer.terminate()