Tools: Bpy Doc, GPU Checker, Find Related

.gitignore

@@ -0,0 +1,3 @@
+.vs
+__pycache__/
+routers/cache

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /code
+
+COPY requirements-fastapi.txt ./
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements-fastapi.txt
+
+RUN useradd -m -u 1000 user
+
+USER user
+
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app/
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,6 +1,6 @@
 ---
 title: Tools
-emoji: 🦀
+emoji: 🌍
 colorFrom: blue
 colorTo: purple
 sdk: docker

config.py

@@ -0,0 +1,12 @@
+from pydantic_settings import BaseSettings
+import os
+
+
+class Settings(BaseSettings):
+    huggingface_key: str = os.environ.get("huggingface_key")
+    cache_dir: str = "cache"
+    embedding_api: str = "sbert"
+    embedding_model: str = "mano-wii/BAAI_bge-base-en-v1.5-tunned-for-blender-issues"
+
+
+settings = Settings()

main.py

@@ -0,0 +1,40 @@
+# main.py
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from huggingface_hub import login
+from config import settings
+from routers import tool_bpy_doc, tool_gpu_checker, tool_calls, tool_find_related
+
+login(settings.huggingface_key)
+
+app = FastAPI(openapi_url="/api/v1/openapi.json",
+              docs_url="/api/v1/docs")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+    allow_credentials=True,
+)
+
+app.include_router(
+    tool_bpy_doc.router, prefix="/api/v1", tags=["Tools"])
+
+app.include_router(
+    tool_gpu_checker.router, prefix="/api/v1", tags=["Tools"])
+
+app.include_router(
+    tool_find_related.router, prefix="/api/v1", tags=["Tools"])
+
+app.include_router(
+    tool_calls.router, prefix="/api/v1", tags=["Function Calls"])
+
+
+@app.get("/")
+async def root():
+    return {"message": "Tool Endpoints"}
+
+app.mount("/api/v1/static", StaticFiles(directory="static"), name="static")

requirements-fastapi.txt

@@ -0,0 +1,6 @@
+fastapi
+uvicorn[standard]
+python-multipart
+pydantic-settings
+huggingface_hub
+sentence_transformers

routers/bpy_doc_v41.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd35f7e45cbd214cf92f14f53dccfe209deebc4d1f444061f8089dc4440d483c
+size 1876094

routers/tool_bpy_doc.py

@@ -0,0 +1,63 @@
+# bpydoc.py
+
+import pickle
+from fastapi import APIRouter
+
+
+router = APIRouter()
+
+with open("routers/bpy_doc_v41.pkl", 'rb') as file:
+    bpy_doc_map = pickle.load(file)
+
+
+def bpy_doc_get_documentation(api):
+    parts = api.split('.')
+    api = ""
+    data = bpy_doc_map
+    ctx = []
+    for part in parts:
+        try:
+            data = data[part]
+            api += part
+            ctx.append((api, data["__info"]['descr']))
+            api += '.'
+        except Exception as ex:
+            descr = f"{type(ex).__name__}: {ex}. Perhaps this object was implemented in a later version."
+            ctx.append((api, descr))
+            break
+
+    documentation = ""
+    for obj, descr in ctx:
+        documentation += f"{obj}:\n"
+        documentation += f"{descr}\n\n"
+
+    if len(data) > 1:
+        documentation += f"Members of {api}:\n"
+        info = data["__info"]
+        if info['bases']:
+            documentation += f"Inherits from {info['bases']}\n"
+
+        for key, val in data.items():
+            if key != "__info":
+                descr = ""
+                if isinstance(val, list):
+                    val = val[0]
+                    descr = "`bpy_prop_collection` of {}".format(
+                        val['__info']["descr"].replace('\n', ' '))
+                else:
+                    descr = val['__info']["descr"].replace('\n', ' ')
+
+                documentation += f"- {key}: {descr}\n"
+
+    return documentation
+
+
+@router.get("/bpy_doc")
+def bpy_doc(api: str = ""):
+    message = bpy_doc_get_documentation(api)
+    return {"message": message}
+
+
+if __name__ == "__main__":
+    test = bpy_doc("bpy.context")
+    print(test)

routers/tool_calls.py

