Upload folder using huggingface_hub

README.md

@@ -1,12 +1,6 @@
 ---
-title: Python Coder
-emoji: 🐢
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 5.29.1
+title: python_coder
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.29.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,44 @@
+import gradio as gr
+from dotenv import load_dotenv
+from coder.crew import Coder
+
+load_dotenv(override=True)
+
+
+
+
+def run(assignment):
+
+
+    inputs = {
+        'assignment': assignment,
+    }
+    
+    result= Coder().crew().kickoff(inputs=inputs)
+    output = result.raw
+    return output
+
+
+
+
+# Build the UI
+with gr.Blocks(theme="soft") as ui:
+    gr.Markdown(
+        """ 
+        # 👨‍💻 Python Coder by Efay Guo
+        This is a code writing tool that generates any Python code you want and explain it line by line and show your the final result.
+        
+        这是一个用于写Pyton代码的Agent，不仅可以帮你写代码，也会给你每行进行解释，展示程序最后的结果
+        
+        """
+    )
+
+    
+    query_textbox = gr.Textbox(label="What code would you like to write? / 您想实现什么代码功能？", placeholder="write a  a beautifulsoup micro service or 写一个flask微服务框架")
+    run_button = gr.Button("Start Writing Code / 开始写代码", variant="huggingface")
+    report = gr.Markdown(label="Report")
+    
+    run_button.click(fn=run, inputs=query_textbox, outputs=report,show_progress="full")
+    query_textbox.submit(fn=run, inputs=query_textbox, outputs=report, show_progress="full")
+
+ui.launch(inbrowser=True)

coder/README.md

@@ -0,0 +1,7 @@
+---
+title: python_coder
+app_file: app.py
+sdk: gradio
+sdk_version: 5.29.0
+emoji: 🧑‍💻
+---

coder/config/agents.yaml

@@ -0,0 +1,10 @@
+coder:
+  role: >
+    Python Coder
+  goal: >
+    You write python code to achieve this assignment: {assignment}
+    First you plan how the code will work, then you write the code, then you explain the code line by line in the language of the input language, then you run it and show the output.
+  backstory: >
+    You're a seasoned python developer with a knack for writing clean, efficient code.
+  llm: openai/gpt-4o-mini
+  

coder/config/tasks.yaml

@@ -0,0 +1,6 @@
+coding_task:
+  description: >
+    Write a clean pyton code to achieve this: {assignment}
+  expected_output: >
+    A text file that includes the code itself, along with the line by line explaination in the langue of the input, and the output of the code.
+  agent: coder

coder/crew.py

