golf-mcp 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

golf/examples/basic/prompts/welcome.py

@@ -1,11 +1,9 @@
 """Welcome prompt for new users."""
 
-from typing import List, Dict
 
-
-async def welcome() -> List[Dict]:
+async def welcome() -> list[dict]:
     """Provide a welcome prompt for new users.
-    
+
     This is a simple example prompt that demonstrates how to define
     a prompt template in GolfMCP.
     """
@@ -15,16 +13,17 @@ async def welcome() -> List[Dict]:
             "content": (
                 "You are an assistant for the {{project_name}} application. "
                 "You help users understand how to interact with this system and its capabilities."
-            )
+            ),
         },
         {
             "role": "user",
             "content": (
                 "Welcome to {{project_name}}! This is a project built with GolfMCP. "
                 "How can I get started?"
-            )
+            ),
         },
     ]
 
+
 # Designate the entry point function
-export = welcome 
+export = welcome

golf/examples/basic/resources/current_time.py

@@ -1,22 +1,22 @@
 """Current time resource example."""
 
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any
 
 # The URI that clients will use to access this resource
 resource_uri = "system://time/{format}"
 
 
-async def current_time(format: str = "full") -> Dict[str, Any]:
+async def current_time(format: str = "full") -> dict[str, Any]:
     """Provide the current time in various formats.
-    
+
     This is a simple resource example that accepts a format parameter.
-    
+
     Args:
         format: The format to return ('full', 'iso', 'unix' or 'rfc')
     """
     now = datetime.now()
-    
+
     # Prepare all possible formats
     all_formats = {
         "iso": now.isoformat(),
@@ -25,10 +25,10 @@ async def current_time(format: str = "full") -> Dict[str, Any]:
         "formatted": {
             "date": now.strftime("%Y-%m-%d"),
             "time": now.strftime("%H:%M:%S"),
-            "timezone": now.astimezone().tzname()
-        }
+            "timezone": now.astimezone().tzname(),
+        },
     }
-    
+
     # Return specific format or all formats
     if format == "full":
         return all_formats
@@ -37,5 +37,6 @@ async def current_time(format: str = "full") -> Dict[str, Any]:
     else:
         return {"error": f"Unknown format: {format}"}
 
+
 # Designate the entry point function
-export = current_time 
+export = current_time

golf/examples/basic/resources/info.py

@@ -2,14 +2,14 @@
 
 import platform
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any
 
 resource_uri = "info://system"
 
 
-async def info() -> Dict[str, Any]:
+async def info() -> dict[str, Any]:
     """Provide system information as a resource.
-    
+
     This is a simple example resource that demonstrates how to expose
     data to an LLM client through the MCP protocol.
     """
@@ -20,8 +20,9 @@ async def info() -> Dict[str, Any]:
             "system": platform.system(),
             "python_version": platform.python_version(),
             "architecture": platform.machine(),
-        }
+        },
     }
 
+
 # Designate the entry point function
-export = info 
+export = info

golf/examples/basic/resources/weather/common.py

@@ -1,6 +1,6 @@
 """Weather shared functionality.
 
-This common.py file demonstrates the recommended pattern for 
+This common.py file demonstrates the recommended pattern for
 sharing functionality across multiple resources in a directory.
 """
 
@@ -14,30 +14,36 @@ TEMPERATURE_UNIT = os.environ.get("WEATHER_TEMP_UNIT", "fahrenheit")
 
 class WeatherApiClient:
     """Mock weather API client."""
-    
-    def __init__(self, api_key: str = WEATHER_API_KEY, api_url: str = WEATHER_API_URL):
+
+    def __init__(
+        self, api_key: str = WEATHER_API_KEY, api_url: str = WEATHER_API_URL
+    ) -> None:
         self.api_key = api_key
         self.api_url = api_url
         self.unit = TEMPERATURE_UNIT
-    
+
     async def get_forecast(self, city: str, days: int = 3):
         """Get weather forecast for a city (mock implementation)."""
         # This would make an API call in a real implementation
-        print(f"Would call {self.api_url}/forecast/{city} with API key {self.api_key[:4]}...")
+        print(
+            f"Would call {self.api_url}/forecast/{city} with API key {self.api_key[:4]}..."
+        )
         return {
             "city": city,
             "unit": self.unit,
-            "forecast": [{"day": i, "temp": 70 + i} for i in range(days)]
+            "forecast": [{"day": i, "temp": 70 + i} for i in range(days)],
         }
-    
+
     async def get_current(self, city: str):
         """Get current weather for a city (mock implementation)."""