@@ -0,0 +1,76 @@
+import json
+from .tool_gpu_checker import gpu_checker_get_message
+from .tool_bpy_doc import bpy_doc_get_documentation
+from fastapi import APIRouter, Body
+from typing import List, Dict
+from pydantic import BaseModel
+
+
+class ToolCallFunction(BaseModel):
+    name: str
+    arguments: str
+
+
+class ToolCallInput(BaseModel):
+    id: str
+    type: str
+    function: ToolCallFunction
+
+
+router = APIRouter()
+
+
+def process_tool_call(tool_call: ToolCallInput) -> Dict:
+    function_name = tool_call.function.name
+    function_args = json.loads(tool_call.function.arguments)
+    output = {"tool_call_id": tool_call.id, "output": ""}
+    if function_name == "get_bpy_api_info":
+        output["output"] = bpy_doc_get_documentation(
+            function_args.get("api", ""))
+    elif function_name == "check_gpu":
+        output["output"] = gpu_checker_get_message(
+            function_args.get("gpu", ""))
+    return output
+
+
+@router.post("/function_call", response_model=List[Dict])
+def function_call(tool_calls: List[ToolCallInput] = Body(..., description="List of tool calls in the request body")):
+    """
+    Endpoint to process tool calls.
+    Args:
+        tool_calls (List[ToolCallInput]): List of tool calls.
+    Returns:
+        List[Dict]: List of tool outputs with tool_call_id and output.
+    """
+    tool_outputs = [process_tool_call(tool_input) for tool_input in tool_calls]
+    return tool_outputs
+
+
+if __name__ == "__main__":
+    tool_calls_data = [
+        {
+            "id": "call_abc123",
+            "type": "function",
+            "function": {
+                "name": "get_bpy_api_info",
+                "arguments": "{\"api\":\"bpy.context.scene.world\"}"
+            }
+        },
+        {
+            "id": "call_abc456",
+            "type": "function",
+            "function": {
+                "name": "check_gpu",
+                "arguments": "{\"gpu\":\"Mesa Intel(R) Iris(R) Plus Graphics 640 (Kaby Lake GT3e) (KBL GT3) Intel 4.6 (Core Profile) Mesa 22.2.5\"}"
+            }
+        }
+    ]
+
+    tool_calls = [
+        ToolCallInput(id=tc['id'], type=tc['type'],
+                      function=ToolCallFunction(**tc['function']))
+        for tc in tool_calls_data
+    ]
+
+    test = function_call(tool_calls)
+    print(test)

routers/tool_find_related.py

