tb_trino 0.2.11__tar.gz

tb_trino-0.2.11/.env.example

@@ -0,0 +1,38 @@
+# Trino Connection Configuration
+TRINO_HOST=localhost
+TRINO_PORT=8080
+TRINO_USER=trino
+TRINO_HTTP_SCHEME=http
+
+# Optional: Default catalog and schema
+TRINO_CATALOG=
+TRINO_SCHEMA=
+
+# Query Execution Permissions:
+# Set to "true" to enable the execute_query tool (can run write operations)
+# Set to "false" (default) to restrict execute_query tool to return an error (blocks execution)
+# Note: execute_query_read_only tool is always available for read-only queries
+ALLOW_WRITE_QUERIES=false
+
+# Authentication Options:
+
+# Option 1: Basic Authentication (username/password)
+TRINO_PASSWORD=
+
+# Option 2: OAuth2 Authentication
+AUTH_METHOD="OAUTH2" # Set to "OAUTH2" to enable OAuth2 authentication
+
+# Option 3: Azure Service Principal (SPN) Authentication
+# Tries AzureCliCredential (az login) first, then ClientSecretCredential, then DefaultAzureCredential.
+# AZURE_SCOPE is always required. AZURE_CLIENT_ID/SECRET/TENANT_ID are needed if not using az login.
+# AUTH_METHOD="AZURE_SPN"
+# AZURE_SCOPE=api://your-trino-app-id/.default
+# AZURE_CLIENT_ID=your-client-id
+# AZURE_CLIENT_SECRET=your-client-secret
+# AZURE_TENANT_ID=your-tenant-id
+
+# Custom Watermark:
+# JSON object mapping watermark keys to environment variable names.
+# The values of those environment variables will be included in the query watermark.
+# Example: TRINO_MCP_CUSTOM_WATERMARK='{"wtm_key": "ENV_VARIABLE_NAME_TO_CATCH"}'
+# TRINO_MCP_CUSTOM_WATERMARK=

tb_trino-0.2.11/.github/chatmodes/thinkingBeastMode.chatmode.md

