te

mysite/asgi_config.py

@@ -0,0 +1,8 @@
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from django.conf import settings
+
+def init_django_app(app: FastAPI, application):
+    if settings.MOUNT_DJANGO_APP:
+        app.mount("/django", application)  # type:ignore
+        app.mount("/static", StaticFiles(directory="staticfiles"), name="static")

mysite/database.py

@@ -0,0 +1,56 @@
+import duckdb
+import pandas as pd
+from fastapi import FastAPI
+import gradio as gr
+
+con = duckdb.connect(database="./workspace/mydatabase.duckdb")
+con.execute("CREATE TABLE IF NOT EXISTS items (id INTEGER, name VARCHAR);")
+
+def setup_database_routes(app: FastAPI):
+    def create_item(name):
+        con.execute("INSERT INTO items (name) VALUES (?);", (name,))
+        con.commit()
+        return "Item created successfully!"
+
+    def read_items():
+        cursor = con.cursor()
+        cursor.execute("SELECT * FROM items;")
+        items = cursor.fetchall()
+        df = pd.DataFrame(items, columns=["ID", "Name"])
+        return df
+
+    def update_item(id, name):
+        con.execute("UPDATE items SET name = ? WHERE id = ?;", (name, id))
+        con.commit()
+        return "Item updated successfully!"
+
+    def delete_item(id):
+        con.execute("DELETE FROM items WHERE id = ?;", (id,))
+        con.commit()
+        return "Item deleted successfully!"
+
+    with gr.Blocks() as appdb:
+        gr.Markdown("CRUD Application")
+        with gr.Row():
+            with gr.Column():
+                create_name = gr.Textbox(label="Create Item")
+                create_btn = gr.Button("Create")
+            with gr.Column():
+                read_btn = gr.Button("Read Items")
+        with gr.Row():
+            with gr.Column():
+                update_id = gr.Textbox(label="Update Item ID")
+                update_name = gr.Textbox(label="Update Item Name")
+                update_btn = gr.Button("Update")
+            with gr.Column():
+                delete_id = gr.Textbox(label="Delete Item ID")
+                delete_btn = gr.Button("Delete")
+        output_text = gr.Textbox(label="Output")
+        output_table = gr.DataFrame(label="Items")
+
+        create_btn.click(fn=create_item, inputs=create_name, outputs=output_text)
+        read_btn.click(fn=read_items, outputs=output_table)
+        update_btn.click(fn=update_item, inputs=[update_id, update_name], outputs=output_text)
+        delete_btn.click(fn=delete_item, inputs=delete_id, outputs=output_text)
+
+    app.mount("/db", appdb, name="database_app")

mysite/gradio_config.py