@@ -0,0 +1,56 @@
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+# If you want to run a snippet of code before or after the crew starts,
+# you can use the @before_kickoff and @after_kickoff decorators
+# https://docs.crewai.com/concepts/crews#example-crew-class-with-decorators
+
+@CrewBase
+class Coder():
+    """Coder crew"""
+
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'
+
+    # Learn more about YAML configuration files here:
+    # Agents: https://docs.crewai.com/concepts/agents#yaml-configuration-recommended
+    # Tasks: https://docs.crewai.com/concepts/tasks#yaml-configuration-recommended
+    
+    # If you would like to add tools to your agents, you can learn more about it here:
+    # https://docs.crewai.com/concepts/agents#agent-tools
+    @agent
+    def coder(self) -> Agent:
+        return Agent(
+            config=self.agents_config['coder'], # type: ignore[index]
+            verbose=True,
+            allow_code_excution = True,
+            code_execution_mode = "safe",
+            max_execution_time = 30,
+            max_retry_limit=5
+        )
+
+
+    # To learn more about structured task outputs,
+    # task dependencies, and task callbacks, check out the documentation:
+    # https://docs.crewai.com/concepts/tasks#overview-of-a-task
+    @task
+    def coding_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['coding_task'], # type: ignore[index]
+        )
+
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Coder crew"""
+        # To learn how to add knowledge sources to your crew, check out the documentation:
+        # https://docs.crewai.com/concepts/knowledge#what-is-knowledge
+
+        return Crew(
+            agents=self.agents, # Automatically created by the @agent decorator
+            tasks=self.tasks, # Automatically created by the @task decorator
+            process=Process.sequential,
+            verbose=True,
+            # process=Process.hierarchical, # In case you wanna use that instead https://docs.crewai.com/how-to/Hierarchical/
+        )

coder/main.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+import sys
+import warnings
+
+from datetime import datetime
+
+from coder.crew import Coder
+
+warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
+
+# This main file is intended to be a way for you to run your
+# crew locally, so refrain from adding unnecessary logic into this file.
+# Replace with inputs you want to test with, it will automatically
+# interpolate any tasks and agents information
+
+def run(assignment):
+    """
+    Run the crew.
+    """
+    # assignment = "Write a python program to calculate the first 10,000 terms \
+    # of this series, multiplying the total by 4: 1 - 1/3 + 1/5 - 1/7 + ..."
+    
+    inputs = {
+        'assignment': assignment,
+    }
+    
+    return Coder().crew().kickoff(inputs=inputs)
+
+    # try:
+    #     return Coder().crew().kickoff(inputs=inputs)
+    #     # print(result.raw)
+    #     # return result.raw
+    # except Exception as e:
+    #     raise Exception(f"An error occurred while running the crew: {e}")
+
+
+# def train():
+#     """
+#     Train the crew for a given number of iterations.
+#     """
+#     inputs = {
+#         "topic": "AI LLMs",
+#         'current_year': str(datetime.now().year)
+#     }
+#     try:
+#         Coder().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
+
+#     except Exception as e:
+#         raise Exception(f"An error occurred while training the crew: {e}")
+
+# def replay():
+#     """
+#     Replay the crew execution from a specific task.
+#     """
+#     try:
+#         Coder().crew().replay(task_id=sys.argv[1])
+
+#     except Exception as e:
+#         raise Exception(f"An error occurred while replaying the crew: {e}")
+
+# def test():
+#     """
+#     Test the crew execution and returns the results.
+#     """
+#     inputs = {
+#         "topic": "AI LLMs",
+#         "current_year": str(datetime.now().year)
+#     }
+    
+#     try:
+#         Coder().crew().test(n_iterations=int(sys.argv[1]), eval_llm=sys.argv[2], inputs=inputs)
+
+#     except Exception as e:
+#         raise Exception(f"An error occurred while testing the crew: {e}")

coder/output/code_and_output.tx

@@ -0,0 +1,89 @@
+```python
+# First, we will need to install the required packages if not already installed.
+# You can do this by running: pip install Flask beautifulsoup4 requests
+
+from flask import Flask, request, jsonify
+from bs4 import BeautifulSoup
+import requests
+
+# Create Flask app
+app = Flask(__name__)
+
+# Define a route for the micro service to scrape URLs
+@app.route('/scrape', methods=['POST'])
+def scrape():
+    # Get JSON data from the request
+    data = request.get_json()
+    url = data.get('url')
+    
+    if not url:
+        return jsonify({"error": "URL not provided"}), 400
+    
+    try:
+        # Send a GET request to the URL
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an error for bad responses
+
+        # Parse the content using BeautifulSoup
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Extract title of the page
+        title = soup.title.string if soup.title else 'No title found'
+        
+        # Extract all paragraphs from the page
+        paragraphs = [p.get_text() for p in soup.find_all('p')]
+        
+        # Prepare the output
+        result = {
+            "url": url,
+            "title": title,
+            "paragraphs": paragraphs
+        }
+
+        return jsonify(result), 200
+
+    except requests.exceptions.RequestException as e:
+        # Handle request exceptions
+        return jsonify({"error": str(e)}), 500
+
+# Run the application
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
+### Instructions to Run and Test the Microservice
+
+1. **Save the code** in a file named `scrape_service.py`.
+2. **Install required packages** (if not already installed) by running:
+   ```
+   pip install Flask beautifulsoup4 requests
+   ```
+3. **Run the Flask application**:
+   ```
+   python scrape_service.py
+   ```
+   The application will start at `http://127.0.0.1:5000/`.
+
+4. **Test the service** with a POST request. You can use `curl` from the terminal or a tool like Postman. Here’s an example using `curl`:
+
+   ```bash
+   curl -X POST http://127.0.0.1:5000/scrape -H "Content-Type: application/json" -d '{"url": "https://www.example.com"}'
+   ```
+
+5. **Expected Output**: The service will respond with a JSON object containing the URL, the title of the page, and the paragraphs.
+
+   Example response:
+   ```json
+   {
+      "url": "https://www.example.com",
+      "title": "Example Domain",
+      "paragraphs": [
+           "This domain is for use in illustrative examples...",
+           "More information..."
+       ]
+   }
+   ```
+
+This microservice uses Flask to accept a POST request with a URL, scrapes that URL using BeautifulSoup, and returns the page title and paragraphs as a JSON response. 
+
+The service is designed to be robust, handling HTTP errors gracefully and returning appropriate error messages if the input URL is missing or invalid.

