parent
19ec72a9bc
commit
0a82832968
@ -1,22 +0,0 @@
|
||||
message='Request to OpenAI API' method=post path=https://api.openai.com/v1/chat/completions
|
||||
api_version=None data='{"messages": [{"role": "user", "content": "Generate a 10,000 word blog on health and wellness."}], "model": "gpt-3.5-turbo", "temperature": 0.5, "max_tokens": 3000}' message='Post details'
|
||||
Converted retries value: 2 -> Retry(total=2, connect=None, read=None, redirect=None, status=None)
|
||||
Starting new HTTPS connection (1): api.openai.com:443
|
||||
https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None
|
||||
message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=13516 request_id=971b8437917cf6e46e5fe1340060f0e4 response_code=200
|
||||
message='Request to OpenAI API' method=post path=https://api.openai.com/v1/chat/completions
|
||||
api_version=None data='{"messages": [{"role": "user", "content": "Title: The Ultimate Guide to Health and Wellness: Unlocking Your Full Potential\\n\\nIntroduction (Word Count: 500)\\nHealth and wellness are essential aspects of our lives that directly impact our overall well-being. In this comprehensive guide, we will explore various dimensions of health and wellness, providing valuable insights, practical tips, and evidence-based strategies to help you achieve optimal physical, mental, and emotional well-being. From nutrition and exercise to stress management and self-care, we will delve into every aspect of leading a healthy and fulfilling life. So, let\'s embark on this transformative journey together!\\n\\nTable of Contents:\\n\\n1. Understanding Health and Wellness (Word Count: 800)\\n1.1 Defining Health and Wellness\\n1.2 The Importance of Health and Wellness\\n1.3 The Connection between Physical, Mental, and Emotional Well-being\\n1.4 The Role of Lifestyle Choices in Health and Wellness\\n\\n2. Nourishing Your Body (Word Count: 1,200)\\n2.1 The Fundamentals of a Balanced Diet\\n2.2 The Power of Whole Foods and Nutrient Density\\n2.3 Understanding Macronutrients and Micronutrients\\n2.4 The Role of Hydration in Health\\n2.5 Exploring Different Dietary Approaches\\n\\n3. Moving Towards Fitness (Word Count: 1,200)\\n3.1 The Benefits of Regular Physical Activity\\n3.2 Designing an Effective Exercise Routine\\n3.3 Cardiovascular Exercise and Its Impact on Health\\n3.4 Strength Training for Optimal Fitness\\n3.5 The Importance of Flexibility and Balance\\n\\n4. Prioritizing Mental and Emotional Well-being (Word Count: 1,500)\\n4.1 Understanding Mental Health and Emotional Well-being\\n4.2 Stress Management Techniques and Coping Strategies\\n4.3 The Power of Mindfulness and Meditation\\n4.4 Building Resilience and Emotional Intelligence\\n4.5 Seeking Professional Help and Support\\n\\n5. Cultivating Healthy Habits (Word Count: 1,500)\\n5.1 The Science of Habit Formation\\n5.2 The Role of Sleep in Health and Wellness\\n5.3 Strategies for Effective Time Management\\n5.4 Creating a Healthy Home Environment\\n5.5 The Importance of Social Connections and Relationships\\n\\n6. Embracing Self-Care (Word Count: 1,000)\\n6.1 Understanding Self-Care and Its Impact on Well-being\\n6.2 Developing a Personalized Self-Care Routine\\n6.3 The Benefits of Regular Relaxation and Recreation\\n6.4 Exploring Creative Outlets for Self-Expression\\n6.5 Practicing Gratitude and Positive Thinking\\n\\n7. Navigating Common Health Concerns (Word Count: 1,800)\\n7.1 Preventing and Managing Chronic Diseases\\n7.2 Mental Health Disorders: Causes, Symptoms, and Treatments\\n7.3 Women\'s Health: From Menstruation to Menopause\\n7.4 Maintaining a Healthy Heart and Cardiovascular System\\n7.5 Strategies for Boosting Immune Function\\n\\n8. Holistic Approaches to Health and Wellness (Word Count: 1,000)\\n8.1 Traditional Medicine and Integrative Health Practices\\n8.2 The Benefits of Herbal Medicine and Natural Remedies\\n8.3 Exploring Alternative Therapies: Acupuncture, Ayurveda, and more\\n8.4 Harnessing the Power of Energy Healing and Chakra Balancing\\n8.5 The Role of Spirituality and Mind-Body Connection\\n\\nConclusion (Word Count: 300)\\nIn this extensive guide, we have covered a wide range of topics related to health and wellness, equipping you with the knowledge and tools to embark on your personal journey towards optimal well-being. Remember, true health and wellness are not achieved overnight but require consistent effort, commitment, and self-care. By implementing the strategies outlined in this guide, you can unlock your full potential and live a vibrant, fulfilling life. So, embrace the power of health and wellness and start your transformative journey today!\\n\\nWord Count: 10,000"}], "model": "gpt-3.5-turbo", "temperature": 0.5, "max_tokens": 3000}' message='Post details'
|
||||
https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None
|
||||
message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=14472 request_id=351166c14151ef9e628dcd036573e36e response_code=200
|
||||
message='Request to OpenAI API' method=post path=https://api.openai.com/v1/chat/completions
|
||||
api_version=None data='{"messages": [{"role": "user", "content": "Note: The word count provided is an estimation and may vary slightly.\\n\\nTitle: The Ultimate Guide to Health and Wellness: Unlocking Your Full Potential\\n\\nIntroduction (Word Count: 500)\\nHealth and wellness are essential aspects of our lives that directly impact our overall well-being. In this comprehensive guide, we will explore various dimensions of health and wellness, providing valuable insights, practical tips, and evidence-based strategies to help you achieve optimal physical, mental, and emotional well-being. From nutrition and exercise to stress management and self-care, we will delve into every aspect of leading a healthy and fulfilling life. So, let\'s embark on this transformative journey together!\\n\\nTable of Contents:\\n\\n1. Understanding Health and Wellness (Word Count: 800)\\n1.1 Defining Health and Wellness\\n1.2 The Importance of Health and Wellness\\n1.3 The Connection between Physical, Mental, and Emotional Well-being\\n1.4 The Role of Lifestyle Choices in Health and Wellness\\n\\n2. Nourishing Your Body (Word Count: 1,200)\\n2.1 The Fundamentals of a Balanced Diet\\n2.2 The Power of Whole Foods and Nutrient Density\\n2.3 Understanding Macronutrients and Micronutrients\\n2.4 The Role of Hydration in Health\\n2.5 Exploring Different Dietary Approaches\\n\\n3. Moving Towards Fitness (Word Count: 1,200)\\n3.1 The Benefits of Regular Physical Activity\\n3.2 Designing an Effective Exercise Routine\\n3.3 Cardiovascular Exercise and Its Impact on Health\\n3.4 Strength Training for Optimal Fitness\\n3.5 The Importance of Flexibility and Balance\\n\\n4. Prioritizing Mental and Emotional Well-being (Word Count: 1,500)\\n4.1 Understanding Mental Health and Emotional Well-being\\n4.2 Stress Management Techniques and Coping Strategies\\n4.3 The Power of Mindfulness and Meditation\\n4.4 Building Resilience and Emotional Intelligence\\n4.5 Seeking Professional Help and Support\\n\\n5. Cultivating Healthy Habits (Word Count: 1,500)\\n5.1 The Science of Habit Formation\\n5.2 The Role of Sleep in Health and Wellness\\n5.3 Strategies for Effective Time Management\\n5.4 Creating a Healthy Home Environment\\n5.5 The Importance of Social Connections and Relationships\\n\\n6. Embracing Self-Care (Word Count: 1,000)\\n6.1 Understanding Self-Care and Its Impact on Well-being\\n6.2 Developing a Personalized Self-Care Routine\\n6.3 The Benefits of Regular Relaxation and Recreation\\n6.4 Exploring Creative Outlets for Self-Expression\\n6.5 Practicing Gratitude and Positive Thinking\\n\\n7. Navigating Common Health Concerns (Word Count: 1,800)\\n7.1 Preventing and Managing Chronic Diseases\\n7.2 Mental Health Disorders: Causes, Symptoms, and Treatments\\n7.3 Women\'s Health: From Menstruation to Menopause\\n7.4 Maintaining a Healthy Heart and Cardiovascular System\\n7.5 Strategies for Boosting Immune Function\\n\\n8. Holistic Approaches to Health and Wellness (Word Count: 1,000)\\n8.1 Traditional Medicine and Integrative Health Practices\\n8.2 The Benefits of Herbal Medicine and Natural Remedies\\n8.3 Exploring Alternative Therapies: Acupuncture, Ayurveda, and more\\n8.4 Harnessing the Power of Energy Healing and Chakra Balancing\\n8.5 The Role of Spirituality and Mind-Body Connection\\n\\nConclusion (Word Count: 300)\\nIn this extensive guide, we have covered a wide range of topics related to health and wellness, equipping you with the knowledge and tools to embark on your personal journey towards optimal well-being. Remember, true health and wellness are not achieved overnight but require consistent effort, commitment, and self-care. By implementing the strategies outlined in this guide, you can unlock your full potential and live a vibrant, fulfilling life. So, embrace the power of health and wellness and start your transformative journey today!\\n\\nWord Count: 10,000"}], "model": "gpt-3.5-turbo", "temperature": 0.5, "max_tokens": 3000}' message='Post details'
|
||||
https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None
|
||||
message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=13492 request_id=adff9627a295fd94fb7d164f9f67acbe response_code=200
|
||||
message='Request to OpenAI API' method=post path=https://api.openai.com/v1/chat/completions
|
||||
api_version=None data='{"messages": [{"role": "user", "content": "Disclaimer: The word count provided is an estimation and may vary slightly.\\n\\nTitle: The Ultimate Guide to Health and Wellness: Unlocking Your Full Potential\\n\\nIntroduction (Word Count: 500)\\nHealth and wellness are essential aspects of our lives that directly impact our overall well-being. In this comprehensive guide, we will explore various dimensions of health and wellness, providing valuable insights, practical tips, and evidence-based strategies to help you achieve optimal physical, mental, and emotional well-being. From nutrition and exercise to stress management and self-care, we will delve into every aspect of leading a healthy and fulfilling life. So, let\'s embark on this transformative journey together!\\n\\nTable of Contents:\\n\\n1. Understanding Health and Wellness (Word Count: 800)\\n1.1 Defining Health and Wellness\\n1.2 The Importance of Health and Wellness\\n1.3 The Connection between Physical, Mental, and Emotional Well-being\\n1.4 The Role of Lifestyle Choices in Health and Wellness\\n\\n2. Nourishing Your Body (Word Count: 1,200)\\n2.1 The Fundamentals of a Balanced Diet\\n2.2 The Power of Whole Foods and Nutrient Density\\n2.3 Understanding Macronutrients and Micronutrients\\n2.4 The Role of Hydration in Health\\n2.5 Exploring Different Dietary Approaches\\n\\n3. Moving Towards Fitness (Word Count: 1,200)\\n3.1 The Benefits of Regular Physical Activity\\n3.2 Designing an Effective Exercise Routine\\n3.3 Cardiovascular Exercise and Its Impact on Health\\n3.4 Strength Training for Optimal Fitness\\n3.5 The Importance of Flexibility and Balance\\n\\n4. Prioritizing Mental and Emotional Well-being (Word Count: 1,500)\\n4.1 Understanding Mental Health and Emotional Well-being\\n4.2 Stress Management Techniques and Coping Strategies\\n4.3 The Power of Mindfulness and Meditation\\n4.4 Building Resilience and Emotional Intelligence\\n4.5 Seeking Professional Help and Support\\n\\n5. Cultivating Healthy Habits (Word Count: 1,500)\\n5.1 The Science of Habit Formation\\n5.2 The Role of Sleep in Health and Wellness\\n5.3 Strategies for Effective Time Management\\n5.4 Creating a Healthy Home Environment\\n5.5 The Importance of Social Connections and Relationships\\n\\n6. Embracing Self-Care (Word Count: 1,000)\\n6.1 Understanding Self-Care and Its Impact on Well-being\\n6.2 Developing a Personalized Self-Care Routine\\n6.3 The Benefits of Regular Relaxation and Recreation\\n6.4 Exploring Creative Outlets for Self-Expression\\n6.5 Practicing Gratitude and Positive Thinking\\n\\n7. Navigating Common Health Concerns (Word Count: 1,800)\\n7.1 Preventing and Managing Chronic Diseases\\n7.2 Mental Health Disorders: Causes, Symptoms, and Treatments\\n7.3 Women\'s Health: From Menstruation to Menopause\\n7.4 Maintaining a Healthy Heart and Cardiovascular System\\n7.5 Strategies for Boosting Immune Function\\n\\n8. Holistic Approaches to Health and Wellness (Word Count: 1,000)\\n8.1 Traditional Medicine and Integrative Health Practices\\n8.2 The Benefits of Herbal Medicine and Natural Remedies\\n8.3 Exploring Alternative Therapies: Acupuncture, Ayurveda, and more\\n8.4 Harnessing the Power of Energy Healing and Chakra Balancing\\n8.5 The Role of Spirituality and Mind-Body Connection\\n\\nConclusion (Word Count: 300)\\nIn this extensive guide, we have covered a wide range of topics related to health and wellness, equipping you with the knowledge and tools to embark on your personal journey towards optimal well-being. Remember, true health and wellness are not achieved overnight but require consistent effort, commitment, and self-care. By implementing the strategies outlined in this guide, you can unlock your full potential and live a vibrant, fulfilling life. So, embrace the power of health and wellness and start your transformative journey today!\\n\\nWord Count: 10,000"}], "model": "gpt-3.5-turbo", "temperature": 0.5, "max_tokens": 3000}' message='Post details'
|
||||
https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None
|
||||
message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=334 request_id=d29d279c03c16a49192a468a6de16400 response_code=200
|
||||
message='Request to OpenAI API' method=post path=https://api.openai.com/v1/chat/completions
|
||||
api_version=None data='{"messages": [{"role": "user", "content": "Disclaimer: The word count provided is an estimation and may vary slightly."}], "model": "gpt-3.5-turbo", "temperature": 0.5, "max_tokens": 3000}' message='Post details'
|
||||
https://api.openai.com:443 "POST /v1/chat/completions HTTP/1.1" 200 None
|
||||
message='OpenAI API response' path=https://api.openai.com/v1/chat/completions processing_ms=704 request_id=a3c58cd690f5bd4d88ac37d8cd64a540 response_code=200
|
@ -1,24 +1,109 @@
|
||||
from swarms.structs import Flow
|
||||
# from swarms.structs import Flow
|
||||
# from swarms.models import OpenAIChat
|
||||
# from swarms.swarms.groupchat import GroupChat
|
||||
# from swarms.agents import SimpleAgent
|
||||
|
||||
# api_key = ""
|
||||
|
||||
# llm = OpenAIChat(
|
||||
# openai_api_key=api_key,
|
||||
# )
|
||||
|
||||
# agent1 = SimpleAgent("Captain Price", Flow(llm=llm, max_loops=4))
|
||||
# agent2 = SimpleAgent("John Mactavis", Flow(llm=llm, max_loops=4))
|
||||
|
||||
# # Create a groupchat with the 2 agents
|
||||
# chat = GroupChat([agent1, agent2])
|
||||
|
||||
# # Assign duties to the agents
|
||||
# chat.assign_duty(agent1.name, "Buy the groceries")
|
||||
# chat.assign_duty(agent2.name, "Clean the house")
|
||||
|
||||
# # Initate a chat
|
||||
# response = chat.run("Captain Price", "Hello, how are you John?")
|
||||
# print(response)
|
||||
|
||||
|
||||
from swarms.models import OpenAIChat
|
||||
from swarms.swarms.groupchat import GroupChat
|
||||
from swarms.agents import SimpleAgent
|
||||
from swarms.structs import Flow
|
||||
import random
|
||||
|
||||
api_key = "" # Your API Key here
|
||||
|
||||
|
||||
class GroupChat:
|
||||
"""
|
||||
GroupChat class that facilitates agent-to-agent communication using multiple instances of the Flow class.
|
||||
"""
|
||||
|
||||
def __init__(self, agents: list):
|
||||
self.agents = {f"agent_{i}": agent for i, agent in enumerate(agents)}
|
||||
self.message_log = []
|
||||
|
||||
def add_agent(self, agent: Flow):
|
||||
agent_id = f"agent_{len(self.agents)}"
|
||||
self.agents[agent_id] = agent
|
||||
|
||||
def remove_agent(self, agent_id: str):
|
||||
if agent_id in self.agents:
|
||||
del self.agents[agent_id]
|
||||
|
||||
def send_message(self, sender_id: str, recipient_id: str, message: str):
|
||||
if sender_id not in self.agents or recipient_id not in self.agents:
|
||||
raise ValueError("Invalid sender or recipient ID.")
|
||||
formatted_message = f"{sender_id} to {recipient_id}: {message}"
|
||||
self.message_log.append(formatted_message)
|
||||
recipient_agent = self.agents[recipient_id]
|
||||
recipient_agent.run(message)
|
||||
|
||||
def broadcast_message(self, sender_id: str, message: str):
|
||||
for agent_id, agent in self.agents.items():
|
||||
if agent_id != sender_id:
|
||||
self.send_message(sender_id, agent_id, message)
|
||||
|
||||
def get_message_log(self):
|
||||
return self.message_log
|
||||
|
||||
|
||||
class EnhancedGroupChatV2(GroupChat):
|
||||
def __init__(self, agents: list):
|
||||
super().__init__(agents)
|
||||
|
||||
def multi_round_conversation(self, rounds: int = 5):
|
||||
"""
|
||||
Initiate a multi-round conversation between agents.
|
||||
|
||||
Args:
|
||||
rounds (int): The number of rounds of conversation.
|
||||
"""
|
||||
for _ in range(rounds):
|
||||
# Randomly select a sender and recipient agent for the conversation
|
||||
sender_id = random.choice(list(self.agents.keys()))
|
||||
recipient_id = random.choice(list(self.agents.keys()))
|
||||
while recipient_id == sender_id: # Ensure the recipient is not the sender
|
||||
recipient_id = random.choice(list(self.agents.keys()))
|
||||
|
||||
# Generate a message (for simplicity, a generic message is used)
|
||||
message = f"Hello {recipient_id}, how are you today?"
|
||||
self.send_message(sender_id, recipient_id, message)
|
||||
|
||||
api_key = ""
|
||||
|
||||
# Sample usage with EnhancedGroupChatV2
|
||||
# Initialize the language model
|
||||
llm = OpenAIChat(
|
||||
openai_api_key=api_key,
|
||||
temperature=0.5,
|
||||
max_tokens=3000,
|
||||
)
|
||||
|
||||
agent1 = SimpleAgent("Captain Price", Flow(llm=llm, max_loops=4))
|
||||
agent2 = SimpleAgent("John Mactavis", Flow(llm=llm, max_loops=4))
|
||||
# Initialize two Flow agents
|
||||
agent1 = Flow(llm=llm, max_loops=5, dashboard=True)
|
||||
agent2 = Flow(llm=llm, max_loops=5, dashboard=True)
|
||||
|
||||
# Create a groupchat with the 2 agents
|
||||
chat = GroupChat([agent1, agent2])
|
||||
# Create an enhanced group chat with the two agents
|
||||
enhanced_group_chat_v2 = EnhancedGroupChatV2(agents=[agent1, agent2])
|
||||
|
||||
# Assign duties to the agents
|
||||
chat.assign_duty(agent1.name, "Buy the groceries")
|
||||
chat.assign_duty(agent2.name, "Clean the house")
|
||||
# Simulate multi-round agent to agent communication
|
||||
enhanced_group_chat_v2.multi_round_conversation(rounds=5)
|
||||
|
||||
# Initate a chat
|
||||
response = chat.run("Captain Price", "Hello, how are you John?")
|
||||
print(response)
|
||||
enhanced_group_chat_v2.get_message_log() # Get the conversation log
|
||||
|
@ -1,925 +0,0 @@
|
||||
import os
|
||||
import re
|
||||
import signal
|
||||
import subprocess
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Callable, Dict, List, Literal, Optional, Tuple, Union
|
||||
|
||||
from langchain.tools import tool
|
||||
from ptrace.debugger import (
|
||||
NewProcessEvent,
|
||||
ProcessExecution,
|
||||
ProcessExit,
|
||||
ProcessSignal,
|
||||
PtraceDebugger,
|
||||
PtraceProcess,
|
||||
)
|
||||
from ptrace.func_call import FunctionCallOptions
|
||||
from ptrace.syscall import PtraceSyscall
|
||||
from ptrace.tools import signal_to_exitcode
|
||||
|
||||
from swarms.tools.base import BaseToolSet, SessionGetter, ToolScope, tool
|
||||
from swarms.utils.logger import logger
|
||||
from swarms.utils.main import ANSI, Color, Style # test
|
||||
|
||||
# helpers
|
||||
PipeType = Union[Literal["stdout"], Literal["stderr"]]
|
||||
|
||||
|
||||
def verify(func):
|
||||
def wrapper(*args, **kwargs):
|
||||
try:
|
||||
filepath = args[0].filepath
|
||||
except AttributeError:
|
||||
raise Exception("This tool doesn't have filepath. Please check your code.")
|
||||
if not str(Path(filepath).resolve()).startswith(str(Path().resolve())):
|
||||
return "You can't access file outside of playground."
|
||||
return func(*args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
class SyscallTimeoutException(Exception):
|
||||
def __init__(self, pid: int, *args) -> None:
|
||||
super().__init__(f"deadline exceeded while waiting syscall for {pid}", *args)
|
||||
|
||||
|
||||
class SyscallTracer:
|
||||
def __init__(self, pid: int):
|
||||
self.debugger: PtraceDebugger = PtraceDebugger()
|
||||
self.pid: int = pid
|
||||
self.process: PtraceProcess = None
|
||||
|
||||
def is_waiting(self, syscall: PtraceSyscall) -> bool:
|
||||
if syscall.name.startswith("wait"):
|
||||
return True
|
||||
return False
|
||||
|
||||
def attach(self):
|
||||
self.process = self.debugger.addProcess(self.pid, False)
|
||||
|
||||
def detach(self):
|
||||
self.process.detach()
|
||||
self.debugger.quit()
|
||||
|
||||
def set_timer(self, timeout: int):
|
||||
def handler(signum, frame):
|
||||
raise SyscallTimeoutException(self.process.pid)
|
||||
|
||||
signal.signal(signal.SIGALRM, handler)
|
||||
signal.alarm(timeout)
|
||||
|
||||
def reset_timer(self):
|
||||
signal.alarm(0)
|
||||
|
||||
def wait_syscall_with_timeout(self, timeout: int):
|
||||
self.set_timer(timeout)
|
||||
self.process.waitSyscall()
|
||||
self.reset_timer()
|
||||
|
||||
def wait_until_stop_or_exit(self) -> Tuple[Optional[int], str]:
|
||||
self.process.syscall()
|
||||
exitcode = None
|
||||
reason = ""
|
||||
while True:
|
||||
if not self.debugger:
|
||||
break
|
||||
|
||||
try:
|
||||
self.wait_syscall_with_timeout(30)
|
||||
except ProcessExit as event:
|
||||
if event.exitcode is not None:
|
||||
exitcode = event.exitcode
|
||||
continue
|
||||
except ProcessSignal as event:
|
||||
event.process.syscall(event.signum)
|
||||
exitcode = signal_to_exitcode(event.signum)
|
||||
reason = event.reason
|
||||
continue
|
||||
except NewProcessEvent:
|
||||
continue
|
||||
except ProcessExecution:
|
||||
continue
|
||||
except Exception as e:
|
||||
reason = str(e)
|
||||
break
|
||||
|
||||
syscall = self.process.syscall_state.event(
|
||||
FunctionCallOptions(
|
||||
write_types=False,
|
||||
write_argname=False,
|
||||
string_max_length=300,
|
||||
replace_socketcall=True,
|
||||
write_address=False,
|
||||
max_array_count=20,
|
||||
)
|
||||
)
|
||||
|
||||
self.process.syscall()
|
||||
|
||||
if syscall is None:
|
||||
continue
|
||||
|
||||
if syscall.result:
|
||||
continue
|
||||
|
||||
self.reset_timer()
|
||||
|
||||
return exitcode, reason
|
||||
|
||||
|
||||
class StdoutTracer:
|
||||
def __init__(
|
||||
self,
|
||||
process: subprocess.Popen,
|
||||
timeout: int = 30,
|
||||
interval: int = 0.1,
|
||||
on_output: Callable[[PipeType, str], None] = lambda: None,
|
||||
):
|
||||
self.process: subprocess.Popen = process
|
||||
self.timeout: int = timeout
|
||||
self.interval: int = interval
|
||||
self.last_output: datetime = None
|
||||
self.on_output: Callable[[PipeType, str], None] = on_output
|
||||
|
||||
def nonblock(self):
|
||||
os.set_blocking(self.process.stdout.fileno(), False)
|
||||
os.set_blocking(self.process.stderr.fileno(), False)
|
||||
|
||||
def get_output(self, pipe: PipeType) -> str:
|
||||
output = None
|
||||
if pipe == "stdout":
|
||||
output = self.process.stdout.read()
|
||||
elif pipe == "stderr":
|
||||
output = self.process.stderr.read()
|
||||
|
||||
if output:
|
||||
decoded = output.decode()
|
||||
self.on_output(pipe, decoded)
|
||||
self.last_output = datetime.now()
|
||||
return decoded
|
||||
return ""
|
||||
|
||||
def last_output_passed(self, seconds: int) -> bool:
|
||||
return (datetime.now() - self.last_output).seconds > seconds
|
||||
|
||||
def wait_until_stop_or_exit(self) -> Tuple[Optional[int], str]:
|
||||
self.nonblock()
|
||||
self.last_output = datetime.now()
|
||||
output = ""
|
||||
exitcode = None
|
||||
while True:
|
||||
new_stdout = self.get_output("stdout")
|
||||
if new_stdout:
|
||||
output += new_stdout
|
||||
|
||||
new_stderr = self.get_output("stderr")
|
||||
if new_stderr:
|
||||
output += new_stderr
|
||||
|
||||
if self.process.poll() is not None:
|
||||
exitcode = self.process.poll()
|
||||
break
|
||||
|
||||
if self.last_output_passed(self.timeout):
|
||||
self.process.kill()
|
||||
break
|
||||
|
||||
time.sleep(self.interval)
|
||||
|
||||
return (exitcode, output)
|
||||
|
||||
|
||||
class Terminal(BaseToolSet):
|
||||
def __init__(self):
|
||||
self.sessions: Dict[str, List[SyscallTracer]] = {}
|
||||
|
||||
@tool(
|
||||
name="Terminal",
|
||||
description="Executes commands in a terminal."
|
||||
"If linux errno occurs, we have to solve the problem with the terminal. "
|
||||
"Input must be one valid command. "
|
||||
"Output will be any output from running that command.",
|
||||
scope=ToolScope.SESSION,
|
||||
)
|
||||
def execute(self, commands: str, get_session: SessionGetter) -> str:
|
||||
session, _ = get_session()
|
||||
|
||||
try:
|
||||
process = subprocess.Popen(
|
||||
commands,
|
||||
shell=True,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
)
|
||||
logger.info(ANSI("Realtime Terminal Output").to(Color.magenta()) + ": ")
|
||||
|
||||
output = ""
|
||||
tracer = StdoutTracer(
|
||||
process,
|
||||
on_output=lambda p, o: logger.info(
|
||||
ANSI(p).to(Style.dim()) + " " + o.strip("\n")
|
||||
),
|
||||
)
|
||||
exitcode, output = tracer.wait_until_stop_or_exit()
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed Terminal, Input Commands: {commands} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
#############
|
||||
|
||||
|
||||
@tool(
|
||||
name="Terminal",
|
||||
description="Executes commands in a terminal."
|
||||
"If linux errno occurs, we have to solve the problem with the terminal. "
|
||||
"Input must be one valid command. "
|
||||
"Output will be any output from running that command.",
|
||||
scope=ToolScope.SESSION,
|
||||
)
|
||||
def terminal_execute(self, commands: str, get_session: SessionGetter) -> str:
|
||||
session, _ = get_session()
|
||||
|
||||
try:
|
||||
process = subprocess.Popen(
|
||||
commands,
|
||||
shell=True,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
)
|
||||
logger.info(ANSI("Realtime Terminal Output").to(Color.magenta()) + ": ")
|
||||
|
||||
output = ""
|
||||
tracer = StdoutTracer(
|
||||
process,
|
||||
on_output=lambda p, o: logger.info(
|
||||
ANSI(p).to(Style.dim()) + " " + o.strip("\n")
|
||||
),
|
||||
)
|
||||
exitcode, output = tracer.wait_until_stop_or_exit()
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed Terminal, Input Commands: {commands} " f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
"""
|
||||
write protocol:
|
||||
|
||||
<filepath>
|
||||
<content>
|
||||
"""
|
||||
|
||||
|
||||
class WriteCommand:
|
||||
separator = "\n"
|
||||
|
||||
def __init__(self, filepath: str, content: int):
|
||||
self.filepath: str = filepath
|
||||
self.content: str = content
|
||||
self.mode: str = "w"
|
||||
|
||||
def with_mode(self, mode: str) -> "WriteCommand":
|
||||
self.mode = mode
|
||||
return self
|
||||
|
||||
@verify
|
||||
def execute(self) -> str:
|
||||
dir_path = os.path.dirname(self.filepath)
|
||||
if dir_path:
|
||||
os.makedirs(dir_path, exist_ok=True)
|
||||
with open(self.filepath, self.mode) as f:
|
||||
f.write(self.content)
|
||||
return self.content
|
||||
|
||||
@staticmethod
|
||||
def from_str(command: str) -> "WriteCommand":
|
||||
filepath = command.split(WriteCommand.separator)[0]
|
||||
return WriteCommand(filepath, command[len(filepath) + 1 :])
|
||||
|
||||
|
||||
class CodeWriter:
|
||||
@staticmethod
|
||||
def write(command: str) -> str:
|
||||
return WriteCommand.from_str(command).with_mode("w").execute()
|
||||
|
||||
@staticmethod
|
||||
def append(command: str) -> str:
|
||||
return WriteCommand.from_str(command).with_mode("a").execute()
|
||||
|
||||
|
||||
"""
|
||||
read protocol:
|
||||
|
||||
<filepath>|<start line>-<end line>
|
||||
"""
|
||||
|
||||
|
||||
class Line:
|
||||
def __init__(self, content: str, line_number: int, depth: int):
|
||||
self.__content: str = content
|
||||
self.__line_number: int = line_number
|
||||
self.__depth: int = depth
|
||||
self.__children: List[Line] = []
|
||||
|
||||
def get_content(self) -> str:
|
||||
return self.__content
|
||||
|
||||
def get_depth(self) -> int:
|
||||
return self.__depth
|
||||
|
||||
def append_child(self, child: "Line") -> None:
|
||||
self.__children.append(child)
|
||||
|
||||
def find_by_lte_depth(self, depth: int) -> List["Line"]:
|
||||
if self.__depth > depth:
|
||||
return []
|
||||
|
||||
lines: List[Line] = [self]
|
||||
for child in self.__children:
|
||||
lines += child.find_by_lte_depth(depth)
|
||||
return lines
|
||||
|
||||
def find_by_content(self, content: str) -> List["Line"]:
|
||||
if content in self.__content:
|
||||
return [self]
|
||||
|
||||
lines: List[Line] = []
|
||||
for child in self.__children:
|
||||
lines += child.find_by_content(content)
|
||||
return lines
|
||||
|
||||
def find_last_lines(self) -> List["Line"]:
|
||||
if len(self.__children) == 0:
|
||||
return [self]
|
||||
else:
|
||||
return [self, *self.__children[-1].find_last_lines()]
|
||||
|
||||
def print(self, depth: int = 0) -> None:
|
||||
print(f"{' ' * depth}{self}", end="")
|
||||
for child in self.__children:
|
||||
child.print(depth + 1)
|
||||
|
||||
def __repr__(self):
|
||||
return f"{self.__line_number}: {self.__content}"
|
||||
|
||||
|
||||
class CodeTree:
|
||||
def __init__(self):
|
||||
self.root: Line = Line("\n", -1, -1)
|
||||
|
||||
def append(self, content: str, line_number: int) -> None:
|
||||
last_lines: List[Line] = self.root.find_last_lines()
|
||||
new_leading_spaces: int = self.__get_leading_spaces(content)
|
||||
|
||||
previous_line: Line = self.root
|
||||
previous_leading_spaces: int = -1
|
||||
for line in last_lines:
|
||||
leading_spaces = self.__get_leading_spaces(line.get_content())
|
||||
if (
|
||||
previous_leading_spaces < new_leading_spaces
|
||||
and new_leading_spaces <= leading_spaces
|
||||
):
|
||||
break
|
||||
previous_line, previous_leading_spaces = line, leading_spaces
|
||||
|
||||
new_line_depth: int = previous_line.get_depth() + 1
|
||||
previous_line.append_child(Line(content, line_number, new_line_depth))
|
||||
|
||||
def find_from_root(self, depth: int) -> List[Line]:
|
||||
return self.root.find_by_lte_depth(depth)
|
||||
|
||||
def find_from_parent(self, depth: int, parent_content: str) -> List[Line]:
|
||||
lines: List[Line] = self.root.find_by_content(parent_content)
|
||||
if len(lines) == 0:
|
||||
return []
|
||||
parent = lines[0]
|
||||
return parent.find_by_lte_depth(depth + parent.get_depth())
|
||||
|
||||
def print(self):
|
||||
print("Code Tree:")
|
||||
print("=================================")
|
||||
self.root.print()
|
||||
print("=================================")
|
||||
|
||||
def __get_leading_spaces(self, content: str) -> int:
|
||||
return len(content) - len(content.lstrip())
|
||||
|
||||
|
||||
class ReadCommand:
|
||||
separator = "|"
|
||||
|
||||
def __init__(self, filepath: str, start: int, end: int):
|
||||
self.filepath: str = filepath
|
||||
self.start: int = start
|
||||
self.end: int = end
|
||||
|
||||
@verify
|
||||
def execute(self) -> str:
|
||||
with open(self.filepath, "r") as f:
|
||||
code = f.readlines()
|
||||
|
||||
if self.start == self.end:
|
||||
code = code[self.start - 1]
|
||||
else:
|
||||
code = "".join(code[self.start - 1 : self.end])
|
||||
return code
|
||||
|
||||
@staticmethod
|
||||
def from_str(command: str) -> "ReadCommand":
|
||||
filepath, line = command.split(ReadCommand.separator)
|
||||
start, end = line.split("-")
|
||||
return ReadCommand(filepath, int(start), int(end))
|
||||
|
||||
|
||||
class SummaryCommand:
|
||||
separator = "|"
|
||||
|
||||
def __init__(self, filepath: str, depth: int, parent_content: Optional[str] = None):
|
||||
self.filepath: str = filepath
|
||||
self.depth: int = depth
|
||||
self.parent_content: Optional[str] = parent_content
|
||||
|
||||
@verify
|
||||
def execute(self) -> str:
|
||||
with open(self.filepath, "r") as f:
|
||||
code = f.readlines()
|
||||
|
||||
code_tree = CodeTree()
|
||||
for i, line in enumerate(code):
|
||||
if line.strip() != "":
|
||||
code_tree.append(line, i + 1)
|
||||
|
||||
if self.parent_content is None:
|
||||
lines = code_tree.find_from_root(self.depth)
|
||||
else:
|
||||
lines = code_tree.find_from_parent(self.depth, self.parent_content)
|
||||
return "".join([str(line) for line in lines])
|
||||
|
||||
@staticmethod
|
||||
def from_str(command: str) -> "SummaryCommand":
|
||||
command_list: List[str] = command.split(SummaryCommand.separator)
|
||||
filepath: str = command_list[0]
|
||||
depth: int = int(command_list[1])
|
||||
parent_content: str | None = command_list[2] if len(command_list) == 3 else None
|
||||
return SummaryCommand(
|
||||
filepath=filepath, depth=depth, parent_content=parent_content
|
||||
)
|
||||
|
||||
|
||||
class CodeReader:
|
||||
@staticmethod
|
||||
def read(command: str) -> str:
|
||||
return ReadCommand.from_str(command).execute()
|
||||
|
||||
@staticmethod
|
||||
def summary(command: str) -> str:
|
||||
return SummaryCommand.from_str(command).execute()
|
||||
|
||||
|
||||
"""
|
||||
patch protocol:
|
||||
|
||||
<filepath>|<line>,<col>|<line>,<col>|<content>
|
||||
---~~~+++===+++~~~---
|
||||
<filepath>|<line>,<col>|<line>,<col>|<content>
|
||||
---~~~+++===+++~~~---
|
||||
...
|
||||
---~~~+++===+++~~~---
|
||||
|
||||
let say original code is:
|
||||
```
|
||||
import requests
|
||||
|
||||
def crawl_news(keyword):
|
||||
url = f"https://www.google.com/search?q={keyword}+news"
|
||||
response = requests.get(url)
|
||||
|
||||
news = []
|
||||
for result in response:
|
||||
news.append(result.text)
|
||||
|
||||
return news
|
||||
```
|
||||
|
||||
and we want to change it to:
|
||||
```
|
||||
import requests
|
||||
from bs4 import BeautifulSoup
|
||||
|
||||
def crawl_news(keyword):
|
||||
url = f"https://www.google.com/search?q={keyword}+news"
|
||||
html = requests.get(url).text
|
||||
soup = BeautifulSoup(html, "html.parser")
|
||||
news_results = soup.find_all("div", class_="BNeawe vvjwJb AP7Wnd")
|
||||
|
||||
news_titles = []
|
||||
for result in news_results:
|
||||
news_titles.append(result.text)
|
||||
|
||||
return news_titles
|
||||
```
|
||||
|
||||
then the command will be:
|
||||
test.py|2,1|2,1|from bs4 import BeautifulSoup
|
||||
|
||||
---~~~+++===+++~~~---
|
||||
test.py|5,5|5,33|html = requests.get(url).text
|
||||
soup = BeautifulSoup(html, "html.parser")
|
||||
news_results = soup.find_all("div", class_="BNeawe vvjwJb AP7Wnd")
|
||||
---~~~+++===+++~~~---
|
||||
test.py|7,5|9,13|news_titles = []
|
||||
for result in news_results:
|
||||
news_titles
|
||||
---~~~+++===+++~~~---
|
||||
test.py|11,16|11,16|_titles
|
||||
"""
|
||||
|
||||
|
||||
class Position:
|
||||
separator = ","
|
||||
|
||||
def __init__(self, line: int, col: int):
|
||||
self.line: int = line
|
||||
self.col: int = col
|
||||
|
||||
def __str__(self):
|
||||
return f"(Ln {self.line}, Col {self.col})"
|
||||
|
||||
@staticmethod
|
||||
def from_str(pos: str) -> "Position":
|
||||
line, col = pos.split(Position.separator)
|
||||
return Position(int(line) - 1, int(col) - 1)
|
||||
|
||||
|
||||
class PatchCommand:
|
||||
separator = "|"
|
||||
|
||||
def __init__(self, filepath: str, start: Position, end: Position, content: str):
|
||||
self.filepath: str = filepath
|
||||
self.start: Position = start
|
||||
self.end: Position = end
|
||||
self.content: str = content
|
||||
|
||||
def read_lines(self) -> list[str]:
|
||||
with open(self.filepath, "r") as f:
|
||||
lines = f.readlines()
|
||||
return lines
|
||||
|
||||
def write_lines(self, lines: list[str]) -> int:
|
||||
with open(self.filepath, "w") as f:
|
||||
f.writelines(lines)
|
||||
return sum([len(line) for line in lines])
|
||||
|
||||
@verify
|
||||
def execute(self) -> Tuple[int, int]:
|
||||
lines = self.read_lines()
|
||||
before = sum([len(line) for line in lines])
|
||||
|
||||
lines[self.start.line] = (
|
||||
lines[self.start.line][: self.start.col]
|
||||
+ self.content
|
||||
+ lines[self.end.line][self.end.col :]
|
||||
)
|
||||
lines = lines[: self.start.line + 1] + lines[self.end.line + 1 :]
|
||||
|
||||
after = self.write_lines(lines)
|
||||
|
||||
written = len(self.content)
|
||||
deleted = before - after + written
|
||||
|
||||
return written, deleted
|
||||
|
||||
@staticmethod
|
||||
def from_str(command: str) -> "PatchCommand":
|
||||
match = re.search(
|
||||
r"(.*)\|([0-9]*),([0-9]*)\|([0-9]*),([0-9]*)(\||\n)(.*)",
|
||||
command,
|
||||
re.DOTALL,
|
||||
)
|
||||
filepath = match.group(1)
|
||||
start_line = match.group(2)
|
||||
start_col = match.group(3)
|
||||
end_line = match.group(4)
|
||||
end_col = match.group(5)
|
||||
content = match.group(7)
|
||||
return PatchCommand(
|
||||
filepath,
|
||||
Position.from_str(f"{start_line},{start_col}"),
|
||||
Position.from_str(f"{end_line},{end_col}"),
|
||||
content,
|
||||
)
|
||||
|
||||
|
||||
class CodePatcher:
|
||||
separator = "\n---~~~+++===+++~~~---\n"
|
||||
|
||||
@staticmethod
|
||||
def sort_commands(commands: list[PatchCommand]) -> list[PatchCommand]:
|
||||
return sorted(commands, key=lambda c: c.start.line, reverse=True)
|
||||
|
||||
@staticmethod
|
||||
def patch(bulk_command: str) -> Tuple[int, int]:
|
||||
commands = [
|
||||
PatchCommand.from_str(command)
|
||||
for command in bulk_command.split(CodePatcher.separator)
|
||||
if command != ""
|
||||
]
|
||||
commands = CodePatcher.sort_commands(commands)
|
||||
|
||||
written, deleted = 0, 0
|
||||
for command in commands:
|
||||
if command:
|
||||
w, d = command.execute()
|
||||
written += w
|
||||
deleted += d
|
||||
return written, deleted
|
||||
|
||||
|
||||
class CodeEditor(BaseToolSet):
|
||||
@tool(
|
||||
name="CodeEditor.READ",
|
||||
description="Read and understand code. "
|
||||
"Input should be filename and line number group. ex. test.py|1-10 "
|
||||
"and the output will be code. ",
|
||||
)
|
||||
def read(self, inputs: str) -> str:
|
||||
try:
|
||||
output = CodeReader.read(inputs)
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.READ, Input Commands: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.SUMMARY",
|
||||
description="Summary code. "
|
||||
"Read the code structured into a tree. "
|
||||
"If you set specific line, it will show the code from the specific line. "
|
||||
"Input should be filename, depth, and specific line if you want. ex. test.py|2 or test.py|3|print('hello world') "
|
||||
"and the output will be list of (line number: code). ",
|
||||
)
|
||||
def summary(self, inputs: str) -> str:
|
||||
try:
|
||||
output = CodeReader.summary(inputs)
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.SUMMARY, Input Commands: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.APPEND",
|
||||
description="Append code to the existing file. "
|
||||
"If the code is completed, use the Terminal tool to execute it, if not, append the code through the this tool. "
|
||||
"Input should be filename and code to append. "
|
||||
"Input code must be the code that should be appended, NOT whole code. "
|
||||
"ex. test.py\nprint('hello world')\n "
|
||||
"and the output will be last 3 lines.",
|
||||
)
|
||||
def append(self, inputs: str) -> str:
|
||||
try:
|
||||
code = CodeWriter.append(inputs)
|
||||
output = "Last 3 line was:\n" + "\n".join(code.split("\n")[-3:])
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.APPEND, Input: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.WRITE",
|
||||
description="Write code to create a new tool. "
|
||||
"If the code is completed, use the Terminal tool to execute it, if not, append the code through the CodeEditor.APPEND tool. "
|
||||
"Input should be formatted like: "
|
||||
"<filename>\n<code>\n\n"
|
||||
"Here is an example: "
|
||||
"test.py\nmessage = 'hello world'\nprint(message)\n"
|
||||
"\n"
|
||||
"The output will be last 3 lines you wrote.",
|
||||
)
|
||||
def write(self, inputs: str) -> str:
|
||||
try:
|
||||
code = CodeWriter.write(inputs.lstrip())
|
||||
output = "Last 3 line was:\n" + "\n".join(code.split("\n")[-3:])
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.WRITE, Input: {inputs} " f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.PATCH",
|
||||
description="Patch the code to correct the error if an error occurs or to improve it. "
|
||||
"Input is a list of patches. The patch is separated by {seperator}. ".format(
|
||||
seperator=CodePatcher.separator.replace("\n", "\\n")
|
||||
)
|
||||
+ "Each patch has to be formatted like below.\n"
|
||||
"<filepath>|<start_line>,<start_col>|<end_line>,<end_col>|<new_code>"
|
||||
"Here is an example. If the original code is:\n"
|
||||
"print('hello world')\n"
|
||||
"and you want to change it to:\n"
|
||||
"print('hi corca')\n"
|
||||
"then the patch should be:\n"
|
||||
"test.py|1,8|1,19|hi corca\n"
|
||||
"Code between start and end will be replaced with new_code. "
|
||||
"The output will be written/deleted bytes or error message. ",
|
||||
)
|
||||
def patch(self, patches: str) -> str:
|
||||
try:
|
||||
w, d = CodePatcher.patch(patches)
|
||||
output = f"successfully wrote {w}, deleted {d}"
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.PATCH, Input Patch: {patches} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.DELETE",
|
||||
description="Delete code in file for a new start. "
|
||||
"Input should be filename."
|
||||
"ex. test.py "
|
||||
"Output will be success or error message.",
|
||||
)
|
||||
def delete(self, inputs: str, filepath: str) -> str:
|
||||
try:
|
||||
with open(filepath, "w") as f:
|
||||
f.write("")
|
||||
output = "success"
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.DELETE, Input filename: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
# ---------------- end
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.READ",
|
||||
description="Read and understand code. "
|
||||
"Input should be filename and line number group. ex. test.py|1-10 "
|
||||
"and the output will be code. ",
|
||||
)
|
||||
def code_editor_read(self, inputs: str) -> str:
|
||||
try:
|
||||
output = CodeReader.read(inputs)
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.READ, Input Commands: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.SUMMARY",
|
||||
description="Summary code. "
|
||||
"Read the code structured into a tree. "
|
||||
"If you set specific line, it will show the code from the specific line. "
|
||||
"Input should be filename, depth, and specific line if you want. ex. test.py|2 or test.py|3|print('hello world') "
|
||||
"and the output will be list of (line number: code). ",
|
||||
)
|
||||
def code_editor_summary(self, inputs: str) -> str:
|
||||
try:
|
||||
output = CodeReader.summary(inputs)
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.SUMMARY, Input Commands: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.APPEND",
|
||||
description="Append code to the existing file. "
|
||||
"If the code is completed, use the Terminal tool to execute it, if not, append the code through the this tool. "
|
||||
"Input should be filename and code to append. "
|
||||
"Input code must be the code that should be appended, NOT whole code. "
|
||||
"ex. test.py\nprint('hello world')\n "
|
||||
"and the output will be last 3 lines.",
|
||||
)
|
||||
def code_editor_append(self, inputs: str) -> str:
|
||||
try:
|
||||
code = CodeWriter.append(inputs)
|
||||
output = "Last 3 line was:\n" + "\n".join(code.split("\n")[-3:])
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.APPEND, Input: {inputs} " f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.WRITE",
|
||||
description="Write code to create a new tool. "
|
||||
"If the code is completed, use the Terminal tool to execute it, if not, append the code through the CodeEditor.APPEND tool. "
|
||||
"Input should be formatted like: "
|
||||
"<filename>\n<code>\n\n"
|
||||
"Here is an example: "
|
||||
"test.py\nmessage = 'hello world'\nprint(message)\n"
|
||||
"\n"
|
||||
"The output will be last 3 lines you wrote.",
|
||||
)
|
||||
def code_editor_write(self, inputs: str) -> str:
|
||||
try:
|
||||
code = CodeWriter.write(inputs.lstrip())
|
||||
output = "Last 3 line was:\n" + "\n".join(code.split("\n")[-3:])
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.WRITE, Input: {inputs} " f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.PATCH",
|
||||
description="Patch the code to correct the error if an error occurs or to improve it. "
|
||||
"Input is a list of patches. The patch is separated by {seperator}. ".format(
|
||||
seperator=CodePatcher.separator.replace("\n", "\\n")
|
||||
)
|
||||
+ "Each patch has to be formatted like below.\n"
|
||||
"<filepath>|<start_line>,<start_col>|<end_line>,<end_col>|<new_code>"
|
||||
"Here is an example. If the original code is:\n"
|
||||
"print('hello world')\n"
|
||||
"and you want to change it to:\n"
|
||||
"print('hi corca')\n"
|
||||
"then the patch should be:\n"
|
||||
"test.py|1,8|1,19|hi corca\n"
|
||||
"Code between start and end will be replaced with new_code. "
|
||||
"The output will be written/deleted bytes or error message. ",
|
||||
)
|
||||
def code_editor_patch(self, patches: str) -> str:
|
||||
try:
|
||||
w, d = CodePatcher.patch(patches)
|
||||
output = f"successfully wrote {w}, deleted {d}"
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.PATCH, Input Patch: {patches} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
||||
|
||||
|
||||
@tool(
|
||||
name="CodeEditor.DELETE",
|
||||
description="Delete code in file for a new start. "
|
||||
"Input should be filename."
|
||||
"ex. test.py "
|
||||
"Output will be success or error message.",
|
||||
)
|
||||
def code_editor_delete(self, inputs: str, filepath: str) -> str:
|
||||
try:
|
||||
with open(filepath, "w") as f:
|
||||
f.write("")
|
||||
output = "success"
|
||||
except Exception as e:
|
||||
output = str(e)
|
||||
|
||||
logger.debug(
|
||||
f"\nProcessed CodeEditor.DELETE, Input filename: {inputs} "
|
||||
f"Output Answer: {output}"
|
||||
)
|
||||
return output
|
@ -1,17 +0,0 @@
|
||||
from langchain.agents.agent_toolkits import FileManagementToolkit
|
||||
from tempfile import TemporaryDirectory
|
||||
|
||||
# We'll make a temporary directory to avoid clutter
|
||||
working_directory = TemporaryDirectory()
|
||||
|
||||
toolkit = FileManagementToolkit(
|
||||
root_dir=str(working_directory.name)
|
||||
) # If you don't provide a root_dir, operations will default to the current working directory
|
||||
toolkit.get_tools()
|
||||
|
||||
file_management_tools = FileManagementToolkit(
|
||||
root_dir=str(working_directory.name),
|
||||
selected_tools=["read_file", "write_file", "list_directory"],
|
||||
).get_tools()
|
||||
|
||||
read_tool, write_tool, list_tool = file_management_tools
|
Loading…
Reference in new issue