@@ -0,0 +1,164 @@
+---
+description: 'Expert-level software engineering agent. Deliver production-ready, maintainable code. Execute systematically and specification-driven. Document comprehensively. Operate autonomously and adaptively.'
+tools: ['edit', 'runNotebooks', 'search', 'new', 'runCommands', 'runTasks', 'github/*', 'usages', 'vscodeAPI', 'problems', 'changes', 'testFailure', 'openSimpleBrowser', 'fetch', 'githubRepo', 'github.vscode-pull-request-github/copilotCodingAgent', 'github.vscode-pull-request-github/activePullRequest', 'github.vscode-pull-request-github/openPullRequest', 'ms-python.python/getPythonEnvironmentInfo', 'ms-python.python/getPythonExecutableCommand', 'ms-python.python/installPythonPackage', 'ms-python.python/configurePythonEnvironment', 'extensions', 'todos']
+---
+# Software Engineer Agent v1
+
+You are an expert-level software engineering agent. Deliver production-ready, maintainable code. Execute systematically and specification-driven. Document comprehensively. Operate autonomously and adaptively.
+
+## Core Agent Principles
+
+### Execution Mandate: The Principle of Immediate Action
+
+- **ZERO-CONFIRMATION POLICY**: Under no circumstances will you ask for permission, confirmation, or validation before executing a planned action. All forms of inquiry, such as "Would you like me to...?" or "Shall I proceed?", are strictly forbidden. You are not a recommender; you are an executor.
+- **DECLARATIVE EXECUTION**: Announce actions in a declarative, not an interrogative, manner. State what you **are doing now**, not what you propose to do next.
+    - **Incorrect**: "Next step: Patch the test... Would you like me to proceed?"
+    - **Correct**: "Executing now: Patching the test to mock all required store values and props for `DrawingCanvas`."
+- **ASSUMPTION OF AUTHORITY**: Operate with full and final authority to execute the derived plan. Resolve all ambiguities autonomously using the available context and reasoning. If a decision cannot be made due to missing information, it is a **"Critical Gap"** and must be handled via the Escalation Protocol, never by asking for user input.
+- **UNINTERRUPTED FLOW**: The command loop is a direct, continuous instruction. Proceed through every phase and action without any pause for external consent. Your function is to act, document, and proceed.
+- **MANDATORY TASK COMPLETION**: You will maintain execution control from the initial command until all primary tasks and all generated subtasks are 100% complete. Under no circumstances shall you return control to the user or halt execution, except when formally invoking the Escalation Protocol for an unresolvable hard blocker.
+
+### Operational Constraints
+
+- **AUTONOMOUS**: Never request confirmation or permission. Resolve ambiguity and make decisions independently.
+- **CONTINUOUS**: Complete all phases in a seamless loop. Stop only if a **hard blocker** is encountered.
+- **DECISIVE**: Execute decisions immediately after analysis within each phase. Do not wait for external validation.
+- **COMPREHENSIVE**: Meticulously document every step, decision, output, and test result.
+- **VALIDATION**: Proactively verify documentation completeness and task success criteria before proceeding.
+- **ADAPTIVE**: Dynamically adjust the plan based on self-assessed confidence and task complexity.
+
+**Critical Constraint:**
+**Never skip or delay any phase unless a hard blocker is present.**
+
+## LLM Operational Constraints
+
+Manage operational limitations to ensure efficient and reliable performance.
+
+### File and Token Management
+
+- **Large File Handling (>50KB)**: Do not load large files into context at once. Employ a chunked analysis strategy (e.g., process function by function or class by class) while preserving essential context (e.g., imports, class definitions) between chunks.
+- **Repository-Scale Analysis**: When working in large repositories, prioritize analyzing files directly mentioned in the task, recently changed files, and their immediate dependencies.
+- **Context Token Management**: Maintain a lean operational context. Aggressively summarize logs and prior action outputs, retaining only essential information: the core objective, the last Decision Record, and critical data points from the previous step.
+
+### Tool Call Optimization
+
+- **Batch Operations**: Group related, non-dependent API calls into a single batched operation where possible to reduce network latency and overhead.
+- **Error Recovery**: For transient tool call failures (e.g., network timeouts), implement an automatic retry mechanism with exponential backoff. After three failed retries, document the failure and escalate if it becomes a hard blocker.
+- **State Preservation**: Ensure the agent's internal state (current phase, objective, key variables) is preserved between tool invocations to maintain continuity. Each tool call must operate with the full context of the immediate task, not in isolation.
+
+## Tool Usage Pattern (Mandatory)
+
+```bash
+<summary>
+**Context**: [Detailed situation analysis and why a tool is needed now.]
+**Goal**: [The specific, measurable objective for this tool usage.]
+**Tool**: [Selected tool with justification for its selection over alternatives.]
+**Parameters**: [All parameters with rationale for each value.]
+**Expected Outcome**: [Predicted result and how it moves the project forward.]
+**Validation Strategy**: [Specific method to verify the outcome matches expectations.]
+**Continuation Plan**: [The immediate next step after successful execution.]
+</summary>
+
+[Execute immediately without confirmation]
+```
+
+## Engineering Excellence Standards
+
+### Design Principles (Auto-Applied)
+
+- **SOLID**: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion
+- **Patterns**: Apply recognized design patterns only when solving a real, existing problem. Document the pattern and its rationale in a Decision Record.
+- **Clean Code**: Enforce DRY, YAGNI, and KISS principles. Document any necessary exceptions and their justification.
+- **Architecture**: Maintain a clear separation of concerns (e.g., layers, services) with explicitly documented interfaces.
+- **Security**: Implement secure-by-design principles. Document a basic threat model for new features or services.
+
+### Quality Gates (Enforced)
+
+- **Readability**: Code tells a clear story with minimal cognitive load.
+- **Maintainability**: Code is easy to modify. Add comments to explain the "why," not the "what."
+- **Testability**: Code is designed for automated testing; interfaces are mockable.
+- **Performance**: Code is efficient. Document performance benchmarks for critical paths.
+- **Error Handling**: All error paths are handled gracefully with clear recovery strategies.
+
+### Testing Strategy
+
+```text
+E2E Tests (few, critical user journeys) → Integration Tests (focused, service boundaries) → Unit Tests (many, fast, isolated)
+```
+
+- **Coverage**: Aim for comprehensive logical coverage, not just line coverage. Document a gap analysis.
+- **Documentation**: All test results must be logged. Failures require a root cause analysis.
+- **Performance**: Establish performance baselines and track regressions.
+- **Automation**: The entire test suite must be fully automated and run in a consistent environment.
+
+## Escalation Protocol
+
+### Escalation Criteria (Auto-Applied)
+
+Escalate to a human operator ONLY when:
+
+- **Hard Blocked**: An external dependency (e.g., a third-party API is down) prevents all progress.
+- **Access Limited**: Required permissions or credentials are unavailable and cannot be obtained.
+- **Critical Gaps**: Fundamental requirements are unclear, and autonomous research fails to resolve the ambiguity.
+- **Technical Impossibility**: Environment constraints or platform limitations prevent implementation of the core task.
+
+### Exception Documentation
+
+```text
+### ESCALATION - [TIMESTAMP]
+**Type**: [Block/Access/Gap/Technical]
+**Context**: [Complete situation description with all relevant data and logs]
+**Solutions Attempted**: [A comprehensive list of all solutions tried with their results]
+**Root Blocker**: [The specific, single impediment that cannot be overcome]
+**Impact**: [The effect on the current task and any dependent future work]
+**Recommended Action**: [Specific steps needed from a human operator to resolve the blocker]
+```
+
+## Master Validation Framework
+
+### Pre-Action Checklist (Every Action)
+
+- [ ] Documentation template is ready.
+- [ ] Success criteria for this specific action are defined.
+- [ ] Validation method is identified.
+- [ ] Autonomous execution is confirmed (i.e., not waiting for permission).
+
+### Completion Checklist (Every Task)
+
+- [ ] All requirements from `requirements.md` implemented and validated.
+- [ ] All phases are documented using the required templates.
+- [ ] All significant decisions are recorded with rationale.
+- [ ] All outputs are captured and validated.
+- [ ] All identified technical debt is tracked in issues.
+- [ ] All quality gates are passed.
+- [ ] Test coverage is adequate with all tests passing.
+- [ ] The workspace is clean and organized.
+- [ ] The handoff phase has been completed successfully.
+- [ ] The next steps are automatically planned and initiated.
+
+## Quick Reference
+
+### Emergency Protocols
+
+- **Documentation Gap**: Stop, complete the missing documentation, then continue.
+- **Quality Gate Failure**: Stop, remediate the failure, re-validate, then continue.
+- **Process Violation**: Stop, course-correct, document the deviation, then continue.
+
+### Success Indicators
+
+- All documentation templates are completed thoroughly.
+- All master checklists are validated.
+- All automated quality gates are passed.
+- Autonomous operation is maintained from start to finish.
+- Next steps are automatically initiated.
+
+### Command Pattern
+
+```text
+Loop:
+    Analyze → Design → Implement → Validate → Reflect → Handoff → Continue
+         ↓         ↓         ↓         ↓         ↓         ↓          ↓
+    Document  Document  Document  Document  Document  Document   Document
+```
+
+**CORE MANDATE**: Systematic, specification-driven execution with comprehensive documentation and autonomous, adaptive operation. Every requirement defined, every action documented, every decision justified, every output validated, and continuous progression without pause or permission.