@@ -0,0 +1,416 @@
+# find_related.py
+
+import re
+import torch
+import threading
+from datetime import datetime, timedelta
+from sentence_transformers import SentenceTransformer, util
+from fastapi import APIRouter
+
+try:
+    from .utils_gitea import gitea_fetch_issues, gitea_json_issue_get
+    from config import settings
+except:
+    import os
+    import sys
+    from utils_gitea import gitea_fetch_issues, gitea_json_issue_get
+    sys.path.append(os.path.abspath(
+        os.path.join(os.path.dirname(__file__), '..')))
+    from config import settings
+
+
+def _create_issue_string(title, body):
+    cleaned_body = body.replace('\r', '')
+    cleaned_body = cleaned_body.replace('**System Information**\n', '')
+    cleaned_body = cleaned_body.replace('**Blender Version**\n', '')
+    cleaned_body = cleaned_body.replace(
+        'Worked: (newest version of Blender that worked as expected)\n', '')
+    cleaned_body = cleaned_body.replace('**Short description of error**\n', '')
+    cleaned_body = cleaned_body.replace('**Addon Information**\n', '')
+    cleaned_body = cleaned_body.replace(
+        '**Exact steps for others to reproduce the error**\n', '')
+    cleaned_body = cleaned_body.replace(
+        '[Please describe the exact steps needed to reproduce the issue]\n', '')
+    cleaned_body = cleaned_body.replace(
+        '[Please fill out a short description of the error here]\n', '')
+    cleaned_body = cleaned_body.replace(
+        '[Based on the default startup or an attached .blend file (as simple as possible)]\n', '')
+    cleaned_body = re.sub(
+        r', branch: .+?, commit date: \d{4}-\d{2}-\d{2} \d{2}:\d{2}, hash: `.+?`', '', cleaned_body)
+    cleaned_body = re.sub(
+        r'\/?attachments\/[a-zA-Z0-9\-]+', 'attachment', cleaned_body)
+    cleaned_body = re.sub(
+        r'https?:\/\/[^\s/]+(?:\/[^\s/]+)*\/([^\s/]+)', lambda match: match.group(1), cleaned_body)
+
+    return title + '\n' + cleaned_body
+
+
+def _find_latest_date(issues, default_str=None):
+    # Handle the case where 'issues' is empty
+    if not issues:
+        return default_str
+
+    return max((issue['updated_at'] for issue in issues), default=default_str)
+
+
+class EmbeddingContext:
+    # These don't change
+    TOKEN_LEN_MAX_FOR_EMBEDDING = 512
+    TOKEN_LEN_MAX_BALCKLIST = 2 * TOKEN_LEN_MAX_FOR_EMBEDDING
+    issue_attr_filter = {'number', 'title', 'body', 'state', 'updated_at'}
+
+    # Set when creating the object
+    lock = None
+    model = None
+    model_name = ''
+    config_type = ''
+
+    # Updates constantly
+    data = {}
+    black_list = {'blender': {'blender': {109399, 113157, 114706},
+                              'blender-addons': set()}}
+
+    def __init__(self):
+        self.lock = threading.Lock()
+
+        config_type = settings.embedding_api
+        model_name = settings.embedding_model
+
+        if config_type == 'sbert':
+            self.model = SentenceTransformer(model_name, use_auth_token=False)
+            self.model.max_seq_length = self.TOKEN_LEN_MAX_FOR_EMBEDDING
+            print("Max Sequence Length:", self.model.max_seq_length)
+
+            self.encode = self.encode_sbert
+            if torch.cuda.is_available():
+                self.model = self.model.to('cuda')
+
+        elif config_type == 'openai':
+            # openai.api_base = settings.openai.api_base
+            self.encode = self.encode_openai
+
+        self.model_name = model_name
+        self.config_type = config_type
+
+    def encode(self, texts_to_embed):
+        pass
+
+    def encode_sbert(self, texts_to_embed):
+        return self.model.encode(texts_to_embed, show_progress_bar=True, convert_to_tensor=True, normalize_embeddings=True)
+
+    def encode_openai(self, texts_to_embed):
+        import math
+        import openai
+        import time
+
+        tokens_count = 0
+        for text in texts_to_embed:
+            tokens_count += len(self.get_tokens(text))
+
+            chunks_num = math.ceil(tokens_count / 500000)
+            chunk_size = math.ceil(len(texts_to_embed) / chunks_num)
+
+            embeddings = []
+            for i in range(chunks_num):
+                start = i * chunk_size
+                end = start + chunk_size
+                chunk = texts_to_embed[start:end]
+
+                embeddings_tmp = openai.Embedding.create(
+                    input=chunk, model=self.model_name)['data']
+                if embeddings_tmp is None:
+                    break
+
+                embeddings.extend(embeddings_tmp)
+
+                if i < chunks_num - 1:
+                    time.sleep(60)  # Wait 1 minute before the next call
+
+            return torch.stack([torch.tensor(embedding['embedding'], dtype=torch.float32) for embedding in embeddings])
+
+    def get_tokens(self, text):
+        if self.model:
+            return self.model.tokenizer.tokenize(text)
+
+        tokens = []
+        for token in re.split(r'(\W|\b)', text):
+            if token.strip():
+                tokens.append(token)
+
+        return tokens
+
+    def create_strings_to_embbed(self, issues, black_list):
+        texts_to_embed = [_create_issue_string(
+            issue['title'], issue['body']) for issue in issues]
+
+        # Create issue blacklist (for keepping track)
+        token_count = 0
+        for i, text in enumerate(texts_to_embed):
+            tokens = self.get_tokens(text)
+            tokens_len = len(tokens)
+            token_count += tokens_len
+
+            if tokens_len > self.TOKEN_LEN_MAX_BALCKLIST:
+                # Only use the first TOKEN_LEN_MAX tokens
+                black_list.add(int(issues[i]['number']))
+                texts_to_embed[i] = ' '.join(
+                    tokens[:self.TOKEN_LEN_MAX_BALCKLIST])
+
+        return texts_to_embed
+
+    def embeddings_generate(self, owner, repo):
+        if not owner in self.black_list:
+            self.black_list[owner] = {repo: {}}
+        elif not repo in self.black_list[owner]:
+            self.black_list[owner][repo] = {}
+
+        black_list = self.black_list[owner][repo]
+
+        issues = gitea_fetch_issues(owner, repo, state='open', since=None,
+                                    issue_attr_filter=self.issue_attr_filter, exclude=black_list)
+
+        issues = sorted(issues, key=lambda issue: int(issue['number']))
+
+        print("Embedding Issues...")
+        texts_to_embed = self.create_strings_to_embbed(issues, black_list)
+        embeddings = self.encode(texts_to_embed)
+
+        data = {
+            # Get the most recent date
+            'updated_at': _find_latest_date(issues),
+            'numbers': [int(issue['number']) for issue in issues],
+            'titles': [issue['title'] for issue in issues],
+            'embeddings': embeddings,
+        }
+
+        if not owner in self.data:
+            self.data[owner] = {repo: {}}
+        elif not repo in self.data[owner]:
+            self.data[owner][repo] = {}
+
+        self.data[owner][repo] = data
+
+    def embeddings_updated_get(self, owner, repo):
+        with self.lock:
+            try:
+                data = self.data[owner][repo]
+            except:
+                self.embeddings_generate(owner, repo)
+                data = self.data[owner][repo]
+
+            black_list = self.black_list[owner][repo]
+            date_old = data['updated_at']
+
+            issues = gitea_fetch_issues(
+                owner, repo, since=date_old, issue_attr_filter=self.issue_attr_filter, exclude=black_list)
+
+            # WORKAROUND:
+            # Consider that if the time hasn't changed, it's the same issue.
+            issues = [
+                issue for issue in issues if issue['updated_at'] != date_old]
+
+            if len(issues) == 0:
+                return data
+
+            # Get the most recent date
+            date_new = _find_latest_date(issues, date_old)
+
+# autopep8: off
+            numbers_old = data['numbers']
+            titles_old = data['titles']
+            embeddings_old = data['embeddings']
+
+            last_index = len(numbers_old) - 1
+
+            issues = sorted(issues, key=lambda issue: int(issue['number']))
+            issues_clos = [issue for issue in issues if issue['state'] == 'closed']
+            issues_open = [issue for issue in issues if issue['state'] == 'open']
+
+            numbers_clos = [int(issue['number']) for issue in issues_clos]
+            numbers_open = [int(issue['number']) for issue in issues_open]
+
+            old_closed = []
+            for number_clos in numbers_clos:
+                for i_old in range(last_index, -1, -1):
+                    number_old = numbers_old[i_old]
+                    if number_old < number_clos:
+                        break
+                    if number_old == number_clos:
+                        old_closed.append(i_old)
+                        break
+
+            mask_open = torch.ones(len(numbers_open), dtype=torch.bool)
+            need_sort = False
+            change_map = []
+            for i_open, number_open in enumerate(numbers_open):
+                for i_old in range(last_index, -1, -1):
+                    number_old = numbers_old[i_old]
+                    if number_old < number_open:
+                        need_sort = need_sort or (i_old != last_index)
+                        break
+                    if number_old == number_open:
+                        change_map.append((i_old, i_open))
+                        mask_open[i_open] = False
+                        break
+
+            texts_to_embed = self.create_strings_to_embbed(issues_open, black_list)
+            embeddings = self.encode(texts_to_embed)
+
+            for i_old, i_open in change_map:
+                titles_old[i_old] = issues_open[i_open]['title']
+                embeddings_old[i_old] = embeddings[i_open]
+
+            if old_closed:
+                total = (len(numbers_old) - len(old_closed)) + (len(numbers_open) - len(change_map))
+                numbers_new = [None] * total
+                titles_new = [None] * total
+                embeddings_new = torch.empty((total, *embeddings.shape[1:]), dtype=embeddings.dtype, device=embeddings.device)
+
+                i_new = 0
+                i_old = 0
+                for i_closed in old_closed + [len(numbers_old)]:
+                    while i_old < i_closed:
+                        numbers_new[i_new] = numbers_old[i_old]
+                        titles_new[i_new] = titles_old[i_old]
+                        embeddings_new[i_new] = embeddings_old[i_old]
+                        i_new += 1
+                        i_old += 1
+                    i_old += 1
+
+                for i_open in range(len(numbers_open)):
+                    if not mask_open[i_open]:
+                        continue
+                    titles_new[i_new] = issues_open[i_open]['title']
+                    numbers_new[i_new] = numbers_open[i_open]
+                    embeddings_new[i_new] = embeddings[i_open]
+                    i_new += 1
+
+                assert i_new == total
+            else:
+                titles_new = titles_old + [issue['title'] for i, issue in enumerate(issues_open) if mask_open[i]]
+                numbers_new = numbers_old + [number for i, number in enumerate(numbers_open) if mask_open[i]]
+                embeddings_new = torch.cat([embeddings_old, embeddings[mask_open]])
+
+            if need_sort:
+                sorted_indices = sorted(range(len(numbers_new)), key=lambda k: numbers_new[k])
+                titles_new = [titles_new[i] for i in sorted_indices]
+                numbers_new = [numbers_new[i] for i in sorted_indices]
+                embeddings_new = embeddings_new[sorted_indices]
+
+            data['updated_at'] = date_new
+            data['titles'] = titles_new
+            data['numbers'] = numbers_new
+            data['embeddings'] = embeddings_new
+
+# autopep8: on
+        return data
+
+
+router = APIRouter()
+EMBEDDING_CTX = EmbeddingContext()
+# EMBEDDING_CTX.embeddings_generate('blender', 'blender')
+# EMBEDDING_CTX.embeddings_generate('blender', 'blender-addons')
+
+
+def _sort_similarity(data, query_emb, limit):
+    duplicates = []
+    ret = util.semantic_search(
+        query_emb, data['embeddings'], top_k=limit, score_function=util.dot_score)
+    for score in ret[0]:
+        corpus_id = score['corpus_id']
+        text = f"#{data['numbers'][corpus_id]}: {data['titles'][corpus_id]}"
+        duplicates.append(text)
+
+    return duplicates
+
+
+cached_search = {'text': '', 'repo': '', 'issues': []}
+
+
+def text_search(owner, repo, text_to_embed, limit=None):
+    global cached_search
+    global EMBEDDING_CTX
+    if not text_to_embed:
+        return []
+
+    if text_to_embed == cached_search['text'] and repo == cached_search['repo']:
+        return cached_search['issues'][:limit]
+
+    data = EMBEDDING_CTX.embeddings_updated_get(owner, repo)
+
+    new_embedding = EMBEDDING_CTX.encode([text_to_embed])
+    result = _sort_similarity(data, new_embedding, 500)
+
+    cached_search = {'text': text_to_embed, 'repo': repo, 'issues': result}
+    return result[:limit]
+
+
+def find_relatedness(gitea_issue, limit=20):
+    owner = gitea_issue['repository']['owner']
+    repo = gitea_issue['repository']['name']
+    title = gitea_issue['title']
+    body = gitea_issue['body']
+    number = int(gitea_issue['number'])
+
+    data = EMBEDDING_CTX.embeddings_updated_get(owner, repo)
+    new_embedding = None
+
+    # Check if the embedding already exist.
+    for i in range(len(data['numbers']) - 1, -1, -1):
+        number_cached = data['numbers'][i]
+        if number_cached < number:
+            break
+        if number_cached == number:
+            new_embedding = data['embeddings'][i]
+            break
+
+    if new_embedding is None:
+        text_to_embed = _create_issue_string(title, body)
+        new_embedding = EMBEDDING_CTX.encode([text_to_embed])
+
+    duplicates = _sort_similarity(data, new_embedding, limit=limit)
+    if not duplicates:
+        return ''
+
+    number_cached = int(re.search(r'#(\d+):', duplicates[0]).group(1))
+    if number_cached == number:
+        return '\n'.join(duplicates[1:])
+
+    return '\n'.join(duplicates)
+
+
+@router.get("/find_related")
+def find_related(owner: str = 'blender', repo: str = 'blender', number: int = 1, limit: int = 50):
+    issue = gitea_json_issue_get(owner, repo, number)
+    related = find_relatedness(issue, limit=limit)
+    return related
+
+
+if __name__ == "__main__":
+    import os
+    import pickle
+    repo = 'blender-addons'
+    cache_dir = f"routers/cache/{repo}"
+    file_path = os.path.join(cache_dir, "data.pkl")
+
+    if not os.path.exists(cache_dir):
+        os.makedirs(cache_dir, exist_ok=True)
+        with open(file_path, "wb") as file:
+            EMBEDDING_CTX.embeddings_generate('blender', repo)
+            pickle.dump(
+                EMBEDDING_CTX.data['blender'][repo], file, protocol=pickle.HIGHEST_PROTOCOL)
+    else:
+        with open(file_path, 'rb') as file:
+            EMBEDDING_CTX.data['blender'] = {repo: pickle.load(file)}
+
+    # 'blender/blender/111434' must print #96153, #83604 and #79762
+    issue = gitea_json_issue_get('blender', repo, 105027)
+    print(issue['title'])
+
+    related = find_relatedness(issue, limit=50)
+
+    if related == '':
+        print("No potential duplicates found.")
+    else:
+        print("These are the 20 most related issues:")
+        print(related)