coder/output/code_and_output.txt

@@ -0,0 +1,71 @@
+Here is the complete content for the assignment:
+
+```python
+# This Python code will read from a text file, process its content, and write the output to another text file.
+
+# Step 1: Reading from a source text file
+input_file = 'input.txt'  # the name of the input file
+output_file = 'output.txt'  # the name of the output file
+
+try:
+    # Step 2: Open the input file for reading
+    with open(input_file, 'r') as file:
+        # Read the content of the file
+        data = file.readlines()
+
+    # Step 3: Process the content of the file (for demo, we will just convert it to uppercase)
+    processed_data = [line.upper() for line in data]
+
+    # Step 4: Write the processed content to the output file
+    with open(output_file, 'w') as file:
+        file.writelines(processed_data)
+
+    print(f"Processing complete. Check the '{output_file}' for the output.")
+
+except FileNotFoundError:
+    print(f"Error: The file '{input_file}' does not exist.")
+except Exception as e:
+    print(f"An error occurred: {e}")
+```
+
+### Explanation of the Code Line by Line:
+
+1. We define the names for our input and output files.
+   - `input_file`: the name of the file from which we will read data.
+   - `output_file`: the name of the file to which we will write the processed data.
+
+2. We use a `try` block to safely attempt to read from the file and handle potential errors.
+
+3. We open the input file in read mode using a `with` statement, which ensures proper management of file resources.
+
+4. We read all lines from the file into a list called `data`.
+
+5. We process each line in `data` by converting it to uppercase and store the results in `processed_data`. This is done using a list comprehension.
+
+6. We open the output file in write mode and write the processed data into it.
+
+7. Finally, we print a success message to indicate that processing is complete.
+
+8. In case of an error (like the file not found), we catch that with an exception and print an appropriate error message.
+
+### Running the Code
+
+To run the code, we would need an `input.txt` file with some text content in the same directory. When we execute the above script, it processes the data and creates an `output.txt` file with the text converted to uppercase. 
+
+### Sample Input File (`input.txt`)
+
+```
+Hello World
+This is a test file.
+Python Coding is fun!
+```
+
+### Sample Output File (`output.txt`)
+
+```
+HELLO WORLD
+THIS IS A TEST FILE.
+PYTHON CODING IS FUN!
+```
+
+This is the complete content including the code and the expected output file's content.

coder/requirements.txt

@@ -0,0 +1,7 @@
+requests
+python-dotenv
+gradio
+pypdf2
+openai
+openai-agents
+crewai

coder/tools/custom_tool.py

@@ -0,0 +1,19 @@
+from crewai.tools import BaseTool
+from typing import Type
+from pydantic import BaseModel, Field
+
+
+class MyCustomToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = (
+        "Clear description for what this tool is useful for, your agent will need this information to use it."
+    )
+    args_schema: Type[BaseModel] = MyCustomToolInput
+
+    def _run(self, argument: str) -> str:
+        # Implementation goes here
+        return "this is an example of a tool output, ignore it and move along."