Create app.py

app.py

@@ -0,0 +1,261 @@
+import fastapi
+from typing import Optional, Dict, Any
+import copy
+import requests
+import json
+import os
+import sys
+from io import StringIO
+import ctypes
+import subprocess
+import logging
+from pathlib import Path
+from llama_cpp import Llama
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import random
+import time
+import inspect
+# Load model directly
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+tokenizer = AutoTokenizer.from_pretrained("meetkai/functionary-small-v3.1", trust_remote_code=True)
+model_path = AutoModelForCausalLM.from_pretrained("meetkai/functionary-small-v3.1", trust_remote_code=True)
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class Tool(fastapi.FastAPI):
+    def __init__(
+            self,
+            tool_name: str,
+            description: str,
+            name_for_human: Optional[str] = None,
+            name_for_model: Optional[str] = None,
+            description_for_human: Optional[str] = None,
+            description_for_model: Optional[str] = None,
+            logo_url: Optional[str] = None,
+            author_github: Optional[str] = None,
+            contact_email: str = "",
+            legal_info_url: str = "",
+            version: str = "0.1.0",
+        ):
+        super().__init__(
+            title=tool_name,
+            description=description,
+            version=version,
+        )
+
+        if name_for_human is None:
+            name_for_human = tool_name
+        if name_for_model is None:
+            name_for_model = name_for_human
+        if description_for_human is None:
+            description_for_human = description
+        if description_for_model is None:
+            description_for_model = description_for_human
+        
+        self.api_info = {
+            "schema_version": "v1",
+            "name_for_human": name_for_human,
+            "name_for_model": name_for_model,
+            "description_for_human": description_for_human,
+            "description_for_model": description_for_model,
+            "auth": {
+                "type": "none",
+            },
+            "api": {
+                "type": "openapi",
+                "url": "/openapi.json",
+                "is_user_authenticated": False,
+            },
+            "author_github": author_github,
+            "logo_url": logo_url,
+            "contact_email": contact_email,
+            "legal_info_url": legal_info_url,
+        }
+
+        @self.get("/.well-known/ai-plugin.json", include_in_schema=False)
+        def get_api_info(request: fastapi.Request):
+            openapi_path = str(request.url).replace("/.well-known/ai-plugin.json", "/openapi.json")
+            info = copy.deepcopy(self.api_info)
+            info["api"]["url"] = str(openapi_path)
+            return info
+
+class SelfLearningTool:
+    def __init__(self):
+        self.tools = {}
+
+    def add_tool(self, name: str, func: callable):
+        self.tools[name] = func
+
+    def use_tool(self, name: str, *args, **kwargs):
+        if name in self.tools:
+            return self.tools[name](*args, **kwargs)
+        else:
+            return f"Tool '{name}' not found."
+
+    def list_tools(self):
+        return list(self.tools.keys())
+
+    def remove_tool(self, name: str):
+        if name in self.tools:
+            del self.tools[name]
+            return f"Tool '{name}' removed successfully."
+        else:
+            return f"Tool '{name}' not found."
+
+class PythonREPL:
+    def __init__(self):
+        self.globals = {}
+        self.locals = {}
+        self.output_buffer = StringIO()
+        self.self_learning_tool = SelfLearningTool()
+
+    def run(self, command: str) -> str:
+        old_stdout = sys.stdout
+        sys.stdout = self.output_buffer
+        try:
+            exec(command, self.globals, self.locals)
+            output = self.output_buffer.getvalue()
+        except Exception as e:
+            output = f"Error: {repr(e)}"
+        finally:
+            sys.stdout = old_stdout
+            self.output_buffer.truncate(0)
+            self.output_buffer.seek(0)
+        return output
+
+    def add_tool(self, name: str, func: callable):
+        self.self_learning_tool.add_tool(name, func)
+
+    def use_tool(self, name: str, *args, **kwargs):
+        return self.self_learning_tool.use_tool(name, *args, **kwargs)
+
+    def list_tools(self):
+        return self.self_learning_tool.list_tools()
+
+    def remove_tool(self, name: str):
+        return self.self_learning_tool.remove_tool(name)
+
+    def self_reflect(self):
+        reflection = "Self-reflection:\n"
+        reflection += f"Number of defined variables: {len(self.locals)}\n"
+        reflection += f"Number of available tools: {len(self.list_tools())}\n"
+        reflection += "Available tools:\n"
+        for tool in self.list_tools():
+            reflection += f"- {tool}\n"
+        return reflection
+
+    def self_inspect(self):
+        inspection = "Self-inspection:\n"
+        for name, value in self.locals.items():
+            inspection += f"{name}: {type(value)}\n"
+            if callable(value):
+                try:
+                    signature = inspect.signature(value)
+                    inspection += f"  Signature: {signature}\n"
+                except ValueError:
+                    inspection += "  Signature: Unable to inspect\n"
+        return inspection
+
+def initialize_llm(model_path: str, n_ctx: int, n_threads: int = 4, n_batch: int = 512) -> Llama:
+    try:
+        return Llama(model_path=model_path, n_ctx=n_ctx, n_threads=n_threads, n_batch=n_batch, verbose=True)
+    except Exception as e:
+        logger.error(f"Failed to initialize LLM: {e}")
+        raise
+
+llm = initialize_llm('../models/lil.gguf', 4096)
+
+def build_tool(config) -> Tool:
+    tool = Tool(
+        "Advanced Python REPL",
+        "Execute sophisticated Python commands with self-learning capabilities",
+        name_for_model="Advanced Python REPL",
+        description_for_model=(
+            "An advanced Python shell for executing complex Python commands. "
+            "Input should be a valid Python command or script. "
+            "Use print(...) to see the output of expressions. "
+            "Capable of handling multi-line code, advanced Python features, "
+            "and self-learning tools."
+        ),
+        logo_url="https://your-app-url.com/.well-known/logo.png",
+        contact_email="hello@contact.com",
+        legal_info_url="hello@legal.com"
+    )
+    
+    python_repl = PythonREPL()
+    
+    def sanitize_input(query: str) -> str:
+        return query.strip().strip("```").strip()
+
+    @tool.get("/run_python")
+    def run_python(query: str):
+        sanitized_query = sanitize_input(query)
+        result = python_repl.run(sanitized_query)
+        return {"result": result, "execution_time": time.time()}
+    
+    @tool.get("/add_tool")
+    def add_tool(name: str, code: str):
+        sanitized_code = sanitize_input(code)
+        try:
+            exec(f"def {name}({sanitized_code})", python_repl.globals, python_repl.locals)
+            python_repl.add_tool(name, python_repl.locals[name])
+            return f"Tool '{name}' added successfully."
+        except Exception as e:
+            return f"Error adding tool: {str(e)}"
+
+    @tool.get("/use_tool")
+    def use_tool(name: str, args: str):
+        try:
+            result = python_repl.use_tool(name, *eval(args))
+            return {"result": result}
+        except Exception as e:
+            return {"error": str(e)}
+
+    @tool.get("/list_tools")
+    def list_tools():
+        return {"tools": python_repl.list_tools()}
+
+    @tool.get("/remove_tool")
+    def remove_tool(name: str):
+        return {"result": python_repl.remove_tool(name)}
+
+    @tool.get("/self_reflect")
+    def self_reflect():
+        return {"reflection": python_repl.self_reflect()}
+
+    @tool.get("/self_inspect")
+    def self_inspect():
+        return {"inspection": python_repl.self_inspect()}
+
+    @tool.get("/write_file")
+    def write_file(file_path: str, text: str) -> str:
+        write_path = Path(file_path)
+        try:
+            write_path.parent.mkdir(exist_ok=True, parents=False)
+            with write_path.open("w", encoding="utf-8") as f:
+                f.write(text)
+            return f"File written successfully to {file_path}."
+        except Exception as e:
+            return "Error: " + str(e)
+        
+    @tool.get("/read_file")
+    def read_file(file_path: str) -> str:
+        read_path = Path(file_path)
+        try:
+            with read_path.open("r", encoding="utf-8") as f:
+                content = f.read()
+            return content
+        except Exception as e:
+            return "Error: " + str(e)
+
+    return tool
+
+if __name__ == "__main__":
+    config = {}  # Add any necessary configuration
+    advanced_python_repl = build_tool(config)
+    
+    # Run the FastAPI server
+    import uvicorn
+    uvicorn.run(advanced_python_repl, host="0.0.0.0", port=8000)