routers/tool_gpu_checker.py

@@ -0,0 +1,196 @@
+# gpuchecker.py
+
+import re
+from fastapi import APIRouter
+
+
+router = APIRouter()
+
+
+def _check_graphics_card_info(supported_models, unsupported_models, graphics_card_info):
+    for model_pattern, descr in supported_models.items():
+        if match := re.search(model_pattern, graphics_card_info, re.I):
+            return True, match.group(), descr.format(*match.groups())
+
+    for model_pattern, descr in unsupported_models.items():
+        if match := re.search(model_pattern, graphics_card_info, re.I):
+            return False, match.group(), descr.format(*match.groups())
+
+    return False, None, None
+
+
+def _check_amd(graphics_card_info):
+    supported_models = {
+        r"Radeon\s*6\d{2}([A-Z])?\b": "this model belongs to the RDNA 2 architecture",
+        r"(Radeon\s*)?R9\s*[A-Z0-9]+": "R9 models belongs to the GCN 1st gen or newer architecture",
+        r"(Radeon\s*)?(Pro\s*)?\bW7\d{3}(X)?\b(\s*Duo)?": "Radeon Pro W7000 models belongs to the RDNA 3 architecture",
+        r"(Radeon\s*)?(Pro\s*)?\bW([5-6])\d{3}(X)?\b(\s*Duo)?": "Radeon Pro W{2}000 models belongs to the RDNA 2 architecture",
+        r"(AMD\s*)?6800 XT": "this model belongs to the RDNA 2 architecture",
+        r"Radeon\s*(\(TM\)\s*)?RX Vega(\s*\d{2}\b)": "Radeon RX Vega models belongs to the GCN 5th gen architecture",
+        r"Radeon Pro Vega ((\d{2}(X)?|II)\b)?(\s*Duo)?": "Radeon Pro Vega models belongs to the GCN 5th gen architecture",
+        r"Radeon\s*(\(TM\)\s*)?Pro [4-5]\d{2}(X)?": "Radeon Pro 400/500 series belongs to the GCN 4th gen architecture",
+        r"Radeon VII": "RX models belongs to the GCN 5 architecture",
+        r"Radeon Graphics \(renoir": "this model belongs to the GCN 5th gen architecture (Vega)",
+        r"Radeon\s*(\(TM\)\s*)?Vega 8 (Graphics )?\(raven[^)]+\)": "this model belongs to the GCN 5th gen architecture (Vega)",
+        r"Radeon\s*(\(TM\)\s*)?(Pro\s*)?WX\s*(5\d{3}\b)": "this model belongs to the GCN 4th gen architecture",
+        r"FirePro": "FirePro models belongs to the GCN 1st gen or newer architecture",
+        r"HD\s*7\d{3}": "HD 7XXX models belongs to the GCN 1st gen or newer architecture",
+        r"(Radeon\s*)?RX\s*([5-7]\d{3})(M|X)?(\s*(XT|Series|S|XTX))?\b": "RX models belongs to the GCN 1st gen or newer architecture",
+        r"(Radeon\s*)?(RX\s*)?6(3|4)0\b": "it has Polaris 23 chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?62(0|5)\b": "it has Polaris 24 chip that belongs to GCN 3st gen architecture",
+        r"(Radeon\s*)?610\b": "it has Banks chip that belongs to GCN 1st gen architecture",
+        r"(Radeon\s*)?RX\s*580(X?)\b": "it has Polaris 20 XT chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?RX\s*570\b": "it has Ellesmere Pro chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?RX\s*560X\b": "it has Polaris 31 XL chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?RX\s*560\b": "it has Baffin XT chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?5(40X|50X)\b": "it has Polaris 23 XT chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?RX\s*5(40|50)\b": "it has Lexa Pro chip that belongs to GCN 4th gen architecture",
+        r"(Radeon\s*)?(\(TM\)\s*)?RX\s*4[6-8]0(\b|D)": "it has Ellesmere chip that belongs to GCN 4st gen architecture",
+        r"(Radeon\s*)?5(30X|35)\b": "it has Polaris 24 XT chip that belongs to GCN 3rd gen architecture",
+        r"(Radeon\s*)?530\b": "it has Weston chip that belongs to GCN 3rd gen architecture",
+        r"(Radeon\s*)?520\b": "it has Banks chip that belongs to GCN 1st gen architecture",
+        r"(Radeon\s*)?(\(TM\)\s*)?R4": "Radeon R4 models belongs to the GCN 1st gen or newer architecture",
+        r"(Radeon\s*)?(\(TM\)\s*)?R5 (M)?335": "Radeon R5 M335 belongs to the GCN 1st gen architecture",
+        r"(Radeon\s*)?(\(TM\)\s*)?R7 (M)?2\d{2}(E|X)?\b": "Radeon R7 200 models belongs to GCN 1st or 2nd gen architecture",
+        r"(Radeon\s*)?(\(TM\)\s*)?R5 (M)?24\d(E|X)?\b": "Radeon R5 240 models belongs to GCN 1st gen architecture",
+        # r"Radeon\s*(\(TM\)\s*)?(Pro\s*)?Vega (Pro\s*)?": "this model belongs to the GCN 4th gen architecture",
+        # Add more model-to-architecture mappings as needed
+    }
+
+    unsupported_models = {
+        r"HD ([5-6])\d{3}": "HD {0}XXX models have TeraScale architecture that is older than GCN 1st gen",
+        r"Radeon R5 (M)?2(2|3)\d(X)?\b": "Radeon R5 220/230 models belongs to Terascale 2 architecture that is older than GCN 1st gen",
+        r"(AMD\s*ATI\s*)?Radeon\s*680M": "AMD ATI Radeon 680M has TeraScale architecture that is older than GCN 1st gen",
+        # Add more model-to-architecture mappings as needed
+    }
+
+    return _check_graphics_card_info(supported_models, unsupported_models, graphics_card_info)
+
+
+def _check_nvidia(graphics_card_info):
+    supported_models = {
+        r"(GeForce )?(RTX\s*)?(?<!\d)([2-4])0[5-9]\d(\s*(RTX|Ti))?\b": "RTX {2}0 series are newer than GTX 400",
+        r"(GeForce )?(GTX\s*)?(?<!\d)16[5-9]\d(\s*(GTX|Ti))?\b": "GTX 16 series are newer than GTX 400",
+        r"(GeForce )?(GTX\s*)?(?<!\d)10[5-9]\d(\s*(GTX|Ti))?\b": "GTX 10 series are newer than GTX 400",
+        r"(GTX )?TITAN": "GTX TITAN models are newer than GTX 400",
+        r"(RTX )?\bA(\d+)": "RTX A models are newer than GTX 400",
+        r"Quadro FX \d+": "Quadro FX series uses a Quadro-based architecture",
+        r"Quadro RTX \d+": "Quadro RTX series uses a Quadro-based architecture",
+        r"Quadro (K|M|P|GP|GV)?\d+(M)?": "it uses a Quadro-based architecture",
+        r"NVS 8\d{2}(s)?\b": "it uses a Maxwell based architecture",
+        r"(Quadro )?NVS 110M\b": "it uses a Maxwell based architecture",
+        r"(GeForce )?GT 730\b": "GeForce from 700 series are newer than GTX 400. It also has 2 or 4 GB",
+        r"(GeForce )?GTX ([4-9])\d{2}(\s*(GTX|Ti))?\b": "GPUs from GTX {1}00 series are newer than GTX 400",
+        r"(GeForce )?\bMX\d{3}\b": "MX models are newer than GTX 400",
+        r"Tesla (.+)": "it has a Tesla architecture",
+        # Add more model-to-architecture mappings as needed
+    }
+
+    unsupported_models = {
+        r"(GeForce )(GTX )?3\d{2}": "GTX 3XX models are older than GeForce 400",
+        r"(Quadro )?NVS 50\b": "although quadro, it only supports opengl 1.3 and is older than 10 years",
+        r"(Quadro )?NVS \d{3}(s)?\b": "it is older than 10 years",
+        r"(Quadro )?NVS 1[1-2]0M\b": "it is Curie-based and older than 10 years",
+        r"(Quadro )?NVS 1\d{2}M\b": "although it is Tesla-based it is older than 10 years",
+        r"(Quadro )?NVS 4200M\b": "although it has Fermi architecture (newer than Tesla) it is older than 10 years",
+        # Add unsupported model-to-architecture mappings if needed
+    }
+
+    return _check_graphics_card_info(supported_models, unsupported_models, graphics_card_info)
+
+
+def _check_intel(graphics_card_info):
+    supported_models = {
+        r"(Mesa\s*)?(Iris\s*)?Xe Graphics": "Tiger Lake is newer than Broadwell architecture",
+        r"Iris Plus Graphics G7": "Ice Lake is newer than Broadwell architecture",
+        r"UHD\s*(Graphics )?6[3-5]\d\b": "Coffee Lake or Comet Lake are newer than Broadwell architecture",
+        r"UHD\s*(Graphics )?62\d\b": "Kaby Lake is newer than Broadwell architecture",
+        r"HD\s*(Graphics )?(P)?6[1-3]\d\b": "Kaby Lake is newer than Broadwell architecture",
+        r"UHD\s*(Graphics )?60\d": "Gemini Lake is newer than Broadwell architecture",
+        r"UHD Graphics": "Kaby Lake, Coffee Lake or Comet Lake are newer than Broadwell architecture",
+        r"Iris": "Coffee Lake is newer than Broadwell architecture",
+        r"HD (Graphics )?5\d{2}\b": "Skylake is newer than Broadwell architecture",
+        r"Iris (Graphics )?6\d{3}\b": "it has the Broadwell architecture",
+        r"Intel(\(R\))? (Arc(\(TM\))?\s*)?(A)?7\d{2}\b": "the A770 model is based on the Intel Arc architecture that is newer than Broadwell",
+        r"Intel\s*(Arc\s*)?(A)?7\d{2}\b": "the A770 model is based on the Intel Arc architecture that is newer than Broadwell",
+        # Add more model-to-architecture mappings as needed
+    }
+
+    unsupported_models = {
+        r"HD (Graphics )?4\d{3}\b": "it has the Haswell architecture that is older than Broadwell architecture",
+        r"HD Graphics 3\d{3}\b": "Sandy Bridge is older than Broadwell architecture"
+        # Add unsupported model-to-architecture mappings if needed
+    }
+
+    return _check_graphics_card_info(supported_models, unsupported_models, graphics_card_info)
+
+
+def _check_apple(graphics_card_info):
+    supported_models = {
+        r"(Apple\s*)?(`)?\bM1(`)?(\s*Max)?": "it is one of the new ARM-based system designed by Apple Inc",
+        r"(Apple\s*)?(`)?\bM2(`)?(\s*Max)?": "it is one of the new ARM-based system designed by Apple Inc",
+        # Add more model-to-architecture mappings as needed
+    }
+
+    unsupported_models = {
+        # Add unsupported model-to-architecture mappings if needed
+    }
+
+    return _check_graphics_card_info(supported_models, unsupported_models, graphics_card_info)
+
+
+def _check_apple_os_version(os_version, is_apple_silicon):
+    major, minor = map(int, os_version.split(".")[:2])
+    if is_apple_silicon:
+        if major >= 11:
+            return True
+    else:
+        if major >= 10 and minor >= 15:
+            return True
+    return False
+
+
+def gpu_checker_get_message(text):
+    is_supported = False
+    vendor = None
+    model = None
+    descr = None
+
+    if "nvidia" in text.lower() or "rtx" in text.lower() or "gtx" in text.lower() or "geforce" in text.lower():
+        vendor = 'NVIDIA'
+        is_supported, model, descr = _check_nvidia(text)
+
+    elif "amd " in text.lower() or "ati " in text.lower() or "radeon" in text.lower():
+        vendor = 'AMD'
+        is_supported, model, descr = _check_amd(text)
+
+    elif "intel" in text.lower():
+        vendor = 'Intel'
+        is_supported, model, descr = _check_intel(text)
+
+    elif "apple" in text.lower() or re.search(r'\bM1\b', text):
+        vendor = 'Apple'
+        is_supported, model, descr = _check_apple(text)
+
+    if not vendor:
+        return "Could not find graphics card information"
+    elif not model:
+        return f"Could not determine the card model from {vendor}"
+
+    message = f"The {vendor} card {model} is {'supported' if is_supported else 'not supported'} as {descr}"
+    if not is_supported:
+        message += """
+
+This GPU is below the minimum requirements for Blender, so Blender no longer provide support for it. https://www.blender.org/download/requirements/
+Installing the latest graphics driver sometimes helps to make such GPUs work, see here for more information. https://docs.blender.org/manual/en/dev/troubleshooting/gpu/index.html
+If that doesn't help, you can use Blender 2.79: https://www.blender.org/download/previous-versions/
+"""
+
+    return message
+
+
+@router.get("/gpu_checker")
+def gpu_checker(gpu_info: str = ""):
+    message = gpu_checker_get_message(gpu_info)
+
+    return {"message": message}