-        print(f"Would call {self.api_url}/current/{city} with API key {self.api_key[:4]}...")
+        print(
+            f"Would call {self.api_url}/current/{city} with API key {self.api_key[:4]}..."
+        )
         return {
             "city": city,
             "unit": self.unit,
             "temperature": 72,
-            "conditions": "Sunny"
+            "conditions": "Sunny",
         }
 
 
@@ -45,4 +51,4 @@ class WeatherApiClient:
 weather_client = WeatherApiClient()
 
 # This could also define shared models or other utilities
-# that would be common across weather-related resources 
+# that would be common across weather-related resources

golf/examples/basic/resources/weather/current.py

@@ -1,16 +1,17 @@
 """Current weather resource example."""
 
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any
+
 from .common import weather_client
 
 # The URI that clients will use to access this resource
 resource_uri = "weather://current/{city}"
 
 
-async def current_weather(city: str) -> Dict[str, Any]:
+async def current_weather(city: str) -> dict[str, Any]:
     """Provide current weather for the specified city.
-    
+
     This example demonstrates:
     1. Nested resource organization (resources/weather/current.py)
     2. Dynamic URI parameters (city in this case)
@@ -18,15 +19,18 @@ async def current_weather(city: str) -> Dict[str, Any]:
     """
     # Use the shared weather client from common.py
     weather_data = await weather_client.get_current(city)
-    
+
     # Add some additional data
-    weather_data.update({
-        "time": datetime.now().isoformat(),
-        "source": "GolfMCP Weather API",
-        "unit": "fahrenheit"
-    })
-    
+    weather_data.update(
+        {
+            "time": datetime.now().isoformat(),
+            "source": "GolfMCP Weather API",
+            "unit": "fahrenheit",
+        }
+    )
+
     return weather_data
 
+
 # Designate the entry point function
-export = current_weather 
+export = current_weather

golf/examples/basic/resources/weather/forecast.py

@@ -1,16 +1,17 @@
 """Weather forecast resource example demonstrating nested resources."""
 
 from datetime import datetime
-from typing import Dict, Any
+from typing import Any
+
 from .common import weather_client
 
 # The URI that clients will use to access this resource
 resource_uri = "weather://forecast/{city}"
 
 
-async def forecast_weather(city: str) -> Dict[str, Any]:
+async def forecast_weather(city: str) -> dict[str, Any]:
     """Provide a weather forecast for the specified city.
-    
+
     This example demonstrates:
     1. Nested resource organization (resources/weather/forecast.py)
     2. Dynamic URI parameters (city in this case)
@@ -18,15 +19,18 @@ async def forecast_weather(city: str) -> Dict[str, Any]:
     """
     # Use the shared weather client from common.py
     forecast_data = await weather_client.get_forecast(city, days=5)
-    
+
     # Add some additional data
-    forecast_data.update({
-        "updated_at": datetime.now().isoformat(),
-        "source": "GolfMCP Weather API",
-        "unit": "fahrenheit"
-    })
-    
+    forecast_data.update(
+        {
+            "updated_at": datetime.now().isoformat(),
+            "source": "GolfMCP Weather API",
+            "unit": "fahrenheit",
+        }
+    )
+
     return forecast_data
 
+
 # Designate the entry point function
-export = forecast_weather 
+export = forecast_weather

golf/examples/basic/tools/github_user.py

@@ -1,25 +1,25 @@
 """Tool for fetching GitHub user information."""
 
-from typing import Optional
-from pydantic import BaseModel
 import httpx
+from pydantic import BaseModel
+
 from golf.auth import get_provider_token
 
 
 class GitHubUserResponse(BaseModel):
     """Response model for GitHub user information."""
-    
+
     login: str
     id: int
-    name: Optional[str] = None
-    email: Optional[str] = None
-    avatar_url: Optional[str] = None
-    location: Optional[str] = None
-    bio: Optional[str] = None
+    name: str | None = None
+    email: str | None = None
+    avatar_url: str | None = None
+    location: str | None = None
+    bio: str | None = None
     public_repos: int = 0
     followers: int = 0
     following: int = 0
-    message: Optional[str] = None
+    message: str | None = None
 
 
 async def get_github_user() -> GitHubUserResponse:
@@ -27,24 +27,24 @@ async def get_github_user() -> GitHubUserResponse:
     try:
         # Get GitHub token using our abstraction
         github_token = get_provider_token()
-        
+
         if not github_token:
             return GitHubUserResponse(
                 login="anonymous",
                 id=0,
-                message="Not authenticated. Please login first."
+                message="Not authenticated. Please login first.",
             )
