Addition of btrees and several updates

Author: cxbxmxcx

.env.default

@@ -1 +1,9 @@
-OPENAI_API_KEY="your openai api key here"
+OPENAI_API_KEY="your openai api key here"
+
+AGENTOPS_API_KEY = "your agentops api key here"
+
+X_EMAIL = "twitter email here"
+X_USERNAME = "twitter username here"
+X_PASSWORD = "twitter password here"
+
+

.vscode/settings.json

@@ -2,8 +2,7 @@
     "[python]": {
       "editor.formatOnSave": true,
       "editor.codeActionsOnSave": {
-        "source.fixAll": "explicit",
-        "source.organizeImports": "explicit"
+        "source.fixAll": "explicit"        
       },
       "editor.defaultFormatter": "charliermarsh.ruff"
     },

btree.py

@@ -1,91 +1,84 @@
-import threading
 import time
 
 import py_trees
 
-from playground.assistants_api import api
-
-
-# Define the ActionWithThread class
-class ActionWrapper(py_trees.behaviour.Behaviour):
-    def __init__(self, name, action_function=None):
-        super(ActionWrapper, self).__init__(name=name)
-        self.thread = None
-        self.thread_running = False
-        self.thread_success = False
-        self.action_function = action_function
-
-    def setup(self):
-        # This is called once at the beginning to setup any necessary state or resources
-        print("%s.setup()" % self.name)
-        return py_trees.common.Status.SUCCESS
-
-    def initialise(self):
-        # This is called once each time the behavior is started
-        print("%s.initialise()" % self.name)
-        self.thread_running = True
-        self.thread_success = False
-        self.thread = threading.Thread(target=self.long_running_process)
-        self.thread.start()
-
-    def long_running_process(self):
-        # Simulate a long-running process
-        try:
-            print("%s: Thread started, running process..." % self.name)
-            result = self.action_function()
-            print(result)
-            self.thread_success = True
-            print("%s: Thread completed successfully." % self.name)
-        except Exception as e:
-            print("%s: Exception in thread: %s" % (self.name, str(e)))
-        finally:
-            self.thread_running = False
-
-    def update(self):
-        # This is called every tick to update the status of the behavior
-        print("%s.update()" % self.name)
-        if self.thread_running:
-            return py_trees.common.Status.RUNNING
-        else:
-            return (
-                py_trees.common.Status.SUCCESS
-                if self.thread_success
-                else py_trees.common.Status.FAILURE
-            )
-
-    def terminate(self, new_status):
-        # This is called once each time the behavior terminates
-        print("%s.terminate(%s)" % (self.name, new_status))
-        if self.thread is not None:
-            self.thread.join()
-        self.thread = None
-        self.thread_running = False
-        self.thread_success = False
-
+from playground.behavior_trees import (
+    create_assistant_action,
+    create_assistant_condition,
+)
 
+search_term = "GPT Agents"
 # Create the root node (sequence)
 root = py_trees.composites.Sequence("RootSequence", memory=True)
 