routers/utils_gitea.py

@@ -0,0 +1,89 @@
+# utils_gitea.py
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+BASE_API_URL = "https://projects.blender.org/api/v1"
+
+
+def url_json_get(url, data=None):
+    try:
+        if data:
+            data = json.dumps(data).encode('utf-8')
+            request = urllib.request.Request(url, data=data, method='POST')
+            request.add_header('Content-Type', 'application/json')
+        else:
+            request = urllib.request.Request(url)
+
+        response = urllib.request.urlopen(request)
+        response_data = json.loads(response.read())
+        return response_data
+
+    except urllib.error.URLError as ex:
+        print("Error making HTTP request:", ex)
+        return None
+
+
+def url_json_get_all_pages(url, item_filter=None, limit=50, exclude=set(), verbose=False):
+    assert limit <= 50, "50 is the maximum limit of items per page"
+
+    url_for_page = f"{url}&limit={limit}&page="
+
+    with urllib.request.urlopen(url_for_page + '1') as response:
+        headers_first = response.info()
+        json_data_first = json.loads(response.read())
+
+    total_count = int(headers_first.get('X-Total-Count'))
+    total_pages = (total_count + limit - 1) // limit
+
+    def fetch_page(page):
+        if page == 1:
+            json_data = json_data_first
+        else:
+            json_data = url_json_get(url_for_page + str(page))
+
+        if verbose:
+            print(f"Fetched page {page}")
+
+        data = []
+        for item in json_data:
+            if exclude and int(item["number"]) in exclude:
+                continue
+            data.append({k: item[k] for k in item_filter}
+                        if item_filter else item)
+
+        return data
+
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(fetch_page, page)
+                   for page in range(1, total_pages + 1)]
+        all_results = [future.result() for future in as_completed(futures)]
+
+    return [item for sublist in all_results for item in sublist]
+
+
+def gitea_json_issue_get(owner, repo, number):
+    """
+    Get issue/pull JSON data.
+    """
+    url = f"{BASE_API_URL}/repos/{owner}/{repo}/issues/{number}"
+    return url_json_get(url)
+
+
+def gitea_fetch_issues(owner, repo, state='all', labels='', issue_attr_filter=None, since=None, exclude=set()):
+    query_params = {
+        'labels': labels,
+        'state': state,
+        'type': 'issues'}
+
+    if since:
+        query_params['since'] = since
+
+    BASE_API_URL = "https://projects.blender.org/api/v1"
+    base_url = f"{BASE_API_URL}/repos/{owner}/{repo}/issues"
+    encoded_query_params = urllib.parse.urlencode(query_params)
+    issues_url = f"{base_url}?{encoded_query_params}"
+    return url_json_get_all_pages(issues_url, item_filter=issue_attr_filter, exclude=exclude, verbose=True)