-        
+
         # Call GitHub API to get user info
         async with httpx.AsyncClient() as client:
             response = await client.get(
                 "https://api.github.com/user",
                 headers={
                     "Authorization": f"Bearer {github_token}",
-                    "Accept": "application/vnd.github.v3+json"
-                }
+                    "Accept": "application/vnd.github.v3+json",
+                },
             )
-            
+
             if response.status_code == 200:
                 data = response.json()
                 return GitHubUserResponse(**data)
@@ -52,16 +52,14 @@ async def get_github_user() -> GitHubUserResponse:
                 return GitHubUserResponse(
                     login="error",
                     id=0,
-                    message=f"GitHub API error: {response.status_code} - {response.text[:100]}"
+                    message=f"GitHub API error: {response.status_code} - {response.text[:100]}",
                 )
-    
+
     except Exception as e:
         return GitHubUserResponse(
-            login="error",
-            id=0,
-            message=f"Error fetching GitHub data: {str(e)}"
+            login="error", id=0, message=f"Error fetching GitHub data: {str(e)}"
         )
 
 
 # Export the tool
-export = get_github_user 
+export = get_github_user

golf/examples/basic/tools/hello.py

@@ -1,30 +1,34 @@
 """Hello World tool {{project_name}}."""
 
 from typing import Annotated
+
 from pydantic import BaseModel, Field
 
 
 class Output(BaseModel):
     """Response from the hello tool."""
-    
+
     message: str
 
 
 async def hello(
-    name: Annotated[str, Field(description="The name of the person to greet")] = "World",
-    greeting: Annotated[str, Field(description="The greeting phrase to use")] = "Hello"
+    name: Annotated[
+        str, Field(description="The name of the person to greet")
+    ] = "World",
+    greeting: Annotated[str, Field(description="The greeting phrase to use")] = "Hello",
 ) -> Output:
     """Say hello to the given name.
-    
+
     This is a simple example tool that demonstrates the basic structure
     of a tool implementation in GolfMCP.
     """
     # The framework will add a context object automatically
     # You can log using regular print during development
     print(f"{greeting} {name}...")
-    
+
     # Create and return the response
     return Output(message=f"{greeting}, {name}!")
 
+
 # Designate the entry point function
-export = hello 
+export = hello

golf/examples/basic/tools/payments/charge.py

@@ -1,40 +1,50 @@
 """Charge payment tool"""
 
 from typing import Annotated
+
 from pydantic import BaseModel, Field
+
 from .common import payment_client
 
 
 class Output(BaseModel):
     """Response from the charge payment tool."""
-    
+
     success: bool
     charge_id: str
     message: str
 
 
 async def charge(
-    amount: Annotated[float, Field(
-        description="Amount to charge in USD",
-        gt=0,  # Must be greater than 0
-        le=10000  # Maximum charge limit
-    )],
-    card_token: Annotated[str, Field(
-        description="Tokenized payment card identifier",
-        pattern=r"^tok_[a-zA-Z0-9]+$"  # Validate token format
-    )],
-    description: Annotated[str, Field(
-        description="Optional payment description for the charge",
-        max_length=200
-    )] = ""
+    amount: Annotated[
+        float,
+        Field(
+            description="Amount to charge in USD",
+            gt=0,  # Must be greater than 0
+            le=10000,  # Maximum charge limit
+        ),
+    ],
+    card_token: Annotated[
+        str,
+        Field(
+            description="Tokenized payment card identifier",
+            pattern=r"^tok_[a-zA-Z0-9]+$",  # Validate token format
+        ),
+    ],
+    description: Annotated[
+        str,
+        Field(
+            description="Optional payment description for the charge", max_length=200
+        ),
+    ] = "",
 ) -> Output:
     """Process a payment charge.
-    
+
     This example demonstrates nested directory organization where related tools
     are grouped in subdirectories (tools/payments/charge.py).
-    
+
     The resulting tool ID will be: charge-payments
-    
+
     Args:
         amount: Amount to charge in USD
         card_token: Tokenized payment card
@@ -43,19 +53,18 @@ async def charge(
     # The framework will add a context object automatically
     # You can log using regular print during development
     print(f"Processing charge for ${amount:.2f}...")
-    
+
     # Use the shared payment client from common.py
     charge_result = await payment_client.create_charge(
-        amount=amount,
-        token=card_token,
-        description=description
+        amount=amount, token=card_token, description=description
     )
-    
+
     # Create and return the response
     return Output(
         success=True,
         charge_id=charge_result["id"],
-        message=f"Successfully charged ${amount:.2f}"
-    ) 
+        message=f"Successfully charged ${amount:.2f}",
+    )
+
 
-export = charge
+export = charge

golf/examples/basic/tools/payments/common.py

@@ -1,6 +1,6 @@
 """Payments shared functionality.
 