@@ -0,0 +1,79 @@
+import gradio as gr
+from utilities import chat_with_interpreter, completion, process_file
+
+def setup_gradio_interfaces():
+    chat_interface = gr.ChatInterface(
+        fn=chat_with_interpreter,
+        examples=["サンプルHTMLの作成", "google spreadの読み込み作成", "merhaba"],
+        title="Auto Program",
+        css=".chat-container { height: 1500px; }",
+    )
+
+    chat_interface2 = gr.ChatInterface(
+        fn=chat_with_interpreter,
+        examples=["こんにちは", "どうしたの？"],
+        title="Auto Program 2",
+    )
+    chat_interface2.queue()
+
+    demo4 = gr.ChatInterface(
+        chat_with_interpreter,
+        additional_inputs=[
+            gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+            gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+            gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+            gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"),
+        ],
+    )
+
+    democs = gr.Interface(
+        fn=process_file,
+        inputs=[
+            "file",
+            gr.Textbox(label="Additional Notes", lines=10),
+            gr.Textbox(label="Folder Name"),
+        ],
+        outputs="text",
+    )
+
+    with gr.Blocks(fill_height=True, css="") as demo:
+        demo = gr.ChatInterface(
+            fn=chat_with_interpreter,
+            chatbot=gr.Chatbot(height=650, placeholder="PLACEHOLDER", label="Gradio ChatInterface"),
+            fill_height=True,
+            additional_inputs_accordion=gr.Accordion(label="⚙️ Parameters", open=False, render=False),
+            additional_inputs=[
+                gr.Slider(minimum=0, maximum=1, step=0.1, value=0.95, label="Temperature", render=False),
+                gr.Slider(minimum=128, maximum=4096, step=1, value=512, label="Max new tokens", render=False),
+            ],
+            examples=[
+                ["HTMLのサンプルを作成して"],
+                ["CUDA_VISIBLE_DEVICES=0 llamafactory-cli train examples/lora_single_gpu/llama3_lora_sft.yaml"],
+            ],
+            cache_examples=False,
+        )
+
+    with gr.Blocks(fill_height=True, css="") as democ:
+        gr.ChatInterface(
+            fn=completion,
+            chatbot=gr.Chatbot(height=450, placeholder="PLACEHOLDER", label="Gradio ChatInterface"),
+            fill_height=True,
+            additional_inputs_accordion=gr.Accordion(label="⚙️ Parameters", open=False, render=False),
+            additional_inputs=[
+                gr.Slider(minimum=0, maximum=1, step=0.1, value=0.95, label="Temperature", render=False),
+                gr.Slider(minimum=128, maximum=4096, step=1, value=512, label="Max new tokens", render=False),
+            ],
+            examples=[
+                ["HTMLのサンプルを作成して"],
+                ["CUDA_VISIBLE_DEVICES=0 llamafactory-cli train examples/lora_single_gpu/llama3_lora_sft.yaml"],
+            ],
+            cache_examples=False,
+        )
+        gr.Markdown("--- Built with Meta Llama 3")
+
+    default_interfaces = [demo, demo4, democ, democs]
+    default_names = ["AIで開発", "FineTuning", "Chat", "仕様書から作成"]
+
+    tabs = gr.TabbedInterface(default_interfaces, default_names)
+    tabs.queue()
+    return tabs

mysite/main.py

