golf-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

golf/examples/api_key/tools/search/code.py

@@ -1,32 +1,49 @@
 """Search GitHub code."""
 
-from typing import Annotated, List, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """Code search results."""
-    results: List[Dict[str, Any]]
+
+    results: list[dict[str, Any]]
     total_count: int
 
 
 async def search(
-    query: Annotated[str, Field(description="Search query (e.g., 'addClass', 'TODO', etc.)")],
-    language: Annotated[Optional[str], Field(description="Filter by programming language (e.g., 'python', 'javascript')")] = None,
-    repo: Annotated[Optional[str], Field(description="Search within a specific repository (format: 'owner/repo')")] = None,
-    org: Annotated[Optional[str], Field(description="Search within repositories of a specific organization")] = None,
-    per_page: Annotated[int, Field(description="Number of results per page (max 100)")] = 10
+    query: Annotated[
+        str, Field(description="Search query (e.g., 'addClass', 'TODO', etc.)")
+    ],
+    language: Annotated[
+        str | None,
+        Field(
+            description="Filter by programming language (e.g., 'python', 'javascript')"
+        ),
+    ] = None,
+    repo: Annotated[
+        str | None,
+        Field(description="Search within a specific repository (format: 'owner/repo')"),
+    ] = None,
+    org: Annotated[
+        str | None,
+        Field(description="Search within repositories of a specific organization"),
+    ] = None,
+    per_page: Annotated[
+        int, Field(description="Number of results per page (max 100)")
+    ] = 10,
 ) -> Output:
     """Search for code on GitHub.
-    
+
     Without authentication, you're limited to 10 requests per minute.
     With authentication, you can make up to 30 requests per minute.
     """
     github_token = get_api_key()
-    
+
     # Build the search query
     search_parts = [query]
     if language:
@@ -35,54 +52,50 @@ async def search(
         search_parts.append(f"repo:{repo}")
     if org:
         search_parts.append(f"org:{org}")
-    
+
     search_query = " ".join(search_parts)
-    
+
     url = "https://api.github.com/search/code"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     try:
         async with httpx.AsyncClient() as client:
             response = await client.get(
                 url,
                 headers=headers,
-                params={
-                    "q": search_query,
-                    "per_page": min(per_page, 100)
-                },
-                timeout=10.0
+                params={"q": search_query, "per_page": min(per_page, 100)},
+                timeout=10.0,
             )
-            
+
             if response.status_code == 403:
                 # Rate limit exceeded
                 return Output(results=[], total_count=0)
-            
+
             response.raise_for_status()
             data = response.json()
-            
+
             # Format results
             results = []
             for item in data.get("items", []):
-                results.append({
-                    "name": item["name"],
-                    "path": item["path"],
-                    "repository": item["repository"]["full_name"],
-                    "url": item["html_url"],
-                    "score": item.get("score", 0.0)
-                })
-            
-            return Output(
-                results=results,
-                total_count=data.get("total_count", 0)
-            )
-            
+                results.append(
+                    {
+                        "name": item["name"],
+                        "path": item["path"],
+                        "repository": item["repository"]["full_name"],
+                        "url": item["html_url"],
+                        "score": item.get("score", 0.0),
+                    }
+                )
+
+            return Output(results=results, total_count=data.get("total_count", 0))
+
     except httpx.HTTPStatusError:
         return Output(results=[], total_count=0)
     except Exception:
@@ -90,4 +103,4 @@ async def search(
 
 
 # Export the function to be used as the tool
-export = search 
+export = search

golf/examples/api_key/tools/users/get.py

@@ -1,28 +1,33 @@
 """Get GitHub user information."""
 
-from typing import Annotated, Optional, Dict, Any
-from pydantic import BaseModel, Field
+from typing import Annotated, Any
+
 import httpx
+from pydantic import BaseModel, Field
 
 from golf.auth import get_api_key
 
 
 class Output(BaseModel):
     """User information result."""
+
     found: bool
-    user: Optional[Dict[str, Any]] = None
+    user: dict[str, Any] | None = None
 
 
 async def get(
-    username: Annotated[Optional[str], Field(description="GitHub username (if not provided, gets authenticated user)")] = None
+    username: Annotated[
+        str | None,
+        Field(description="GitHub username (if not provided, gets authenticated user)"),
+    ] = None,
 ) -> Output:
     """Get information about a GitHub user.
-    
+
     If no username is provided, returns information about the authenticated user.
     This is useful for testing if authentication is working correctly.
     """
     github_token = get_api_key()
-    
+
     # Determine the API endpoint
     if username:
         url = f"https://api.github.com/users/{username}"
@@ -31,26 +36,22 @@ async def get(
         if not github_token:
             return Output(found=False)
         url = "https://api.github.com/user"
-    
+
     # Prepare headers
     headers = {
         "Accept": "application/vnd.github.v3+json",
-        "User-Agent": "Golf-GitHub-MCP-Server"
+        "User-Agent": "Golf-GitHub-MCP-Server",
     }
     if github_token:
         headers["Authorization"] = f"Bearer {github_token}"
-    
+
     try:
         async with httpx.AsyncClient() as client:
-            response = await client.get(
-                url,
-                headers=headers,
-                timeout=10.0
-            )
-            
+            response = await client.get(url, headers=headers, timeout=10.0)
+
             response.raise_for_status()
             user_data = response.json()
-            
+
             return Output(
                 found=True,
                 user={
@@ -64,10 +65,10 @@ async def get(
                     "followers": user_data.get("followers", 0),
                     "following": user_data.get("following", 0),
                     "created_at": user_data["created_at"],
-                    "url": user_data["html_url"]
-                }
+                    "url": user_data["html_url"],
+                },
             )
-            
+
     except httpx.HTTPStatusError as e:
         if e.response.status_code in [401, 404]:
             return Output(found=False)
@@ -78,4 +79,4 @@ async def get(
 
 
 # Export the function to be used as the tool
-export = get 
+export = get

golf/examples/basic/pre_build.py

@@ -16,13 +16,13 @@ github_provider = ProviderConfig(
     token_url="https://github.com/login/oauth/access_token",
     userinfo_url="https://api.github.com/user",
     scopes=["read:user", "user:email"],
-    issuer_url="http://127.0.0.1:3000", # This should be your Golf server's accessible URL
-    callback_path="/auth/callback",     # Golf's callback path
-    token_expiration=3600  # 1 hour
+    issuer_url="http://127.0.0.1:3000",  # This should be your Golf server's accessible URL
+    callback_path="/auth/callback",  # Golf's callback path
+    token_expiration=3600,  # 1 hour
 )
 
 # Configure authentication with the provider
 configure_auth(
     provider=github_provider,
     required_scopes=["read:user"],  # Require read:user scope for protected endpoints
-)
+)

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