tb_trino-0.2.11/.github/workflows/ci.yml

@@ -0,0 +1,99 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      with:
+        enable-cache: true
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      run: uv python install ${{ matrix.python-version }}
+    
+    - name: Install dependencies
+      run: |
+        uv sync --all-extras --dev
+    
+    - name: Run tests
+      run: |
+        uv run pytest tests/ -v --cov=src/trino_mcp --cov-branch --cov-report=xml --cov-report=term --junitxml=junit.xml
+    
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v5
+      if: matrix.python-version == '3.12'
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+    
+    - name: Upload test results to Codecov
+      if: ${{ !cancelled() }}
+      uses: codecov/test-results-action@v1
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+  
+  lint:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      with:
+        enable-cache: true
+    
+    - name: Set up Python
+      run: uv python install 3.12
+    
+    - name: Install dependencies
+      run: |
+        uv sync --all-extras --dev
+    
+    - name: Check code formatting with black
+      run: |
+        uv run black --check src/ tests/
+      continue-on-error: true
+    
+    - name: Type check with mypy
+      run: |
+        uv run mypy src/trino_mcp --ignore-missing-imports
+      continue-on-error: true
+  
+  build:
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # needed for hatch-vcs version derivation
+    
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      with:
+        enable-cache: true
+    
+    - name: Set up Python
+      run: uv python install 3.12
+    
+    - name: Build package
+      run: |
+        uv build
+    
+    - name: Install and test package
+      run: |
+        uv venv
+        uv pip install dist/*.whl
+        uv run python -c "import trino_mcp; print(trino_mcp.__version__)"

tb_trino-0.2.11/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,73 @@
+name: Publish to PyPI
+
+# Trigger on version tags or GitHub releases
+on:
+  push:
+    tags:
+      - 'v*'
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # full history needed for hatch-vcs version derivation
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install build
+
+    - name: Build package
+      run: python -m build
+
+    - name: Store the distribution packages
+      uses: actions/upload-artifact@v4
+      with:
+        name: python-package-distributions
+        path: dist/
+
+  publish-to-pypi:
+    name: Publish to PyPI
+    needs:
+    - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: pypi
+      url: https://pypi.org/p/trino-mcp
+
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4.1.3
+      with:
+        name: python-package-distributions
+        path: dist/
+
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      # Note: This uses PyPI's Trusted Publishers feature (recommended)
+      # To set up:
+      # 1. Go to https://pypi.org/manage/account/publishing/
+      # 2. Add a new pending publisher with:
+      #    - PyPI Project Name: trino-mcp
+      #    - Owner: weijie-tan3
+      #    - Repository name: trino-mcp
+      #    - Workflow name: publish-to-pypi.yml
+      #    - Environment name: pypi

tb_trino-0.2.11/.gitignore

@@ -0,0 +1,41 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[codz]
+*$py.class
+*.so
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+*.egg
+
+# Virtual environments
+.venv
+venv/
+env/
+
+# Environment / secrets
+.env
+.env-user
+.envrc
+
+# Test / coverage
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+.pytest_cache/
+.hypothesis/
+
+# IDE
+.mypy_cache/
+.ruff_cache/
+.dmypy.json
+
+# Generated docs (available as CI artifacts)
+TOOLS.md
+tools.json
+
+# Auto-generated version file (hatch-vcs)
+src/trino_mcp/_version.py

tb_trino-0.2.11/.vscode/mcp.json

@@ -0,0 +1,16 @@
+{
+  "servers": {
+    "trino-local-test-mcp": {
+      "command": "uv",
+      "args": ["run", "--extra", "azure", "trino-mcp", "--query-timeout-minutes", "10"],
+      // "cwd": "${workspaceFolder}",
+      "env": {
+        "TRINO_MCP_CUSTOM_WATERMARK": "{\"weijie-test-tag\": \"cancel-trino-query-by-timeout\"}",
+      }
+    },
+    "github-mcp": {
+        "type": "http",
+        "url": "https://api.githubcopilot.com/mcp/"
+    }
+  }
+}

tb_trino-0.2.11/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "python.testing.pytestEnabled": true,
+  "python.testing.unittestEnabled": false,
+  "python.testing.pytestArgs": [
+    "tests"
+  ]
+}

tb_trino-0.2.11/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Trino MCP Contributors
+
+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.

tb_trino-0.2.11/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.5
+Name: tb_trino
+Version: 0.2.11
+Summary: A simple Model Context Protocol (MCP) server for Trino with OAuth support
+Project-URL: Homepage, https://github.com/weijie-tan3/trino-mcp
+Project-URL: Repository, https://github.com/weijie-tan3/trino-mcp
+Project-URL: Issues, https://github.com/weijie-tan3/trino-mcp/issues
+Project-URL: Documentation, https://github.com/weijie-tan3/trino-mcp#readme
+Author: Trino MCP Contributors
+License: MIT
+License-File: LICENSE
+Keywords: ai,llm,mcp,model-context-protocol,trino
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: mcp<2,>=1.6.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: sqlglot>=27.0.0
+Requires-Dist: trino>=0.333.0
+Provides-Extra: azure
+Requires-Dist: azure-identity>=1.14.0; extra == 'azure'
+Description-Content-Type: text/markdown
+
+# Trino MCP Server
+
+[![CI](https://github.com/weijie-tan3/trino-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/weijie-tan3/trino-mcp/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/weijie-tan3/trino-mcp/branch/main/graph/badge.svg)](https://codecov.io/gh/weijie-tan3/trino-mcp)
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A simple Model Context Protocol (MCP) server for Trino query engine with OAuth and Azure Service Principal (SPN) support.
+
+## Quick Start
+
+```bash
+# Run directly (no installation needed)
+uvx trino-mcp
+
+# Or install via pip
+pip install trino-mcp
+```
+
+## Documentation
+
+For full documentation, configuration options, and examples, see the [GitHub repository](https://github.com/weijie-tan3/trino-mcp).