mcp-scoring-engine 0.1.0__tar.gz

mcp_scoring_engine-0.1.0/.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.pytest_cache/
+.ruff_cache/

mcp_scoring_engine-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Brightwing Systems LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_scoring_engine-0.1.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: mcp-scoring-engine
+Version: 0.1.0
+Summary: Scoring engine for MCP server quality assessment
+Project-URL: Homepage, https://patchworkmcp.com
+Project-URL: Repository, https://github.com/Brightwing-Systems-LLC/mcp-scoring-engine
+Author-email: Brightwing Systems LLC <support@brightwingsystems.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,mcp,model-context-protocol,quality,scoring
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.12
+Requires-Dist: httpx
+Requires-Dist: httpx-sse
+Requires-Dist: mcp>=1.26
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: respx>=0.22; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# mcp-scoring-engine
+
+Standalone scoring engine for MCP server quality assessment. Used by [PatchworkMCP](https://patchworkmcp.com) to evaluate and grade Model Context Protocol servers.
+
+## Installation
+
+```bash
+pip install mcp-scoring-engine
+```
+
+## License
+
+MIT

mcp_scoring_engine-0.1.0/README.md

@@ -0,0 +1,13 @@
+# mcp-scoring-engine
+
+Standalone scoring engine for MCP server quality assessment. Used by [PatchworkMCP](https://patchworkmcp.com) to evaluate and grade Model Context Protocol servers.
+
+## Installation
+
+```bash
+pip install mcp-scoring-engine
+```
+
+## License
+
+MIT

mcp_scoring_engine-0.1.0/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mcp-scoring-engine"
+version = "0.1.0"
+description = "Scoring engine for MCP server quality assessment"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.12"
+authors = [
+    { name = "Brightwing Systems LLC", email = "support@brightwingsystems.com" },
+]
+keywords = ["mcp", "scoring", "quality", "model-context-protocol", "ai"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "mcp>=1.26",
+    "httpx",
+    "httpx-sse",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=1.0",
+    "respx>=0.22",
+]
+
+[project.urls]
+Homepage = "https://patchworkmcp.com"
+Repository = "https://github.com/Brightwing-Systems-LLC/mcp-scoring-engine"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_scoring_engine"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"

mcp_scoring_engine-0.1.0/src/mcp_scoring_engine/__init__.py

@@ -0,0 +1,72 @@
+"""MCP Scoring Engine — standalone quality assessment for MCP servers.
+
+Public API for scoring, probing, and classifying MCP servers.
+No Django, no database — pure Python.
+"""
+
+from .badges import generate_badges
+from .classification import classify_server
+from .flags import detect_flags, FlagContext
+from .probes.health import probe_server, probe_server_stdio
+from .probes.protocol import deep_probe_server, deep_probe_server_stdio
+from .probes.reliability import compute_reliability_score
+from .probes.static import analyze_repo
+from .scoring import (
+    compute_score,
+    extract_publisher,
+    GRADE_THRESHOLDS,
+    is_verified_publisher,
+    score_to_grade,
+    VERIFIED_PUBLISHERS,
+    WEIGHT_MAINTENANCE,
+    WEIGHT_PROTOCOL,
+    WEIGHT_RELIABILITY,
+    WEIGHT_SCHEMA_DOCS,
+    WEIGHT_SECURITY,
+)
+from .types import (
+    Badge,
+    DeepProbeResult,
+    FastProbeResult,
+    Flag,
+    ReliabilityData,
+    ScoreResult,
+    ServerInfo,
+    StaticAnalysis,
+)
+
+__all__ = [
+    # Types
+    "Badge",
+    "DeepProbeResult",
+    "FastProbeResult",
+    "Flag",
+    "FlagContext",
+    "ReliabilityData",
+    "ScoreResult",
+    "ServerInfo",
+    "StaticAnalysis",
+    # Scoring
+    "compute_score",
+    "score_to_grade",
+    "is_verified_publisher",
+    "extract_publisher",
+    "GRADE_THRESHOLDS",
+    "VERIFIED_PUBLISHERS",
+    "WEIGHT_SCHEMA_DOCS",
+    "WEIGHT_PROTOCOL",
+    "WEIGHT_RELIABILITY",
+    "WEIGHT_MAINTENANCE",
+    "WEIGHT_SECURITY",
+    # Probes
+    "probe_server",
+    "probe_server_stdio",
+    "deep_probe_server",
+    "deep_probe_server_stdio",
+    "analyze_repo",
+    "compute_reliability_score",
+    # Classification & Flags & Badges
+    "classify_server",
+    "detect_flags",
+    "generate_badges",
+]

mcp_scoring_engine-0.1.0/src/mcp_scoring_engine/badges.py

@@ -0,0 +1,228 @@
+"""Structured badge generation for MCP server scoring.
+
+Generates badge pills grouped by scoring category. Each badge conveys
+a quick status signal: good (green), neutral (gray), warning (orange),
+critical (red).
+"""
+
+from __future__ import annotations
+
+import re
+
+from .types import Badge, DeepProbeResult, ReliabilityData, ServerInfo, StaticAnalysis
+
+
+def generate_badges(
+    server: ServerInfo,
+    static_result: StaticAnalysis | None = None,
+    deep_probe: DeepProbeResult | None = None,
+    reliability: ReliabilityData | None = None,
+    flags: list[dict] | None = None,
+) -> dict:
+    """Generate badge groups keyed by scoring category.
+
+    Returns {"schema": [...], "protocol": [...], ...} where each value
+    is a list of serialized badge dicts.
+    """
+    badges = {
+        "schema": _schema_badges(server, static_result, flags),
+        "protocol": _protocol_badges(deep_probe),
+        "reliability": _reliability_badges(server, reliability),
+        "maintenance": _maintenance_badges(static_result),
+        "security": _security_badges(server),
+    }
+    return {k: [_serialize(b) for b in v] for k, v in badges.items()}
+
+
+def _serialize(badge: Badge) -> dict:
+    return {"key": badge.key, "label": badge.label, "level": badge.level}
+
+
+def _schema_badges(
+    server: ServerInfo,
+    static_result: StaticAnalysis | None,
+    flags: list[dict] | None,
+) -> list[Badge]:
+    badges = []
+
+    if static_result:
+        details = static_result.details or {}
+
+        doc_checks = details.get("documentation_coverage", {}).get("checks", {})
+        if doc_checks.get("has_readme"):
+            badges.append(Badge("has_readme", "README", "good"))
+        elif doc_checks:
+            badges.append(Badge("no_readme", "No README", "critical"))
+
+        if doc_checks.get("has_changelog"):
+            badges.append(Badge("has_changelog", "Changelog", "good"))
+        if doc_checks.get("has_examples"):
+            badges.append(Badge("has_examples", "Examples", "good"))
+        if doc_checks.get("has_contributing"):
+            badges.append(Badge("has_contributing", "Contributing Guide", "good"))
+        if doc_checks.get("has_docs_dir"):
+            badges.append(Badge("has_docs_dir", "Docs Dir", "good"))
+
+        prov_checks = details.get("provenance", {}).get("checks", {})
+        if prov_checks.get("has_security_policy"):
+            badges.append(Badge("security_policy", "SECURITY.md", "good"))
+        if prov_checks.get("has_code_of_conduct"):
+            badges.append(Badge("code_of_conduct", "Code of Conduct", "good"))
+        if prov_checks.get("namespace_owner_match") is True:
+            badges.append(Badge("namespace_match", "Namespace Match", "good"))
+        elif prov_checks.get("namespace_owner_match") is False:
+            badges.append(Badge("namespace_mismatch", "Namespace Mismatch", "warning"))
+        if prov_checks.get("has_installable_package"):
+            badges.append(Badge("installable", "Installable", "good"))
+
+        desc_checks = details.get("description_quality", {}).get("checks", {})
+        if desc_checks.get("has_usage_section"):
+            badges.append(Badge("usage_docs", "Usage Docs", "good"))
+        if desc_checks.get("has_code_examples"):
+            badges.append(Badge("code_examples", "Code Examples", "good"))
+
+    if flags:
+        flag_keys = {f["key"] if isinstance(f, dict) else f.key for f in flags}
+        if "TEMPLATE_DESCRIPTION" in flag_keys:
+            badges.append(Badge("template_desc", "Template Description", "warning"))
+
+    return badges
+
+
+def _protocol_badges(deep_probe: DeepProbeResult | None) -> list[Badge]:
+    badges = []
+
+    if not deep_probe:
+        return badges
+
+    if deep_probe.is_reachable:
+        badges.append(Badge("reachable", "Reachable", "good"))
+    else:
+        badges.append(Badge("unreachable", "Unreachable", "critical"))
+
+    if deep_probe.schema_valid is True:
+        badges.append(Badge("schema_valid", "Schema Valid", "good"))
+    elif deep_probe.schema_valid is False:
+        badges.append(Badge("schema_invalid", "Schema Invalid", "warning"))
+
+    if deep_probe.tools_count is not None and deep_probe.tools_count > 0:
+        badges.append(Badge("has_tools", f"{deep_probe.tools_count} Tools", "good"))
+
+    if deep_probe.error_handling_score is not None:
+        if deep_probe.error_handling_score >= 70:
+            badges.append(Badge("good_errors", "Good Error Handling", "good"))
+        elif deep_probe.error_handling_score < 40:
+            badges.append(Badge("poor_errors", "Poor Error Handling", "warning"))
+
+    if deep_probe.auth_discovery_valid is True:
+        badges.append(Badge("auth_discovery", "Auth Discovery", "good"))
+
+    return badges
+
+
+def _reliability_badges(
+    server: ServerInfo, reliability: ReliabilityData | None
+) -> list[Badge]:
+    badges = []
+
+    if reliability and reliability.uptime_pct is not None:
+        if reliability.uptime_pct >= 99.0:
+            badges.append(Badge("high_uptime", "99%+ Uptime", "good"))
+        elif reliability.uptime_pct >= 95.0:
+            badges.append(Badge("good_uptime", "95%+ Uptime", "good"))
+        elif reliability.uptime_pct >= 80.0:
+            badges.append(Badge("degraded_uptime", "Degraded Uptime", "warning"))
+        else:
+            badges.append(Badge("low_uptime", "Low Uptime", "critical"))
+
+    if reliability and reliability.latency_p50_ms is not None:
+        p50 = reliability.latency_p50_ms
+        if p50 < 200:
+            badges.append(Badge("low_latency", "Fast (<200ms)", "good"))
+        elif p50 < 500:
+            badges.append(Badge("med_latency", "Moderate Latency", "neutral"))
+        elif p50 < 1000:
+            badges.append(Badge("high_latency", "Slow (>500ms)", "warning"))
+        else:
+            badges.append(Badge("very_high_latency", "Very Slow (>1s)", "critical"))
+
+    if not server.is_remote:
+        badges.append(Badge("local_only", "Local Only", "neutral"))
+
+    return badges
+
+
+def _maintenance_badges(static_result: StaticAnalysis | None) -> list[Badge]:
+    badges = []
+
+    if not static_result:
+        return badges
+
+    details = static_result.details or {}
+
+    maint = details.get("maintenance_pulse", {})
+    days = maint.get("days_since_last_push")
+    if days is not None:
+        if days <= 30:
+            badges.append(Badge("active", "Active Development", "good"))
+        elif days <= 180:
+            badges.append(Badge("moderate", "Moderate Activity", "neutral"))
+        elif days <= 365:
+            badges.append(Badge("stale", "Stale", "warning"))
+        else:
+            badges.append(Badge("abandoned", "Possibly Abandoned", "critical"))
+
+    if maint.get("release_count", 0) >= 3:
+        badges.append(Badge("regular_releases", "Regular Releases", "good"))
+    elif maint.get("release_count", 0) >= 1:
+        badges.append(Badge("has_releases", "Has Releases", "good"))
+
+    dep_checks = details.get("dependency_health", {}).get("checks", {})
+    if dep_checks.get("has_ci"):
+        badges.append(Badge("has_ci", "CI/CD", "good"))
+    if dep_checks.get("has_lock_file"):
+        badges.append(Badge("lock_file", "Lock File", "good"))
+    if dep_checks.get("has_dependency_automation"):
+        badges.append(Badge("dep_automation", "Dep Automation", "good"))
+
+    lic = details.get("license_clarity", {})
+    if lic.get("spdx_id") and lic["spdx_id"] != "NOASSERTION":
+        badges.append(Badge("licensed", lic["spdx_id"], "good"))
+    elif lic.get("issue") == "no_license_detected":
+        badges.append(Badge("no_license", "No License", "warning"))
+
+    ver = details.get("version_hygiene", {})
+    if ver.get("semver_ratio", 0) >= 0.8:
+        badges.append(Badge("semver", "Semver", "good"))
+
+    return badges
+
+
+def _security_badges(server: ServerInfo) -> list[Badge]:
+    badges = []
+
+    meta = server.registry_metadata or {}
+    env_vars = meta.get("env_vars", [])
+
+    secret_pattern = re.compile(
+        r"(api[_-]?key|secret|token|password|auth|credential|private[_-]?key)",
+        re.IGNORECASE,
+    )
+    sensitive_vars = [v for v in env_vars if secret_pattern.search(v)]
+
+    if len(sensitive_vars) == 0:
+        badges.append(Badge("no_secrets", "No Secrets Required", "good"))
+    elif len(sensitive_vars) <= 2:
+        badges.append(Badge("few_secrets", f"{len(sensitive_vars)} Secret(s)", "neutral"))
+    else:
+        badges.append(Badge("many_secrets", f"{len(sensitive_vars)} Secrets", "warning"))
+
+    if not server.is_remote:
+        badges.append(Badge("stdio", "STDIO Only", "good"))
+    else:
+        badges.append(Badge("remote", "Remote Endpoint", "neutral"))
+
+    if server.npm_url or server.pypi_url or server.dockerhub_url:
+        badges.append(Badge("published", "Published Package", "good"))
+
+    return badges

mcp_scoring_engine-0.1.0/src/mcp_scoring_engine/classification.py

@@ -0,0 +1,186 @@
+"""Server categorization engine.
+
+Classifies servers into categories based on name, description, namespace,
+and repo URL analysis. Also identifies target platforms.
+"""
+
+from __future__ import annotations
+
+import re
+
+from .types import ServerInfo
+
+# Target platforms: keyword → (platform_label, category)
+TARGET_PLATFORMS = {
+    # AI/ML
+    "openai": ("OpenAI", "ai_ml"),
+    "gpt": ("OpenAI", "ai_ml"),
+    "chatgpt": ("OpenAI", "ai_ml"),
+    "anthropic": ("Anthropic", "ai_ml"),
+    "claude": ("Anthropic", "ai_ml"),
+    "huggingface": ("Hugging Face", "ai_ml"),
+    "hugging-face": ("Hugging Face", "ai_ml"),
+    "ollama": ("Ollama", "ai_ml"),
+    "langchain": ("LangChain", "ai_ml"),
+    "cohere": ("Cohere", "ai_ml"),
+    "replicate": ("Replicate", "ai_ml"),
+    "stable-diffusion": ("Stable Diffusion", "ai_ml"),
+    "midjourney": ("Midjourney", "ai_ml"),
+    "vertex-ai": ("Google Vertex AI", "ai_ml"),
+    "bedrock": ("AWS Bedrock", "ai_ml"),
+    "gemini": ("Google Gemini", "ai_ml"),
+    # Database
+    "postgres": ("PostgreSQL", "database"),
+    "postgresql": ("PostgreSQL", "database"),
+    "mysql": ("MySQL", "database"),
+    "mongodb": ("MongoDB", "database"),
+    "redis": ("Redis", "database"),
+    "sqlite": ("SQLite", "database"),
+    "supabase": ("Supabase", "database"),
+    "firebase": ("Firebase", "database"),
+    "dynamodb": ("DynamoDB", "database"),
+    "elasticsearch": ("Elasticsearch", "database"),
+    "pinecone": ("Pinecone", "database"),
+    "qdrant": ("Qdrant", "database"),
+    "chromadb": ("ChromaDB", "database"),
+    "weaviate": ("Weaviate", "database"),
+    "neon": ("Neon", "database"),
+    "turso": ("Turso", "database"),
+    # DevTools
+    "github": ("GitHub", "devtools"),
+    "gitlab": ("GitLab", "devtools"),
+    "bitbucket": ("Bitbucket", "devtools"),
+    "docker": ("Docker", "devtools"),
+    "kubernetes": ("Kubernetes", "devtools"),
+    "terraform": ("Terraform", "devtools"),
+    "npm": ("npm", "devtools"),
+    "jira": ("Jira", "devtools"),
+    "linear": ("Linear", "devtools"),
+    "sentry": ("Sentry", "devtools"),
+    "jest": ("Jest", "devtools"),
+    "eslint": ("ESLint", "devtools"),
+    "prettier": ("Prettier", "devtools"),
+    # Cloud
+    "aws": ("AWS", "cloud"),
+    "gcp": ("Google Cloud", "cloud"),
+    "azure": ("Azure", "cloud"),
+    "cloudflare": ("Cloudflare", "cloud"),
+    "vercel": ("Vercel", "cloud"),
+    "netlify": ("Netlify", "cloud"),
+    "heroku": ("Heroku", "cloud"),
+    "digitalocean": ("DigitalOcean", "cloud"),
+    "fly.io": ("Fly.io", "cloud"),
+    "railway": ("Railway", "cloud"),
+    # Communication
+    "slack": ("Slack", "communication"),
+    "discord": ("Discord", "communication"),
+    "telegram": ("Telegram", "communication"),
+    "email": ("Email", "communication"),
+    "twilio": ("Twilio", "communication"),
+    "sendgrid": ("SendGrid", "communication"),
+    "whatsapp": ("WhatsApp", "communication"),
+    # Productivity
+    "notion": ("Notion", "productivity"),
+    "obsidian": ("Obsidian", "productivity"),
+    "google-docs": ("Google Docs", "productivity"),
+    "google-drive": ("Google Drive", "productivity"),
+    "google-sheets": ("Google Sheets", "productivity"),
+    "airtable": ("Airtable", "productivity"),
+    "todoist": ("Todoist", "productivity"),
+    "trello": ("Trello", "productivity"),
+    "asana": ("Asana", "productivity"),
+    "calendar": ("Calendar", "productivity"),
+    # Search
+    "brave-search": ("Brave Search", "search"),
+    "google-search": ("Google Search", "search"),
+    "tavily": ("Tavily", "search"),
+    "exa": ("Exa", "search"),
+    "perplexity": ("Perplexity", "search"),
+    "wikipedia": ("Wikipedia", "search"),
+    "arxiv": ("arXiv", "search"),
+    # Monitoring
+    "datadog": ("Datadog", "monitoring"),
+    "grafana": ("Grafana", "monitoring"),
+    "prometheus": ("Prometheus", "monitoring"),
+    "pagerduty": ("PagerDuty", "monitoring"),
+    "newrelic": ("New Relic", "monitoring"),
+    # Data
+    "snowflake": ("Snowflake", "data"),
+    "bigquery": ("BigQuery", "data"),
+    "dbt": ("dbt", "data"),
+    "pandas": ("pandas", "data"),
+    "jupyter": ("Jupyter", "data"),
+    # Finance
+    "stripe": ("Stripe", "finance"),
+    "plaid": ("Plaid", "finance"),
+    "coinbase": ("Coinbase", "finance"),
+    # Media
+    "youtube": ("YouTube", "media"),
+    "spotify": ("Spotify", "media"),
+    "figma": ("Figma", "media"),
+    "canva": ("Canva", "media"),
+    # E-Commerce
+    "shopify": ("Shopify", "ecommerce"),
+    "woocommerce": ("WooCommerce", "ecommerce"),
+    # Browser
+    "puppeteer": ("Puppeteer", "browser"),
+    "playwright": ("Playwright", "browser"),
+    "selenium": ("Selenium", "browser"),
+    "browserbase": ("Browserbase", "browser"),
+    "fetch": ("Web Fetch", "browser"),
+    "scraper": ("Web Scraper", "browser"),
+    "scraping": ("Web Scraping", "browser"),
+    "crawl": ("Web Crawler", "browser"),
+}
+
+
+def classify_server(server: ServerInfo) -> tuple[str, list[str]]:
+    """Classify a server into a category and identify target platforms.
+
+    Uses 4-tier matching: name, description, registry namespace, repo URL.
+    Returns (category, list_of_target_labels).
+    """
+    targets_found: set[str] = set()
+    category_votes: dict[str, int] = {}
+
+    name_lower = (server.name or "").lower()
+    desc_lower = (server.description or "").lower()
+
+    namespace = ""
+    rid = server.registry_id or ""
+    if "/" in rid:
+        namespace = rid.rsplit("/", 1)[-1].lower()
+
+    repo_path = ""
+    if server.repo_url:
+        repo_path = (
+            server.repo_url.lower().rstrip("/").rsplit("/", 1)[-1]
+            if "/" in server.repo_url
+            else ""
+        )
+
+    search_fields = [
+        (name_lower, 3),
+        (desc_lower, 1),
+        (namespace, 2),
+        (repo_path, 2),
+    ]
+
+    for keyword, (platform_label, category) in TARGET_PLATFORMS.items():
+        kw_pattern = re.compile(
+            r"(?:^|[\s\-_/])(" + re.escape(keyword) + r")(?:[\s\-_/.]|$)", re.IGNORECASE
+        )
+        for text, weight in search_fields:
+            if not text:
+                continue
+            if keyword in text or kw_pattern.search(text):
+                targets_found.add(platform_label)
+                category_votes[category] = category_votes.get(category, 0) + weight
+                break
+
+    if category_votes:
+        best_category = max(category_votes, key=category_votes.get)
+    else:
+        best_category = "other"
+
+    return best_category, sorted(targets_found)