-This common.py file demonstrates the recommended pattern for 
+This common.py file demonstrates the recommended pattern for
 sharing functionality across multiple tools in a directory.
 """
 
@@ -13,17 +13,19 @@ PAYMENT_API_URL = os.environ.get("PAYMENT_API_URL", "https://api.example.com/pay
 
 class PaymentClient:
     """Mock payment provider client."""
-    
-    def __init__(self, api_key: str = PAYMENT_API_KEY, api_url: str = PAYMENT_API_URL):
+
+    def __init__(
+        self, api_key: str = PAYMENT_API_KEY, api_url: str = PAYMENT_API_URL
+    ) -> None:
         self.api_key = api_key
         self.api_url = api_url
-    
+
     async def create_charge(self, amount: float, token: str, **kwargs):
         """Create a charge (mock implementation)."""
         # In a real implementation, this would make an API request
         # using the configured API key and URL
         return {"id": f"ch_{int(amount * 100)}_{hash(token) % 10000:04d}"}
-    
+
     async def create_refund(self, charge_id: str, amount: float, **kwargs):
         """Create a refund (mock implementation)."""
         # In a real implementation, this would make an API request
@@ -31,4 +33,4 @@ class PaymentClient:
 
 
 # Create a shared payment client that can be imported by all tools in this directory
-payment_client = PaymentClient()
+payment_client = PaymentClient()

golf/examples/basic/tools/payments/refund.py

@@ -1,57 +1,61 @@
 """Refund payment tool"""
 
-from typing import Annotated, Optional
+from typing import Annotated
+
 from pydantic import BaseModel, Field
+
 from .common import payment_client
 
 
 class Output(BaseModel):
     """Response from the refund payment tool."""
-    
+
     success: bool
     refund_id: str
     message: str
 
 
 async def refund(
-    charge_id: Annotated[str, Field(
-        description="The ID of the charge to refund",
-        pattern=r"^ch_[a-zA-Z0-9]+$"
-    )],
-    amount: Annotated[Optional[float], Field(
-        description="Amount to refund in USD. If not specified, refunds the full charge amount",
-        gt=0,
-        default=None
-    )] = None,
-    reason: Annotated[str, Field(
-        description="Reason for the refund",
-        min_length=3,
-        max_length=200
-    )] = "Customer request"
+    charge_id: Annotated[
+        str,
+        Field(
+            description="The ID of the charge to refund", pattern=r"^ch_[a-zA-Z0-9]+$"
+        ),
+    ],
+    amount: Annotated[
+        float | None,
+        Field(
+            description="Amount to refund in USD. If not specified, refunds the full charge amount",
+            gt=0,
+            default=None,
+        ),
+    ] = None,
+    reason: Annotated[
+        str, Field(description="Reason for the refund", min_length=3, max_length=200)
+    ] = "Customer request",
 ) -> Output:
     """Process a payment refund.
-    
+
     This example demonstrates nested directory organization where related tools
     are grouped in subdirectories (tools/payments/refund.py).
-    
+
     The resulting tool ID will be: refund-payments
     """
     # The framework will add a context object automatically
     # You can log using regular print during development
     print(f"Processing refund for charge {charge_id}...")
-    
+
     # Use the shared payment client from common.py
     refund_result = await payment_client.create_refund(
-        charge_id=charge_id,
-        amount=amount,
-        reason=reason
+        charge_id=charge_id, amount=amount, reason=reason
     )
-    
+
     # Create and return the response
     return Output(
         success=True,
         refund_id=refund_result["id"],
-        message=f"Successfully refunded charge {charge_id}"
+        message=f"Successfully refunded charge {charge_id}",
     )
 
-export = refund
+
+export = refund

golf/telemetry/__init__.py

@@ -1,19 +1,19 @@
 """Golf telemetry module for OpenTelemetry instrumentation."""
 
 from golf.telemetry.instrumentation import (
-    instrument_tool,
-    instrument_resource,
+    get_tracer,
+    init_telemetry,
     instrument_prompt,
+    instrument_resource,
+    instrument_tool,
     telemetry_lifespan,
-    init_telemetry,
-    get_tracer,
 )
 
 __all__ = [
     "instrument_tool",
-    "instrument_resource", 
+    "instrument_resource",
     "instrument_prompt",
     "telemetry_lifespan",
     "init_telemetry",
     "get_tracer",
-] 
+]