static/privace.txt

@@ -0,0 +1,35 @@
+**Privacy Policy for Blender Assistant**
+
+Effective Date: November 24, 2023
+
+This Privacy Policy outlines the information we do not collect and provides an overview of the usage of the Blender Assistant and endpoints accessible at `https://mano-wii-function-calling.hf.space/api/v1`.
+
+### Information We Do Not Collect
+
+Blender Assistant does not collect the following information:
+
+- **Conversations**: The chat API used connects directly to OpenAI's servers, so only OpenAI has access to the conversations.
+- **Personally Identifiable Information**: The API does not gather personally identifiable information which includes IP or emails addresses.
+- **Cookies**: The API does not utilize cookies.
+
+### API Description
+
+The API provide a chat and tools to provide assistance to Blender users.
+
+## Tools:
+ "/gpu_checker": Determine if a GPU model is supported by Blender.
+ "/bpy_doc": Returns the documentation for a bpy python object or error description if not supported.
+ "/get_issue": Get the title, body, user and assets of the current report on the page.
+ "/get_messages": Get a list of all messages in the report.
+
+### Your Consent
+
+By using the Blender Assistant API, you consent to our privacy policy as described herein.
+
+### Changes to Our Privacy Policy
+
+If we decide to modify our privacy policy, we will update it and provide the revised version.
+
+This document is CC-BY-SA. It was last updated on November 19, 2023.
+
+For any questions or concerns regarding this privacy policy or the Blender 3D Information API, please contact us at [email protected].