| |
| """Keyword coding of collected threads (no paid APIs, no LLM). |
| |
| Input : raw/threads.jsonl (from collect.py) |
| Output: raw/coded_kw.jsonl (all metadata + kw_* coded columns + private excerpt) |
| Usage : python3 -I scripts/code.py [threads.jsonl] [out.jsonl] [--drop-removed] |
| --drop-removed skips the repos removed after the full-build review (SkyPilot, replicate/cog) |
| Rules are ordered: first match wins for single-valued columns; list columns join |
| up to 3 matches with ';'. See codebook.md for definitions. |
| """ |
| import json, os, re, sys |
|
|
| HERE = os.path.dirname(os.path.abspath(__file__)) |
| sys.path.insert(0, HERE) |
| import filters |
|
|
| ROOT = os.path.dirname(HERE) |
| I = re.I | re.A |
|
|
|
|
| def rx(s): |
| return re.compile(s, I) |
|
|
|
|
| HOSTS = [ |
| ("hf_inference_endpoints", rx(r"inference endpoints?\b|ui\.endpoints\.huggingface|dedicated endpoint")), |
| ("hf_spaces", rx(r"hugging ?face spaces?|\bhf spaces?|\b(on|to|in) (a |the |my )?(hf |hugging ?face )?spaces?\b|spaces? (sdk|hardware|build|container)|huggingface\.co/spaces|hf\.space")), |
| ("streamlit_cloud", rx(r"streamlit (community )?cloud|share\.streamlit|streamlit\.app\b")), |
| ("vercel", rx(r"\bvercel\b(?!/ai)(?! ai sdk)")), |
| ("netlify", rx(r"\bnetlify\b")), |
| ("cloudflare", rx(r"\bcloudflare|\bworkers?\.dev|wrangler|\bpages\.dev")), |
| ("fly", rx(r"\bfly\.io\b|\bflyctl\b|\bfly deploy\b|fly\.toml")), |
| ("railway", rx(r"\brailway\b")), |
| ("render", rx(r"\brender\.com\b|\bon render\b|\bto render\b|onrender\.com|render\.yaml")), |
| ("heroku", rx(r"\bheroku\b")), |
| ("supabase", rx(r"\bsupabase\b")), |
| ("langgraph_platform", rx(r"langgraph (platform|cloud)|langsmith deploy|langgraph deploy|langgraph-api|langgraph up")), |
| ("azure", rx(r"\bazure\b|\bazd\b|app service|container apps|\baks\b")), |
| ("gcp", rx(r"cloud ?run\b|\bgcp\b|google cloud|app engine|\bgke\b|vertex|cloud functions|firebase")), |
| ("aws", rx(r"\baws\b|aws lambda|\b(on|to|in|via) lambda\b|lambda (deploy\w*|layers?|cold start|timeouts?|function url|@edge)|sagemaker|\becs\b|\beks\b|\bec2\b|amplify|bedrock|fargate|elastic beanstalk|apprunner|app runner")), |
| ("digitalocean", rx(r"digital ?ocean|\bdroplet")), |
| ("runpod", rx(r"\brunpod\b")), |
| ("modal", rx(r"\bmodal\.com\b|\bmodal (deploy|serve|labs)\b|on modal\b")), |
| ("replicate", rx(r"\breplicate\.com\b|\bcog push\b|on replicate\b|to replicate\b")), |
| ("kubernetes", rx(r"kubernetes|\bk8s\b|\bhelm\b|openshift")), |
| ("posit_connect", rx(r"posit connect|rstudio connect")), |
| ("vps_docker", rx(r"\bvps\b|docker[- ]compose|\bdocker\b|self[- ]host\w*|nginx|own server|ubuntu server|coolify|easypanel|dokploy|caprover")), |
| ] |
| REPO_HOST = {"vercel/vercel": "vercel", "netlify/cli": "netlify", "superfly/flyctl": "fly", |
| "railwayapp/cli": "railway", "Azure-Samples/azure-search-openai-demo": "azure", |
| "Azure-Samples/chat-with-your-data-solution-accelerator": "azure", |
| "microsoft/sample-app-aoai-chatGPT": "azure", "GoogleCloudPlatform/generative-ai": "gcp", "GoogleCloudPlatform/agent-starter-pack": "gcp", |
| "Azure-Samples/contoso-chat": "azure", "Azure-Samples/rag-postgres-openai-python": "azure", |
| "replicate/cog": "replicate"} |
|
|
| FRAMEWORKS = [ |
| ("streamlit", rx(r"\bstreamlit\b")), ("gradio", rx(r"\bgradio\b")), ("chainlit", rx(r"\bchainlit\b")), |
| ("nextjs", rx(r"next\.?js|\bnext (13|14|15|16)\b|app router|\bnext build\b")), |
| ("remix", rx(r"\bremix\b")), ("sveltekit", rx(r"svelte")), ("nuxt", rx(r"\bnuxt")), |
| ("vite_react", rx(r"\bvite\b")), ("astro", rx(r"\bastro\b")), |
| ("fastapi", rx(r"fastapi|uvicorn")), ("flask", rx(r"\bflask\b")), ("django", rx(r"\bdjango\b")), |
| ("express_node", rx(r"\bexpress\b|node\.?js")), ("hono", rx(r"\bhono\b")), |
| ("langgraph", rx(r"langgraph")), ("langchain", rx(r"langchain")), ("llamaindex", rx(r"llama_?index|llama-index")), |
| ("vercel_ai_sdk", rx(r"ai[- ]sdk|vercel/ai|@ai-sdk|useChat|streamText")), |
| ("flowise", rx(r"flowise")), ("langflow", rx(r"langflow")), ("open_webui", rx(r"open[- ]?webui")), |
| ("nextchat", rx(r"nextchat|chatgpt-next-web")), ("chatbot_ui", rx(r"chatbot[- ]ui")), |
| ("cog", rx(r"\bcog (push|predict|build)\b|cog\.yaml")), ("tgi", rx(r"text-generation-inference|\btgi\b")), ("ollama", rx(r"\bollama\b")), |
| ("vllm", rx(r"\bvllm\b")), ("dify", rx(r"\bdify\b")), ("ragflow", rx(r"ragflow")), ("anythingllm", rx(r"anything-?llm")), |
| ("litellm", rx(r"litellm")), ("mastra", rx(r"\bmastra\b")), ("google_adk", rx(r"\badk\b|agent development kit")), |
| ("crewai", rx(r"crew ?ai")), ("agno", rx(r"\bagno\b")), ("skypilot", rx(r"skypilot|\bsky (serve|launch)")), |
| ] |
| REPO_FRAMEWORK = {"streamlit/streamlit": "streamlit", "gradio-app/gradio": "gradio", "Chainlit/chainlit": "chainlit", |
| "langchain-ai/langchain": "langchain", "langchain-ai/langchainjs": "langchain", |
| "langchain-ai/langgraph": "langgraph", "vercel/ai": "vercel_ai_sdk", "ollama/ollama": "ollama", |
| "ChatGPTNextWeb/NextChat": "nextchat", "mckaywrigley/chatbot-ui": "chatbot_ui", |
| "FlowiseAI/Flowise": "flowise", "langflow-ai/langflow": "langflow", |
| "run-llama/llama_index": "llamaindex", "open-webui/open-webui": "open_webui", |
| "huggingface/text-generation-inference": "tgi", "replicate/cog": "cog", |
| "stackblitz-labs/bolt.diy": "vite_react", "microsoft/sample-app-aoai-chatGPT": "flask", |
| "langgenius/dify": "dify", "infiniflow/ragflow": "ragflow", "Mintplex-Labs/anything-llm": "anythingllm", |
| "huggingface/chat-ui": "hf_chat_ui", "vercel/chatbot": "nextjs", "BerriAI/litellm": "litellm", |
| "vllm-project/vllm": "vllm", "mastra-ai/mastra": "mastra", "google/adk-python": "google_adk", |
| "crewAIInc/crewAI": "crewai", "agno-agi/agno": "agno", "skypilot-org/skypilot": "skypilot", |
| "Azure-Samples/rag-postgres-openai-python": "fastapi", "Azure-Samples/contoso-chat": "prompty"} |
|
|
| PROVIDERS = [ |
| ("azure_openai", rx(r"azure[ _-]?open ?ai|\baoai\b")), ("openai", rx(r"\bopen ?ai\b|\bgpt-?[345o]|chatgpt")), |
| ("anthropic", rx(r"anthropic|\bclaude\b(?![- ]code)(?! made| told| deployed| concludes)")), ("google", rx(r"gemini|vertex ?ai|palm\b")), |
| ("aws_bedrock", rx(r"bedrock")), ("local_ollama", rx(r"\bollama\b|llama\.cpp|lm studio|\bgguf\b")), |
| ("huggingface", rx(r"hugging ?face|transformers|\bhf_|inference endpoint|\btgi\b")), |
| ("mistral", rx(r"mistral")), ("deepseek", rx(r"deepseek")), ("groq", rx(r"\bgroq\b")), |
| ("openrouter", rx(r"openrouter")), ("replicate", rx(r"replicate")), ("cohere", rx(r"cohere")), |
| ] |
| REPO_PROVIDER = {"Azure-Samples/azure-search-openai-demo": "azure_openai", |
| "Azure-Samples/chat-with-your-data-solution-accelerator": "azure_openai", |
| "microsoft/sample-app-aoai-chatGPT": "azure_openai", "GoogleCloudPlatform/generative-ai": "google", |
| "GoogleCloudPlatform/agent-starter-pack": "google", "Azure-Samples/contoso-chat": "azure_openai", |
| "Azure-Samples/rag-postgres-openai-python": "azure_openai", |
| "ollama/ollama": "local_ollama", "huggingface/text-generation-inference": "huggingface"} |
|
|
| |
| _CRED = (r"(secrets?\b|credentials?|api[_ -]?keys?|(access|auth|bearer|github|gh|hf|hugging ?face|personal access|oauth|refresh|session|jwt|api|secret)[_ -]?tokens?\b|" |
| r"passwords?|\.env\b|\.dev\.vars|private[_ -]?keys?|sensitive (files?|data|values?|info\w*))") |
| _SEC_ACT = r"(?<!avoid )(?<!not )(?<!never )(\bleak\w*|\bexpos(ed|es|ing)\b|(deployed|deploys|published|publishes|uploaded|uploads) |(in |as )?plain ?text)" |
| _SEC_ACT_AFTER = r"(\bleak\w*|\bexpos\w*|(in|as) plain ?text|publicly|made public|(is|are|was|were|now) public\b|(in|to|into) (a |the |my )?public (repo\w*|github|bundle|url))" |
| ERRORS = [ |
| ("oom", rx(r"memory leak\w*|leak\w* memory|memory (usage|use|consumption) (keeps|continues|grows|growing|increas\w*)|ram growth|out of memory|\boom\b|oomkill|memory limit|heap out|killed.*memory|cuda out of memory|exceeded memory")), |
| ("size_limit", rx(r"(volume|disk|storage).{0,25}(capacity|full|space|running low)|(size|bundle|function|slug|image|payload|body).{0,25}(limit|too large|exceed)|250 ?mb|50 ?mb|exceeds the maximum|too big|request entity too large|\b413\b")), |
| ("timeout", rx(r"timed? ?out\b|timeout (error|exceeded|after)|\b504\b|deadline exceeded|maxduration|max duration|took too long|\d+ ?(s|sec|seconds|minutes) (limit|timeout)")), |
| ("missing_env_var", rx(r"env(ironment)? ?var\w*.{0,40}(not|missing|undefined|empty)|(missing|undefined|not set|not found).{0,30}(api[_ ]?key|env|secret|token)|api[_ ]?key.{0,30}(missing|not (set|found|provided)|undefined|invalid|incorrect)|\.env\b")), |
| |
| |
| ("secret_exposed", rx(_SEC_ACT + r"(?:(?!\. )[^\n]){0,30}" + _CRED + "|" + _CRED + r"(?:(?!\. )[^\n]){0,40}" + _SEC_ACT_AFTER)), |
| ("iac_template_error", rx(r"invalidtemplate|template (deployment|validation)|bicep|terraform|arm template|deploymentfailed|resourcedeploymentfailure|failing invoking action .provision|error deploying infrastructure|cloudformation")), |
| ("quota_billing", rx(r"quota|billing|payment|insufficient (funds|credits)|rate limit|\b429\b|credit card|\bcapacity\b|usage limit|limit of number")), |
| ("permission_rbac", rx(r"permission denied|forbidden|\b403\b|unauthori[sz]ed|\b401\b|role assignment|rbac|authorizationfailed|not authorized|access denied")), |
| ("port_binding", rx(r"\bport\b.{0,30}(\d{2,5}|bind|listen|expos)|\b(port|host) 0\.0\.0\.0|0\.0\.0\.0|failed to listen|listen(ing)? on port|health ?check|127\.0\.0\.1")), |
| ("module_dependency", rx(r"module not found|cannot find module|modulenotfound|no module named|could not resolve|importerror|import error|dependency|peer dep|requirements\.txt|pip install|not compatible|incompatible|edge runtime")), |
| ("build_failure", rx(r"build (fail|error)|failed to build|failed during stage .building|build script returned|npm run build|next build|exit code [1-9]|compil\w* (error|fail)|type (error|issue)s?|lockfile|frozen-lockfile")), |
| ("cors_network", rx(r"\bcors\b|network error|econnrefused|connection refused|ssl|certificate|dns|websocket|\bwss?\b|proxy")), |
| ("streaming", rx(r"stream(ing)?.{0,40}(not|doesn|broken|buffer|stuck|all at once|cut)|buffer(ed|ing)|(responses?|output) (are |is )?cut off")), |
| ("not_found_routing", rx(r"\b404\b|page not found|routing|blank page|white (page|screen)|root[- ]path|sub ?path|base ?path|redirect")), |
| ("server_error_5xx", rx(r"\b50[0-3]\b|internal ?server ?error|bad gateway|crash\w*|exited with|segmentation fault|application error|server-side exception")), |
| ] |
|
|
| CATEGORY_OF_ERROR = {"secret_exposed": "secrets_api_keys", "iac_template_error": "provisioning_iac", "oom": "memory_model_size", "size_limit": "memory_model_size", "timeout": "timeouts", |
| "missing_env_var": "secrets_api_keys", "quota_billing": "costs_quota", |
| "permission_rbac": "auth_permissions", "port_binding": "networking", |
| "module_dependency": "runtime_dependencies", "build_failure": "build", |
| "cors_network": "networking", "streaming": "streaming", |
| "not_found_routing": "routing_config", "server_error_5xx": "other"} |
| CATEGORY_EXTRA = [ |
| ("gpu", rx(r"\bgpu|cuda|nvidia|a100|h100|\bt4\b|\bl4\b")), |
| ("cold_start", rx(r"cold start|spin(s|ning)? (up|down)|sleep(ing)? (mode|after)|scale to zero|wake")), |
| ("database", rx(r"database|postgres|mysql|sqlite|redis|mongo|vector (db|store)|cosmos|pgvector|chroma|pinecone|supabase")), |
| ("auth_permissions", rx(r"\boauth|login|sign[- ]?in|\bsso\b|entra|easy auth|authentication")), |
| ("costs_quota", rx(r"\bcosts?\b|pricing|expensive|\bbill(ed|ing)?\b|hobby plan|pro plan")), |
| ] |
|
|
| |
| |
| |
| AGENT_CTX = rx(r"\bclaude\b|\bthe (ai|agent|model|assistant)\b|coding agent|\bai agent|\bcodex\b|copilot|\bcursor\b|windsurf|auto[- ]?mode") |
| _DEP = r"(deploy\w*|push\w*|production|prod\b|merge\w*|release\w*)" |
| AGENT_ERRORS = [ |
| ("agent_wrong_target", rx(r"deploy\w* (\w+ )?to (the |a )?wrong|wrong (\w+ ){0,2}(project|environment|account|repo\w*|server|cluster|org\w*|vm|region|branch)\b")), |
| ("agent_false_success", rx(r"false (completion|success)|(claim\w*|report\w*)[^.\n]{0,25}(unverified|untested) deploy|claim\w* (to (have )?)?deploy|" |
| r"report\w* (broken|failed) \w+ as (working|success\w*)|checks? pass\w* incorrectly|" |
| r"(claim\w*|report\w*|said|says|told)[^.\n]{0,40}(deploy\w*|production)[^.\n]{0,30}(work\w*|succe\w*|verified|live|fixed)[^.\n]{0,40}(but|when|while|although)|" |
| r"reported what a deploy|told [^.\n]{0,40}deploy[^.\n]{0,60}without (checking|verifying)")), |
| ("agent_deployed_unasked", rx(_DEP + r"[^.\n]{0,40}(without (asking (for |me )?|any |explicit |user |prior |my )?(permission|confirmation|authori[sz]ation|approval|consent|being asked))|" |
| r"(autonomously|immediately|unilaterally) " + _DEP + r"|deploy\w*[^.\n]{0,20}(proceeded )?despite (explicit )?(non-deployment|instructions)|" |
| r"unintended deploy\w*|unreviewed deploy\w*|unasked deploy\w*|deploy\w* (proceeded|happened) despite")), |
| ("agent_blocked_refused", rx(r"(auto[- ]?mode|classifier|safety (filter|flag|check)\w*|false positive)[^.\n]{0,60}(block\w*|den(y|ies|ied|ial)\w*|refus\w*|flag\w*)|" |
| r"(block\w*|refus\w*|den(y|ies|ied))[^.\n]{0,40}(" + _DEP[1:-1] + r")[^.\n]{0,40}(user[- ](authori[sz]ed|requested|approv\w*)|explicit\w*|valid|legitimate|approv\w*|authori[sz]\w*)|" |
| r"refus\w* [^.\n]{0,35}(merge|deploy)|false positive[^.\n]{0,40}(deploy|production)|flag\w*[^.\n]{0,40}blocks? (the )?deploy")), |
| ] |
| |
| |
| |
| |
| OBSERVABILITY = rx(r"langfuse|langsmith (trac\w*|observab\w*|monitor\w*)|opentelemetry|\botel\b|\botlp\b|telemetry|\btracing\b|(?<!stack )\btraces\b|\btracer\b|dd-trace|" |
| r"\bsentry\b|prometheus|grafana|datadog|servicemonitor|observability|\bmonitoring\b|\bmetrics\b|helicone|\barize\b|new relic|application insights") |
| OBSERVABILITY_BODY = rx(r"langfuse|\botlp\b|\btracing\b(?! (the|this|it|back|down))|prometheus|grafana|datadog|\bsentry\b|servicemonitor|" |
| r"observability|helicone|\barize\b") |
| |
| PERFORMANCE = rx(r"\bslow(ly|ness|er|s)?\b|latency|throughput|concurren\w*|auto-?scal\w*|horizontal\w* scal\w*|scale (out|horizontally)|" |
| r"multi-?replicas?|\breplicas\b|single (api )?replica|in parallel|parallel (requests|agents|workers)|requests per second|tokens?/s\b|" |
| r"\[performance\]|performance (issue|problem|degrad\w*)|load balancing|high load|under load") |
| PERFORMANCE_BODY = rx(r"auto-?scal(ing|er)\b|horizontal\w* scal\w*|scale (out|horizontally)|multiple (replicas|workers)|multi-?replicas?|" |
| r"high(ly)? availab\w*|load balancing|throughput|concurrent (requests|users)|requests per second|tokens?/s\b|" |
| r"(very|extremely|too|really|painfully) slow|slow (responses?|startup|start|inference|performance)|high latency|latency (spikes?|increase\w*)") |
|
|
|
|
| def new_topic(repo, title, body): |
| """(topic, agent error_type or None) for a thread whose topic is otherwise 'other', or (None, None). |
| Title first, then body (body = the first 3,000 raw characters, as for error_type).""" |
| agent_ok = repo == "anthropics/claude-code" or AGENT_CTX.search(title + "\n" + body) |
| e = agent_ok and first(AGENT_ERRORS, title) |
| if e: |
| return "agent_behavior", e |
| if OBSERVABILITY.search(title): |
| return "observability", None |
| if PERFORMANCE.search(title): |
| return "performance_scaling", None |
| e = agent_ok and first(AGENT_ERRORS, body) |
| if e: |
| return "agent_behavior", e |
| short = clean(body)[:1500] |
| if OBSERVABILITY_BODY.search(short): |
| return "observability", None |
| if PERFORMANCE_BODY.search(short): |
| return "performance_scaling", None |
| return None, None |
|
|
|
|
| AI_TOOLS = [("lovable", rx(r"lovable")), ("bolt", rx(r"\bbolt(\.new|\.diy)?\b")), ("v0", rx(r"v0\.dev|\bv0 (by vercel|app|generated)|(with|in|using|from) v0\b(?!\.)")), |
| ("cursor", rx(r"\bcursor\b")), ("claude_code", rx(r"claude[- ]code")), ("replit", rx(r"replit")), |
| ("copilot", rx(r"copilot")), ("windsurf", rx(r"windsurf")), ("dyad", rx(r"\bdyad\b")), |
| ("codex", rx(r"\bcodex\b"))] |
| REPO_AI_TOOL = {"stackblitz-labs/bolt.diy": "bolt", "dyad-sh/dyad": "dyad", "anthropics/claude-code": "claude_code"} |
|
|
| REMOTE = rx(r"vercel|netlify|cloudflare|fly\.io|flyctl|railway|render|heroku|azure|azd|cloud ?run|gcp|google cloud|aws|lambda|" |
| r"sagemaker|ecs|kubernetes|k8s|spaces|streamlit cloud|production|prod\b|server|hosted|vps|digitalocean|runpod|modal|" |
| r"replicate|supabase|langgraph (platform|cloud)|deployed|deployment|serverless") |
|
|
|
|
| def clean(t): |
| t = re.sub(r"<!--.*?-->", " ", t or "", flags=re.S) |
| t = re.sub(r"```.*?```", " ", t, flags=re.S) |
| t = re.sub(r"`[^`]*`", " ", t) |
| t = re.sub(r"https?://\S+", "<url>", t) |
| t = re.sub(r"[\w.+-]+@[\w-]+\.[\w.]+", "<email>", t) |
| t = re.sub(r"@[\w-]+", "@<user>", t) |
| t = re.sub(r"^\s*(#+.*|[-*] \[[ x]\].*|\*\*[^*]+\*\*:?\s*)$", " ", t, flags=re.M) |
| t = re.sub(r"!\[[^\]]*\]\([^)]*\)", " ", t) |
| return re.sub(r"\s+", " ", t).strip() |
|
|
|
|
| def excerpt(body, n=30): |
| w = clean(body).split() |
| return " ".join(w[:n]) |
|
|
|
|
| def first(rules, text): |
| for lab, r in rules: |
| if r.search(text): |
| return lab |
| return None |
|
|
|
|
| def multi(rules, text, k=3): |
| return ";".join([lab for lab, r in rules if r.search(text)][:k]) or None |
|
|
|
|
| |
| NOT_DEPLOY = rx(r"deployment[_ ]?name|\bptu\b|serverless (api )?endpoint|bedrock marketplace|" |
| r"(model|llm|embedding)s? (deployed|hosted) (via|with|by|in|on) (vllm|xinference|azure|tgi|ollama)|" |
| r"(locally|local(ly)?[- ]deployed|my own) (model|llm|embedding)|deployed (embedding|chat|llm) model|" |
| r"use (a |my )?(remote|locally) deployed") |
| LOCAL = rx(r"\blocal(ly)? deploy\w*|\blocal(ly)? (docker|private|offline|intranet )?(docker |compose )?(deploy\w*|setup|install\w*)|docker local|docker desktop|\bwsl2?\b|truenas|langgraph dev\b|\bon my (mac|laptop|pc|machine)|desktop app|\.exe\b|" |
| r"windows 1[01]\b.{0,40}(server|local)|test(ing)? (it |your agent )?locally|errors when testing locally") |
| PITCH = rx(r"we('re| are) building|our (open-source )?platform|open-source platform for|happy to (help|contribute)|" |
| r"\bwithdrawn\b|marketplace where agents|we have implemented") |
| FEATURE = rx(r"^\s*(\[?feat(ure)?( request)?\]?[:\s]|add (support|a |an )|support (for )?|idea:|enhance|request:|" |
| r"allow |make .* (easier|friendly)|proposal)") |
| CLASSIFIER = rx(r"classifier|\baup\b|usage[- ]policy|safeguard|flag(s|ged)? .{0,30}(malicious|policy)|prompt[- ]injection") |
| REMOTE_T = rx(r"vercel|netlify|cloudflare|fly\.io|flyctl|railway|render\b|heroku|azure|azd|cloud ?run|gcp|google cloud|aws|" |
| r"lambda|sagemaker|ecs|eks|aks|gke|kubernetes|k8s|helm|spaces|streamlit cloud|production|prod\b|server|hosted|" |
| r"vps|digitalocean|runpod|modal|replicate|supabase|langgraph (platform|cloud)|reasoning engine|agent engine|" |
| r"inference endpoint|app service|container app|coolify|amplify|fargate|deploy\w*|serverless|edge") |
| BUILDER_SELF = rx(r"(deploy\w*|host\w*|run\w*|install\w*) (the |custom |costum |own )?(bolt|blot)(\.diy)?\b|" |
| r"\bbolt(\.diy)? (on|to|in) |bolt\.diy (is|on)|coolify|easypanel|docker|cloudflare runtime") |
|
|
|
|
| |
| HOSTING_T = rx(r"vercel|netlify|railway|render\.com|onrender|\b(on|to) render\b(?!ing)(?! (the|a|an|it|html|markdown|text|images?)\b)|render (deploy\w*|blueprint|service)\b|" |
| r"heroku|fly\.io|flyctl|cloud ?run|app service|container apps?|" |
| r"aws lambda|\b(on|to|in|via) lambda\b|lambda (deploy\w*|layers?|cold start|timeouts?|function url|@edge|runtime)|" |
| r"ecs\b|fargate|\beks\b|\bgke\b|\baks\b|kubernetes|\bk8s?\b|\bk3s\b|helm|openshift|hugging ?face spaces?|hf spaces?|" |
| r"\b(on|to|in) (hf |hugging ?face |a |the |my )?spaces?\b(?! (between|in|and|before|after|at|around|instead|characters?|key))|\bspaces? (sdk|hardware|build|container|secrets|app|demo)|zerogpu|" |
| r"sagemaker (deploy\w*|endpoint deploy\w*)|deploy\w* .{0,40}sagemaker|\b(on|in|to) (an? |the )?(aws|azure|gcp|google cloud|ec2|sagemaker)\b|" |
| r"runpod|modal\.com|\bon modal\b|modal (deploy|serve|labs)|cloudformation|reverse proxy|nginx|traefik|ingress|cloudflared?[ -]tunnels?|\[serve\]|agent ?engine|reasoning engine|langgraph (platform|cloud)|" |
| r"langsmith deploy|mastra cloud|supabase (edge )?functions?|cloudflare (workers?|pages)|workers?\.dev|amplify|" |
| r"elastic beanstalk|app engine|digital ?ocean|coolify|docker[- ]compose|\bdocker\b|podman|\bvps\b|ec2|azd\b|streamlit (community )?cloud|" |
| r"inference endpoints?|posit connect|sky serve|skyserve|firebase hosting|firebase (app|functions)|" |
| r"(remote|cloud|linux|ubuntu|production|prod|company|shared|dedicated) (server|vm|instance|host|gpu)s?|\bon (a |the |my )?(remote )?(server|vm)\b") |
| DEPLOY_VERB_T = rx(r"\bdeploy\w*|\bhosting\b|\bhosted\b|self[- ]host\w*|\bredeploy\w*|\bprovision\w*|\bpublish\w*|go(ing)? live|" |
| r"\b(in|on|for|to) (the )?(production|prod)\b(?)|production (only|server|environment|build|deployment|mode|setup)|(prod|production) (env|build)\b|" |
| r"\bon (the )?server\b|\bazd up\b") |
| NOT_DEPLOY_SENSE = rx(r"router|load ?balanc\w* (between|across) (models|deployments)|model deployment(?! (to|on|in) )|deployment[_ ]?(name|id)s?\b|" |
| r"custom[- ]priced|cost map|\[usage\]|" |
| r"deploy\w* (the )?(new |latest )?version|after (deploying|upgrading) (to )?(v|version)|gpu deployment|deployment (thinking|defaults|settings)|" |
| r"(ios|macos|android) deployment|deployment target (too|for ios|version)|publish(ing)? (to )?(npm|pypi|the package|package)|published (package|version)|npm publish") |
| |
| MANAGED_API_T = rx(r"vertex ?ai(?! agent ?engine)|bedrock|azure ?open ?ai|\baoai\b|ai foundry|azure ai (services|inference)|batch (prediction|api|inference|job)|" |
| r"gemini api|openai api|workers ai|ai gateway|sagemaker(?! deploy)|\bvercel_ai_gateway|\bsagemaker_|" |
| r"(serverless|provisioned|ptu|global|standard) (api |model )?(endpoint|deployment|throughput)") |
| APP_HOST_T = rx(r"vercel(?! ai gateway)(?!_ai)|netlify|railway|render\.com|heroku|fly\.io|cloud ?run|app service|container apps?|lambda\b|ecs\b|fargate|eks|gke|aks|" |
| r"kubernetes|k8s|helm|openshift|spaces?\b|(on|to|in) sagemaker|deploy\w* .{0,40}sagemaker|agent ?engine|reasoning engine|docker|vps|\bazd\b|app engine|cloudflare (workers?|pages)(?! ai)|" |
| r"deploy\w* (my |the |our |a |an )?(app|agent|server|proxy|litellm|chatbot|bot|application|site|frontend|backend|ui)|" |
| r"deploy\w* (a |the )?(model|llm|endpoint) (to|on|in) (azure ml|azure machine learning|sagemaker|vertex ai endpoint)|managed online endpoint") |
| |
| CI_T = rx(r"\bci\b|\[ci\]|^ci[:(]|github actions?|gh actions?|workflows? (fail\w*|run|broken)|\be2e\b|end[- ]to[- ]end tests?|integration tests?|unit tests?|" |
| r"smoke ?tests?|regression tests?|flaky|\btests? (fail\w*|for|of|against|on|broken)|^\[?tests?\]?[:(]|ci[- ]failure|release (pipeline|workflow|job)") |
| |
| APP_BUG_T = rx(r"\b(ui|button|display\w*|markdown|chat history|hallucinat\w*|infinite loop|loops? forever|repeat(s|ing|ed)? (itself|the|output|answer)|" |
| r"output (is )?(wrong|garbled|empty|incorrect)|answers?|citations?|i18n|translation|dark mode|theme|layout|css|font|style|" |
| r"tool[- ]call\w*|function[- ]call\w*|structured output|tokeni[sz]\w*|accuracy|quality|reasoning (text|content)|thinking (text|content)|" |
| r"cost tracking|spend|usage (data|tracking)|logs? (clutter|spam)|telemetry|metrics?|cach(e|ed|ing) tokens?|prompt_tokens)\b") |
| HOST_LINK = rx(r"\b(deploy\w* (fail\w*|error\w*|broken|stuck|crash\w*|times? out)|fail\w* (to|when|while|after|on|in) (deploy\w*|start\w*|boot|run(ning)? (on|in))|" |
| r"(cannot|can'?t|unable to|won'?t|doesn'?t|does not|not) (deploy|start|boot|connect|reach|access|load|run)|works? (fine )?locally|local(ly)? (works|fine)|" |
| r"but not (on|in|when|after)|only (on|in|when) (deploy\w*|production|prod|spaces|vercel|k8s|kubernetes|docker|server)|" |
| r"env\w*|config\w*|port|proxy|https?\b|ssl|tls|cors|domain|subpath|root[_ ]path|base[_ ]?path|timeout|timed out|memory|oom|ram|disk|volume|storage|" |
| r"startup|start(s|ing)?|crash\w*|restart\w*|container|image|helm|chart|ingress|install\w*|permission|forbidden|40[134]|50[0234]|auth\w*|login|oauth|" |
| r"secret|keys?|database|postgres|redis|network\w*|dns|websocket|stream\w*|cold start|scal\w*|replica\w*|pod|node|gpu|cuda|nccl|driver|build\w*|" |
| r"read[- ]only|non[- ]?root|filesystem|mount\w*|bucket|s3|gcs|blob|iframe|static files?|assets?|routing|redirect\w*|404|session)\b") |
| CC_NOISE = rx(r"browser pane|built-in browser|in-app browser|desktop|warp\b|oauth|connector|plugin|email|turnstile|challenge page|sub-?agents?|cowork|msix|" |
| r"auto-?updat\w*|managed[- ](settings|mcp|config)|deployment (mode|surface|store|mount)|third-party deployment|custom-3p|org(anization)?[- ]skill|" |
| r"skills? (deploy|publish)|marketplace|remote control|voice mode|install\.sh|binarydeployment|ssh remote|deployment target|ios|" |
| r"model deployed instead|driver deployment|deployed instead of|56-agent|deploy(ed|s)? .{0,20}(sub-?)?agents\b") |
| |
| CC_DEPLOY = rx(r"deploy\w*|production|\bprod\b|publish\w*|go live|vercel|netlify|cloudflare (workers?|pages)|firebase|railway|supabase|heroku|" |
| r"fly\.io|cloud ?run|kubernetes|k8s|nginx|\bvps\b|\bserver\b|\bdomain\b|website|\bsite\b|\bhosting\b") |
| CC_LIMIT = rx(r"classifier|auto[- ]?mode|blocked|blocks|denied|deny|refus\w*|flag\w*|false (positive|completion)|claim\w*|reported .{0,40}(success|working|deployed)|" |
| r"without (asking|confirmation|permission|authori[sz]ation|warning)|unauthori[sz]ed|unrequested|unprompted|autonomous\w*|" |
| r"(deployed|published|uploaded) .{0,40}(secret|credential|\.env|\.dev\.vars|sensitive)|secret|credential|wrong (project|account|repo)|destroy\w*|took down|broke") |
| GENERIC_RE = filters.GENERIC_REPOS |
| SERVING_REPOS = {"vllm-project/vllm", "ollama/ollama", "huggingface/text-generation-inference", "skypilot-org/skypilot", "replicate/cog"} |
| AGENT_DEPLOY_REPOS = {"google/adk-python", "GoogleCloudPlatform/agent-starter-pack", "langchain-ai/langgraph", "mastra-ai/mastra", "crewAIInc/crewAI", "agno-agi/agno"} |
|
|
|
|
| def relevance(t, title, text, alltext): |
| """Rules v4 (owner decisions 2026-10-28). Returns (yes|no, unsure_reason or ''). |
| unsure_reason marks rows the keywords cannot settle; they are judged by the reviewer.""" |
| g, repo = t["group"], t["repo"] |
| generic = g in ("host", "framework_generic") or repo in GENERIC_RE |
| tclean = re.sub(r"vercel ai sdk|ai sdk|sandbox-vercel|@vercel/\S+|vercel/ai\b|vercel[_ ]ai[_ ]gateway|ai gateway", " ", title, flags=I) |
| hosting, verb = bool(HOSTING_T.search(tclean)), bool(DEPLOY_VERB_T.search(tclean)) |
| |
| if generic and not filters.AI_EVIDENCE.search(re.sub(r"gradio|streamlit|vercel|next\.?js|netlify", " ", alltext, flags=I)): |
| return "no", "" |
| if PITCH.search(text[:1500]): |
| return "no", "" |
| if repo == "anthropics/claude-code": |
| if CC_NOISE.search(title) or NOT_DEPLOY_SENSE.search(title): |
| return "no", "" |
| if not CC_DEPLOY.search(title): |
| return "no", "" |
| |
| if re.search(r"local `?docker build|locally", title, I): |
| return "no", "" |
| if CC_LIMIT.search(title) or re.search(r"deploy\w*", title, I): |
| return "yes", "" if CC_LIMIT.search(title) and re.search(r"deploy\w*|production|prod\b|publish", title, I) else "cc:deploy_context_unclear" |
| return "no", "cc:host_word_only" |
| if CLASSIFIER.search(title): |
| return "no", "" |
| if NOT_DEPLOY.search(text) and not re.search(r"deploy\w* (to|on|in) (vercel|netlify|azure|aws|gcp|cloud|render|railway|k8s|kubernetes|hugging)", title, I): |
| return "no", "" |
| remote = bool(HOSTING_T.search(re.sub(r"docker[- ]?(compose)?|podman", " ", tclean, flags=I))) |
| if LOCAL.search(title) and not remote or LOCAL.search(text[:2500]) and not hosting: |
| return "no", "" |
| if not remote and re.search(r"\b(macos|mac (intel|m[1-4])|windows(?!\.net)|apple silicon|rtx \d{4}|jetson|raspberry|offline (device|machine)|local (gpu|machine|computer))\b", title, I) \ |
| and not re.search(r"works? (fine )?(on|in) (the |my )?local|locally|\bbut\b|\b(adk|mastra|azd|az|gcloud|vercel|wrangler|langgraph|flowise) (deploy|build|up|webapp)\b|deploy\w* (to|on) (?!(the |my |a )?(mac|windows|jetson|raspberry))|agent_engine|gh actions", title, I): |
| return "no", "" |
| if not (g in ("framework", "sample", "builder") or filters.AI.search(text)): |
| return "no", "" |
| if not (hosting or verb): |
| return "no", "" |
| |
| own_host = g == "sample" or repo in SERVING_REPOS or repo in AGENT_DEPLOY_REPOS |
| if MANAGED_API_T.search(title) and not APP_HOST_T.search(tclean): |
| if own_host and (verb or re.search(r"\b(on|to|in) (gcp |google )?(vertex ai|sagemaker)\b", title, I)): |
| pass |
| elif verb and re.search(r"deploy\w*", tclean, I): |
| return "yes", "managed_api:deploy_word" |
| else: |
| return "no", "" |
| if NOT_DEPLOY_SENSE.search(title) and not hosting: |
| return "no", "" |
| ci = bool(CI_T.search(title)) or any(re.search(r"ci[- ]failure|^ci$|area:ci|testing", l, I) for l in t["labels"]) |
| if ci: |
| return ("yes", "") if hosting else ("no", "ci:no_cloud_named" if verb else "") |
| if repo == "BerriAI/litellm" and not (hosting or re.search(r"deploy\w* (litellm|the proxy|proxy)|docker|helm", title, I)): |
| return "no", "" |
| if repo in SERVING_REPOS and not hosting: |
| |
| if re.search(r"\b(server|production|prod|cluster|multi[- ]node|remote|cloud|container|docker|instance|api access|concurren\w*)\b", text[:2500], I): |
| return "yes", "serving:host_not_named" |
| return "no", "" |
| if g == "host" and re.search(r"agent", title, I) and not re.search(r"app|deploy\w* (my|a|the)", title, I): |
| return "no", "host:agent_tooling" |
| if not hosting and not re.search(r"deploy\w*|hosting|hosted|self[- ]host|provision|publish|go(ing)? live|on (the )?server|azd up", tclean, I): |
| return "yes", "production_only" |
| |
| if APP_BUG_T.search(re.sub(r"chat-ui|open[- ]?webui|chatbot[- ]ui", " ", title, flags=I)) and not HOST_LINK.search(title): |
| return "yes", "app_bug:host_link_unclear" |
| return "yes", "" |
|
|
|
|
| |
| TT_PREFIX = [("pr_ci", rx(r"^\s*(\[(ci|test|tests|chore|build)\]|(ci|test|tests|chore)(\(\w+\))?:)")), |
| ("docs", rx(r"^\s*(\[(docs?|documentation)\]|docs?(\(\w+\))?:|documentation:)")), |
| ("feature", rx(r"^\s*(\[(feat(ure)?( request)?|enhancement|rfc|proposal|idea|request)\]|(feat|feature|feature request|enhancement|rfc|proposal|idea|request)(\(\w+\))?:)")), |
| ("question", rx(r"^\s*(\[(question|usage|help|support|discussion)\]|(question|usage|help)(\(\w+\))?:)")), |
| ("problem", rx(r"^\s*(\[(bug|bug report|installation|regression|model|refund)\]|bug(\(\w+\))?:)"))] |
| ERRORISH = rx(r"\b(errors?|fail\w*|broken|break(s|ing)?|crash\w*|not work\w*|doesn'?t work|does not work|isn'?t working|cannot|can'?t|unable|won'?t|stuck|" |
| r"timeouts?|timed out|exception|bug|wrong|incorrect|invalid|denied|refused|rejected|blocked|undefined|not found|hang(s|ing)?|freez\w*|" |
| r"[45]\d\d|missing|issue with|problem with|no longer|regression|leak\w*|ignor\w*|without (asking|confirmation|permission))\b") |
| FEATURE_T = rx(r"^\s*(add(ing)?|support(ing)?|allow|enable|provide|implement|introduce|make|expose|offer|create|let)\b|feature request|\bplease add\b|would be (nice|great|good|helpful)|" |
| r"\bsupport for\b|\bproposal\b|\bshould (support|allow|be able)|\bwish\b|\bability to\b|\boption (to|for)\b|\bconfigurable\b") |
| DOCS_T = rx(r"\bdocs?\b|documentation|readme|\bguide\b|tutorial|instructions?|\bexamples? (for|of|on)\b|recipe|cookbook|how-?to guide") |
| QUESTION_T = rx(r"^\s*(how|what|which|why|where|when|is|are|can|could|does|do|should|any)\b|\?\s*$|\bhow (to|do|can|should)\b|is it possible|is there a way|" |
| r"best (way|practice)|recommend\w*|guidance|help needed|need help|question") |
| FEATURE_L = rx(r"enhancement|feature|rfc|proposal|integration request|idea") |
| DOCS_L = rx(r"documentation|\bdocs?\b") |
| QUESTION_L = rx(r"question|support|usage|answered|help wanted(?!.)|discussion") |
| BUG_L = rx(r"\bbug\b|regression|crash|has repro|possible bug|🐞") |
| CI_L = rx(r"ci[- ]failure|^ci$|area:ci|\btests?\b|flaky") |
|
|
|
|
| def thread_type(t, title): |
| labels = [l.lower() for l in t["labels"]] |
| for lab, r in TT_PREFIX: |
| if r.search(title): |
| if lab == "docs" and re.search(r"(fail|error|broken|not working|outdated|wrong|incorrect)", title, I) and not DOCS_T.search(title): |
| return "problem" |
| return lab |
| if CI_T.search(title) or any(CI_L.search(l) for l in labels): |
| return "pr_ci" |
| err = bool(ERRORISH.search(title)) |
| if DOCS_T.search(title) and not err: |
| return "docs" |
| if any(DOCS_L.search(l) for l in labels) and not any(BUG_L.search(l) for l in labels): |
| return "docs" |
| if any(FEATURE_L.search(l) for l in labels) and not err: |
| return "feature" |
| if FEATURE_T.search(title) and not err: |
| return "feature" |
| if err or any(BUG_L.search(l) for l in labels): |
| return "problem" |
| if QUESTION_T.search(title) or any(QUESTION_L.search(l) for l in labels): |
| return "question" |
| if ERRORISH.search(t.get("body", "")[:1500]): |
| return "problem" |
| return "other" |
|
|
|
|
| def code(t): |
| title, body = t["title"], t["body"] |
| others_c = [c for c in t["comments"] if not c["by_author"] and not c["is_bot"]] |
| coms = " ".join(c["body"] for c in t["comments"]) |
| text = title + "\n" + body |
| repo, g = t["repo"], t["group"] |
| out = {} |
| alltext = text + "\n" + coms |
| out["kw_relevant"], out["kw_unsure"] = relevance(t, title, text, alltext) |
| out["kw_thread_type"] = thread_type(t, title) |
| builder_self = g == "builder" and repo == "stackblitz-labs/bolt.diy" and bool(BUILDER_SELF.search(text[:2000])) |
| |
| out["kw_target_host"] = first(HOSTS, title) or first(HOSTS, body) or REPO_HOST.get(repo) or "unspecified" |
| |
| data_cue = re.search(r"\brag\b|retriev|vector|embedding|knowledge base|ai search|cognitive ?search|own data|your data|index(es)? ", text, I) |
| if g == "builder" and not builder_self: |
| at = "ai_generated_web_app" |
| elif re.search(r"\bagents?\b|langgraph|crew|reasoning engine|agent engine|adk\b", text, I) or repo in ("langchain-ai/langgraph", "mastra-ai/mastra", "google/adk-python", "crewAIInc/crewAI", "agno-agi/agno", "GoogleCloudPlatform/agent-starter-pack"): |
| at = "agent" |
| elif repo in ("Azure-Samples/azure-search-openai-demo", "Azure-Samples/chat-with-your-data-solution-accelerator", "infiniflow/ragflow", "Mintplex-Labs/anything-llm", "Azure-Samples/rag-postgres-openai-python", "Azure-Samples/contoso-chat") or data_cue: |
| at = "rag" |
| elif repo in ("huggingface/text-generation-inference", "replicate/cog", "ollama/ollama", "vllm-project/vllm", "BerriAI/litellm", "skypilot-org/skypilot") or re.search(r"serv(e|ing) (the |a )?model|inference (server|endpoint)|model serving|sagemaker endpoint", text, I): |
| at = "model_serving" |
| elif repo in ("ChatGPTNextWeb/NextChat", "mckaywrigley/chatbot-ui", "huggingface/chat-ui", "vercel/chatbot", "Chainlit/chainlit", "open-webui/open-webui", "microsoft/sample-app-aoai-chatGPT") or re.search(r"chat ?bot|\bchat\b", text, I): |
| at = "chatbot" |
| else: |
| at = "other" |
| out["kw_app_type"] = at |
| fw_default = "remix" if builder_self else (None if g == "builder" else REPO_FRAMEWORK.get(repo)) |
| out["kw_framework"] = fw_default or first(FRAMEWORKS, text) or "unspecified" |
| stack = [fw_default] + [lab for lab, r in FRAMEWORKS if r.search(text)] |
| out["kw_stack"] = ";".join(dict.fromkeys(s for s in stack if s)) or None |
| prov_text = text if repo != "anthropics/claude-code" else re.sub(r"claude|anthropic", " ", text, flags=I) |
| out["kw_model_provider"] = multi(PROVIDERS, prov_text) or REPO_PROVIDER.get(repo) or "unspecified" |
| |
| err_t, err_b = first(ERRORS, title), first(ERRORS, body[:3000]) |
| extra_t = first(CATEGORY_EXTRA, title) |
| if err_t == "iac_template_error": |
| inner = first([e for e in ERRORS if e[0] in ("quota_billing", "permission_rbac")], body[:3000]) |
| err_t = inner or err_t |
| if err_t: |
| cat, conf = CATEGORY_OF_ERROR[err_t], "title" |
| elif extra_t: |
| cat, conf = extra_t, "title" |
| elif err_t: |
| cat, conf = CATEGORY_OF_ERROR[err_t], "title" |
| elif err_b: |
| cat, conf = CATEGORY_OF_ERROR[err_b], "body" |
| else: |
| cat, conf = "other", "none" |
| err = err_t or err_b or "other_unknown" |
| if cat == "other": |
| nt, agent_err = new_topic(repo, title, body[:3000]) |
| if nt: |
| cat = nt |
| |
| |
| |
| if agent_err and (err == "other_unknown" or (err == "server_error_5xx" and conf == "body")): |
| err = agent_err |
| out["kw_error_type"] = err |
| out["kw_topic"] = cat |
| out["coding_confidence"] = conf |
| |
| tool = first(AI_TOOLS, text) if re.search(r"(built|made|generated|created|wrote|written|vibe)[^.]{0,40}(with|by|using)|vibe.?cod", text, I) else None |
| tool = REPO_AI_TOOL.get(repo) or tool |
| if builder_self: |
| out["kw_ai_generated_app"], out["kw_ai_tool"] = "no", None |
| else: |
| out["kw_ai_generated_app"] = "yes" if tool else "unknown" |
| out["kw_ai_tool"] = tool |
| |
| maint = [c for c in others_c if c.get("assoc") in ("OWNER", "MEMBER", "COLLABORATOR")] |
| out["maintainer_replied"] = "yes" if maint else "no" |
| stale = any(re.search(r"stale|inactiv|auto-?clos", l, I) for l in t["labels"]) or any( |
| re.search(r"stale|inactiv|automatically closed|no activity|closing (this|due)", c["body"], I) for c in t["comments"] if c["is_bot"] or not c["by_author"]) |
| fix_words = r"(it )?works now|that (worked|fixed)|solved|resolved|fixed it|found (the|a) (fix|solution|problem|issue)|the (problem|issue) was|turns out|was related to|i fixed it|managed to" |
| author_ok = any(c["by_author"] and re.search(fix_words + r"|thank(s| you).{0,40}(work|fix|help)", c["body"], I) for c in t["comments"]) \ |
| or bool(re.search(r"i fixed it|update: .{0,40}(fixed|solved)", body, I)) |
| dup = any(re.search(r"duplicate", l, I) for l in t["labels"]) or t.get("state_reason") == "duplicate" |
| if t["state"] == "open": |
| resolved = "yes" if author_ok else "no" |
| else: |
| resolved = "yes" if (t.get("state_reason") == "completed" and not stale) or author_ok else "no" |
| out["resolved"] = resolved |
| ocoms = " ".join(c["body"] for c in others_c) |
| if dup: |
| rt = "duplicate" |
| elif not others_c: |
| rt = "self_resolved" if author_ok else ("stale_closed" if stale and t["state"] == "closed" else "unanswered") |
| elif re.search(r"not (intended|designed|supported|possible|planned)|limitation|by design|won'?t fix|out of scope|isn'?t supported|is not an? (actual )?(bug|flowise error)", ocoms, I) and t["state"] == "closed": |
| rt = "platform_limit_no_fix" if not re.search(r"your (deployment )?environment|not a \w+ error", ocoms, I) else "user_error_config" |
| elif re.search(r"fixed in|released in|(upgrade|update) to (the latest|v?\d)|new (version|release)|latest (version|release)|beta release|now fixed|merged a fix|merging a fix", ocoms, I): |
| rt = "version_upgrade" |
| elif re.search(r"downgrad|pin(ned)? to|roll(ed)? back to", coms, I): |
| rt = "version_downgrade" |
| elif re.search(r"workaround|work around|in the meantime|temporar|stopgap", coms, I): |
| rt = "workaround" |
| elif re.search(r"my (bad|mistake|fault)|typo|you forgot|user error|misconfig|your (deployment )?environment", coms, I): |
| rt = "user_error_config" |
| elif author_ok and re.search(r"\bset\b|config|setting|env(ironment)? var|--host|0\.0\.0\.0|add(ing)? .{0,20}to (your|the)|change", coms, I): |
| rt = "config_fix" |
| elif author_ok: |
| rt = "self_resolved" |
| elif stale and t["state"] == "closed": |
| rt = "stale_closed" |
| elif t["state"] == "open": |
| rt = "open_unresolved" |
| else: |
| rt = "closed_unclear" |
| out["kw_resolution_type"] = rt |
| return out |
|
|
|
|
| |
| DROPPED_REPOS = set() |
|
|
|
|
| def main(): |
| src = sys.argv[1] if len(sys.argv) > 1 else os.path.join(ROOT, "raw", "threads.jsonl") |
| dst = sys.argv[2] if len(sys.argv) > 2 else os.path.join(ROOT, "raw", "coded_kw.jsonl") |
| if "--drop-removed" in sys.argv: |
| DROPPED_REPOS.update({"skypilot-org/skypilot", "replicate/cog"}) |
| with open(dst, "w") as f: |
| for line in open(src): |
| t = json.loads(line) |
| if t["repo"] in DROPPED_REPOS: |
| continue |
| if t["repo"] in filters.GENERIC_REPOS and t["group"] == "framework": |
| t["group"] = "framework_generic" |
| rec = {k: v for k, v in t.items() if k not in ("body", "comments")} |
| rec.update(code(t)) |
| rec["excerpt_private"] = excerpt(t["body"]) |
| f.write(json.dumps(rec) + "\n") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
