Zack Bradshaw
2 years ago
committed by
GitHub
commit
cc3e48b800
@ -0,0 +1,346 @@
|
||||
# Walkthrough Guide: Getting Started with Swarms Module's Flow Feature
|
||||
|
||||
## Introduction
|
||||
|
||||
Welcome to the walkthrough guide for beginners on using the "Flow" feature within the Swarms module. This guide is designed to help you understand and utilize the capabilities of the Flow class for seamless interactions with AI language models.
|
||||
|
||||
|
||||
### Table of Contents
|
||||
|
||||
1. **Introduction to Swarms Flow Module**
|
||||
- 1.1 What is Swarms?
|
||||
- 1.2 Understanding the Flow Module
|
||||
|
||||
2. **Setting Up Your Development Environment**
|
||||
- 2.1 Installing Required Dependencies
|
||||
- 2.2 API Key Setup
|
||||
- 2.3 Creating Your First Flow
|
||||
|
||||
3. **Creating Your First Flow**
|
||||
- 3.1 Importing Necessary Libraries
|
||||
- 3.2 Defining Constants
|
||||
- 3.3 Initializing the Flow Object
|
||||
- 3.4 Initializing the Language Model
|
||||
- 3.5 Running Your Flow
|
||||
- 3.6 Understanding Flow Options
|
||||
|
||||
4. **Advanced Flow Concepts**
|
||||
- 4.1 Custom Stopping Conditions
|
||||
- 4.2 Dynamic Temperature Handling
|
||||
- 4.3 Providing Feedback on Responses
|
||||
- 4.4 Retry Mechanism
|
||||
- 4.5 Response Filtering
|
||||
- 4.6 Interactive Mode
|
||||
|
||||
5. **Saving and Loading Flows**
|
||||
- 5.1 Saving Flow State
|
||||
- 5.2 Loading a Saved Flow
|
||||
|
||||
6. **Troubleshooting and Tips**
|
||||
- 6.1 Analyzing Feedback
|
||||
- 6.2 Troubleshooting Common Issues
|
||||
|
||||
7. **Conclusion**
|
||||
|
||||
---
|
||||
|
||||
### 1. Introduction to Swarms Flow Module
|
||||
|
||||
#### 1.1 What is Swarms?
|
||||
|
||||
Swarms is a powerful framework designed to provide tools and capabilities for working with language models and automating various tasks. It allows developers to interact with language models seamlessly.
|
||||
|
||||
## 1.2 Understanding the Flow Feature
|
||||
|
||||
### What is the Flow Feature?
|
||||
|
||||
The Flow feature is a powerful component of the Swarms framework that allows developers to create a sequential, conversational interaction with AI language models. It enables developers to build multi-step conversations, generate long-form content, and perform complex tasks using AI. The Flow class provides autonomy to language models, enabling them to generate responses in a structured manner.
|
||||
|
||||
### Key Concepts
|
||||
|
||||
Before diving into the practical aspects, let's clarify some key concepts related to the Flow feature:
|
||||
|
||||
- **Flow:** A Flow is an instance of the Flow class that represents an ongoing interaction with an AI language model. It consists of a series of steps and responses.
|
||||
|
||||
- **Stopping Condition:** A stopping condition is a criterion that, when met, allows the Flow to stop generating responses. This can be user-defined and can depend on the content of the responses.
|
||||
|
||||
- **Loop Interval:** The loop interval specifies the time delay between consecutive interactions with the AI model.
|
||||
|
||||
- **Retry Mechanism:** In case of errors or failures during AI model interactions, the Flow can be configured to make multiple retry attempts with a specified interval.
|
||||
|
||||
- **Interactive Mode:** Interactive mode allows developers to have a back-and-forth conversation with the AI model, making it suitable for real-time interactions.
|
||||
|
||||
|
||||
### 2. Setting Up Your Development Environment
|
||||
|
||||
#### 2.1 Installing Required Dependencies
|
||||
|
||||
Before you can start using the Swarms Flow module, you need to set up your development environment. First, you'll need to install the necessary dependencies, including Swarms itself.
|
||||
|
||||
```bash
|
||||
# Install Swarms and required libraries
|
||||
pip3 install --upgrade swarms
|
||||
```
|
||||
|
||||
#### 2 Creating Your First Flow
|
||||
|
||||
Now, let's create your first Flow. A Flow represents a chain-like structure that allows you to engage in multi-step conversations with language models. The Flow structure is what gives an LLM autonomy. It's the Mitochondria of an autonomous agent.
|
||||
|
||||
```python
|
||||
# Import necessary modules
|
||||
from swarms.models import OpenAIChat # Zephr, Mistral
|
||||
from swarms.structs import Flow
|
||||
|
||||
api_key = ""
|
||||
|
||||
# Initialize the language model (LLM)
|
||||
llm = OpenAIChat(openai_api_key=api_key, temperature=0.5, max_tokens=3000)
|
||||
|
||||
# Initialize the Flow object
|
||||
flow = Flow(llm=llm, max_loops=5)
|
||||
```
|
||||
|
||||
|
||||
#### 3.3 Initializing the Flow Object
|
||||
|
||||
Create a Flow object that will be the backbone of your conversational flow.
|
||||
|
||||
```python
|
||||
# Initialize the Flow object
|
||||
flow = Flow(
|
||||
llm=llm,
|
||||
max_loops=5,
|
||||
stopping_condition=None, # You can define custom stopping conditions
|
||||
loop_interval=1,
|
||||
retry_attempts=3,
|
||||
retry_interval=1,
|
||||
interactive=False, # Set to True for interactive mode
|
||||
dashboard=False, # Set to True for a dashboard view
|
||||
dynamic_temperature=False, # Enable dynamic temperature handling
|
||||
)
|
||||
```
|
||||
|
||||
#### 3.4 Initializing the Language Model
|
||||
|
||||
Initialize the language model (LLM) that your Flow will interact with. In this example, we're using OpenAI's GPT-3 as the LLM.
|
||||
|
||||
- You can also use `Mistral` or `Zephr` or any of other models!
|
||||
|
||||
```python
|
||||
# Initialize the language model (LLM)
|
||||
llm = OpenAIChat(
|
||||
openai_api_key=api_key,
|
||||
temperature=0.5,
|
||||
max_tokens=3000,
|
||||
)
|
||||
```
|
||||
|
||||
#### 3.5 Running Your Flow
|
||||
|
||||
Now, you're ready to run your Flow and start interacting with the language model.
|
||||
|
||||
If you are using a multi modality model, you can pass in the image path as another parameter
|
||||
|
||||
```python
|
||||
# Run your Flow
|
||||
out = flow.run(
|
||||
"Generate a 10,000 word blog on health and wellness.",
|
||||
# "img.jpg" , Image path for multi-modal models
|
||||
)
|
||||
|
||||
print(out)
|
||||
```
|
||||
|
||||
This code will initiate a conversation with the language model, and you'll receive responses accordingly.
|
||||
|
||||
### 4. Advanced Flow Concepts
|
||||
|
||||
In this section, we'll explore advanced concepts that can enhance your experience with the Swarms Flow module.
|
||||
|
||||
#### 4.1 Custom Stopping Conditions
|
||||
|
||||
You can define custom stopping conditions for your Flow. For example, you might want the Flow to stop when a specific word is mentioned in the response.
|
||||
|
||||
```python
|
||||
# Custom stopping condition example
|
||||
def stop_when_repeats(response: str) -> bool:
|
||||
return "Stop" in response.lower()
|
||||
|
||||
# Set the stopping condition in your Flow
|
||||
flow.stopping_condition = stop_when_repeats
|
||||
```
|
||||
|
||||
#### 4.2 Dynamic Temperature Handling
|
||||
|
||||
Dynamic temperature handling allows you to adjust the temperature attribute of the language model during the conversation.
|
||||
|
||||
```python
|
||||
# Enable dynamic temperature handling in your Flow
|
||||
flow.dynamic_temperature = True
|
||||
```
|
||||
|
||||
This feature randomly changes the temperature attribute for each loop, providing a variety of responses.
|
||||
|
||||
#### 4.3 Providing Feedback on Responses
|
||||
|
||||
You can provide feedback on responses generated by the language model using the `provide_feedback` method.
|
||||
|
||||
```python
|
||||
# Provide feedback on a response
|
||||
flow.provide_feedback("The response was helpful.")
|
||||
```
|
||||
|
||||
This feedback can be valuable for improving the quality of responses.
|
||||
|
||||
#### 4.4 Retry Mechanism
|
||||
|
||||
In case of errors or issues during conversation, you can implement a retry mechanism to attempt generating a response again.
|
||||
|
||||
```python
|
||||
# Set the number
|
||||
|
||||
of retry attempts and interval
|
||||
flow.retry_attempts = 3
|
||||
flow.retry_interval = 1 # in seconds
|
||||
```
|
||||
|
||||
#### 4.5 Response Filtering
|
||||
|
||||
You can add response filters to filter out certain words or phrases from the responses.
|
||||
|
||||
```python
|
||||
# Add a response filter
|
||||
flow.add_response_filter("inappropriate_word")
|
||||
```
|
||||
|
||||
This helps in controlling the content generated by the language model.
|
||||
|
||||
#### 4.6 Interactive Mode
|
||||
|
||||
Interactive mode allows you to have a back-and-forth conversation with the language model. When enabled, the Flow will prompt for user input after each response.
|
||||
|
||||
```python
|
||||
# Enable interactive mode
|
||||
flow.interactive = True
|
||||
```
|
||||
|
||||
This is useful for real-time conversations with the model.
|
||||
|
||||
### 5. Saving and Loading Flows
|
||||
|
||||
#### 5.1 Saving Flow State
|
||||
|
||||
You can save the state of your Flow, including the conversation history, for future use.
|
||||
|
||||
```python
|
||||
# Save the Flow state to a file
|
||||
flow.save("path/to/flow_state.json")
|
||||
```
|
||||
|
||||
#### 5.2 Loading a Saved Flow
|
||||
|
||||
To continue a conversation or reuse a Flow, you can load a previously saved state.
|
||||
|
||||
```python
|
||||
# Load a saved Flow state
|
||||
flow.load("path/to/flow_state.json")
|
||||
```
|
||||
|
||||
### 6. Troubleshooting and Tips
|
||||
|
||||
#### 6.1 Analyzing Feedback
|
||||
|
||||
You can analyze the feedback provided during the conversation to identify issues and improve the quality of interactions.
|
||||
|
||||
```python
|
||||
# Analyze feedback
|
||||
flow.analyze_feedback()
|
||||
```
|
||||
|
||||
#### 6.2 Troubleshooting Common Issues
|
||||
|
||||
If you encounter issues during conversation, refer to the troubleshooting section for guidance on resolving common problems.
|
||||
|
||||
# 7. Conclusion: Empowering Developers with Swarms Framework and Flow Structure for Automation
|
||||
|
||||
In a world where digital tasks continue to multiply and diversify, the need for automation has never been more critical. Developers find themselves at the forefront of this automation revolution, tasked with creating reliable solutions that can seamlessly handle an array of digital tasks. Enter the Swarms framework and the Flow structure, a dynamic duo that empowers developers to build autonomous agents capable of efficiently and effectively automating a wide range of digital tasks.
|
||||
|
||||
## The Automation Imperative
|
||||
|
||||
Automation is the driving force behind increased efficiency, productivity, and scalability across various industries. From mundane data entry and content generation to complex data analysis and customer support, the possibilities for automation are vast. Developers play a pivotal role in realizing these possibilities, and they require robust tools and frameworks to do so effectively.
|
||||
|
||||
## Swarms Framework: A Developer's Swiss Army Knife
|
||||
|
||||
The Swarms framework emerges as a comprehensive toolkit designed to empower developers in their automation endeavors. It equips developers with the tools and capabilities needed to create autonomous agents capable of interacting with language models, orchestrating multi-step workflows, and handling error scenarios gracefully. Let's explore why the Swarms framework is a game-changer for developers:
|
||||
|
||||
### 1. Language Model Integration
|
||||
|
||||
One of the standout features of Swarms is its seamless integration with state-of-the-art language models, such as GPT-3. These language models have the ability to understand and generate human-like text, making them invaluable for tasks like content creation, translation, code generation, and more.
|
||||
|
||||
By leveraging Swarms, developers can effortlessly incorporate these language models into their applications and workflows. For instance, they can build chatbots that provide intelligent responses to customer inquiries or generate lengthy documents with minimal manual intervention. This not only saves time but also enhances overall productivity.
|
||||
|
||||
### 2. Multi-Step Conversational Flows
|
||||
|
||||
Swarms excels in orchestrating multi-step conversational flows. Developers can define intricate sequences of interactions, where the system generates responses, and users provide input at various stages. This functionality is a game-changer for building chatbots, virtual assistants, or any application requiring dynamic and context-aware conversations.
|
||||
|
||||
These conversational flows can be tailored to handle a wide range of scenarios, from customer support interactions to data analysis. By providing a structured framework for conversations, Swarms empowers developers to create intelligent and interactive systems that mimic human-like interactions.
|
||||
|
||||
### 3. Customization and Extensibility
|
||||
|
||||
Every development project comes with its unique requirements and challenges. Swarms acknowledges this by offering a high degree of customization and extensibility. Developers can define custom stopping conditions, implement dynamic temperature handling for language models, and even add response filters to control the generated content.
|
||||
|
||||
Moreover, Swarms supports an interactive mode, allowing developers to engage in real-time conversations with the language model. This feature is invaluable for rapid prototyping, testing, and fine-tuning the behavior of autonomous agents.
|
||||
|
||||
### 4. Feedback-Driven Improvement
|
||||
|
||||
Swarms encourages the collection of feedback on generated responses. Developers and users alike can provide feedback to improve the quality and accuracy of interactions over time. This iterative feedback loop ensures that applications built with Swarms continually improve, becoming more reliable and capable of autonomously handling complex tasks.
|
||||
|
||||
### 5. Handling Errors and Retries
|
||||
|
||||
Error handling is a critical aspect of any automation framework. Swarms simplifies this process by offering a retry mechanism. In case of errors or issues during conversations, developers can configure the framework to attempt generating responses again, ensuring robust and resilient automation.
|
||||
|
||||
### 6. Saving and Loading Flows
|
||||
|
||||
Developers can save the state of their conversational flows, allowing for seamless continuity and reusability. This feature is particularly beneficial when working on long-term projects or scenarios where conversations need to be resumed from a specific point.
|
||||
|
||||
## Unleashing the Potential of Automation with Swarms and Flow
|
||||
|
||||
The combined power of the Swarms framework and the Flow structure creates a synergy that empowers developers to automate a multitude of digital tasks. These tools provide versatility, customization, and extensibility, making them ideal for a wide range of applications. Let's explore some of the remarkable ways in which developers can leverage Swarms and Flow for automation:
|
||||
|
||||
### 1. Customer Support and Service Automation
|
||||
|
||||
Swarms and Flow enable the creation of AI-powered customer support chatbots that excel at handling common inquiries, troubleshooting issues, and escalating complex problems to human agents when necessary. This level of automation not only reduces response times but also enhances the overall customer experience.
|
||||
|
||||
### 2. Content Generation and Curation
|
||||
|
||||
Developers can harness the power of Swarms and Flow to automate content generation tasks, such as writing articles, reports, or product descriptions. By providing an initial prompt, the system can generate high-quality content that adheres to specific guidelines and styles.
|
||||
|
||||
Furthermore, these tools can automate content curation by summarizing lengthy articles, extracting key insights from research papers, and even translating content into multiple languages.
|
||||
|
||||
### 3. Data Analysis and Reporting
|
||||
|
||||
Automation in data analysis and reporting is fundamental for data-driven decision-making. Swarms and Flow simplify these processes by enabling developers to create flows that interact with databases, query data, and generate reports based on user-defined criteria. This empowers businesses to derive insights quickly and make informed decisions.
|
||||
|
||||
### 4. Programming and Code Generation
|
||||
|
||||
Swarms and Flow streamline code generation and programming tasks. Developers can create flows to assist in writing code snippets, auto-completing code, or providing solutions to common programming challenges. This accelerates software development and reduces the likelihood of coding errors.
|
||||
|
||||
### 5. Language Translation and Localization
|
||||
|
||||
With the ability to interface with language models, Swarms and Flow can automate language translation tasks. They can seamlessly translate content from one language to another, making it easier for businesses to reach global audiences and localize their offerings effectively.
|
||||
|
||||
### 6. Virtual Assistants and AI Applications
|
||||
|
||||
Developers can build virtual assistants and AI applications that offer personalized experiences. These applications can automate tasks such as setting reminders, answering questions, providing recommendations, and much more. Swarms and Flow provide the foundation for creating intelligent, interactive virtual assistants.
|
||||
|
||||
## Future Opportunities and Challenges
|
||||
|
||||
As Swarms and Flow continue to evolve, developers can look forward to even more advanced features and capabilities. However, with great power comes great responsibility. Developers must remain vigilant about the ethical use of automation and language models. Ensuring that automated systems provide accurate and unbiased information is an ongoing challenge that the developer community must address.
|
||||
|
||||
## In Conclusion
|
||||
|
||||
The Swarms framework and the Flow structure empower developers to automate an extensive array of digital tasks by offering versatility, customization, and extensibility. From natural language understanding and generation to orchestrating multi-step conversational flows, these tools simplify complex automation scenarios.
|
||||
|
||||
By embracing Swarms and Flow, developers can not only save time and resources but also unlock new opportunities for innovation. The ability to harness the power of language models and create intelligent, interactive applications opens doors to a future where automation plays a pivotal role in our digital lives.
|
||||
|
||||
As the developer community continues to explore the capabilities of Swarms and Flow, it is essential to approach automation with responsibility, ethics, and a commitment to delivering valuable, user-centric experiences. With Swarms and Flow, the future of automation is in the hands of developers, ready to create a more efficient, intelligent, and automated world.
|
||||
@ -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