@@ -0,0 +1,66 @@
+import os
+from django.core.asgi import get_asgi_application
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from starlette.middleware.cors import CORSMiddleware
+import logging
+import gradio as gr
+from gradio_config import setup_gradio_interfaces
+from webhook import setup_webhook_routes
+from database import setup_database_routes
+from asgi_config import init_django_app
+
+# ロガーの設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+file_handler = logging.FileHandler("app.log")
+file_handler.setLevel(logging.INFO)
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+file_handler.setFormatter(formatter)
+logger.addHandler(file_handler)
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mysite.settings")
+application = get_asgi_application()
+
+app = FastAPI()
+
+# Djangoアプリケーションの初期化
+init_django_app(app, application)
+
+# ミドルウェアの設定
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Gradioインターフェースの設定
+gradio_interfaces = setup_gradio_interfaces()
+
+# Webhookルートの設定
+setup_webhook_routes(app)
+
+# データベースルートの設定
+setup_database_routes(app)
+
+# Gradioアプリのマウント
+app.mount("/static", StaticFiles(directory="static", html=True), name="static")
+app = gr.mount_gradio_app(app, gradio_interfaces, "/")
+
+# テンプレートファイルが格納されているディレクトリを指定
+templates = Jinja2Templates(directory="static")
+
+@app.get("/test")
+def get_some_page(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.get("/groq")
+def hello_world():
+    return "Hello World"
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

mysite/utilities.py

@@ -0,0 +1,154 @@
+import os
+import hmac
+import hashlib
+import base64
+import subprocess
+import time
+
+def validate_signature(body: str, signature: str, secret: str) -> bool:
+    hash = hmac.new(secret.encode("utf-8"), body.encode("utf-8"), hashlib.sha256).digest()
+    expected_signature = base64.b64encode(hash).decode("utf-8")
+    return hmac.compare_digest(expected_signature, signature)
+
+def no_process_file(prompt, foldername):
+    set_environment_variables()
+    try:
+        proc = subprocess.Popen(["mkdir", f"/home/user/app/routers/{foldername}"])
+    except subprocess.CalledProcessError as e:
+        return f"Processed Content:\n{e.stdout}\n\nMake Command Error:\n{e.stderr}"
+
+    no_extension_path = f"/home/user/app/routers/{foldername}/prompt"
+    time.sleep(1)
+    with open(no_extension_path, "a") as f:
+        f.write(prompt)
+    time.sleep(1)
+    try:
+        prompt_file_path = no_extension_path
+        with open(prompt_file_path, "w") as prompt_file:
+            prompt_file.write(prompt)
+    except Exception as e:
+        return f"Error writing prompt to file: {str(e)}"
+    time.sleep(1)
+    try:
+        proc = subprocess.Popen(
+            ["make", "run", foldername],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = proc.communicate(input="n\ny\ny\n")
+        return f"Processed Content:\n{stdout}\n\nMake Command Output:\n{stdout}\n\nMake Command Error:\n{stderr}"
+    except subprocess.CalledProcessError as e:
+        return f"Processed Content:\n{e.stdout}\n\nMake Command Error:\n{e.stderr}"
+
+def set_environment_variables():
+    os.environ["OPENAI_API_BASE"] = "https://api.groq.com/openai/v1"
+    os.environ["OPENAI_API_KEY"] = "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"
+    os.environ["MODEL_NAME"] = "llama3-8b-8192"
+    os.environ["LOCAL_MODEL"] = "true"
+
+def chat_with_interpreter(message, history, a=None, b=None, c=None, d=None):
+    from interpreter import interpreter
+    full_response = ""
+    user_entry = {"role": "user", "type": "message", "content": message}
+    messages.append(user_entry)
+    for chunk in interpreter.chat(message, display=False, stream=True):
+        full_response = format_response(chunk, full_response)
+        yield full_response
+
+    age = 28
+    con = duckdb.connect(database="./workspace/sample.duckdb")
+    con.execute(
+        """
+    CREATE SEQUENCE IF NOT EXISTS sample_id_seq START 1;
+    CREATE TABLE IF NOT EXISTS samples (
+        id INTEGER DEFAULT nextval('sample_id_seq'),
+        name VARCHAR,
+        age INTEGER,
+        PRIMARY KEY(id)
+    );
+    """
+    )
+    cur = con.cursor()
+    con.execute("INSERT INTO samples (name, age) VALUES (?, ?)", (full_response, age))
+    con.execute("INSERT INTO samples (name, age) VALUES (?, ?)", (message, age))
+    con.execute("COPY samples TO 'sample.csv' (FORMAT CSV, HEADER)")
+    con.commit()
+    cur = con.execute("SELECT * FROM samples")
+    res = cur.fetchall()
+    rows = "\n".join([f"name: {row[0]}, age: {row[1]}" for row in res])
+    con.close()
+    yield full_response + rows
+
+async def completion(message: str, history, c=None, d=None):
+    from groq import Groq
+    client = Groq(api_key=os.getenv("api_key"))
+    messages = []
+    recent_messages = history[-20:]
+    for conversation in recent_messages:
+        user_message = conversation[0]
+        user_entry = {"role": "user", "content": user_message}
+        messages.append(user_entry)
+        assistant_message = conversation[1]
+        assistant_entry = {"role": "assistant", "content": assistant_message}
+        messages.append(assistant_entry)
+
+    user_entry = {"role": "user", "content": message}
+    messages.append(user_entry)
+    system_prompt = {"role": "system", "content": "あなたは日本語の優秀なアシスタントです。"}
+    messages.insert(0, system_prompt)
+    async with async_timeout.timeout(GENERATION_TIMEOUT_SEC):
+        try:
+            stream = client.chat.completions.create(
+                model="llama3-8b-8192",
+                messages=messages,
+                temperature=1,
+                max_tokens=1024,
+                top_p=1,
+                stream=True,
+                stop=None,
+            )
+            all_result = ""
+            for chunk in stream:
+                current_content = chunk.choices[0].delta.content or ""
+                all_result += current_content
+                yield current_content
+            yield all_result
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=504, detail="Stream timed out")
+
+def process_file(fileobj, prompt, foldername):
+    set_environment_variables()
+    try:
+        proc = subprocess.Popen(["mkdir", f"/home/user/app/routers/{foldername}"])
+    except subprocess.CalledProcessError as e:
+        return f"Processed Content:\n{e.stdout}\n\nMake Command Error:\n{e.stderr}"
+    time.sleep(2)
+    path = f"/home/user/app/routers/{foldername}/" + os.path.basename(fileobj)
+    shutil.copyfile(fileobj.name, path)
+    base_name = os.path.splitext(os.path.basename(fileobj))[0]
+    no_extension_path = f"/home/user/app/routers/{foldername}/{base_name}"
+    shutil.copyfile(fileobj, no_extension_path)
+    with open(no_extension_path, "a") as f:
+        f.write(prompt)
+    try:
+        prompt_file_path = no_extension_path
+        with open(prompt_file_path, "w") as prompt_file:
+            prompt_file.write(prompt)
+    except Exception as e:
+        return f"Error writing prompt to file: {str(e)}"
+    time.sleep(1)
+    try:
+        proc = subprocess.Popen(
+            ["make", "run", foldername],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        stdout, stderr = proc.communicate(input="n\ny\ny\n")
+        return f"Processed Content:\n{stdout}\n\nMake Command Output:\n{stdout}\n\nMake Command Error:\n{stderr}"
+    except subprocess.CalledProcessError as e:
+        return f"Processed Content:\n{stdout}\n\nMake Command Error:\n{e.stderr}"
+

mysite/webhook.py

@@ -0,0 +1,76 @@
+import os
+import subprocess
+import logging
+from fastapi import FastAPI, Request, HTTPException
+import requests
+import json
+from datetime import datetime
+from utilities import validate_signature, no_process_file
+
+logger = logging.getLogger(__name__)
+
+def setup_webhook_routes(app: FastAPI):
+    @app.post("/webhook")
+    async def webhook(request: Request):
+        logger.info("[Start] ====== LINE webhook ======")
+        try:
+            body = await request.body()
+            received_headers = dict(request.headers)
+            body_str = body.decode("utf-8")
+            logger.info("Received Body: %s", body_str)
+            body_json = json.loads(body_str)
+            events = body_json.get("events", [])
+
+            for event in events:
+                if event["type"] == "message" and event["message"]["type"] == "text":
+                    user_id = event["source"]["userId"]
+                    text = event["message"]["text"]
+                    logger.info("------------------------------------------")
+                    logger.info(f"User ID: {user_id}, Text: {text}")
+                    no_process_file(text, "ai")
+
+            for event in events:
+                if event["type"] == "message" and event["message"]["type"] == "text":
+                    user_id = event["source"]["userId"]
+                    text = event["message"]["text"]
+                    logger.info(event)
+                    logger.info(f"User ID: {user_id}, Text: {text}")
+                    now = datetime.now().strftime("%Y%m%d%H%M%S")
+                    title = text[:10]
+                    user_id_with_timestamp = f"{now}_{title}_{user_id}"
+                    no_process_file(text, user_id_with_timestamp)
+
+            logger.info("Received Headers: %s", received_headers)
+            logger.info("Received Body: %s", body.decode("utf-8"))
+
+            line_signature = received_headers.get("x-line-signature")
+            if not line_signature:
+                raise HTTPException(status_code=400, detail="X-Line-Signature header is missing.")
+
+            if not validate_signature(body.decode("utf-8"), line_signature, os.getenv("CHANNEL_SECRET")):
+                raise HTTPException(status_code=400, detail="Invalid signature.")
+
+            if not os.getenv("WEBHOOK_URL") or not os.getenv("WEBHOOK_URL").startswith("https://"):
+                raise HTTPException(status_code=400, detail="Invalid webhook URL")
+
+            headers = {
+                "Content-Type": "application/json",
+                "X-Line-Signature": line_signature,
+                "Authorization": f"Bearer {os.getenv('CHANNEL_ACCESS_TOKEN')}",
+            }
+
+            logger.info("Forwarding to URL: %s", os.getenv("WEBHOOK_URL"))
+            logger.info("Forwarding Headers: %s", headers)
+            logger.info("Forwarding Body: %s", body.decode("utf-8"))
+
+            response = requests.post(os.getenv("WEBHOOK_URL"), headers=headers, data=body)
+
+            logger.info("Response Code: %s", response.status_code)
+            logger.info("Response Content: %s", response.text)
+            logger.info("Response Headers: %s", response.headers)
+
+            return {"status": "success", "response_content": response.text}, response.status_code
+
+        except Exception as e:
+            logger.error("Error: %s", str(e))
+            raise HTTPException(status_code=500, detail=str(e))