-thread = api.create_thread()
-assistant = api.get_assistant_by_name("manager")
-message = "check the status of the thread, if there are no recent user messages, do nothing and return the word 'success'"
-
-action_function = lambda: api.call_assistant_with_thread(thread, assistant.id, message)
-
-# Create an instance of ActionWithThread and add it to the root node
-long_running_action = ActionWithThread(
-    name="LongRunningAction", action_function=action_function
+file_condition = create_assistant_condition(
+    condition_name="Check File Date",
+    assistant_name="File Manager",
+    assistant_instructions="""
+    load the file youtube_current.txt.
+    it will contain a date and time in the form HH-MM-DD-YY
+    where HH (01-24) is the hour, DD is the month (01 - 31), MM is the day (01 - 12) and YY is the year (24)
+    Return just the word SUCCESS if the date and time is earlier than the current date and time, 
+    Return just the word FAILURE if the date and time is the same or later than the current date and time.
+    """,
+)
+root.add_child(file_condition)
+
+search_youtube_action = create_assistant_action(
+    action_name="Search YouTube",
+    assistant_name="YouTube Researcher",
+    assistant_instructions=f"""
+    Search Term: {search_term}
+    Use the query "{search_term}" to search for videos on YouTube.
+    then for each video download the transcript and summarize it for relevance to {search_term}
+    be sure to include a link to each of the videos,
+    and then save all summarizations to a file called youtube_transcripts.txt
+    """,
 )
-root.add_child(long_running_action)
+root.add_child(search_youtube_action)
+
+write_post_action = create_assistant_action(
+    action_name="Write Post",
+    assistant_name="Twitter Post Writer",
+    assistant_instructions=f"""
+    Load the file called youtube_transcripts.txt,
+    analyze the contents for references to {search_term} and then select
+    the most exciting and relevant video to post on Twitter.
+    Then write a Twitter post that is relevant to the video,
+    and include a link to the video, along
+    with exciting highlights or mentions, 
+    and save it to a file called youtube_twitter_post.txt.
+    """,
+)
+root.add_child(write_post_action)
+
+post_action = create_assistant_action(
+    action_name="Post",
+    assistant_name="Social Media Assistant",
+    assistant_instructions="""
+    Load the file called youtube_twitter_post.txt and post the content to Twitter.
+    If the content is empty please do not post anything.
+    """,
+)
+root.add_child(post_action)
+
+file_write_action = create_assistant_action(
+    action_name="Write File Date",
+    assistant_name="File Manager",
+    assistant_instructions="""
+    write the current date and time to a file called youtube_current.txt.
+    Format the date and time in the form HH-MM-DD-YY
+    where HH (01-24) is the hour, DD is the month (01 - 31), MM is the day (01 - 12) and YY is the year (24)
+    Be sure to increment the hour by 1 each time this action is called.    
+    """,
+)
+root.add_child(file_write_action)
 
 # Create the behavior tree
 tree = py_trees.trees.BehaviourTree(root)
 
 # Tick the tree to run it
-for i in range(100):
+for i in range(1000):
     print(f"Tick {i + 1}")
     tree.tick()
-    time.sleep(5)  # Simulate time between ticks
-
-# Add a blackboard watcher to visualize the tree
-# py_trees.display.render_dot_tree(tree.root)
+    time.sleep(300)  # Simulate time between ticks

btree_examples/first_btree.py

@@ -0,0 +1,70 @@
+import py_trees
+
+
+# Define the conditions and actions
+class HasApple(py_trees.behaviour.Behaviour):
+    def __init__(self, name):
+        super(HasApple, self).__init__(name)
+
+    def update(self):
+        # Condition check (placeholder for actual logic)
+        if True:  # Replace with actual condition
+            return py_trees.common.Status.SUCCESS
+        else:
+            return py_trees.common.Status.FAILURE
+
+
+class EatApple(py_trees.behaviour.Behaviour):
+    def __init__(self, name):
+        super(EatApple, self).__init__(name)
+
+    def update(self):
+        # Action (placeholder for actual action)
+        print("Eating apple")
+        return py_trees.common.Status.SUCCESS
+
+
+class HasPear(py_trees.behaviour.Behaviour):
+    def __init__(self, name):
+        super(HasPear, self).__init__(name)
+
+    def update(self):
+        # Condition check (placeholder for actual logic)
+        if True:  # Replace with actual condition
+            return py_trees.common.Status.SUCCESS
+        else:
+            return py_trees.common.Status.FAILURE
+
+
+class EatPear(py_trees.behaviour.Behaviour):
+    def __init__(self, name):
+        super(EatPear, self).__init__(name)
+
+    def update(self):
+        # Action (placeholder for actual action)
+        print("Eating pear")
+        return py_trees.common.Status.SUCCESS
+
+
+# Create the behavior tree nodes
+has_apple = HasApple(name="Has apple")
+eat_apple = EatApple(name="Eat apple")
+sequence_1 = py_trees.composites.Sequence(name="Sequence 1", memory=True)
+sequence_1.add_children([has_apple, eat_apple])
+
+has_pear = HasPear(name="Has pear")
+eat_pear = EatPear(name="Eat pear")
+sequence_2 = py_trees.composites.Sequence(name="Sequence 2", memory=True)
+sequence_2.add_children([has_pear, eat_pear])
+
+root = py_trees.composites.Selector(name="Selector", memory=True)
+root.add_children([sequence_1, sequence_2])
+
+# Create the behavior tree
+behavior_tree = py_trees.trees.BehaviourTree(root)
+
+# Execute the behavior tree
+py_trees.logging.level = py_trees.logging.Level.DEBUG
+for i in range(1, 4):
+    print("\n------------------ Tick {0} ------------------".format(i))
+    behavior_tree.tick()

gradio_theme_builder.py

@@ -0,0 +1,3 @@
+import gradio as gr
+
+gr.themes.builder()

logs/logs.txt

@@ -1,30 +1,5 @@
-Running on local URL:  http://127.0.0.1:7860
+Running on local URL:  http://127.0.0.1:7861
 
 To create a public link, set `share=True` in `launch()`.
-# >>> Code Interpreter
-import matplotlib.pyplot as plt
-import numpy as np
-
-# Define the linear function
-def linear_function(x):
-    return 3*x + 6
-
-# Generate x values
-x = np.linspace(-10, 10, 400)
-# Generate y values
-y = linear_function(x)
-
-# Create the plot
-plt.figure(figsize=(8, 6))
-plt.plot(x, y, label='y = 3x + 6', color='blue')
-plt.xlabel('x')
-plt.ylabel('y')
-plt.title('Plot of y = 3x + 6')
-plt.axhline(0, color='black',linewidth=0.5)
-plt.axvline(0, color='black',linewidth=0.5)
-plt.legend()
-plt.grid(True)
-plt.show()
-Output >
-assistant > File saved as assistant_outputs\file_20240526150025.png
-File saved as assistant_outputs\file_20240526150025.png
+action: post_to_twitter(args={"content":"Hello there from the OpenAI Assistants API, I am a Social Media Assistant."}) -> None
+assistant > 

main.py

@@ -165,8 +165,13 @@ def stream_worker(assistant_id, thread_id, event_handler):
 }
 """
 
+theme = gr.themes.Default()
 
-with gr.Blocks(css=custom_css) as demo:
+# theme = gr.themes.Glass()
+# theme = gr.themes.Monochrome()
+# theme = gr.themes.Soft()
+
+with gr.Blocks(css=custom_css, theme=theme) as demo:
     with gr.Tab(label="Playground"):
         with gr.Row():
             with gr.Column(scale=4):
@@ -213,6 +218,7 @@ def stream_worker(assistant_id, thread_id, event_handler):
             )
             demo.load(logger.read_logs, None, logs, every=1)
 
+
 demo.queue()
 
 

playground/__init__.py

@@ -190,6 +190,9 @@ def inspect_file_for_decorated_actions(self, file_contents, full_path):
                         decorated_actions.append(
                             {
                                 "name": node.name,
+                                "group": os.path.splitext(os.path.basename(full_path))[
+                                    0
+                                ],
                                 "pointer": function_pointer,
                                 "agent_action": getattr(
                                     function_pointer, "_agent_action", None

playground/actions_manager.py

@@ -0,0 +1,60 @@
+import gradio as gr
+
+
+def assistants_actions_panel(actions_manager):
+    available_actions = actions_manager.get_actions()
+
+    # Group actions by their group property
+    action_groups = {}
+    for action in available_actions:
+        group = action.get("group", "Ungrouped")
+        if group not in action_groups:
+            action_groups[group] = []
+        action_groups[group].append(action["name"])
+
+    with gr.Accordion("Actions", open=False):
+        group_accordions = []
+        for group, actions in action_groups.items():
+            with gr.Accordion(group, open=False) as group_accordion:
+                group_checkbox = gr.CheckboxGroup(
+                    label=f"{group} Actions", choices=actions, interactive=True
+                )
+                group_accordions.append((group_accordion, group_checkbox))
+
+        # Hidden control to store all selected actions
+        assistant_actions = gr.CheckboxGroup(
+            label="All Selected Actions", choices=[], visible=False
+        )
+
+    def sync_actions(selected_actions):
+        # Update the assistant actions control with the new selection
+        assistant_actions.update(value=selected_actions)
+        return selected_actions
+
+    # Create a change listener for each group's checkbox group
+    for _, group_checkbox in group_accordions:
+        group_checkbox.change(
+            fn=sync_actions, inputs=group_checkbox, outputs=assistant_actions
+        )
+
+    return assistant_actions
+
+
+# Example usage
+if __name__ == "__main__":
+
+    class ActionsManager:
+        def get_actions(self):
+            return [
+                {"name": "Action1", "group": "Group1"},
+                {"name": "Action2", "group": "Group1"},
+                {"name": "Action3", "group": "Group2"},
+                {"name": "Action4", "group": "Group2"},
+                {"name": "Action5", "group": "Group3"},
+            ]
+
+    actions_manager = ActionsManager()
+    demo = gr.Interface(
+        fn=lambda x: x, inputs=assistants_actions_panel(actions_manager), outputs="text"
+    )
+    demo.launch()